@camstack/addon-pipeline 1.2.94 → 1.2.96

package/dist/{dist-BbRv3bM2.js → dist-w9QWDvWn.js}

@@ -22,7 +22,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 //#endregion
 let node_crypto = require("node:crypto");
-//#region ../types/dist/event-category-C0lyLd5U.mjs
+//#region ../types/dist/event-category-XfKNtfCc.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -61,6 +61,22 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["AddonInstalled"] = "addon.installed";
 	EventCategory["AddonUninstalled"] = "addon.uninstalled";
 	EventCategory["AddonCrashed"] = "addon.crashed";
+	/**
+	* A RUNNER the D6 crash circuit-breaker gave up on — terminal.
+	*
+	* `AddonCrashed` is the routine, self-healing fact ("it crashed; it is being
+	* respawned"); this is the one that never resolves itself. Emitted exactly
+	* once per trip, by `process-service.ts`, carrying the node, the runner, the
+	* addons it hosted and the crash count that tripped the breaker.
+	*
+	* It exists because a runner marked terminally `failed` used to be SILENT:
+	* on 2026-08-18 the `recorder` runner died of three unhandled ffmpeg spawn
+	* errors, the breaker stopped respawning it (correctly), `/health` kept
+	* returning 200, and fleet-wide recording was gone for 3h15 before the
+	* operator's phone told him. The Notification Center's system-event intake
+	* consumes this category and maps it to the `addon-crash-loop` kind.
+	*/
+	EventCategory["AddonRunnerFailed"] = "addon.runner-failed";
 	EventCategory["AddonError"] = "addon.error";
 	EventCategory["AddonPageReady"] = "addon.page-ready";
 	EventCategory["AddonWidgetReady"] = "addon.widget-ready";
