@camstack/addon-pipeline 1.2.93 → 1.2.95

package/dist/{addon-utils-CTRpEiSd.js → addon-utils-UMWiMAxR.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-D9To_r_d.js");
+const require_dist = require("./dist-hyryByiw.js");
 require("node:crypto");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path, 1);

package/dist/audio-analyzer/index.js

@@ -2,9 +2,9 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-D9To_r_d.js");
-const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
-const require_addon_utils = require("../addon-utils-CTRpEiSd.js");
+const require_dist = require("../dist-hyryByiw.js");
+const require_process_memory = require("../process-memory-B9-UD7Rp.js");
+const require_addon_utils = require("../addon-utils-UMWiMAxR.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_fs = require("node:fs");
@@ -135,6 +135,9 @@ var YamnetPythonPipeline = class {
 		if (ready["status"] !== "ready") throw new Error(`YAMNet Python: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info(`YAMNet Python pipeline initialized (${String(ready["labels"] ?? "?")} labels)`);
 	}
+	getPid() {
+		return this.process?.pid ?? null;
+	}
 	async classify(chunk) {
 		if (!this.process?.stdin) throw new Error("YAMNet Python: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
@@ -241,6 +244,9 @@ var AppleSoundAnalysisPipeline = class {
 		if (ready["status"] !== "ready") throw new Error(`Apple SoundAnalysis: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info("Apple SoundAnalysis pipeline initialized (macOS built-in, Swift CLI bridge)");
 	}
+	getPid() {
+		return this.process?.pid ?? null;
+	}
 	async classify(chunk) {
 		if (!this.process?.stdin) throw new Error("Apple SoundAnalysis: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
@@ -477,6 +483,53 @@ var AudioAnalyzerProvider = class {
 		this.log = logger;
 		this.backendName = initialBackend;
 		this.desiredBackend = initialBackend;
+		this.memoryGuard = new require_dist.PoolMemoryWatchdog({
+			policy: require_dist.resolvePoolMemoryPolicy(process.env),
+			log: this.log.child("pool-memory"),
+			sample: () => this.samplePipelineMemory(),
+			restart: () => this.restartPipelineForMemory()
+		});
+		this.memoryGuard.start();
+	}
+	/** Memory watchdog for the inference subprocess (see constructor). */
+	memoryGuard;
+	async samplePipelineMemory() {
+		const live = this.pipeline;
+		const pid = live?.getPid() ?? null;
+		if (!live || pid === null) return [];
+		const mem = await require_process_memory.readProcessMemory(pid);
+		if (!mem) {
+			this.log.warn("audio pipeline memory sample dropped", { meta: {
+				pid,
+				backend: this.backendName
+			} });
+			return [];
+		}
+		const mb = (bytes) => Math.round(bytes / (1024 * 1024));
+		return [{
+			key: "audio",
+			pids: [pid],
+			rssBytes: mem.rssBytes,
+			meta: {
+				backend: this.backendName,
+				vmMb: mb(mem.vmBytes),
+				peakRssMb: mb(mem.hwmBytes),
+				swapMb: mb(mem.swapBytes),
+				threads: mem.threads,
+				classifyCount: this.classifyCount
+			}
+		}];
+	}
+	/** Watchdog restart: tear the subprocess down NOW; the next classify
+	*  re-spawns lazily (same recovery as an idle-dispose). An in-flight
+	*  classify fails once and is handled by the existing classify error
+	*  path — a bounded gap, unlike the kernel's OOM alternative. */
+	async restartPipelineForMemory() {
+		if (this.disposed) return;
+		const live = this.pipeline;
+		if (!live) return;
+		this.pipeline = null;
+		await live.dispose();
 	}
 	/**
 	* Lazily spawn + initialize the inference pipeline on first use. The
@@ -712,6 +765,7 @@ var AudioAnalyzerProvider = class {
 	}
 	async dispose() {
 		this.disposed = true;
+		this.memoryGuard.stop();
 		if (this.idleTimer) {
 			clearTimeout(this.idleTimer);
 			this.idleTimer = null;
@@ -890,7 +944,7 @@ var AudioAnalyzerAddon = class extends require_dist.BaseAddon {
 		const localNode = this.ctxIfReady?.kernel?.localNodeId;
 		if (!nodeId || nodeId === localNode) return process.platform;
 		try {
-			const { platform } = require_node_topology_platform.pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
+			const { platform } = require_process_memory.pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
 			if (platform) return platform;
 		} catch {}
 		return process.platform;

package/dist/audio-analyzer/index.mjs

@@ -1,6 +1,6 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { D as audioAnalyzerCapability, E as audioAnalysisCapability, U as mapAudioLabelToMacro, at as errMsg, dt as BaseAddon, gt as hydrateSchema, h as HF_BASE_URL, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG } from "../dist-6POVIYmC.mjs";
-import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
+import { D as audioAnalysisCapability, O as audioAnalyzerCapability, W as mapAudioLabelToMacro, ct as errMsg, h as HF_BASE_URL, mt as BaseAddon, n as AUDIO_BACKEND_CHOICES, s as DEFAULT_AUDIO_ANALYZER_CONFIG, tt as resolvePoolMemoryPolicy, y as PoolMemoryWatchdog, yt as hydrateSchema } from "../dist-C49o1k7u.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DXOB6eHX.mjs";
 import { i as downloadFile } from "../addon-utils-A2S9D7pu.mjs";
 import * as path$1 from "node:path";
 import * as fs from "node:fs";
@@ -130,6 +130,9 @@ var YamnetPythonPipeline = class {
 		if (ready["status"] !== "ready") throw new Error(`YAMNet Python: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info(`YAMNet Python pipeline initialized (${String(ready["labels"] ?? "?")} labels)`);
 	}
+	getPid() {
+		return this.process?.pid ?? null;
+	}
 	async classify(chunk) {
 		if (!this.process?.stdin) throw new Error("YAMNet Python: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
@@ -236,6 +239,9 @@ var AppleSoundAnalysisPipeline = class {
 		if (ready["status"] !== "ready") throw new Error(`Apple SoundAnalysis: unexpected init response: ${JSON.stringify(ready)}`);
 		this.log.info("Apple SoundAnalysis pipeline initialized (macOS built-in, Swift CLI bridge)");
 	}
+	getPid() {
+		return this.process?.pid ?? null;
+	}
 	async classify(chunk) {
 		if (!this.process?.stdin) throw new Error("Apple SoundAnalysis: process not initialized");
 		const waveform = chunk.sampleRate === 16e3 && chunk.channels === 1 ? chunk.data : resampleMono16k(chunk);
@@ -472,6 +478,53 @@ var AudioAnalyzerProvider = class {
 		this.log = logger;
 		this.backendName = initialBackend;
 		this.desiredBackend = initialBackend;
+		this.memoryGuard = new PoolMemoryWatchdog({
+			policy: resolvePoolMemoryPolicy(process.env),
+			log: this.log.child("pool-memory"),
+			sample: () => this.samplePipelineMemory(),
+			restart: () => this.restartPipelineForMemory()
+		});
+		this.memoryGuard.start();
+	}
+	/** Memory watchdog for the inference subprocess (see constructor). */
+	memoryGuard;
+	async samplePipelineMemory() {
+		const live = this.pipeline;
+		const pid = live?.getPid() ?? null;
+		if (!live || pid === null) return [];
+		const mem = await readProcessMemory(pid);
+		if (!mem) {
+			this.log.warn("audio pipeline memory sample dropped", { meta: {
+				pid,
+				backend: this.backendName
+			} });
+			return [];
+		}
+		const mb = (bytes) => Math.round(bytes / (1024 * 1024));
+		return [{
+			key: "audio",
+			pids: [pid],
+			rssBytes: mem.rssBytes,
+			meta: {
+				backend: this.backendName,
+				vmMb: mb(mem.vmBytes),
+				peakRssMb: mb(mem.hwmBytes),
+				swapMb: mb(mem.swapBytes),
+				threads: mem.threads,
+				classifyCount: this.classifyCount
+			}
+		}];
+	}
+	/** Watchdog restart: tear the subprocess down NOW; the next classify
+	*  re-spawns lazily (same recovery as an idle-dispose). An in-flight
+	*  classify fails once and is handled by the existing classify error
+	*  path — a bounded gap, unlike the kernel's OOM alternative. */
+	async restartPipelineForMemory() {
+		if (this.disposed) return;
+		const live = this.pipeline;
+		if (!live) return;
+		this.pipeline = null;
+		await live.dispose();
 	}
 	/**
 	* Lazily spawn + initialize the inference pipeline on first use. The
@@ -707,6 +760,7 @@ var AudioAnalyzerProvider = class {
 	}
 	async dispose() {
 		this.disposed = true;
+		this.memoryGuard.stop();
 		if (this.idleTimer) {
 			clearTimeout(this.idleTimer);
 			this.idleTimer = null;

package/dist/detection-pipeline/index.js

@@ -2,11 +2,11 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-D9To_r_d.js");
-const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-CGacbzXq.js");
-const require_lazy_sharp = require("../lazy-sharp-C3zOnmiU.js");
-const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
-const require_addon_utils = require("../addon-utils-CTRpEiSd.js");
+const require_dist = require("../dist-hyryByiw.js");
+const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DPNTzGOT.js");
+const require_lazy_sharp = require("../lazy-sharp-Dxg6UeW-.js");
+const require_process_memory = require("../process-memory-B9-UD7Rp.js");
+const require_addon_utils = require("../addon-utils-UMWiMAxR.js");
 let sharp = require("sharp");
 sharp = require_dist.__toESM(sharp);
 let node_child_process = require("node:child_process");
@@ -708,6 +708,14 @@ var PoolWorker = class {
 		const payload = Buffer.from(JSON.stringify(cmd), "utf8");
 		return await this.dispatch(MSG_COMMAND, payload);
 	}
+	/** Command whose reply shape is NOT the load/unload/replace/status envelope
+	*  (e.g. `mem_stats`) — returns the raw JSON record, so no cast is needed
+	*  at the call site. */
+	async sendRawCommand(cmd) {
+		this.ensureReady();
+		const payload = Buffer.from(JSON.stringify(cmd), "utf8");
+		return this.dispatch(MSG_COMMAND, payload);
+	}
 	async dispose() {
 		const proc = this.process;
 		if (!proc) return;
@@ -1072,6 +1080,46 @@ var SharedInferencePool = class {
 		for (const resp of responses) if (resp.status !== "ok") throw new Error(`Failed to replace model at index ${index}: ${resp.error ?? "unknown"}`);
 		return { loadMs: Math.max(...responses.map((r) => r.loadMs ?? 0)) };
 	}
+	/**
+	* Per-worker Python-side memory diagnostics (`mem_stats` command):
+	* RSS/VmSize/peak/threads from /proc/self, getrusage maxrss, glibc malloc
+	* arena count, gc counts, served-request counters, per-model queue depth,
+	* cache entry counts. Queried by the pool memory watchdog once per sweep —
+	* the internals that distinguish "leak" from "working set" and that
+	* /proc/<pid> alone cannot see. A worker that is not ready (or whose
+	* command fails) contributes an `error` record instead of vanishing.
+	*/
+	async getMemStats() {
+		const out = [];
+		for (const [i, w] of this.workers.entries()) {
+			if (!w.isReady()) {
+				out.push({
+					worker: `w${i}`,
+					pid: w.getPid(),
+					stats: null,
+					error: "worker not ready"
+				});
+				continue;
+			}
+			try {
+				const stats = await w.sendRawCommand({ cmd: "mem_stats" });
+				out.push({
+					worker: `w${i}`,
+					pid: w.getPid(),
+					stats,
+					error: null
+				});
+			} catch (err) {
+				out.push({
+					worker: `w${i}`,
+					pid: w.getPid(),
+					stats: null,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		}
+		return out;
+	}
 	async getStatus() {
 		if (this.workers.length === 0) return [];
 		return (await this.workers[0].sendCommand({ cmd: "status" })).models ?? [];
@@ -1790,6 +1838,29 @@ var EngineFactory = class {
 	getPoolPid() {
 		return this.pool?.getPid() ?? null;
 	}
+	/** All live worker pids of the underlying Python pool (memory watchdog). */
+	getPoolPids() {
+		return (this.pool?.getPids() ?? []).filter((pid) => pid !== null);
+	}
+	/** Summed backlog / shed / dropped across the pool's workers — the cheap
+	*  internals the memory watchdog attaches to its periodic `pool memory`
+	*  line so a leak (RSS up, work flat) is separable from load. */
+	getPoolBacklog() {
+		if (!this.pool) return {
+			inFlight: 0,
+			shed: 0,
+			dropped: 0
+		};
+		return {
+			...this.pool.getBacklog(),
+			dropped: this.pool.getDroppedResponseCount()
+		};
+	}
+	/** Python-side per-worker memory diagnostics (see SharedInferencePool). */
+	async getPoolMemStats() {
+		if (!this.pool) return [];
+		return this.pool.getMemStats();
+	}
 	/**
 	* Whether this factory exposes the batched fast path (`batchInferRaw`).
 	*/
@@ -1999,6 +2070,65 @@ var IdlePoolReaper = class {
 	}
 };
 //#endregion
+//#region src/detection-pipeline/engine/pool-memory-guard.ts
+function createDetectionPoolMemoryGuard(source, logger) {
+	const log = logger.child("pool-memory");
+	return new require_dist.PoolMemoryWatchdog({
+		policy: require_dist.resolvePoolMemoryPolicy(process.env),
+		log,
+		restart: (key) => source.restartPool(key),
+		sample: async () => {
+			const out = [];
+			for (const pool of source.listPools()) {
+				const telemetry = await samplePool(pool, log);
+				if (telemetry) out.push(telemetry);
+			}
+			return out;
+		}
+	});
+}
+async function samplePool(pool, log) {
+	const pids = pool.factory.getPoolPids();
+	if (pids.length === 0) return null;
+	let maxRssBytes = 0;
+	const workers = [];
+	for (const pid of pids) {
+		const mem = await require_process_memory.readProcessMemory(pid);
+		if (!mem) {
+			log.warn("pool memory sample dropped for worker pid", { meta: {
+				poolKey: pool.key,
+				pid
+			} });
+			continue;
+		}
+		if (mem.rssBytes > maxRssBytes) maxRssBytes = mem.rssBytes;
+		workers.push({
+			pid,
+			rssMb: Math.round(mem.rssBytes / (1024 * 1024)),
+			vmMb: Math.round(mem.vmBytes / (1024 * 1024)),
+			peakRssMb: Math.round(mem.hwmBytes / (1024 * 1024)),
+			swapMb: Math.round(mem.swapBytes / (1024 * 1024)),
+			threads: mem.threads
+		});
+	}
+	if (workers.length === 0) return null;
+	const backlog = pool.factory.getPoolBacklog();
+	const memStats = await pool.factory.getPoolMemStats().catch((err) => err instanceof Error ? err.message : String(err));
+	return {
+		key: pool.key,
+		pids,
+		rssBytes: maxRssBytes,
+		meta: {
+			workers,
+			inFlight: backlog.inFlight,
+			shed: backlog.shed,
+			dropped: backlog.dropped,
+			modelsLoaded: pool.factory.listLoaded().length,
+			memStats
+		}
+	};
+}
+//#endregion
 //#region src/detection-pipeline/engine-provisioner.ts
 /** Incremental backoff growing to a ~5 min cap; retries indefinitely at cap. */
 var BACKOFF_SCHEDULE_MS = [
@@ -4790,6 +4920,55 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} })
 	});
 	static OVERRIDE_CACHE_TTL_MS = 6e4;
+	/**
+	* RSS bound + periodic memory telemetry for the Python inference pools
+	* (2026-08-18 OOM audit: the pools, not the recorder, were the host's OOM
+	* driver — grow for hours, kernel-killed at 3.8/8.8 GB, respawn, repeat).
+	* Policy, restart budget and the `pool memory` Loki line live in
+	* `@camstack/types` (`PoolMemoryWatchdog`); this provider only enumerates
+	* its pools and exposes its EXISTING dispose-and-recreate machinery as the
+	* restart action. Started in `init()`, stopped in `shutdown()`.
+	*/
+	poolMemoryGuard = null;
+	/** Watchdog view of the live pools: the node-default pool plus every
+	*  per-device pool. Keys are stable per pool identity so the watchdog's
+	*  baseline tracks one pool across sweeps. */
+	listGuardedPools() {
+		const pools = [];
+		if (this.engineFactory) pools.push({
+			key: `default:${deviceKeyOf(this.currentEngine)}`,
+			factory: this.engineFactory
+		});
+		for (const [deviceKey, factory] of this.factoriesByDevice) pools.push({
+			key: deviceKey,
+			factory
+		});
+		return pools;
+	}
+	/**
+	* Watchdog restart action — the same dispose-then-lazy-recreate the idle
+	* reaper and the tuning respawn already use, never a second lifecycle. The
+	* map/field is cleared FIRST so a concurrent dispatch rebuilds fresh via
+	* the single-flight guards instead of grabbing the disposing instance;
+	* models reload on the next dispatch via `ensureModelsForSteps`. Frames
+	* arriving during the seconds-long re-spin are dropped (and counted by the
+	* existing shed/timeout paths), not crashed — a bounded gap, unlike the
+	* kernel's alternative.
+	*/
+	async restartGuardedPool(key) {
+		if (key.startsWith("default:")) {
+			const factory = this.engineFactory;
+			if (!factory) return;
+			this.engineFactory = null;
+			await factory.dispose();
+			return;
+		}
+		const factory = this.factoriesByDevice.get(key);
+		if (!factory) return;
+		this.factoriesByDevice.delete(key);
+		this.deviceReaper.cancel(key);
+		await factory.dispose();
+	}
 	/** Read the addon settings store (all keys). */
 	readStore;
 	/** Write a patch to the addon settings store. */
@@ -4825,6 +5004,13 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async init() {
 		this.needsAutoPick = true;
 		this.log.info("Node-default engine derive deferred to setApi()");
+		if (!this.poolMemoryGuard) {
+			this.poolMemoryGuard = createDetectionPoolMemoryGuard({
+				listPools: () => this.listGuardedPools(),
+				restartPool: (key) => this.restartGuardedPool(key)
+			}, this.log);
+			this.poolMemoryGuard.start();
+		}
 	}
 	/**
 	* Lazy-install the pip requirements file matching `engine.backend` into
@@ -6655,6 +6841,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		};
 	}
 	async shutdown() {
+		this.poolMemoryGuard?.stop();
+		this.poolMemoryGuard = null;
 		await this.evictOverrideCache("shutdown");
 		if (this.engineFactory) {
 			await this.engineFactory.dispose();
@@ -7798,7 +7986,7 @@ var DetectionPipelineAddon = class extends require_dist.BaseAddon {
 	*/
 	async resolveTopologyPlatform(nodeId) {
 		try {
-			const picked = require_node_topology_platform.pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
+			const picked = require_process_memory.pickNodePlatformArch(await this.ctxIfReady?.api?.nodes?.topology.query(), nodeId);
 			return {
 				platform: toNodePlatform(picked.platform),
 				arch: picked.arch