camstack 1.2.57 → 1.2.59

package/dist/{launcher-5UCFBJXW.js → launcher-WK4Q3DVU.js}

@@ -23633,9 +23633,9 @@ var require_zod = __commonJS({
   }
 });
 
-// ../system/dist/dist-CImxMt5h.js
-var require_dist_CImxMt5h = __commonJS({
-  "../system/dist/dist-CImxMt5h.js"(exports) {
+// ../system/dist/dist-C7uZ_fOb.js
+var require_dist_C7uZ_fOb = __commonJS({
+  "../system/dist/dist-C7uZ_fOb.js"(exports) {
     "use strict";
     var zod = require_zod();
     var EventCategory = /* @__PURE__ */ (function(EventCategory2) {
@@ -32718,6 +32718,38 @@ var require_dist_CImxMt5h = __commonJS({
       /** Wall-clock uptime (seconds). Parsed from `ps etime`. */
       uptimeSec: zod.z.number()
     });
+    var ContainerMemoryPointSchema = zod.z.object({
+      /** Which hierarchy answered, so a reading is never ambiguous. */
+      source: zod.z.enum(["cgroup-v2", "cgroup-v1"]),
+      /** `memory.current` (v2) / `memory.usage_in_bytes` (v1). Always known. */
+      currentBytes: zod.z.number(),
+      /** The cgroup's ceiling. `null` = NO LIMIT — never a sentinel, never zero. */
+      limitBytes: zod.z.number().nullable(),
+      /** Anonymous pages: the closest thing to "what the processes allocated". */
+      anonBytes: zod.z.number().nullable(),
+      /** Page cache. Charged to the cgroup, owned by no process. */
+      fileBytes: zod.z.number().nullable(),
+      /**
+      * Shared memory — and the field that explained the largest single surprise.
+      * The i915 driver backs GPU buffers with shmem, so an inference pool or a
+      * hardware-decode session holding DRM objects is charged HERE and appears
+      * nowhere in a `ps` scan.
+      */
+      shmemBytes: zod.z.number().nullable(),
+      /** Kernel slab charged to this cgroup. `null` on v1, which never publishes it. */
+      slabBytes: zod.z.number().nullable(),
+      /**
+      * Shrinkable i915 GEM object bytes, from debugfs.
+      *
+      * **Host-wide across every DRM client, NOT cgroup-scoped.** It is not a
+      * component of `currentBytes` and must not be subtracted from it; it says
+      * what put the shmem there, where `shmemBytes` only says how much.
+      *
+      * `null` wherever debugfs is not mounted — which is inside every camstack
+      * container today — and on any node with no Intel GPU.
+      */
+      gpuShmemBytes: zod.z.number().nullable()
+    }).extend({ atMs: zod.z.number() });
     var DumpHeapSnapshotInputSchema = zod.z.object({
       /** The addon whose runner should dump a heap snapshot. */
       addonId: zod.z.string()
@@ -32767,6 +32799,21 @@ var require_dist_CImxMt5h = __commonJS({
       /** One entry per function seen in the window, heaviest-first. */
       series: zod.z.array(LoadFunctionSeriesSchema).readonly(),
       /**
+      * The CONTAINER's memory over the same window, oldest-first.
+      *
+      * Sits next to `series` rather than in a method of its own because the whole
+      * question is a subtraction: the per-process rows in `series` sum to one
+      * number and this one is another, and an operator who has to issue two calls
+      * to compare them will compare two different instants. Same reader, same
+      * `sinceMs`, same `bucketMs`, same timestamps.
+      *
+      * **EMPTY means ABSENT, never zero.** A node with no cgroup — a developer
+      * Mac, a bare-metal host, a container with the hierarchy hidden — reports no
+      * points at all. A zero here would be indistinguishable from a healthy
+      * container and is precisely the lie this field exists to avoid.
+      */
+      containerMemory: zod.z.array(ContainerMemoryPointSchema).readonly(),
+      /**
       * Width of one returned bucket, in ms. Equals the sampling cadence when no
       * reduction was needed — so a caller can always say what one point covers
       * without having to know whether it was reduced.
@@ -58639,7 +58686,7 @@ var require_alerts_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     function selectExpired(alerts, cutoffMs) {
       return alerts.filter((a) => a.createdAt < cutoffMs).sort((a, b) => a.createdAt - b.createdAt).map((a) => a.id);
     }
@@ -59458,7 +59505,7 @@ var require_console_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var require_formatter = require_formatter_DqAKDlvN();
     var LEVEL_RANK = {
       debug: 0,
@@ -59552,7 +59599,7 @@ var require_core_blocks_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     node_fs_promises = require_chunk.__toESM(node_fs_promises);
@@ -60449,11 +60496,11 @@ var require_core_blocks = __commonJS({
   }
 });
 
-// ../system/dist/retired-settings-keys-C7gLUS3x.js
-var require_retired_settings_keys_C7gLUS3x = __commonJS({
-  "../system/dist/retired-settings-keys-C7gLUS3x.js"(exports) {
+// ../system/dist/retired-settings-keys-CBU4-TJO.js
+var require_retired_settings_keys_CBU4_TJO = __commonJS({
+  "../system/dist/retired-settings-keys-CBU4-TJO.js"(exports) {
     "use strict";
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     function settingsStoreIsAuthoritativeHere(env) {
       const raw = (env["CAMSTACK_ROLE"] ?? "").trim().toLowerCase();
       return raw === "" || raw === "hub";
@@ -62667,8 +62714,8 @@ var require_device_manager_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
-    var require_retired_settings_keys = require_retired_settings_keys_C7gLUS3x();
+    var require_dist10 = require_dist_C7uZ_fOb();
+    var require_retired_settings_keys = require_retired_settings_keys_CBU4_TJO();
     var node_crypto = __require("crypto");
     var _camstack_types_node = require_node();
     var JOB_HISTORY = 20;
@@ -67417,7 +67464,7 @@ var require_hub_forwarder = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var require_formatter = require_formatter_DqAKDlvN();
     var DEFAULT_OUTBOUND_BUFFER_SIZE = 500;
     var HubForwarderDestination = class {
@@ -67554,7 +67601,7 @@ var require_liveness_monitor_addon = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var NO_DEVICES = "liveness:no-devices";
     var ALL_OFFLINE = "liveness:all-devices-offline";
     var NO_FOOTAGE_PREFIX = "liveness:no-footage:";
@@ -67744,7 +67791,7 @@ var require_local_auth_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var node_crypto = __require("crypto");
     node_crypto = require_chunk.__toESM(node_crypto);
     var crypto$1 = __require("crypto");
@@ -75557,7 +75604,7 @@ var require_loki_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     function sanitizeLabelName(raw) {
       const replaced = raw.replaceAll(/[^a-zA-Z0-9_]/g, "_");
       return /^[a-zA-Z_]/.test(replaced) ? replaced : `_${replaced}`;
@@ -76122,14 +76169,859 @@ var require_native_metrics_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var node_fs_promises = __require("fs/promises");
     var node_child_process = __require("child_process");
     var node_util = __require("util");
-    var node_os = __require("os");
-    node_os = require_chunk.__toESM(node_os);
     var node_fs = __require("fs");
     node_fs = require_chunk.__toESM(node_fs);
+    var node_os = __require("os");
+    node_os = require_chunk.__toESM(node_os);
+    var nodeCgroupFileReader = { read(path) {
+      try {
+        return (0, node_fs.readFileSync)(path, "utf8");
+      } catch {
+        return null;
+      }
+    } };
+    var CGROUP_MOUNT_ROOT = "/sys/fs/cgroup";
+    var I915_GEM_OBJECTS_PATH = "/sys/kernel/debug/dri/0/i915_gem_objects";
+    var V1_UNLIMITED_SENTINEL = 9223372036854772e3;
+    function parseCgroupSelf(text) {
+      let v1 = null;
+      for (const rawLine of text.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0) continue;
+        const first = line.indexOf(":");
+        if (first < 0) continue;
+        const second = line.indexOf(":", first + 1);
+        if (second < 0) continue;
+        const controllers = line.slice(first + 1, second);
+        const path = line.slice(second + 1);
+        if (path.length === 0) continue;
+        const normalized = path.startsWith("/") ? path : `/${path}`;
+        if (controllers.length === 0) return {
+          version: "v2",
+          path: normalized
+        };
+        if (v1 === null && controllers.split(",").includes("memory")) v1 = {
+          version: "v1",
+          path: normalized
+        };
+      }
+      return v1;
+    }
+    function parseCgroupStat(text) {
+      const out = /* @__PURE__ */ new Map();
+      for (const rawLine of text.split("\n")) {
+        const line = rawLine.trim();
+        if (line.length === 0) continue;
+        const space = line.indexOf(" ");
+        if (space <= 0) continue;
+        const key = line.slice(0, space);
+        const value = Number(line.slice(space + 1).trim());
+        if (!Number.isFinite(value)) continue;
+        out.set(key, value);
+      }
+      return out;
+    }
+    function parseCgroupScalar(text) {
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return null;
+      if (trimmed === "max") return null;
+      const value = Number(trimmed);
+      if (!Number.isFinite(value) || value < 0) return null;
+      if (value >= V1_UNLIMITED_SENTINEL) return null;
+      return value;
+    }
+    function parseI915GemObjects(text) {
+      const match = text.match(/^\s*\d+\s+shrinkable\b[^,\n]*,\s*(\d+)\s+bytes/m);
+      if (match === null) return null;
+      const bytes = Number(match[1]);
+      return Number.isFinite(bytes) ? bytes : null;
+    }
+    function resolveCgroupMemoryLayout(fs) {
+      const selfText = fs.read("/proc/self/cgroup");
+      if (selfText === null) return null;
+      const entry = parseCgroupSelf(selfText);
+      if (entry === null) return null;
+      const suffix = entry.path === "/" ? "" : entry.path;
+      const candidates = entry.version === "v2" ? [`${CGROUP_MOUNT_ROOT}${suffix}`, CGROUP_MOUNT_ROOT] : [`${CGROUP_MOUNT_ROOT}/memory${suffix}`, `${CGROUP_MOUNT_ROOT}/memory`];
+      const usageFile = entry.version === "v2" ? "memory.current" : "memory.usage_in_bytes";
+      const limitFile = entry.version === "v2" ? "memory.max" : "memory.limit_in_bytes";
+      for (const directory of candidates) {
+        if (fs.read(`${directory}/${usageFile}`) === null) continue;
+        return {
+          source: entry.version === "v2" ? "cgroup-v2" : "cgroup-v1",
+          directory,
+          currentPath: `${directory}/${usageFile}`,
+          limitPath: `${directory}/${limitFile}`,
+          statPath: `${directory}/memory.stat`
+        };
+      }
+      return null;
+    }
+    function statValue(stat, key) {
+      const value = stat.get(key);
+      return value === void 0 ? null : value;
+    }
+    function resolveSlab(stat) {
+      const direct = statValue(stat, "slab");
+      if (direct !== null) return direct;
+      const reclaimable = stat.get("slab_reclaimable");
+      const unreclaimable = stat.get("slab_unreclaimable");
+      if (reclaimable === void 0 || unreclaimable === void 0) return null;
+      return reclaimable + unreclaimable;
+    }
+    function buildContainerMemorySnapshot(input) {
+      const currentBytes = parseCgroupScalar(input.currentText);
+      if (currentBytes === null) return null;
+      const stat = input.statText === null ? /* @__PURE__ */ new Map() : parseCgroupStat(input.statText);
+      const isV2 = input.source === "cgroup-v2";
+      return {
+        source: input.source,
+        currentBytes,
+        limitBytes: input.limitText === null ? null : parseCgroupScalar(input.limitText),
+        anonBytes: statValue(stat, isV2 ? "anon" : "rss"),
+        fileBytes: statValue(stat, isV2 ? "file" : "cache"),
+        shmemBytes: statValue(stat, "shmem"),
+        slabBytes: isV2 ? resolveSlab(stat) : null,
+        gpuShmemBytes: input.gpuShmemBytes
+      };
+    }
+    var ContainerMemoryProbe = class {
+      logger;
+      fs;
+      wantGpu;
+      resolved = false;
+      layout = null;
+      gpuProbed = false;
+      gpuReadable = false;
+      /** `null` until the first sample — so the FIRST outcome is a transition too. */
+      lastReadOk = null;
+      constructor(deps) {
+        this.logger = deps.logger;
+        this.fs = deps.fs ?? nodeCgroupFileReader;
+        this.wantGpu = deps.readGpu ?? true;
+      }
+      /** Did this node resolve a cgroup at all? Absent is a reportable fact. */
+      get available() {
+        return this.layout !== null;
+      }
+      /**
+      * One reading, or `null` when this node has no cgroup or the cgroup stopped
+      * answering. `null` is ABSENT — the caller contributes no point, and no
+      * point is what a chart must show, never a zero.
+      */
+      sample() {
+        const layout = this.resolveOnce();
+        if (layout === null) return null;
+        const currentText = this.fs.read(layout.currentPath);
+        if (currentText === null) {
+          this.noteRead(false, `unreadable: ${layout.currentPath}`);
+          return null;
+        }
+        const snapshot = buildContainerMemorySnapshot({
+          source: layout.source,
+          currentText,
+          limitText: this.fs.read(layout.limitPath),
+          statText: this.fs.read(layout.statPath),
+          gpuShmemBytes: this.readGpuShmem()
+        });
+        if (snapshot === null) {
+          this.noteRead(false, `unparseable: ${layout.currentPath}`);
+          return null;
+        }
+        this.noteRead(true, null);
+        return snapshot;
+      }
+      /** Resolve on first use and never again — a cgroup does not move under a pid. */
+      resolveOnce() {
+        if (this.resolved) return this.layout;
+        this.resolved = true;
+        try {
+          this.layout = resolveCgroupMemoryLayout(this.fs);
+        } catch (err) {
+          this.layout = null;
+          this.logger.warn("cgroup memory resolution failed \u2014 container memory will be ABSENT", { meta: { error: require_dist10.errMsg(err) } });
+          return null;
+        }
+        if (this.layout === null) {
+          this.logger.info("no cgroup on this node \u2014 container memory is ABSENT, not zero, for every sample", { meta: {
+            platform: process.platform,
+            probed: "/proc/self/cgroup"
+          } });
+          return null;
+        }
+        this.logger.info("container memory resolved from the cgroup", { meta: {
+          source: this.layout.source,
+          directory: this.layout.directory
+        } });
+        return this.layout;
+      }
+      /**
+      * The GPU number, probed once.
+      *
+      * It is host-wide and lives in debugfs, so it is absent far more often than
+      * it is present — inside every camstack container today. One `open` decides
+      * it for the life of the process; after that an unreadable file costs
+      * nothing at all, not even a syscall.
+      */
+      readGpuShmem() {
+        if (!this.wantGpu) return null;
+        if (!this.gpuProbed) {
+          this.gpuProbed = true;
+          const text2 = this.fs.read(I915_GEM_OBJECTS_PATH);
+          this.gpuReadable = text2 !== null && parseI915GemObjects(text2) !== null;
+          this.logger.info(this.gpuReadable ? "i915 GEM accounting is readable \u2014 GPU-backed shmem will be reported" : "i915 GEM accounting is NOT readable \u2014 gpuShmemBytes stays UNKNOWN (this is normal: debugfs is not mounted in the container, and a node with no Intel GPU has no such file)", { meta: { path: I915_GEM_OBJECTS_PATH } });
+          if (!this.gpuReadable) return null;
+          return text2 === null ? null : parseI915GemObjects(text2);
+        }
+        if (!this.gpuReadable) return null;
+        const text = this.fs.read(I915_GEM_OBJECTS_PATH);
+        return text === null ? null : parseI915GemObjects(text);
+      }
+      /** Log a read outcome only when it CHANGES. Never once per tick. */
+      noteRead(ok, reason) {
+        if (this.lastReadOk === ok) return;
+        const first = this.lastReadOk === null;
+        this.lastReadOk = ok;
+        if (!ok) {
+          this.logger.warn("cgroup memory stopped answering \u2014 container memory is ABSENT until it returns", { meta: { reason: reason ?? "unknown" } });
+          return;
+        }
+        if (!first) this.logger.info("cgroup memory is answering again");
+      }
+    };
+    var LoadPartition = class {
+      capacity;
+      slots;
+      head = 0;
+      count = 0;
+      rows = 0;
+      /** Newest retained sample's timestamp — the monotonic gate for `push`. */
+      newestAtMs = null;
+      constructor(capacity) {
+        this.capacity = capacity;
+        this.slots = Array.from({ length: capacity });
+      }
+      /**
+      * Accept a sample.
+      *
+      * A sample at or before the newest one already held is REFUSED. The bus drops
+      * a node's own broadcast echo, but a cross-node redelivery or a replayed
+      * subscription must not be able to double a point — and idempotence here is
+      * what lets every reader above treat the series as a set.
+      *
+      * `accepted` is reported separately from `rowDelta` on purpose: a full ring
+      * that evicts a sample of the same size has a delta of zero and is not a
+      * refusal, and conflating the two would silently stop advancing the write
+      * ordinal on a steady-state cluster.
+      */
+      push(sample) {
+        if (this.newestAtMs !== null && sample.atMs <= this.newestAtMs) return {
+          accepted: false,
+          rowDelta: 0
+        };
+        const evicted = this.count === this.capacity ? this.slots[this.head]?.processes.length ?? 0 : 0;
+        this.slots[this.head] = sample;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.count < this.capacity) this.count++;
+        this.newestAtMs = sample.atMs;
+        const rowDelta = sample.processes.length - evicted;
+        this.rows += rowDelta;
+        return {
+          accepted: true,
+          rowDelta
+        };
+      }
+      /** Drop the oldest sample. Returns the rows reclaimed (0 when empty). */
+      dropOldest() {
+        if (this.count === 0) return 0;
+        const index = (this.head - this.count + this.capacity) % this.capacity;
+        const victim = this.slots[index];
+        this.slots[index] = void 0;
+        this.count--;
+        const reclaimed = victim?.processes.length ?? 0;
+        this.rows -= reclaimed;
+        if (this.count === 0) this.newestAtMs = null;
+        return reclaimed;
+      }
+      /** Oldest-first, optionally only what is strictly newer than `sinceMs`. */
+      list(sinceMs) {
+        const out = [];
+        for (let i = 0; i < this.count; i++) {
+          const index = (this.head - this.count + i + this.capacity) % this.capacity;
+          const sample = this.slots[index];
+          if (sample === void 0) continue;
+          if (sinceMs !== void 0 && sample.atMs <= sinceMs) continue;
+          out.push(sample);
+        }
+        return out;
+      }
+      size() {
+        return this.count;
+      }
+      rowCount() {
+        return this.rows;
+      }
+      oldestAtMs() {
+        if (this.count === 0) return null;
+        const index = (this.head - this.count + this.capacity) % this.capacity;
+        return this.slots[index]?.atMs ?? null;
+      }
+      lastWriteAtMs() {
+        return this.newestAtMs;
+      }
+    };
+    var NodeLoadRing = class {
+      partitions = /* @__PURE__ */ new Map();
+      /**
+      * Node id → write ordinal of its last accepted sample. A monotonic counter,
+      * not a clock: partition eviction must follow the order writes actually
+      * happened, and node clocks disagree.
+      */
+      lastWriteSeq = /* @__PURE__ */ new Map();
+      writeSeq = 0;
+      totalRows = 0;
+      samplesPerNode;
+      maxTotalProcessRows;
+      maxNodes;
+      idleEvictionMs;
+      now;
+      constructor(options = {}) {
+        this.samplesPerNode = options.samplesPerNode ?? 180;
+        this.maxTotalProcessRows = options.maxTotalProcessRows ?? 32e3;
+        this.maxNodes = options.maxNodes ?? 16;
+        this.idleEvictionMs = options.idleEvictionMs ?? 36e5;
+        this.now = options.now ?? Date.now;
+      }
+      /**
+      * Retain one snapshot. `processes` is stored by reference — the payload is
+      * already an immutable arrival off the bus, and copying it would double the
+      * measured cost for nothing.
+      *
+      * Returns whether the sample was ACCEPTED — that is, whether it was new
+      * rather than a replay of a timestamp this node has already delivered.
+      *
+      * The return value is not diagnostics. It is the idempotence gate the
+      * DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
+      * appended to the table, which is what lets that table carry an `INTEGER`
+      * rowid key instead of a composite unique index over two million rows. The
+      * gate is one monotonic comparison in memory; the index it replaces was
+      * measured at ~40 bytes per row.
+      */
+      record(nodeId, atMs, processes) {
+        if (nodeId.length === 0) return false;
+        this.sweepIdle();
+        let partition = this.partitions.get(nodeId);
+        if (partition === void 0) {
+          partition = new LoadPartition(this.samplesPerNode);
+          this.partitions.set(nodeId, partition);
+        }
+        const outcome = partition.push({
+          atMs,
+          processes
+        });
+        if (!outcome.accepted) {
+          if (partition.size() === 0) this.partitions.delete(nodeId);
+          return false;
+        }
+        this.totalRows += outcome.rowDelta;
+        this.lastWriteSeq.set(nodeId, ++this.writeSeq);
+        if (this.partitions.size > this.maxNodes) this.evictPartitions(this.partitions.size - this.maxNodes, nodeId);
+        this.enforceRowBudget();
+        return true;
+      }
+      /**
+      * Read one node's retained series, oldest-first.
+      *
+      * `sinceMs` is EXCLUSIVE: a caller passes the newest timestamp it already
+      * holds and gets back only what it is missing. That is the whole contract
+      * that lets the admin UI seed from here and then continue live without
+      * doubling a point it already drew.
+      *
+      * A node nobody has recorded answers with an empty series, not an error —
+      * unknown is the truth about a node that has not reported.
+      */
+      read(nodeId, sinceMs) {
+        this.sweepIdle();
+        const partition = this.partitions.get(nodeId);
+        if (partition === void 0) return {
+          nodeId,
+          samples: [],
+          retainedSamples: 0,
+          oldestAtMs: null,
+          capacity: this.samplesPerNode
+        };
+        return {
+          nodeId,
+          samples: partition.list(sinceMs),
+          retainedSamples: partition.size(),
+          oldestAtMs: partition.oldestAtMs(),
+          capacity: this.samplesPerNode
+        };
+      }
+      /** Node ids with a live partition. Observability for the fleet bound. */
+      nodeIds() {
+        return [...this.partitions.keys()];
+      }
+      /** Process rows retained across every partition — the number that IS memory. */
+      rowCount() {
+        return this.totalRows;
+      }
+      /** Samples retained across every partition. */
+      sampleCount() {
+        let total = 0;
+        for (const partition of this.partitions.values()) total += partition.size();
+        return total;
+      }
+      /**
+      * Drop partitions whose newest sample is older than the retention window.
+      *
+      * Lazy, on write and on read — never a timer. A timer would be a new
+      * periodic cost in a subsystem whose entire premise is that it adds none,
+      * and a ring that nobody writes to and nobody reads is not growing either.
+      */
+      sweepIdle() {
+        const cutoff = this.now() - this.idleEvictionMs;
+        for (const [nodeId, partition] of [...this.partitions.entries()]) {
+          const lastWrite = partition.lastWriteAtMs();
+          if (lastWrite !== null && lastWrite > cutoff) continue;
+          this.dropPartition(nodeId);
+        }
+      }
+      /**
+      * Bring the fleet back under the row budget by dropping the OLDEST sample of
+      * the HEAVIEST partition, repeatedly.
+      *
+      * Terminates: every iteration removes one sample from a non-empty partition,
+      * and the population of samples is finite and strictly decreasing.
+      */
+      enforceRowBudget() {
+        while (this.totalRows > this.maxTotalProcessRows) {
+          const victim = this.heaviestPartition();
+          if (victim === null) return;
+          const [nodeId, partition] = victim;
+          this.totalRows -= partition.dropOldest();
+          if (partition.size() === 0) this.dropPartition(nodeId);
+        }
+      }
+      heaviestPartition() {
+        let best = null;
+        for (const entry of this.partitions.entries()) {
+          if (entry[1].size() === 0) continue;
+          if (best === null || entry[1].rowCount() > best[1].rowCount()) best = entry;
+        }
+        return best;
+      }
+      /** Drop `count` whole partitions, least-recently-written first. */
+      evictPartitions(count, protectedNodeId) {
+        const order = [...this.partitions.keys()].filter((nodeId) => nodeId !== protectedNodeId).toSorted((a, b) => (this.lastWriteSeq.get(a) ?? 0) - (this.lastWriteSeq.get(b) ?? 0));
+        let remaining = count;
+        for (const nodeId of order) {
+          if (remaining <= 0) return;
+          this.dropPartition(nodeId);
+          remaining -= 1;
+        }
+      }
+      /** Remove a partition and everything that indexes it. */
+      dropPartition(nodeId) {
+        const partition = this.partitions.get(nodeId);
+        if (partition === void 0) return;
+        this.totalRows -= partition.rowCount();
+        this.partitions.delete(nodeId);
+        this.lastWriteSeq.delete(nodeId);
+      }
+    };
+    var CONTAINER_MEMORY_COLLECTION = "metrics:node-memory-samples";
+    var CONTAINER_MEMORY_MAX_TOTAL_ROWS = 2880;
+    var CONTAINER_MEMORY_MAX_ROWS = 5e4;
+    var CONTAINER_MEMORY_COLUMNS = [
+      {
+        name: "id",
+        type: "INTEGER",
+        primaryKey: true,
+        notNull: true
+      },
+      {
+        name: "nodeId",
+        type: "TEXT",
+        notNull: true
+      },
+      /** Shared with the process rows of the same tick — that is the whole point. */
+      {
+        name: "atMs",
+        type: "INTEGER",
+        notNull: true
+      },
+      {
+        name: "source",
+        type: "TEXT",
+        notNull: true
+      },
+      /**
+      * Whole MiB, like `rssMib` on the process row and for the same reason: a
+      * byte-exact residency on a value in the tens of gigabytes is precision no
+      * chart can draw, and it costs bytes on every row forever.
+      */
+      {
+        name: "currentMib",
+        type: "INTEGER",
+        notNull: true
+      },
+      /** `NULL` = NO LIMIT. Never a sentinel. */
+      {
+        name: "limitMib",
+        type: "INTEGER"
+      },
+      /** `NULL` = UNKNOWN on all four. Never zero. */
+      {
+        name: "anonMib",
+        type: "INTEGER"
+      },
+      {
+        name: "fileMib",
+        type: "INTEGER"
+      },
+      {
+        name: "shmemMib",
+        type: "INTEGER"
+      },
+      {
+        name: "slabMib",
+        type: "INTEGER"
+      },
+      /** Host-wide i915 GEM bytes. `NULL` wherever debugfs is not mounted. */
+      {
+        name: "gpuShmemMib",
+        type: "INTEGER"
+      }
+    ];
+    var CONTAINER_MEMORY_INDEXES = [
+      /** The one index, and it serves both the read and the prune — see the
+      *  process table's `idx_load_samples_node_at` for the full reasoning. */
+      {
+        name: "idx_node_memory_node_at",
+        columns: ["nodeId", "atMs"]
+      }
+    ];
+    var BYTES_PER_MIB$1 = 1048576;
+    function toMib(value) {
+      return value === null ? null : Math.round(value / BYTES_PER_MIB$1);
+    }
+    function fromMib(value) {
+      return value === null ? null : value * BYTES_PER_MIB$1;
+    }
+    function snapshotToRow(nodeId, atMs, snapshot) {
+      return {
+        nodeId,
+        atMs,
+        source: snapshot.source,
+        currentMib: Math.round(snapshot.currentBytes / BYTES_PER_MIB$1),
+        limitMib: toMib(snapshot.limitBytes),
+        anonMib: toMib(snapshot.anonBytes),
+        fileMib: toMib(snapshot.fileBytes),
+        shmemMib: toMib(snapshot.shmemBytes),
+        slabMib: toMib(snapshot.slabBytes),
+        gpuShmemMib: toMib(snapshot.gpuShmemBytes)
+      };
+    }
+    function rowToPoint(row) {
+      if (row.source !== "cgroup-v2" && row.source !== "cgroup-v1") return null;
+      return {
+        atMs: row.atMs,
+        source: row.source,
+        currentBytes: row.currentMib * BYTES_PER_MIB$1,
+        limitBytes: fromMib(row.limitMib),
+        anonBytes: fromMib(row.anonMib),
+        fileBytes: fromMib(row.fileMib),
+        shmemBytes: fromMib(row.shmemMib),
+        slabBytes: fromMib(row.slabMib),
+        gpuShmemBytes: fromMib(row.gpuShmemMib)
+      };
+    }
+    function recordToMemoryRow(data) {
+      const nodeId = data["nodeId"];
+      const source = data["source"];
+      if (typeof nodeId !== "string" || typeof source !== "string") return null;
+      const atMs = Number(data["atMs"]);
+      const currentMib = Number(data["currentMib"]);
+      if (!Number.isFinite(atMs) || !Number.isFinite(currentMib)) return null;
+      const optional = (raw) => {
+        if (raw === null || raw === void 0) return null;
+        const n = Number(raw);
+        return Number.isFinite(n) ? n : null;
+      };
+      return {
+        nodeId,
+        atMs,
+        source,
+        currentMib,
+        limitMib: optional(data["limitMib"]),
+        anonMib: optional(data["anonMib"]),
+        fileMib: optional(data["fileMib"]),
+        shmemMib: optional(data["shmemMib"]),
+        slabMib: optional(data["slabMib"]),
+        gpuShmemMib: optional(data["gpuShmemMib"])
+      };
+    }
+    var ContainerMemoryRing = class {
+      ring;
+      constructor(options = {}) {
+        this.ring = new NodeLoadRing({
+          samplesPerNode: options.samplesPerNode ?? 180,
+          maxTotalProcessRows: CONTAINER_MEMORY_MAX_TOTAL_ROWS,
+          ...options.now !== void 0 ? { now: options.now } : {}
+        });
+      }
+      /** Retain one reading. `false` = a timestamp this node already delivered. */
+      record(nodeId, atMs, snapshot) {
+        return this.ring.record(nodeId, atMs, [snapshot]);
+      }
+      /**
+      * Read one node's retained readings, oldest-first. `sinceMs` is EXCLUSIVE,
+      * matching every other reader in this subsystem.
+      *
+      * A node nobody has recorded answers EMPTY — which is what "this node has no
+      * cgroup" looks like, and it must stay distinguishable from a zero.
+      */
+      read(nodeId, sinceMs) {
+        const series = this.ring.read(nodeId, sinceMs);
+        const out = [];
+        for (const sample of series.samples) {
+          const snapshot = sample.processes[0];
+          if (snapshot === void 0) continue;
+          out.push({
+            ...snapshot,
+            atMs: sample.atMs
+          });
+        }
+        return out;
+      }
+    };
+    function reduceContainerMemory(points, bucketMs, origin) {
+      if (bucketMs <= 0 || points.length === 0) return points;
+      const buckets = /* @__PURE__ */ new Map();
+      for (const point of points) {
+        const start = origin + Math.floor((point.atMs - origin) / bucketMs) * bucketMs;
+        const held = buckets.get(start);
+        if (held === void 0 || point.currentBytes > held.currentBytes) buckets.set(start, {
+          ...point,
+          atMs: start
+        });
+      }
+      return [...buckets.values()].toSorted((a, b) => a.atMs - b.atMs);
+    }
+    function mergeContainerMemory(cold, hot) {
+      const byAt = /* @__PURE__ */ new Map();
+      for (const point of cold) byAt.set(point.atMs, point);
+      for (const point of hot) byAt.set(point.atMs, point);
+      return [...byAt.values()].toSorted((a, b) => a.atMs - b.atMs);
+    }
+    var ContainerMemoryStore = class {
+      declared = false;
+      store;
+      logger;
+      nowFn;
+      prunePageRows;
+      constructor(deps) {
+        this.store = deps.store;
+        this.logger = deps.logger;
+        this.nowFn = deps.now ?? (() => Date.now());
+        this.prunePageRows = deps.prunePageRows ?? 2e4;
+      }
+      /** Idempotently declare the collection. `false` when the store refused. */
+      async declare() {
+        if (this.declared) return true;
+        try {
+          await this.store.declareCollection.mutate({
+            collection: CONTAINER_MEMORY_COLLECTION,
+            columns: [...CONTAINER_MEMORY_COLUMNS],
+            indexes: CONTAINER_MEMORY_INDEXES.map((i) => ({
+              name: i.name,
+              columns: [...i.columns]
+            }))
+          });
+          this.declared = true;
+          return true;
+        } catch (err) {
+          this.logger.warn("container memory declareCollection failed \u2014 nothing will be retained on disk", { meta: {
+            collection: CONTAINER_MEMORY_COLLECTION,
+            error: require_dist10.errMsg(err)
+          } });
+          return false;
+        }
+      }
+      /** Append ONE reading. */
+      async append(nodeId, atMs, snapshot) {
+        if (!await this.declare()) return 0;
+        const record = { ...snapshotToRow(nodeId, atMs, snapshot) };
+        try {
+          const { inserted } = await this.store.insertMany.mutate({
+            collection: CONTAINER_MEMORY_COLLECTION,
+            records: [{ data: record }]
+          });
+          return inserted;
+        } catch (err) {
+          this.logger.warn("container memory reading not retained \u2014 this interval will be missing", { meta: {
+            nodeId,
+            atMs,
+            error: require_dist10.errMsg(err)
+          } });
+          return 0;
+        }
+      }
+      /** Read one node's cold readings, oldest-first. `sinceMs` is EXCLUSIVE. */
+      async read(nodeId, sinceMs, limitRows) {
+        if (!await this.declare()) return [];
+        try {
+          const records = await this.store.query.query({
+            collection: CONTAINER_MEMORY_COLLECTION,
+            filter: {
+              where: { nodeId },
+              whereBetween: { atMs: [sinceMs + 1, Number.MAX_SAFE_INTEGER] },
+              orderBy: {
+                field: "atMs",
+                direction: "asc"
+              },
+              limit: limitRows
+            }
+          });
+          const points = [];
+          for (const record of records) {
+            const row = recordToMemoryRow(record.data);
+            if (row === null) continue;
+            const point = rowToPoint(row);
+            if (point !== null) points.push(point);
+          }
+          return points;
+        } catch (err) {
+          this.logger.warn("container memory cold read failed \u2014 answering from the hot window only", { meta: {
+            nodeId,
+            sinceMs,
+            error: require_dist10.errMsg(err)
+          } });
+          return [];
+        }
+      }
+      /**
+      * Enforce BOTH bounds, oldest-first, through a bounded page each.
+      *
+      * Not rate-limited here: it is driven by the process store's own prune
+      * cadence, so it runs at most once a minute by construction and a second
+      * timer would be a second thing to get wrong.
+      */
+      async prune(nodeIds, retention) {
+        if (!await this.declare()) return null;
+        const ageCutoff = this.nowFn() - retention.retentionHours * 36e5;
+        let deletedByAge = 0;
+        let rowsExamined = 0;
+        for (const nodeId of nodeIds) {
+          const outcome = await this.deleteOldestPage(nodeId, ageCutoff, this.prunePageRows);
+          deletedByAge += outcome.deleted;
+          rowsExamined += outcome.examined;
+        }
+        const total = await this.count();
+        const excess = total === null ? 0 : total - CONTAINER_MEMORY_MAX_ROWS;
+        let deletedByCap = 0;
+        if (excess > 0) {
+          let remaining = Math.min(excess, this.prunePageRows);
+          for (const nodeId of nodeIds) {
+            if (remaining <= 0) break;
+            const outcome = await this.deleteOldestPage(nodeId, null, remaining);
+            deletedByCap += outcome.deleted;
+            remaining -= outcome.deleted;
+            rowsExamined += outcome.examined;
+          }
+          this.logger.warn("container memory ROW CAP bit \u2014 evicting the oldest readings", { meta: {
+            collection: CONTAINER_MEMORY_COLLECTION,
+            rows: total,
+            cap: CONTAINER_MEMORY_MAX_ROWS,
+            over: excess,
+            deleted: deletedByCap,
+            hint: "lower the retention or the sampling cadence \u2014 the cap is the guarantee, not the intention"
+          } });
+        }
+        return {
+          deletedByAge,
+          deletedByCap,
+          rowsExamined,
+          capBit: excess > 0
+        };
+      }
+      /** Total rows, or `null` when the store could not answer. */
+      async count() {
+        if (!await this.declare()) return null;
+        try {
+          return await this.store.count.query({ collection: CONTAINER_MEMORY_COLLECTION });
+        } catch (err) {
+          this.logger.warn("container memory count failed \u2014 the row cap is not enforced this pass", { meta: { error: require_dist10.errMsg(err) } });
+          return null;
+        }
+      }
+      /**
+      * Delete this node's oldest rows, at most one page's worth.
+      *
+      * `cutoff === null` means "the oldest rows, whatever their age" — the
+      * row-cap path, which is bounded by `limitRows` instead. Either way the page
+      * is READ FIRST, ordered by the one index, and its last `atMs` becomes the
+      * effective cutoff for a single bounded delete. An unbounded `deleteWhere`
+      * would be one statement and one stalling transaction the first time a
+      * retention is lowered.
+      */
+      async deleteOldestPage(nodeId, cutoff, limitRows) {
+        if (limitRows <= 0) return {
+          deleted: 0,
+          examined: 0
+        };
+        try {
+          const page = await this.store.query.query({
+            collection: CONTAINER_MEMORY_COLLECTION,
+            filter: {
+              where: { nodeId },
+              ...cutoff === null ? {} : { whereBetween: { atMs: [0, cutoff] } },
+              orderBy: {
+                field: "atMs",
+                direction: "asc"
+              },
+              limit: Math.min(limitRows, this.prunePageRows)
+            },
+            columns: ["atMs"]
+          });
+          if (page.length === 0) return {
+            deleted: 0,
+            examined: 0
+          };
+          const effectiveCutoff = Number(page.at(-1)?.data["atMs"]);
+          if (!Number.isFinite(effectiveCutoff)) return {
+            deleted: 0,
+            examined: page.length
+          };
+          const { deleted } = await this.store.deleteWhere.mutate({
+            collection: CONTAINER_MEMORY_COLLECTION,
+            filter: {
+              where: { nodeId },
+              whereBetween: { atMs: [0, effectiveCutoff] }
+            }
+          });
+          return {
+            deleted,
+            examined: page.length
+          };
+        } catch (err) {
+          this.logger.warn("container memory prune failed \u2014 the table keeps growing this pass", { meta: {
+            nodeId,
+            cutoff,
+            error: require_dist10.errMsg(err)
+          } });
+          return {
+            deleted: 0,
+            examined: 0
+          };
+        }
+      }
+    };
     var IS_DARWIN = node_os.platform() === "darwin";
     var IS_LINUX = node_os.platform() === "linux";
     var NativeMetricsProvider = class {
@@ -76594,247 +77486,6 @@ var require_native_metrics_addon = __commonJS({
         });
       });
     }
-    var LoadPartition = class {
-      capacity;
-      slots;
-      head = 0;
-      count = 0;
-      rows = 0;
-      /** Newest retained sample's timestamp — the monotonic gate for `push`. */
-      newestAtMs = null;
-      constructor(capacity) {
-        this.capacity = capacity;
-        this.slots = Array.from({ length: capacity });
-      }
-      /**
-      * Accept a sample.
-      *
-      * A sample at or before the newest one already held is REFUSED. The bus drops
-      * a node's own broadcast echo, but a cross-node redelivery or a replayed
-      * subscription must not be able to double a point — and idempotence here is
-      * what lets every reader above treat the series as a set.
-      *
-      * `accepted` is reported separately from `rowDelta` on purpose: a full ring
-      * that evicts a sample of the same size has a delta of zero and is not a
-      * refusal, and conflating the two would silently stop advancing the write
-      * ordinal on a steady-state cluster.
-      */
-      push(sample) {
-        if (this.newestAtMs !== null && sample.atMs <= this.newestAtMs) return {
-          accepted: false,
-          rowDelta: 0
-        };
-        const evicted = this.count === this.capacity ? this.slots[this.head]?.processes.length ?? 0 : 0;
-        this.slots[this.head] = sample;
-        this.head = (this.head + 1) % this.capacity;
-        if (this.count < this.capacity) this.count++;
-        this.newestAtMs = sample.atMs;
-        const rowDelta = sample.processes.length - evicted;
-        this.rows += rowDelta;
-        return {
-          accepted: true,
-          rowDelta
-        };
-      }
-      /** Drop the oldest sample. Returns the rows reclaimed (0 when empty). */
-      dropOldest() {
-        if (this.count === 0) return 0;
-        const index = (this.head - this.count + this.capacity) % this.capacity;
-        const victim = this.slots[index];
-        this.slots[index] = void 0;
-        this.count--;
-        const reclaimed = victim?.processes.length ?? 0;
-        this.rows -= reclaimed;
-        if (this.count === 0) this.newestAtMs = null;
-        return reclaimed;
-      }
-      /** Oldest-first, optionally only what is strictly newer than `sinceMs`. */
-      list(sinceMs) {
-        const out = [];
-        for (let i = 0; i < this.count; i++) {
-          const index = (this.head - this.count + i + this.capacity) % this.capacity;
-          const sample = this.slots[index];
-          if (sample === void 0) continue;
-          if (sinceMs !== void 0 && sample.atMs <= sinceMs) continue;
-          out.push(sample);
-        }
-        return out;
-      }
-      size() {
-        return this.count;
-      }
-      rowCount() {
-        return this.rows;
-      }
-      oldestAtMs() {
-        if (this.count === 0) return null;
-        const index = (this.head - this.count + this.capacity) % this.capacity;
-        return this.slots[index]?.atMs ?? null;
-      }
-      lastWriteAtMs() {
-        return this.newestAtMs;
-      }
-    };
-    var NodeLoadRing = class {
-      partitions = /* @__PURE__ */ new Map();
-      /**
-      * Node id → write ordinal of its last accepted sample. A monotonic counter,
-      * not a clock: partition eviction must follow the order writes actually
-      * happened, and node clocks disagree.
-      */
-      lastWriteSeq = /* @__PURE__ */ new Map();
-      writeSeq = 0;
-      totalRows = 0;
-      samplesPerNode;
-      maxTotalProcessRows;
-      maxNodes;
-      idleEvictionMs;
-      now;
-      constructor(options = {}) {
-        this.samplesPerNode = options.samplesPerNode ?? 180;
-        this.maxTotalProcessRows = options.maxTotalProcessRows ?? 32e3;
-        this.maxNodes = options.maxNodes ?? 16;
-        this.idleEvictionMs = options.idleEvictionMs ?? 36e5;
-        this.now = options.now ?? Date.now;
-      }
-      /**
-      * Retain one snapshot. `processes` is stored by reference — the payload is
-      * already an immutable arrival off the bus, and copying it would double the
-      * measured cost for nothing.
-      *
-      * Returns whether the sample was ACCEPTED — that is, whether it was new
-      * rather than a replay of a timestamp this node has already delivered.
-      *
-      * The return value is not diagnostics. It is the idempotence gate the
-      * DURABLE tier rides on (`load-series-store.ts`): only an accepted sample is
-      * appended to the table, which is what lets that table carry an `INTEGER`
-      * rowid key instead of a composite unique index over two million rows. The
-      * gate is one monotonic comparison in memory; the index it replaces was
-      * measured at ~40 bytes per row.
-      */
-      record(nodeId, atMs, processes) {
-        if (nodeId.length === 0) return false;
-        this.sweepIdle();
-        let partition = this.partitions.get(nodeId);
-        if (partition === void 0) {
-          partition = new LoadPartition(this.samplesPerNode);
-          this.partitions.set(nodeId, partition);
-        }
-        const outcome = partition.push({
-          atMs,
-          processes
-        });
-        if (!outcome.accepted) {
-          if (partition.size() === 0) this.partitions.delete(nodeId);
-          return false;
-        }
-        this.totalRows += outcome.rowDelta;
-        this.lastWriteSeq.set(nodeId, ++this.writeSeq);
-        if (this.partitions.size > this.maxNodes) this.evictPartitions(this.partitions.size - this.maxNodes, nodeId);
-        this.enforceRowBudget();
-        return true;
-      }
-      /**
-      * Read one node's retained series, oldest-first.
-      *
-      * `sinceMs` is EXCLUSIVE: a caller passes the newest timestamp it already
-      * holds and gets back only what it is missing. That is the whole contract
-      * that lets the admin UI seed from here and then continue live without
-      * doubling a point it already drew.
-      *
-      * A node nobody has recorded answers with an empty series, not an error —
-      * unknown is the truth about a node that has not reported.
-      */
-      read(nodeId, sinceMs) {
-        this.sweepIdle();
-        const partition = this.partitions.get(nodeId);
-        if (partition === void 0) return {
-          nodeId,
-          samples: [],
-          retainedSamples: 0,
-          oldestAtMs: null,
-          capacity: this.samplesPerNode
-        };
-        return {
-          nodeId,
-          samples: partition.list(sinceMs),
-          retainedSamples: partition.size(),
-          oldestAtMs: partition.oldestAtMs(),
-          capacity: this.samplesPerNode
-        };
-      }
-      /** Node ids with a live partition. Observability for the fleet bound. */
-      nodeIds() {
-        return [...this.partitions.keys()];
-      }
-      /** Process rows retained across every partition — the number that IS memory. */
-      rowCount() {
-        return this.totalRows;
-      }
-      /** Samples retained across every partition. */
-      sampleCount() {
-        let total = 0;
-        for (const partition of this.partitions.values()) total += partition.size();
-        return total;
-      }
-      /**
-      * Drop partitions whose newest sample is older than the retention window.
-      *
-      * Lazy, on write and on read — never a timer. A timer would be a new
-      * periodic cost in a subsystem whose entire premise is that it adds none,
-      * and a ring that nobody writes to and nobody reads is not growing either.
-      */
-      sweepIdle() {
-        const cutoff = this.now() - this.idleEvictionMs;
-        for (const [nodeId, partition] of [...this.partitions.entries()]) {
-          const lastWrite = partition.lastWriteAtMs();
-          if (lastWrite !== null && lastWrite > cutoff) continue;
-          this.dropPartition(nodeId);
-        }
-      }
-      /**
-      * Bring the fleet back under the row budget by dropping the OLDEST sample of
-      * the HEAVIEST partition, repeatedly.
-      *
-      * Terminates: every iteration removes one sample from a non-empty partition,
-      * and the population of samples is finite and strictly decreasing.
-      */
-      enforceRowBudget() {
-        while (this.totalRows > this.maxTotalProcessRows) {
-          const victim = this.heaviestPartition();
-          if (victim === null) return;
-          const [nodeId, partition] = victim;
-          this.totalRows -= partition.dropOldest();
-          if (partition.size() === 0) this.dropPartition(nodeId);
-        }
-      }
-      heaviestPartition() {
-        let best = null;
-        for (const entry of this.partitions.entries()) {
-          if (entry[1].size() === 0) continue;
-          if (best === null || entry[1].rowCount() > best[1].rowCount()) best = entry;
-        }
-        return best;
-      }
-      /** Drop `count` whole partitions, least-recently-written first. */
-      evictPartitions(count, protectedNodeId) {
-        const order = [...this.partitions.keys()].filter((nodeId) => nodeId !== protectedNodeId).toSorted((a, b) => (this.lastWriteSeq.get(a) ?? 0) - (this.lastWriteSeq.get(b) ?? 0));
-        let remaining = count;
-        for (const nodeId of order) {
-          if (remaining <= 0) return;
-          this.dropPartition(nodeId);
-          remaining -= 1;
-        }
-      }
-      /** Remove a partition and everything that indexes it. */
-      dropPartition(nodeId) {
-        const partition = this.partitions.get(nodeId);
-        if (partition === void 0) return;
-        this.totalRows -= partition.rowCount();
-        this.partitions.delete(nodeId);
-        this.lastWriteSeq.delete(nodeId);
-      }
-    };
     var LOAD_SERIES_COLLECTION = "metrics:node-load-samples";
     var DEFAULT_MAX_ROWS = 5e5;
     var LOAD_SERIES_COLUMNS = [
@@ -77545,6 +78196,20 @@ var require_native_metrics_addon = __commonJS({
       * per sample, to reach that very same table.
       */
       loadStore = null;
+      /**
+      * The container's OWN memory, sampled on the process-snapshot tick.
+      *
+      * It rides that tick rather than a timer of its own so a memory reading and
+      * the process rows it must be compared against carry the SAME timestamp —
+      * the whole question is a subtraction, and two clocks make it an estimate.
+      * Constructed in `onInitialize`, where the logger exists; it resolves the
+      * cgroup once and latches.
+      */
+      memoryProbe = null;
+      /** Hot tier for the container reading. Bounds in `container-memory-series.ts`. */
+      memoryRing = new ContainerMemoryRing();
+      /** Cold tier, HUB only — same reasoning as `loadStore`. */
+      memoryStore = null;
       /** The resolved knobs. Re-resolved on every settings write. */
       loadConfig = {
         cadenceSec: 10,
@@ -77617,13 +78282,20 @@ var require_native_metrics_addon = __commonJS({
           dumpHeapSnapshot: (params) => this.dumpHeapSnapshot(params)
         };
         this.applyLoadSeriesConfig();
-        if (this.isHub) this.loadStore = new LoadSeriesStore({
-          store: this.ctx.api.settingsStore,
-          logger: this.ctx.logger.child("LoadSeries")
-        });
+        if (this.isHub) {
+          this.loadStore = new LoadSeriesStore({
+            store: this.ctx.api.settingsStore,
+            logger: this.ctx.logger.child("LoadSeries")
+          });
+          this.memoryStore = new ContainerMemoryStore({
+            store: this.ctx.api.settingsStore,
+            logger: this.ctx.logger.child("ContainerMemory")
+          });
+        }
+        this.memoryProbe = new ContainerMemoryProbe({ logger: this.ctx.logger.child("ContainerMemory") });
         this.snapshotTimer = setInterval(() => this.emitResourcesSnapshot(), METRICS_SNAPSHOT_INTERVAL_MS);
         this.startProcessSnapshotTimer();
-        this.ctx.addDisposer(this.ctx.eventBus.subscribe({ category: require_dist10.EventCategory.MetricsNodeProcessesSnapshot }, (event) => this.retainSnapshot(event.data.nodeId, event.data.timestamp, event.data.processes)));
+        this.ctx.addDisposer(this.ctx.eventBus.subscribe({ category: require_dist10.EventCategory.MetricsNodeProcessesSnapshot }, (event) => this.retainSnapshot(event.data.nodeId, event.data.timestamp, event.data.processes, event.data.containerMemory)));
         return [{
           capability: require_dist10.metricsProviderCapability,
           provider: composed
@@ -77641,19 +78313,31 @@ var require_native_metrics_addon = __commonJS({
       * The durable append is fire-and-forget: a storage stall must cost a gap in
       * the cold window, never a blocked event-bus handler. Every failure logs.
       */
-      retainSnapshot(nodeId, atMs, processes) {
+      retainSnapshot(nodeId, atMs, processes, containerMemory) {
         const retained = processes.map((p) => NativeMetricsAddon2.toRetained(p));
         if (!this.loadRing.record(nodeId, atMs, retained)) return;
         this.observedRowsByNode.set(nodeId, retained.length);
+        if (containerMemory !== null) this.memoryRing.record(nodeId, atMs, containerMemory);
         const store = this.loadStore;
         if (store === null) return;
-        store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).catch((err) => {
+        store.append(nodeId, atMs, retained).then(() => store.prune([...this.observedRowsByNode.keys()], this.loadConfig)).then(async (outcome) => {
+          if (outcome === null) return;
+          await this.memoryStore?.prune([...this.observedRowsByNode.keys()], this.loadConfig);
+        }).catch((err) => {
           this.ctx.logger.warn("durable load series write failed", { meta: {
             nodeId,
             atMs,
             error: err instanceof Error ? err.message : String(err)
           } });
         });
+        if (containerMemory === null) return;
+        this.memoryStore?.append(nodeId, atMs, containerMemory).catch((err) => {
+          this.ctx.logger.warn("durable container memory write failed", { meta: {
+            nodeId,
+            atMs,
+            error: err instanceof Error ? err.message : String(err)
+          } });
+        });
       }
       /**
       * The ONE reader, over both tiers.
@@ -77682,6 +78366,14 @@ var require_native_metrics_addon = __commonJS({
         return {
           nodeId: params.forNodeId,
           series: merged.series,
+          containerMemory: await this.readContainerMemory({
+            forNodeId: params.forNodeId,
+            sinceMs,
+            ...params.sinceMs !== void 0 ? { exclusiveSinceMs: params.sinceMs } : {},
+            bucketMs: merged.bucketMs,
+            cadenceMs,
+            origin: merged.oldestAtMs
+          }),
           bucketMs: merged.bucketMs,
           retainedSamples: merged.retainedSamples,
           oldestAtMs: merged.oldestAtMs,
@@ -77690,6 +78382,24 @@ var require_native_metrics_addon = __commonJS({
         };
       }
       /**
+      * The container's memory over the same window, on the same x-axis.
+      *
+      * Both tiers, merged and deduped on `atMs` like the process series, then
+      * reduced against the SAME `bucketMs` and the SAME origin — otherwise the
+      * two series in one answer would sit on two different axes and the
+      * subtraction they exist for would be an eyeball.
+      *
+      * An EMPTY answer means the node has no cgroup, or nothing has been retained
+      * for it yet. It never means zero.
+      */
+      async readContainerMemory(params) {
+        const hot = this.memoryRing.read(params.forNodeId, params.exclusiveSinceMs);
+        const store = this.memoryStore;
+        const merged = mergeContainerMemory(store === null ? [] : await store.read(params.forNodeId, params.sinceMs, CONTAINER_MEMORY_MAX_ROWS), hot);
+        if (params.bucketMs <= params.cadenceMs) return merged;
+        return reduceContainerMemory(merged, params.bucketMs, params.origin ?? 0);
+      }
+      /**
       * Re-resolve the knobs and restate the fixed cadence.
       *
       * A REFUSED value (out of 5-60 s, or out of 1-72 h) leaves the previous
@@ -77806,6 +78516,7 @@ var require_native_metrics_addon = __commonJS({
         const timestamp = Date.now();
         try {
           const processes = await this.listNodeProcesses();
+          const containerMemory = this.memoryProbe?.sample() ?? null;
           eventBus.emit(require_dist10.createEvent(require_dist10.EventCategory.MetricsNodeProcessesSnapshot, {
             type: "node",
             id: nodeId,
@@ -77813,7 +78524,8 @@ var require_native_metrics_addon = __commonJS({
           }, {
             nodeId,
             processes,
-            timestamp
+            timestamp,
+            containerMemory
           }));
         } catch (err) {
           this.ctx.logger.warn("process snapshot skipped \u2014 this interval will be missing", { meta: {
@@ -78079,14 +78791,14 @@ var require_filesystem_storage_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     var node_path = __require("path");
     node_path = require_chunk.__toESM(node_path);
-    var node_os = __require("os");
     var node_fs = __require("fs");
     node_fs = require_chunk.__toESM(node_fs);
+    var node_os = __require("os");
     function isWithinAllowedRoots(candidate, allowedRoots) {
       const norm = (0, node_path.resolve)(candidate);
       return allowedRoots.some((root) => {
@@ -79195,8 +79907,8 @@ var require_sqlite_settings_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
-    var require_retired_settings_keys = require_retired_settings_keys_C7gLUS3x();
+    var require_dist10 = require_dist_C7uZ_fOb();
+    var require_retired_settings_keys = require_retired_settings_keys_CBU4_TJO();
     var node_crypto = __require("crypto");
     var node_fs = __require("fs");
     var node_module = __require("module");
@@ -81475,7 +82187,7 @@ var require_storage_orchestrator_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var node_crypto = __require("crypto");
     var node_fs_promises = __require("fs/promises");
     node_fs_promises = require_chunk.__toESM(node_fs_promises);
@@ -83356,7 +84068,7 @@ var require_system_config_addon = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var SECTION_TITLES = {
       server: "Server",
       auth: "Authentication"
@@ -101417,7 +102129,7 @@ var require_winston_logging = __commonJS({
       [Symbol.toStringTag]: { value: "Module" }
     });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var require_formatter = require_formatter_DqAKDlvN();
     var node_path = __require("path");
     node_path = require_chunk.__toESM(node_path);
@@ -102447,9 +103159,9 @@ var require_file_data_plane_DO8KbxCe = __commonJS({
   }
 });
 
-// ../system/dist/tls-u8QCJCFE.js
-var require_tls_u8QCJCFE = __commonJS({
-  "../system/dist/tls-u8QCJCFE.js"(exports) {
+// ../system/dist/tls-BxQlomxd.js
+var require_tls_BxQlomxd = __commonJS({
+  "../system/dist/tls-BxQlomxd.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
     var node_crypto = __require("crypto");
@@ -102457,9 +103169,9 @@ var require_tls_u8QCJCFE = __commonJS({
     var node_path = __require("path");
     var node_child_process = __require("child_process");
     var node_util = __require("util");
+    var node_fs = __require("fs");
     var node_os = __require("os");
     node_os = require_chunk.__toESM(node_os);
-    var node_fs = __require("fs");
     var node_http = __require("http");
     var node_net = __require("net");
     var DEFAULT_HTTP_PORT = 4480;
@@ -113905,12 +114617,12 @@ var require_dist2 = __commonJS({
   }
 });
 
-// ../system/dist/manifest-python-deps-BqWrDjSN.js
-var require_manifest_python_deps_BqWrDjSN = __commonJS({
-  "../system/dist/manifest-python-deps-BqWrDjSN.js"(exports) {
+// ../system/dist/manifest-python-deps-CRTx_j4k.js
+var require_manifest_python_deps_CRTx_j4k = __commonJS({
+  "../system/dist/manifest-python-deps-CRTx_j4k.js"(exports) {
     "use strict";
     var require_chunk = require_chunk_Cek0wNdY();
-    require_dist_CImxMt5h();
+    require_dist_C7uZ_fOb();
     var node_crypto = __require("crypto");
     node_crypto = require_chunk.__toESM(node_crypto);
     var _camstack_types_node = require_node();
@@ -113919,19 +114631,166 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
     node_path = require_chunk.__toESM(node_path);
     var node_child_process = __require("child_process");
     var node_util = __require("util");
-    var node_os = __require("os");
-    node_os = require_chunk.__toESM(node_os);
     var node_fs = __require("fs");
     node_fs = require_chunk.__toESM(node_fs);
+    var node_os = __require("os");
+    node_os = require_chunk.__toESM(node_os);
     var node_http = __require("http");
-    var node_perf_hooks = __require("perf_hooks");
     var node_v8 = __require("v8");
     node_v8 = require_chunk.__toESM(node_v8);
+    var node_perf_hooks = __require("perf_hooks");
     var node_vm = __require("vm");
     node_vm = require_chunk.__toESM(node_vm);
     var _camstack_types_addon = require_addon();
     var node_net = __require("net");
     var _trpc_client = require_dist2();
+    function createEventPlaneReader(sources) {
+      return () => {
+        try {
+          const registry = sources.registry();
+          if (registry === null) return void 0;
+          const children = [];
+          const listed = registry.listChildren();
+          for (const child of listed) {
+            const stats = registry.getChildEventStats(child.childId);
+            if (stats === null) continue;
+            children.push({
+              childId: child.childId,
+              sent: stats.sent,
+              suppressed: stats.suppressed
+            });
+          }
+          const crossNode = sources.crossNodeStats();
+          return {
+            udsMode: registry.eventFanoutMode,
+            crossNodeMode: sources.crossNodeMode(),
+            children,
+            childrenConnected: listed.length,
+            childrenUndeclared: registry.undeclaredChildCount(),
+            crossNodeDelivered: crossNode?.delivered ?? 0,
+            crossNodeSuppressed: crossNode?.suppressed ?? 0
+          };
+        } catch {
+          return;
+        }
+      };
+    }
+    var EVENT_PLANE_TOP_N = 5;
+    var EMPTY_EVENT_PLANE_BASELINE = {
+      children: /* @__PURE__ */ new Map(),
+      crossNodeDelivered: 0,
+      crossNodeSuppressed: 0
+    };
+    function diffEventPlane(baseline, current, topN = 5) {
+      const deltas = [];
+      let fanoutSent = 0;
+      let fanoutSuppressed = 0;
+      for (const sample of current.children) {
+        const before = baseline.children.get(sample.childId);
+        const sent = Math.max(0, sample.sent - (before?.sent ?? 0));
+        const suppressed = Math.max(0, sample.suppressed - (before?.suppressed ?? 0));
+        fanoutSent += sent;
+        fanoutSuppressed += suppressed;
+        if (sent > 0 || suppressed > 0) deltas.push({
+          childId: sample.childId,
+          sent,
+          suppressed
+        });
+      }
+      return {
+        udsMode: current.udsMode,
+        crossNodeMode: current.crossNodeMode,
+        childrenConnected: current.childrenConnected,
+        childrenUndeclared: current.childrenUndeclared,
+        fanoutSent,
+        fanoutSuppressed,
+        crossNodeDelivered: Math.max(0, current.crossNodeDelivered - baseline.crossNodeDelivered),
+        crossNodeSuppressed: Math.max(0, current.crossNodeSuppressed - baseline.crossNodeSuppressed),
+        top: deltas.toSorted((a, b) => b.sent - a.sent || a.childId.localeCompare(b.childId)).slice(0, topN)
+      };
+    }
+    function createEventPlaneMeter(reader, topN = 5) {
+      let baseline = EMPTY_EVENT_PLANE_BASELINE;
+      return { read: () => {
+        const current = reader();
+        if (current === void 0) return void 0;
+        const window2 = diffEventPlane(baseline, current, topN);
+        baseline = {
+          children: new Map(current.children.map((s) => [s.childId, s])),
+          crossNodeDelivered: current.crossNodeDelivered,
+          crossNodeSuppressed: current.crossNodeSuppressed
+        };
+        return window2;
+      } };
+    }
+    function formatEventPlane(window2) {
+      if (window2 === void 0) return "";
+      const top = window2.top.map((d) => `${d.childId}:${d.sent}/${d.suppressed}`).join(",");
+      return ` fanoutMode=uds:${window2.udsMode}/cross-node:${window2.crossNodeMode} children=${window2.childrenConnected} childrenUndeclared=${window2.childrenUndeclared} fanoutSent=${window2.fanoutSent} fanoutSuppressed=${window2.fanoutSuppressed} crossNodeDelivered=${window2.crossNodeDelivered} crossNodeSuppressed=${window2.crossNodeSuppressed}` + (top.length === 0 ? "" : ` fanoutTop=${top}`);
+    }
+    var DECISIVE_HEAP_SPACES = ["old_space", "large_object_space"];
+    var HEAP_SPACE_REPORT_MIN_MB = 32;
+    var BYTES_PER_MB = 1048576;
+    function mb(bytes) {
+      return Math.round(bytes / BYTES_PER_MB);
+    }
+    function tenthsMb(bytes) {
+      return Math.round(bytes / BYTES_PER_MB * 10) / 10;
+    }
+    function readHeapSpaces() {
+      try {
+        return node_v8.getHeapSpaceStatistics().map((space) => ({
+          name: space.space_name,
+          usedBytes: space.space_used_size
+        }));
+      } catch {
+        return [];
+      }
+    }
+    function heapSpaceField(v8Name) {
+      return v8Name.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+    }
+    function selectReportedSpaces(spaces, minMb = 32) {
+      const decisive = DECISIVE_HEAP_SPACES.map((name) => spaces.find((space) => space.name === name)).filter((space) => space !== void 0);
+      const rest = spaces.filter((space) => !DECISIVE_HEAP_SPACES.includes(space.name)).filter((space) => mb(space.usedBytes) >= minMb).toSorted((a, b) => b.usedBytes - a.usedBytes || a.name.localeCompare(b.name));
+      return [...decisive, ...rest];
+    }
+    function formatHeapSpaces(spaces, minMb = 32) {
+      const selected = selectReportedSpaces(spaces, minMb);
+      if (selected.length === 0) return "";
+      return ` ${selected.map((s) => `${heapSpaceField(s.name)}=${mb(s.usedBytes)}MB`).join(" ")}`;
+    }
+    var RUNNER_HEAP_SNAPSHOT_ENV = "CAMSTACK_RUNNER_HEAP_SNAPSHOT";
+    function heapSnapshotAuthorised(env = process.env) {
+      return env[RUNNER_HEAP_SNAPSHOT_ENV] === "on";
+    }
+    var defaultDeps = {
+      readMemory: () => process.memoryUsage(),
+      readSpaces: readHeapSpaces,
+      writeSnapshot: (path) => {
+        node_v8.writeHeapSnapshot(path);
+      },
+      env: process.env
+    };
+    function emitHeapDiagnosticReport(request, deps = defaultDeps) {
+      try {
+        const mu = deps.readMemory();
+        const spaces = deps.readSpaces().filter((space) => space.usedBytes > 0).map((space) => `${space.name}=${tenthsMb(space.usedBytes)}`).join(" ");
+        request.sink.info(`[mem] node="${request.label}" addons=[${request.addons.join(",")}] rss=${tenthsMb(mu.rss)} heapUsed=${tenthsMb(mu.heapUsed)} heapTotal=${tenthsMb(mu.heapTotal)} external=${tenthsMb(mu.external)} arrayBuffers=${tenthsMb(mu.arrayBuffers)} | ${spaces}`);
+      } catch (error) {
+        request.sink.warn(`[mem] node="${request.label}" space report failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      if (!heapSnapshotAuthorised(deps.env)) {
+        request.sink.info(`[mem] node="${request.label}" heap snapshot NOT taken \u2014 it is an admin mutation (a multi-GB write and a stop-the-world walk of the heap). The per-space breakdown above is the free half and needs no authorisation. Set ${RUNNER_HEAP_SNAPSHOT_ENV}=on for this runner and signal again to take one.`);
+        return;
+      }
+      try {
+        deps.writeSnapshot(request.snapshotPath);
+        request.sink.info(`[mem] node="${request.label}" heap snapshot written -> ${request.snapshotPath}`);
+      } catch (error) {
+        request.sink.warn(`[mem] node="${request.label}" snapshot failed: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     var HUB_MAIN_HEAP_WATCH_LABEL = "hub-main";
     var HEAP_WATCH_INTERVAL_MS = 6e4;
     var HEAP_WATCH_WARN_RATIO = 0.8;
@@ -113943,6 +114802,10 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
     }
     var HEAP_RECLAIM_TRIGGER_MB = 1024;
     var HEAP_RECLAIM_MIN_INTERVAL_MS = 12e4;
+    var HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS = 6e5;
+    function reclaimIntervalMs(passesAtFloor, minIntervalMs = HEAP_RECLAIM_MIN_INTERVAL_MS, steadyStateIntervalMs = HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS, steadyStatePasses = 6) {
+      return passesAtFloor >= steadyStatePasses ? Math.max(minIntervalMs, steadyStateIntervalMs) : minIntervalMs;
+    }
     var ZERO_LOOP_DELAY = {
       p50Ms: 0,
       p99Ms: 0,
@@ -113952,14 +114815,15 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
       try {
         const histogram = (0, node_perf_hooks.monitorEventLoopDelay)({ resolution: resolutionMs });
         histogram.enable();
+        const delay2 = (nanoseconds) => Math.max(0, Math.round(nanoseconds / 1e6) - resolutionMs);
         return {
           read: () => {
             try {
               if (histogram.count === 0) return ZERO_LOOP_DELAY;
               const sample = {
-                p50Ms: Math.round(histogram.percentile(50) / 1e6),
-                p99Ms: Math.round(histogram.percentile(99) / 1e6),
-                maxMs: Math.round(histogram.max / 1e6)
+                p50Ms: delay2(histogram.percentile(50)),
+                p99Ms: delay2(histogram.percentile(99)),
+                maxMs: delay2(histogram.max)
               };
               histogram.reset();
               return sample;
@@ -114069,16 +114933,19 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
     function formatOverBudget(label, b, source) {
       return `[mem] ${label} OVER RSS BUDGET rss=${b.rssMb}MB budget=${b.budgetMb}MB over=+${b.overMb}MB shape=${b.shape} heapUsed=${b.heapUsedMb}MB(${share(b.heapUsedMb, b.rssMb)}%) external=${b.externalMb}MB(${share(b.externalMb, b.rssMb)}%) nativeResidue=${b.nativeResidueMb}MB(${share(b.nativeResidueMb, b.rssMb)}%) arrayBuffers=${b.arrayBuffersMb}MB budgetFrom="${source}" \u2014 ${SHAPE_ADVICE[b.shape]}`;
     }
-    function format2(label, s, loop, budgetMb) {
+    function format2(label, s, loop, budgetMb, suffix) {
       const line = `[mem] ${label} rss=${s.rssMb}MB heapUsed=${s.heapUsedMb}MB heapTotal=${s.heapTotalMb}MB heapLimit=${s.heapLimitMb}MB used=${Math.round(s.usedRatio * 100)}% external=${s.externalMb}MB arrayBuffers=${s.arrayBuffersMb}MB` + (budgetMb === void 0 ? "" : ` rssBudget=${budgetMb}MB`);
-      if (loop === void 0) return line;
-      return `${line} loopP50=${loop.p50Ms}ms loopP99=${loop.p99Ms}ms loopMax=${loop.maxMs}ms`;
+      if (loop === void 0) return `${line}${suffix}`;
+      return `${line} loopP50=${loop.p50Ms}ms loopP99=${loop.p99Ms}ms loopMax=${loop.maxMs}ms${suffix}`;
     }
-    function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, intervalMs = HEAP_WATCH_INTERVAL_MS, reclaimOptions, loopDelay = createLoopDelayMeter(), execArgv = process.execArgv, announceCeilingOrigin = true, rssBudget) {
+    function startHeapWatch(label = HUB_MAIN_HEAP_WATCH_LABEL, sink = consoleSink, intervalMs = HEAP_WATCH_INTERVAL_MS, reclaimOptions, loopDelay = createLoopDelayMeter(), execArgv = process.execArgv, announceCeilingOrigin = true, rssBudget, probes) {
+      const readSpaces = probes?.readSpaces ?? readHeapSpaces;
+      const eventPlane = probes?.eventPlane === void 0 ? void 0 : createEventPlaneMeter(probes.eventPlane);
       const readMemory = reclaimOptions?.readMemory ?? (() => process.memoryUsage());
       const now = reclaimOptions?.now ?? (() => Date.now());
       const triggerMb = reclaimOptions?.triggerMb ?? 1024;
       const minIntervalMs = reclaimOptions?.minIntervalMs ?? 12e4;
+      const steadyStateIntervalMs = reclaimOptions?.steadyStateIntervalMs ?? 6e5;
       const fastIntervalMs = reclaimOptions?.fastIntervalMs ?? 2e3;
       const escalateRatio = reclaimOptions?.escalateRatio ?? 0.7;
       const deescalateRatio = reclaimOptions?.deescalateRatio ?? 0.6;
@@ -114096,9 +114963,10 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
           steadyStateAnnounced = false;
           return;
         }
+        const floorMs = reclaimIntervalMs(passesAtFloor, minIntervalMs, steadyStateIntervalMs);
         const sinceLast = now() - lastReclaimAt;
-        if (sinceLast < minIntervalMs) return;
-        passesAtFloor = sinceLast <= minIntervalMs * 2 ? passesAtFloor + 1 : 1;
+        if (sinceLast < floorMs) return;
+        passesAtFloor = sinceLast <= floorMs * 2 ? passesAtFloor + 1 : 1;
         lastReclaimAt = now();
         const startedAt = now();
         try {
@@ -114111,7 +114979,8 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB\u2192${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB\u2192${after.arrayBuffersMb}MB took=${now() - startedAt}ms`);
         if (passesAtFloor >= 6 && !steadyStateAnnounced) {
           steadyStateAnnounced = true;
-          sink.warn(`[mem] reclaim ${label} has run at the floor for ${passesAtFloor} consecutive passes (every ${minIntervalMs}ms) \u2014 the stop-the-world is now STEADY STATE, not a rescue. The allocation source is what needs the fix; this pass only bounds its peak.`);
+          const nextFloorMs = reclaimIntervalMs(passesAtFloor, minIntervalMs, steadyStateIntervalMs);
+          sink.warn(`[mem] reclaim ${label} has run at the floor for ${passesAtFloor} consecutive passes (every ${minIntervalMs}ms) \u2014 the stop-the-world is now STEADY STATE, not a rescue: stranded never fell back under ${triggerMb}MB between passes, so the trigger is not discriminating on this process and what is left deciding is the timer. BACKING OFF to every ${nextFloorMs}ms \u2014 the pass keeps running (it is still the only measurement of this process's live ArrayBuffer set) at a cost the router can pay. The allocation source is what needs the fix; this pass only bounds its peak.`);
         }
       };
       let mode = "steady";
@@ -114149,7 +115018,7 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
           const due = at - lastLoggedAt >= intervalMs;
           if (mode === "escalated" || due) {
             lastLoggedAt = at;
-            const line = format2(label, sample, loopDelay?.read(), budgetMb);
+            const line = format2(label, sample, loopDelay?.read(), budgetMb, `${formatHeapSpaces(readSpaces())}${formatEventPlane(eventPlane?.read())}`);
             if (sample.nearLimit) sink.warn(`${line} \u2014 APPROACHING HEAP LIMIT`);
             else if (mode === "escalated") sink.warn(`${line} \u2014 heap elevated, sampling every ${probeIntervalMs}ms`);
             else sink.info(line);
@@ -118254,6 +119123,34 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         };
       }
       /**
+      * The regime the counters above were produced under, read once from
+      * `CAMSTACK_UDS_EVENT_FANOUT` at construction.
+      *
+      * A suppressed count means "nothing WAS dropped" under `filter` and "nothing
+      * WOULD have been dropped" under `shadow`. Those are different claims, and
+      * until this getter existed the mode was invisible at runtime — the counters
+      * were readable and the regime that produced them was not.
+      */
+      get eventFanoutMode() {
+        return this.fanoutMode;
+      }
+      /**
+      * Connected children that never declared a subscription pattern set.
+      *
+      * Each one is a fail-open on BOTH planes: `childWantsEvent` returns true for
+      * an undeclared child ({@link ChildEntry.eventPatterns} `=== null`), and
+      * `aggregateEventInterest` returns `null` — accept everything — if ANY
+      * connected child is undeclared, which disables the node's inbound cross-node
+      * gate as well. **One legacy runner silently turns off the filtering for the
+      * whole node**, and nothing reported it, so a zero here is as load-bearing as
+      * a non-zero one.
+      */
+      undeclaredChildCount() {
+        let count = 0;
+        for (const entry of this.children.values()) if (entry.eventPatterns === null) count += 1;
+        return count;
+      }
+      /**
       * Does `entry` want to receive an event in `category`? Honours the fan-out
       * mode: `broadcast` → always; undeclared patterns (`null`) → always
       * (fail-open); else the child's declared set must match via `matchesPattern`
@@ -120709,12 +121606,24 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return CapabilityUnavailableError;
       }
     });
+    Object.defineProperty(exports, "DECISIVE_HEAP_SPACES", {
+      enumerable: true,
+      get: function() {
+        return DECISIVE_HEAP_SPACES;
+      }
+    });
     Object.defineProperty(exports, "DeviceRegistry", {
       enumerable: true,
       get: function() {
         return DeviceRegistry;
       }
     });
+    Object.defineProperty(exports, "EVENT_PLANE_TOP_N", {
+      enumerable: true,
+      get: function() {
+        return EVENT_PLANE_TOP_N;
+      }
+    });
     Object.defineProperty(exports, "EVENT_TOPIC_PREFIX", {
       enumerable: true,
       get: function() {
@@ -120733,12 +121642,24 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return HEAP_RECLAIM_MIN_INTERVAL_MS;
       }
     });
+    Object.defineProperty(exports, "HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS", {
+      enumerable: true,
+      get: function() {
+        return HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS;
+      }
+    });
     Object.defineProperty(exports, "HEAP_RECLAIM_TRIGGER_MB", {
       enumerable: true,
       get: function() {
         return HEAP_RECLAIM_TRIGGER_MB;
       }
     });
+    Object.defineProperty(exports, "HEAP_SPACE_REPORT_MIN_MB", {
+      enumerable: true,
+      get: function() {
+        return HEAP_SPACE_REPORT_MIN_MB;
+      }
+    });
     Object.defineProperty(exports, "HEAP_WATCH_INTERVAL_MS", {
       enumerable: true,
       get: function() {
@@ -120811,6 +121732,12 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return RSS_BUDGET_RELEASE_RATIO;
       }
     });
+    Object.defineProperty(exports, "RUNNER_HEAP_SNAPSHOT_ENV", {
+      enumerable: true,
+      get: function() {
+        return RUNNER_HEAP_SNAPSHOT_ENV;
+      }
+    });
     Object.defineProperty(exports, "RUNNER_HEAP_WATCH_INTERVAL_MS", {
       enumerable: true,
       get: function() {
@@ -120847,6 +121774,12 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return UdsLocalTransportServer;
       }
     });
+    Object.defineProperty(exports, "ZERO_LOOP_DELAY", {
+      enumerable: true,
+      get: function() {
+        return ZERO_LOOP_DELAY;
+      }
+    });
     Object.defineProperty(exports, "__resetCapUsageRegistryForTests", {
       enumerable: true,
       get: function() {
@@ -120973,6 +121906,18 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return createDeferredHeapWatchSink;
       }
     });
+    Object.defineProperty(exports, "createEventPlaneMeter", {
+      enumerable: true,
+      get: function() {
+        return createEventPlaneMeter;
+      }
+    });
+    Object.defineProperty(exports, "createEventPlaneReader", {
+      enumerable: true,
+      get: function() {
+        return createEventPlaneReader;
+      }
+    });
     Object.defineProperty(exports, "createHubCapForwardService", {
       enumerable: true,
       get: function() {
@@ -120991,6 +121936,12 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return createLocalTransport;
       }
     });
+    Object.defineProperty(exports, "createLoopDelayMeter", {
+      enumerable: true,
+      get: function() {
+        return createLoopDelayMeter;
+      }
+    });
     Object.defineProperty(exports, "createParentUnownedCallHandler", {
       enumerable: true,
       get: function() {
@@ -121045,12 +121996,36 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return deserializeTypedArrays;
       }
     });
+    Object.defineProperty(exports, "diffEventPlane", {
+      enumerable: true,
+      get: function() {
+        return diffEventPlane;
+      }
+    });
+    Object.defineProperty(exports, "emitHeapDiagnosticReport", {
+      enumerable: true,
+      get: function() {
+        return emitHeapDiagnosticReport;
+      }
+    });
     Object.defineProperty(exports, "encodeFrame", {
       enumerable: true,
       get: function() {
         return encodeFrame;
       }
     });
+    Object.defineProperty(exports, "formatEventPlane", {
+      enumerable: true,
+      get: function() {
+        return formatEventPlane;
+      }
+    });
+    Object.defineProperty(exports, "formatHeapSpaces", {
+      enumerable: true,
+      get: function() {
+        return formatHeapSpaces;
+      }
+    });
     Object.defineProperty(exports, "getBrokerEventBus", {
       enumerable: true,
       get: function() {
@@ -121099,6 +122074,18 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return getWorkerNativeCapSnapshot;
       }
     });
+    Object.defineProperty(exports, "heapSnapshotAuthorised", {
+      enumerable: true,
+      get: function() {
+        return heapSnapshotAuthorised;
+      }
+    });
+    Object.defineProperty(exports, "heapSpaceField", {
+      enumerable: true,
+      get: function() {
+        return heapSpaceField;
+      }
+    });
     Object.defineProperty(exports, "hubMainRssBudget", {
       enumerable: true,
       get: function() {
@@ -121159,6 +122146,24 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return parseRssBudgetMb;
       }
     });
+    Object.defineProperty(exports, "readHeapSpaces", {
+      enumerable: true,
+      get: function() {
+        return readHeapSpaces;
+      }
+    });
+    Object.defineProperty(exports, "readMoleculerFanoutMode", {
+      enumerable: true,
+      get: function() {
+        return readMoleculerFanoutMode;
+      }
+    });
+    Object.defineProperty(exports, "reclaimIntervalMs", {
+      enumerable: true,
+      get: function() {
+        return reclaimIntervalMs;
+      }
+    });
     Object.defineProperty(exports, "registerEventBusService", {
       enumerable: true,
       get: function() {
@@ -121189,6 +122194,12 @@ var require_manifest_python_deps_BqWrDjSN = __commonJS({
         return runNpm;
       }
     });
+    Object.defineProperty(exports, "selectReportedSpaces", {
+      enumerable: true,
+      get: function() {
+        return selectReportedSpaces;
+      }
+    });
     Object.defineProperty(exports, "serializeTypedArrays", {
       enumerable: true,
       get: function() {
@@ -125057,7 +126068,7 @@ var require_dist3 = __commonJS({
     "use strict";
     Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
     var require_chunk = require_chunk_Cek0wNdY();
-    var require_dist10 = require_dist_CImxMt5h();
+    var require_dist10 = require_dist_C7uZ_fOb();
     var require_builtins_alerts_alerts_addon = require_alerts_addon();
     require_alerts();
     var require_formatter = require_formatter_DqAKDlvN();
@@ -125082,8 +126093,8 @@ var require_dist3 = __commonJS({
     require_system_config();
     var require_builtins_winston_logging_index = require_winston_logging();
     var require_file_data_plane = require_file_data_plane_DO8KbxCe();
-    var require_tls$1 = require_tls_u8QCJCFE();
-    var require_manifest_python_deps = require_manifest_python_deps_BqWrDjSN();
+    var require_tls$1 = require_tls_BxQlomxd();
+    var require_manifest_python_deps = require_manifest_python_deps_CRTx_j4k();
     var require_resource_monitor = require_resource_monitor_CdnzxBLP();
     var require_custom_action_registry = require_custom_action_registry_jY0NOZK8();
     var zod = require_zod();
@@ -125095,11 +126106,11 @@ var require_dist3 = __commonJS({
     var node_child_process = __require("child_process");
     var node_util = __require("util");
     node_util = require_chunk.__toESM(node_util);
-    var node_os = __require("os");
-    node_os = require_chunk.__toESM(node_os);
     var node_fs = __require("fs");
     var node_fs$1 = require_chunk.__toESM(node_fs, 1);
     node_fs = require_chunk.__toESM(node_fs);
+    var node_os = __require("os");
+    node_os = require_chunk.__toESM(node_os);
     var node_http = __require("http");
     var node_vm = __require("vm");
     node_vm = require_chunk.__toESM(node_vm);
@@ -205454,6 +206465,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.ConsoleLoggingAddon = require_builtins_console_logging_index.ConsoleLoggingAddon$1;
     exports.CoreBlocksAddon = require_builtins_core_blocks_core_blocks_addon.CoreBlocksAddon;
     exports.CustomActionRegistry = require_custom_action_registry.CustomActionRegistry;
+    exports.DECISIVE_HEAP_SPACES = require_manifest_python_deps.DECISIVE_HEAP_SPACES;
     exports.DEFAULT_DATA_PATH = DEFAULT_DATA_PATH;
     exports.DEFAULT_LAN_HTTP_PORT = require_tls$1.DEFAULT_LAN_HTTP_PORT;
     exports.DEFAULT_LOG_LEVEL = DEFAULT_LOG_LEVEL;
@@ -205463,6 +206475,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.DeviceManagerAddon = require_builtins_device_manager_device_manager_addon.DeviceManagerAddon;
     exports.DeviceRegistry = require_manifest_python_deps.DeviceRegistry;
     exports.DeviceStore = require_builtins_sqlite_storage_index.DeviceStore$1;
+    exports.EVENT_PLANE_TOP_N = require_manifest_python_deps.EVENT_PLANE_TOP_N;
     exports.EVENT_TOPIC_PREFIX = require_manifest_python_deps.EVENT_TOPIC_PREFIX;
     exports.EngineManagerResolver = EngineManagerResolver;
     exports.EventBus = EventBus;
@@ -205475,7 +206488,9 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.HEALTH_MONITOR_RETRY_INTERVALS_MS = HEALTH_MONITOR_RETRY_INTERVALS_MS;
     exports.HEALTH_MONITOR_TICK_MS = HEALTH_MONITOR_TICK_MS;
     exports.HEAP_RECLAIM_MIN_INTERVAL_MS = require_manifest_python_deps.HEAP_RECLAIM_MIN_INTERVAL_MS;
+    exports.HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS = require_manifest_python_deps.HEAP_RECLAIM_STEADY_STATE_INTERVAL_MS;
     exports.HEAP_RECLAIM_TRIGGER_MB = require_manifest_python_deps.HEAP_RECLAIM_TRIGGER_MB;
+    exports.HEAP_SPACE_REPORT_MIN_MB = require_manifest_python_deps.HEAP_SPACE_REPORT_MIN_MB;
     exports.HEAP_WATCH_INTERVAL_MS = require_manifest_python_deps.HEAP_WATCH_INTERVAL_MS;
     exports.HEAP_WATCH_WARN_RATIO = require_manifest_python_deps.HEAP_WATCH_WARN_RATIO;
     exports.HUB_CAP_FWD_ACTION = require_manifest_python_deps.HUB_CAP_FWD_ACTION;
@@ -205524,6 +206539,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.RESTART_MARKER_FILE = RESTART_MARKER_FILE;
     exports.RSS_BUDGET_REANNOUNCE_MIN_MS = require_manifest_python_deps.RSS_BUDGET_REANNOUNCE_MIN_MS;
     exports.RSS_BUDGET_RELEASE_RATIO = require_manifest_python_deps.RSS_BUDGET_RELEASE_RATIO;
+    exports.RUNNER_HEAP_SNAPSHOT_ENV = require_manifest_python_deps.RUNNER_HEAP_SNAPSHOT_ENV;
     exports.RUNNER_HEAP_WATCH_INTERVAL_MS = require_manifest_python_deps.RUNNER_HEAP_WATCH_INTERVAL_MS;
     exports.RUNNER_RSS_BUDGET_ENV = require_manifest_python_deps.RUNNER_RSS_BUDGET_ENV;
     exports.RUNTIME_DEFAULTS = require_dist10.RUNTIME_DEFAULTS;
@@ -205552,6 +206568,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.UserManager = require_builtins_local_auth_local_auth_addon.UserManager;
     exports.WinstonDestination = require_builtins_winston_logging_index.WinstonDestination$1;
     exports.WinstonLoggingAddon = require_builtins_winston_logging_index.WinstonLoggingAddon$1;
+    exports.ZERO_LOOP_DELAY = require_manifest_python_deps.ZERO_LOOP_DELAY;
     exports.__resetCapUsageRegistryForTests = require_manifest_python_deps.__resetCapUsageRegistryForTests;
     exports.__resetLoggingGateForTests = __resetLoggingGateForTests;
     exports.adaptBrokerToCluster = require_manifest_python_deps.adaptBrokerToCluster;
@@ -205603,11 +206620,14 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.createCoreCapService = createCoreCapService;
     exports.createDeferredHeapWatchSink = require_manifest_python_deps.createDeferredHeapWatchSink;
     exports.createDoorSettingsView = createDoorSettingsView;
+    exports.createEventPlaneMeter = require_manifest_python_deps.createEventPlaneMeter;
+    exports.createEventPlaneReader = require_manifest_python_deps.createEventPlaneReader;
     exports.createFileDataPlaneHandler = require_file_data_plane.createFileDataPlaneHandler;
     exports.createHubCapForwardService = require_manifest_python_deps.createHubCapForwardService;
     exports.createHubService = createHubService;
     exports.createKernelHwAccel = require_manifest_python_deps.createKernelHwAccel;
     exports.createLocalTransport = require_manifest_python_deps.createLocalTransport;
+    exports.createLoopDelayMeter = require_manifest_python_deps.createLoopDelayMeter;
     exports.createParentUnownedCallHandler = require_manifest_python_deps.createParentUnownedCallHandler;
     exports.createProcessService = createProcessService;
     exports.createReadinessService = createReadinessService;
@@ -205625,6 +206645,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.describeProviderKindDrift = describeProviderKindDrift;
     exports.describeRss = require_manifest_python_deps.describeRss;
     exports.detectWorkspacePackagesDir = detectWorkspacePackagesDir;
+    exports.diffEventPlane = require_manifest_python_deps.diffEventPlane;
     Object.defineProperty(exports, "downloadBinary", {
       enumerable: true,
       get: function() {
@@ -205634,6 +206655,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.downloadFile = require_file_data_plane.downloadFile;
     exports.downloadModel = require_file_data_plane.downloadModel;
     exports.emitDownForOwnedCaps = require_dist10.emitDownForOwnedCaps;
+    exports.emitHeapDiagnosticReport = require_manifest_python_deps.emitHeapDiagnosticReport;
     exports.encodeFrame = require_manifest_python_deps.encodeFrame;
     exports.ensureAddonNativePrebuilds = ensureAddonNativePrebuilds;
     Object.defineProperty(exports, "ensureBinary", {
@@ -205668,6 +206690,8 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
         return _camstack_types_node.findInPath;
       }
     });
+    exports.formatEventPlane = require_manifest_python_deps.formatEventPlane;
+    exports.formatHeapSpaces = require_manifest_python_deps.formatHeapSpaces;
     exports.formatLogLine = require_formatter.formatLogLine;
     exports.getBrokerEventBus = require_manifest_python_deps.getBrokerEventBus;
     exports.getCapUsageRegistry = require_manifest_python_deps.getCapUsageRegistry;
@@ -205700,6 +206724,8 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.getWorkerDeviceRegistry = require_manifest_python_deps.getWorkerDeviceRegistry;
     exports.hasDotNode = hasDotNode;
     exports.hashClusterSecret = hashClusterSecret;
+    exports.heapSnapshotAuthorised = require_manifest_python_deps.heapSnapshotAuthorised;
+    exports.heapSpaceField = require_manifest_python_deps.heapSpaceField;
     exports.hubMainRssBudget = require_manifest_python_deps.hubMainRssBudget;
     exports.installManifestNativeDeps = require_manifest_python_deps.installManifestNativeDeps;
     exports.installManifestPythonDeps = require_manifest_python_deps.installManifestPythonDeps;
@@ -205738,11 +206764,14 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.proxyToUpstream = proxyToUpstream;
     exports.quarantineAddonResidue = quarantineAddonResidue;
     exports.readExtraSans = require_tls$1.readExtraSans;
+    exports.readHeapSpaces = require_manifest_python_deps.readHeapSpaces;
     exports.readLanHttpState = require_tls$1.readLanHttpState;
+    exports.readMoleculerFanoutMode = require_manifest_python_deps.readMoleculerFanoutMode;
     exports.readPendingRestart = readPendingRestart;
     exports.readTlsAccessStatus = require_tls$1.readTlsAccessStatus;
     exports.readTlsMode = require_tls$1.readTlsMode;
     exports.readinessKey = require_dist10.readinessKey;
+    exports.reclaimIntervalMs = require_manifest_python_deps.reclaimIntervalMs;
     exports.registerEventBusService = require_manifest_python_deps.registerEventBusService;
     exports.registerLanHttpHandler = require_tls$1.registerLanHttpHandler;
     exports.reissueTlsLeaf = require_tls$1.reissueTlsLeaf;
@@ -205756,6 +206785,7 @@ globstar while`, t, d, e, f, m), this.matchOne(t.slice(d), e.slice(f), s)) retur
     exports.scopesAllowAddon = require_dist10.scopesAllowAddon;
     exports.scopesAllowDeviceCap = require_dist10.scopesAllowDeviceCap;
     exports.selectAddonResidue = selectAddonResidue;
+    exports.selectReportedSpaces = require_manifest_python_deps.selectReportedSpaces;
     exports.serializeTypedArrays = require_manifest_python_deps.serializeTypedArrays;
     exports.setHubConnected = require_manifest_python_deps.setHubConnected;
     exports.setNodeEventInterest = require_manifest_python_deps.setNodeEventInterest;
@@ -214762,6 +215792,38 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       /** Wall-clock uptime (seconds). Parsed from `ps etime`. */
       uptimeSec: zod.z.number()
     });
+    var ContainerMemoryPointSchema = zod.z.object({
+      /** Which hierarchy answered, so a reading is never ambiguous. */
+      source: zod.z.enum(["cgroup-v2", "cgroup-v1"]),
+      /** `memory.current` (v2) / `memory.usage_in_bytes` (v1). Always known. */
+      currentBytes: zod.z.number(),
+      /** The cgroup's ceiling. `null` = NO LIMIT — never a sentinel, never zero. */
+      limitBytes: zod.z.number().nullable(),
+      /** Anonymous pages: the closest thing to "what the processes allocated". */
+      anonBytes: zod.z.number().nullable(),
+      /** Page cache. Charged to the cgroup, owned by no process. */
+      fileBytes: zod.z.number().nullable(),
+      /**
+      * Shared memory — and the field that explained the largest single surprise.
+      * The i915 driver backs GPU buffers with shmem, so an inference pool or a
+      * hardware-decode session holding DRM objects is charged HERE and appears
+      * nowhere in a `ps` scan.
+      */
+      shmemBytes: zod.z.number().nullable(),
+      /** Kernel slab charged to this cgroup. `null` on v1, which never publishes it. */
+      slabBytes: zod.z.number().nullable(),
+      /**
+      * Shrinkable i915 GEM object bytes, from debugfs.
+      *
+      * **Host-wide across every DRM client, NOT cgroup-scoped.** It is not a
+      * component of `currentBytes` and must not be subtracted from it; it says
+      * what put the shmem there, where `shmemBytes` only says how much.
+      *
+      * `null` wherever debugfs is not mounted — which is inside every camstack
+      * container today — and on any node with no Intel GPU.
+      */
+      gpuShmemBytes: zod.z.number().nullable()
+    }).extend({ atMs: zod.z.number() });
     var DumpHeapSnapshotInputSchema = zod.z.object({
       /** The addon whose runner should dump a heap snapshot. */
       addonId: zod.z.string()
@@ -214811,6 +215873,21 @@ ${recipe.triggers.map((t, i) => emitTrigger(t, i)).join("\n\n")}
       /** One entry per function seen in the window, heaviest-first. */
       series: zod.z.array(LoadFunctionSeriesSchema).readonly(),
       /**
+      * The CONTAINER's memory over the same window, oldest-first.
+      *
+      * Sits next to `series` rather than in a method of its own because the whole
+      * question is a subtraction: the per-process rows in `series` sum to one
+      * number and this one is another, and an operator who has to issue two calls
+      * to compare them will compare two different instants. Same reader, same
+      * `sinceMs`, same `bucketMs`, same timestamps.
+      *
+      * **EMPTY means ABSENT, never zero.** A node with no cgroup — a developer
+      * Mac, a bare-metal host, a container with the hierarchy hidden — reports no
+      * points at all. A zero here would be indistinguishable from a healthy
+      * container and is precisely the lie this field exists to avoid.
+      */
+      containerMemory: zod.z.array(ContainerMemoryPointSchema).readonly(),
+      /**
       * Width of one returned bucket, in ms. Equals the sampling cadence when no
       * reduction was needed — so a caller can always say what one point covers
       * without having to know whether it was reduced.
@@ -420662,7 +421739,17 @@ var require_main4 = __commonJS({
       const heapReclaimer = (0, system_1.createV8Reclaimer)();
       const heapReclaim = heapReclaimer === void 0 ? void 0 : { reclaim: heapReclaimer };
       const heapWatchSink = (0, system_1.createDeferredHeapWatchSink)(system_1.HUB_MAIN_HEAP_WATCH_LABEL);
-      (0, system_1.startHeapWatch)(system_1.HUB_MAIN_HEAP_WATCH_LABEL, heapWatchSink.sink, void 0, heapReclaim, void 0, void 0, true, (0, system_1.hubMainRssBudget)());
+      let moleculerForEventPlane = null;
+      (0, system_1.startHeapWatch)(system_1.HUB_MAIN_HEAP_WATCH_LABEL, heapWatchSink.sink, void 0, heapReclaim, void 0, void 0, true, (0, system_1.hubMainRssBudget)(), {
+        eventPlane: (0, system_1.createEventPlaneReader)({
+          registry: () => moleculerForEventPlane?.childRegistry ?? null,
+          crossNodeStats: () => {
+            const broker = moleculerForEventPlane?.broker;
+            return broker === void 0 ? null : (0, system_1.getMoleculerEventStats)(broker);
+          },
+          crossNodeMode: () => (0, system_1.readMoleculerFanoutMode)()
+        })
+      });
       cleanupOrphanProcesses();
       let spaIndexHtml = null;
       const configPath = process.env.CONFIG_PATH ?? path.join(process.env.CAMSTACK_DATA ?? path.join(process.cwd(), "camstack-data"), "config.yaml");
@@ -420782,6 +421869,7 @@ var require_main4 = __commonJS({
       console.log("[bootstrap] app.init() complete \u2014 all onModuleInit hooks have run");
       capabilityRegistry.ready();
       const moleculer = app.get(moleculer_service_1.MoleculerService);
+      moleculerForEventPlane = moleculer;
       moleculer.registerLogReceiver();
       capabilityRegistry.registerProvider("model-distributor", "$hub", (0, model_distributor_js_1.buildModelDistributorProvider)(moleculer, loggingService));
       try {