@@ -16094,6 +16110,7 @@ var NcSystemEventKindSchema = _enum([
 	"node-offline",
 	"node-inference-unavailable",
 	"detection-blind",
+	"addon-crash-loop",
 	"addon-update-available",
 	"server-update-available",
 	"alarm-triggered",
@@ -22013,6 +22030,14 @@ var ClipSchema = object({
 		endMs: number()
 	}),
 	/**
+	* Distinct object classes attached to this visit (`person`, `car`, …),
+	* dominant first, capped at {@link MAX_CLIP_LABELS}. The ribbon renders these
+	* instead of the bare kind — "Object" tells the operator nothing a colour bar
+	* did not. Absent (never empty) when the visit attached no classified object
+	* event, so a motion/audio-only visit keeps its kind label.
+	*/
+	labels: array(string()).max(3).optional(),
+	/**
 	* Lazy thumbnail URL, never inlined.
 	*
 	* Recording-derived clips (events-mode keep-window, and the prepared
@@ -36448,6 +36473,303 @@ function maskUrlCredentials(rawUrl) {
 		return rawUrl;
 	}
 }
+var MB = 1024 * 1024;
+var DEFAULT_POOL_MEMORY_POLICY = {
+	sampleIntervalMs: 6e4,
+	baselineSettleSamples: 5,
+	baselineSampleCount: 3,
+	restartMultiple: 4,
+	floorBytes: 1024 * MB,
+	ceilingBytes: 3072 * MB,
+	cooldownMs: 30 * 6e4,
+	maxRestartsPerWindow: 6,
+	restartWindowMs: 1440 * 6e4
+};
+/**
+* Resolve the policy from env overrides (`CAMSTACK_POOL_MEM_*`). Garbage or
+* absent values keep the default — an operator typo must never disable the
+* bound or set it to zero.
+*/
+function resolvePoolMemoryPolicy(env) {
+	const num = (key, fallback, min) => {
+		const raw = env[key];
+		if (raw === void 0) return fallback;
+		const parsed = Number(raw);
+		return Number.isFinite(parsed) && parsed >= min ? parsed : fallback;
+	};
+	const d = DEFAULT_POOL_MEMORY_POLICY;
+	return {
+		sampleIntervalMs: num("CAMSTACK_POOL_MEM_INTERVAL_MS", d.sampleIntervalMs, 5e3),
+		baselineSettleSamples: d.baselineSettleSamples,
+		baselineSampleCount: d.baselineSampleCount,
+		restartMultiple: num("CAMSTACK_POOL_MEM_MULTIPLE", d.restartMultiple, 1.5),
+		floorBytes: num("CAMSTACK_POOL_MEM_FLOOR_MB", d.floorBytes / MB, 128) * MB,
+		ceilingBytes: num("CAMSTACK_POOL_MEM_CEILING_MB", d.ceilingBytes / MB, 256) * MB,
+		cooldownMs: num("CAMSTACK_POOL_MEM_COOLDOWN_MS", d.cooldownMs, 6e4),
+		maxRestartsPerWindow: num("CAMSTACK_POOL_MEM_MAX_RESTARTS", d.maxRestartsPerWindow, 1),
+		restartWindowMs: num("CAMSTACK_POOL_MEM_RESTART_WINDOW_MS", d.restartWindowMs, 6e4)
+	};
+}
+/** Parse the fields this watchdog needs out of `/proc/<pid>/status` text.
+*  Returns null when VmRSS is missing (dead pid, kernel thread, bad read). */
+function parseProcStatus(text) {
+	const kb = (label) => {
+		const match = text.match(new RegExp(`^${label}:\\s+(\\d+)\\s*kB`, "m"));
+		return match ? Number(match[1]) * 1024 : null;
+	};
+	const rssBytes = kb("VmRSS");
+	if (rssBytes === null) return null;
+	const threadsMatch = text.match(/^Threads:\s+(\d+)/m);
+	return {
+		rssBytes,
+		vmBytes: kb("VmSize") ?? 0,
+		hwmBytes: kb("VmHWM") ?? 0,
+		swapBytes: kb("VmSwap") ?? 0,
+		threads: threadsMatch ? Number(threadsMatch[1]) : 0
+	};
+}
+function initialPoolMemoryState() {
+	return {
+		settleSeen: 0,
+		baselineWindow: [],
+		baselineBytes: null,
+		restartsAt: [],
+		lastRestartAt: null
+	};
+}
+function median(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor(sorted.length / 2)];
+}
+function advanceBaseline(state, rssBytes, policy) {
+	if (state.baselineBytes !== null) return state;
+	if (state.settleSeen < policy.baselineSettleSamples) return {
+		...state,
+		settleSeen: state.settleSeen + 1
+	};
+	const window = [...state.baselineWindow, rssBytes];
+	if (window.length < policy.baselineSampleCount) return {
+		...state,
+		baselineWindow: window
+	};
+	return {
+		...state,
+		baselineWindow: window,
+		baselineBytes: median(window)
+	};
+}
+/** The one place a pool's restart threshold is computed. */
+function poolMemoryThreshold(baselineBytes, policy) {
+	if (baselineBytes === null) return policy.ceilingBytes;
+	return Math.min(policy.ceilingBytes, Math.max(policy.floorBytes, policy.restartMultiple * baselineBytes));
+}
+function pruneRestarts(restartsAt, nowMs, policy) {
+	return restartsAt.filter((t) => nowMs - t < policy.restartWindowMs);
+}
+/**
+* Evaluate one RSS sample. Pure: returns the successor state plus the verdict.
+* The caller performs (and logs) the restart, then commits it via
+* {@link commitWatchdogRestart}.
+*/
+function evaluatePoolMemory(state, rssBytes, nowMs, policy) {
+	const next = advanceBaseline(state, rssBytes, policy);
+	const thresholdBytes = poolMemoryThreshold(next.baselineBytes, policy);
+	if (rssBytes <= thresholdBytes) return {
+		state: next,
+		action: next.baselineBytes === null ? "baseline-pending" : "ok",
+		baselineBytes: next.baselineBytes,
+		thresholdBytes
+	};
+	const inWindow = pruneRestarts(next.restartsAt, nowMs, policy);
+	const pruned = {
+		...next,
+		restartsAt: inWindow
+	};
+	if (inWindow.length >= policy.maxRestartsPerWindow) return {
+		state: pruned,
+		action: "exhausted",
+		baselineBytes: next.baselineBytes,
+		thresholdBytes
+	};
+	if (pruned.lastRestartAt !== null && nowMs - pruned.lastRestartAt < policy.cooldownMs) return {
+		state: pruned,
+		action: "cooldown",
+		baselineBytes: next.baselineBytes,
+		thresholdBytes
+	};
+	return {
+		state: pruned,
+		action: "restart",
+		baselineBytes: next.baselineBytes,
+		thresholdBytes
+	};
+}
+/** Record a performed watchdog restart: budget consumed, baseline reset —
+*  the recreated pool is a NEW process and gets a fresh settle window. */
+function commitWatchdogRestart(state, nowMs) {
+	return {
+		...initialPoolMemoryState(),
+		restartsAt: [...state.restartsAt, nowMs],
+		lastRestartAt: nowMs
+	};
+}
+/** Reset baseline tracking (pool process replaced OUTSIDE the watchdog —
+*  kernel OOM kill + respawn, idle-reaper eviction, tuning respawn). The
+*  restart budget is kept: it bounds the WATCHDOG, not the pool. */
+function resetPoolBaseline(state) {
+	return {
+		...initialPoolMemoryState(),
+		restartsAt: state.restartsAt,
+		lastRestartAt: state.lastRestartAt
+	};
+}
+/**
+* Pick ONE pool to restart this sweep — the worst overage ratio. Restarting
+* several pools at once (e.g. after a model rollout grew every baseline)
+* would take detection down on every camera simultaneously; one per sweep
+* means the survivors keep serving while the worst offender reloads, and the
+* next sweep (one interval later) takes the next one.
+*/
+function pickRestartCandidate(candidates) {
+	if (candidates.length === 0) return null;
+	let worst = candidates[0];
+	for (const c of candidates) if (c.rssBytes / c.thresholdBytes > worst.rssBytes / worst.thresholdBytes) worst = c;
+	return worst.key;
+}
+var PoolMemoryWatchdog = class {
+	pools = /* @__PURE__ */ new Map();
+	timer = null;
+	sweeping = false;
+	stopped = false;
+	opts;
+	now;
+	setTimer;
+	clearTimer;
+	constructor(opts) {
+		this.opts = opts;
+		this.now = opts.now ?? (() => Date.now());
+		this.setTimer = opts.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+		this.clearTimer = opts.clearTimer ?? ((t) => clearTimeout(t));
+	}
+	start() {
+		if (this.timer || this.stopped) return;
+		this.arm();
+	}
+	stop() {
+		this.stopped = true;
+		if (this.timer) {
+			this.clearTimer(this.timer);
+			this.timer = null;
+		}
+	}
+	arm() {
+		const timer = this.setTimer(() => {
+			this.sweep().finally(() => {
+				if (!this.stopped) this.arm();
+			});
+		}, this.opts.policy.sampleIntervalMs);
+		if (typeof timer.unref === "function") timer.unref();
+		this.timer = timer;
+	}
+	/** One sweep: sample → log every pool → restart at most one. Public so the
+	*  loop is testable without fake global timers. */
+	async sweep() {
+		if (this.sweeping) return;
+		this.sweeping = true;
+		try {
+			await this.doSweep();
+		} catch (err) {
+			this.opts.log.warn("pool memory sweep failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		} finally {
+			this.sweeping = false;
+		}
+	}
+	async doSweep() {
+		const nowMs = this.now();
+		const samples = await this.opts.sample();
+		const candidates = [];
+		const verdictByKey = /* @__PURE__ */ new Map();
+		for (const t of samples) {
+			const tracked = this.pools.get(t.key);
+			let state = tracked?.state ?? initialPoolMemoryState();
+			if (tracked && tracked.pids.length > 0 && !samePids(tracked.pids, t.pids)) {
+				this.opts.log.warn("pool process changed outside the watchdog — re-baselining", { meta: {
+					poolKey: t.key,
+					previousPids: tracked.pids,
+					pids: t.pids
+				} });
+				state = resetPoolBaseline(state);
+			}
+			const verdict = evaluatePoolMemory(state, t.rssBytes, nowMs, this.opts.policy);
+			this.pools.set(t.key, {
+				state: verdict.state,
+				pids: t.pids
+			});
+			verdictByKey.set(t.key, verdict);
+			this.opts.log.info("pool memory", { meta: {
+				poolKey: t.key,
+				pids: t.pids,
+				rssMb: Math.round(t.rssBytes / MB),
+				baselineMb: verdict.baselineBytes === null ? null : Math.round(verdict.baselineBytes / MB),
+				thresholdMb: Math.round(verdict.thresholdBytes / MB),
+				action: verdict.action,
+				...t.meta
+			} });
+			if (verdict.action === "restart") candidates.push({
+				key: t.key,
+				rssBytes: t.rssBytes,
+				thresholdBytes: verdict.thresholdBytes
+			});
+			else if (verdict.action === "cooldown") this.opts.log.warn("pool over memory threshold but inside restart cooldown", { meta: {
+				poolKey: t.key,
+				rssMb: Math.round(t.rssBytes / MB),
+				thresholdMb: Math.round(verdict.thresholdBytes / MB),
+				cooldownMs: this.opts.policy.cooldownMs
+			} });
+			else if (verdict.action === "exhausted") this.opts.log.error("pool memory watchdog gave up — restart budget exhausted, pool leaks faster than restarts can pay for; needs a heap profile (py-spy / tracemalloc)", { meta: {
+				poolKey: t.key,
+				rssMb: Math.round(t.rssBytes / MB),
+				thresholdMb: Math.round(verdict.thresholdBytes / MB),
+				maxRestartsPerWindow: this.opts.policy.maxRestartsPerWindow,
+				restartWindowMs: this.opts.policy.restartWindowMs
+			} });
+		}
+		for (const key of [...this.pools.keys()]) if (!samples.some((t) => t.key === key)) this.pools.delete(key);
+		const pickedKey = pickRestartCandidate(candidates);
+		if (pickedKey === null) return;
+		const picked = candidates.find((c) => c.key === pickedKey);
+		const verdict = verdictByKey.get(pickedKey);
+		const tracked = this.pools.get(pickedKey);
+		const restartsInWindow = tracked.state.restartsAt.length + 1;
+		this.opts.log.warn("pool memory watchdog restarting pool — RSS over threshold", { meta: {
+			poolKey: pickedKey,
+			pids: tracked.pids,
+			rssMb: Math.round(picked.rssBytes / MB),
+			thresholdMb: Math.round(picked.thresholdBytes / MB),
+			baselineMb: verdict.baselineBytes === null ? null : Math.round(verdict.baselineBytes / MB),
+			restartsInWindow,
+			deferredCandidates: candidates.filter((c) => c.key !== pickedKey).map((c) => c.key)
+		} });
+		try {
+			await this.opts.restart(pickedKey);
+			this.pools.set(pickedKey, {
+				state: commitWatchdogRestart(tracked.state, this.now()),
+				pids: []
+			});
+		} catch (err) {
+			this.opts.log.error("pool memory watchdog restart failed", { meta: {
+				poolKey: pickedKey,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+		}
+	}
+};
+function samePids(a, b) {
+	if (a.length !== b.length) return false;
+	const sortedA = [...a].sort((x, y) => x - y);
+	const sortedB = [...b].sort((x, y) => x - y);
+	return sortedA.every((v, i) => v === sortedB[i]);
+}
 /**
 * Fixed-capacity ring buffer. When full, push() overwrites the oldest entry.
 * drain() returns up to maxCount items in FIFO order and removes them.
@@ -36935,6 +37257,12 @@ Object.defineProperty(exports, "OpsLogEntrySchema", {
 		return OpsLogEntrySchema;
 	}
 });
+Object.defineProperty(exports, "PoolMemoryWatchdog", {
+	enumerable: true,
+	get: function() {
+		return PoolMemoryWatchdog;
+	}
+});
 Object.defineProperty(exports, "RATE_CONTROL_RELAXED", {
 	enumerable: true,
 	get: function() {
@@ -37223,6 +37551,12 @@ Object.defineProperty(exports, "parseJsonUnknown", {
 		return parseJsonUnknown;
 	}
 });
+Object.defineProperty(exports, "parseProcStatus", {
+	enumerable: true,
+	get: function() {
+		return parseProcStatus;
+	}
+});
 Object.defineProperty(exports, "parseProfileBrokerId", {
 	enumerable: true,
 	get: function() {
@@ -37277,6 +37611,12 @@ Object.defineProperty(exports, "resolveEgressDecodeHwAccel", {
 		return resolveEgressDecodeHwAccel;
 	}
 });
+Object.defineProperty(exports, "resolvePoolMemoryPolicy", {
+	enumerable: true,
+	get: function() {
+		return resolvePoolMemoryPolicy;
+	}
+});
 Object.defineProperty(exports, "resolveRecordingProfiles", {
 	enumerable: true,
 	get: function() {

package/dist/{event-loop-stall-monitor-CFWrOZ6G.mjs → event-loop-stall-monitor-BDC8qURn.mjs}

@@ -1,4 +1,4 @@
-import { H as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-XbrYiMV3.mjs";
+import { U as hfModelUrl, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS } from "./dist-LIWfUNC_.mjs";
 import { PerformanceObserver } from "node:perf_hooks";
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/{event-loop-stall-monitor-D9hqbc68.js → event-loop-stall-monitor-DndI0S2s.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BbRv3bM2.js");
+const require_dist = require("./dist-w9QWDvWn.js");
 let node_perf_hooks = require("node:perf_hooks");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/{lazy-sharp-U0EtN7_C.js → lazy-sharp-BVqBydNU.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-BbRv3bM2.js");
+const require_dist = require("./dist-w9QWDvWn.js");
 let node_url = require("node:url");
 let node_module = require("node:module");
 let node_path = require("node:path");

package/dist/motion-wasm/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BbRv3bM2.js");
-const require_lazy_sharp = require("../lazy-sharp-U0EtN7_C.js");
+const require_dist = require("../dist-w9QWDvWn.js");
+const require_lazy_sharp = require("../lazy-sharp-BVqBydNU.js");
 let node_path = require("node:path");
 let node_fs = require("node:fs");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { G as motionDetectionCapability, V as evaluateZoneRules, dt as BaseAddon, gt as hydrateSchema, mt as DeviceType } from "../dist-XbrYiMV3.mjs";
+import { H as evaluateZoneRules, K as motionDetectionCapability, _t as DeviceType, mt as BaseAddon, yt as hydrateSchema } from "../dist-LIWfUNC_.mjs";
 import { t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
 import { join } from "node:path";
 import { readFileSync } from "node:fs";

package/dist/pipeline-runner/index.js

@@ -2,11 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-BbRv3bM2.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-D9hqbc68.js");
-const require_worker_protocol = require("../worker-protocol-CNC-ZcU3.js");
+const require_dist = require("../dist-w9QWDvWn.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DndI0S2s.js");
+const require_worker_protocol = require("../worker-protocol-DqrXmX0g.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-U0EtN7_C.js");
+const require_lazy_sharp = require("../lazy-sharp-BVqBydNU.js");
 const require_remote_restream = require("../remote-restream-BYbAsgUf.js");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);

package/dist/pipeline-runner/index.mjs

@@ -1,6 +1,6 @@
-import { At as literal, Dt as boolean, Et as array, F as deriveDetailCropRect, It as EventCategory, K as pickDetailCropConvention, Mt as object, N as defineCustomActions, Pt as string, Tt as _enum, Y as pipelineRunnerCapability, at as errMsg, bt as nodePin, c as DEFAULT_DETAIL_CROP_CONVENTION, d as DEVICE_BACKEND_TO_FORMAT, dt as BaseAddon, ht as createEvent, j as customAction, jt as number, kt as lazy, q as pickNativeLeaseOverride } from "../dist-XbrYiMV3.mjs";
-import { c as getStepDefinition, t as attributeStall } from "../event-loop-stall-monitor-CFWrOZ6G.mjs";
-import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-D0ewr67U.mjs";
+import { At as boolean, Ct as nodePin, Ft as object, I as deriveDetailCropRect, J as pickDetailCropConvention, Lt as string, M as customAction, Mt as lazy, Nt as literal, Ot as _enum, P as defineCustomActions, Pt as number, Y as pickNativeLeaseOverride, Z as pipelineRunnerCapability, c as DEFAULT_DETAIL_CROP_CONVENTION, ct as errMsg, d as DEVICE_BACKEND_TO_FORMAT, kt as array, mt as BaseAddon, vt as createEvent, zt as EventCategory } from "../dist-LIWfUNC_.mjs";
+import { c as getStepDefinition, t as attributeStall } from "../event-loop-stall-monitor-BDC8qURn.mjs";
+import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-DTe7Ntat.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-6oymT_yf.mjs";
 import { i as withDetectionIntent, n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-Ci7RXNGb.mjs";

package/dist/process-memory-C6zWIgos.js

@@ -0,0 +1,78 @@
+const require_dist = require("./dist-w9QWDvWn.js");
+let node_child_process = require("node:child_process");
+let node_fs = require("node:fs");
+node_fs = require_dist.__toESM(node_fs);
+//#region src/shared/node-topology-platform.ts
+/**
+* Pick a node's `{ platform, arch }` from the cluster topology. Returns an empty
+* object when the topology is missing or the node is absent (caller falls back).
+*/
+function pickNodePlatformArch(topology, nodeId) {
+	const entry = topology?.find((n) => n.id === nodeId);
+	if (!entry) return {};
+	return {
+		platform: entry.platform,
+		arch: entry.arch
+	};
+}
+//#endregion
+//#region src/shared/process-memory.ts
+/**
+* Read a child process's memory footprint for the pool memory watchdog.
+*
+* Linux (the fleet): parse `/proc/<pid>/status` — RSS, VmSize, VmHWM (peak
+* RSS ≈ getrusage maxrss), VmSwap and Threads in one 4 KB read, no exec.
+* macOS (dev only): `ps -o rss=` gives RSS alone; the extended fields read 0.
+*
+* Returns null when the pid is gone or unreadable — the CALLER logs the
+* dropped sample (a pool the watchdog silently stopped seeing is a bound
+* that silently stopped existing).
+*
+* The parse itself (`parseProcStatus`) lives in `@camstack/types` next to the
+* watchdog policy so it is unit-tested once and shared with
+* `addon-post-analysis`, which cannot import this addon. Only the `fs` read
+* lives here.
+*/
+var IS_LINUX = process.platform === "linux";
+async function readProcessMemory(pid) {
+	if (IS_LINUX) try {
+		return require_dist.parseProcStatus(await node_fs.promises.readFile(`/proc/${pid}/status`, "utf8"));
+	} catch {
+		return null;
+	}
+	return readViaPs(pid);
+}
+function readViaPs(pid) {
+	return new Promise((resolve) => {
+		(0, node_child_process.execFile)("ps", [
+			"-o",
+			"rss=",
+			"-p",
+			String(pid)
+		], { timeout: 2e3 }, (err, stdout) => {
+			if (err) return resolve(null);
+			const kb = Number(stdout.trim());
+			if (!Number.isFinite(kb) || kb <= 0) return resolve(null);
+			resolve({
+				rssBytes: kb * 1024,
+				vmBytes: 0,
+				hwmBytes: 0,
+				swapBytes: 0,
+				threads: 0
+			});
+		});
+	});
+}
+//#endregion
+Object.defineProperty(exports, "pickNodePlatformArch", {
+	enumerable: true,
+	get: function() {
+		return pickNodePlatformArch;
+	}
+});
+Object.defineProperty(exports, "readProcessMemory", {
+	enumerable: true,
+	get: function() {
+		return readProcessMemory;
+	}
+});

package/dist/process-memory-k45KJaKH.mjs

@@ -0,0 +1,66 @@
+import { q as parseProcStatus } from "./dist-LIWfUNC_.mjs";
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+//#region src/shared/node-topology-platform.ts
+/**
+* Pick a node's `{ platform, arch }` from the cluster topology. Returns an empty
+* object when the topology is missing or the node is absent (caller falls back).
+*/
+function pickNodePlatformArch(topology, nodeId) {
+	const entry = topology?.find((n) => n.id === nodeId);
+	if (!entry) return {};
+	return {
+		platform: entry.platform,
+		arch: entry.arch
+	};
+}
+//#endregion
+//#region src/shared/process-memory.ts
+/**
+* Read a child process's memory footprint for the pool memory watchdog.
+*
+* Linux (the fleet): parse `/proc/<pid>/status` — RSS, VmSize, VmHWM (peak
+* RSS ≈ getrusage maxrss), VmSwap and Threads in one 4 KB read, no exec.
+* macOS (dev only): `ps -o rss=` gives RSS alone; the extended fields read 0.
+*
+* Returns null when the pid is gone or unreadable — the CALLER logs the
+* dropped sample (a pool the watchdog silently stopped seeing is a bound
+* that silently stopped existing).
+*
+* The parse itself (`parseProcStatus`) lives in `@camstack/types` next to the
+* watchdog policy so it is unit-tested once and shared with
+* `addon-post-analysis`, which cannot import this addon. Only the `fs` read
+* lives here.
+*/
+var IS_LINUX = process.platform === "linux";
+async function readProcessMemory(pid) {
+	if (IS_LINUX) try {
+		return parseProcStatus(await fs.promises.readFile(`/proc/${pid}/status`, "utf8"));
+	} catch {
+		return null;
+	}
+	return readViaPs(pid);
+}
+function readViaPs(pid) {
+	return new Promise((resolve) => {
+		execFile("ps", [
+			"-o",
+			"rss=",
+			"-p",
+			String(pid)
+		], { timeout: 2e3 }, (err, stdout) => {
+			if (err) return resolve(null);
+			const kb = Number(stdout.trim());
+			if (!Number.isFinite(kb) || kb <= 0) return resolve(null);
+			resolve({
+				rssBytes: kb * 1024,
+				vmBytes: 0,
+				hwmBytes: 0,
+				swapBytes: 0,
+				threads: 0
+			});
+		});
+	});
+}
+//#endregion
+export { pickNodePlatformArch as n, readProcessMemory as t };