@camstack/system 1.2.60 → 1.2.62

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { startHeapWatch, buildHeapSample, HEAP_WATCH_INTERVAL_MS, HEAP_WATCH_WARN_RATIO, } from './kernel/heap-watch.js';
-export type { HeapSample, HeapWatchSink } from './kernel/heap-watch.js';
+export { startHeapWatch, buildHeapSample, createV8Reclaimer, shouldReclaim, strandedMb, HEAP_WATCH_INTERVAL_MS, HEAP_WATCH_WARN_RATIO, HEAP_RECLAIM_TRIGGER_MB, HEAP_RECLAIM_MIN_INTERVAL_MS, } from './kernel/heap-watch.js';
+export type { HeapSample, HeapWatchSink, HeapReclaimer, HeapReclaimOptions, } from './kernel/heap-watch.js';
 export { ensureBinary, downloadBinary, findInPath, getPlatformInfo, buildBinaryPath, ensureFfmpeg, getFfmpegDownloadUrl, ensurePython, installPythonPackages, installPythonRequirements, getPythonDownloadUrl, PYTHON_VERSION, } from '@camstack/types/node';
 export type { PlatformInfo } from '@camstack/types/node';
 export { ALL_CAPABILITY_DEFINITIONS, METHOD_ACCESS_MAP, expandCapMethods, isArrayOutputSchema, isCollectionArrayMethod, addonSettingsCapability, DEVICE_SETTINGS_CONTRIBUTION_METHODS, DEVICE_STATUS_METHOD, } from '@camstack/types';

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_dist = require("./dist-Cis_iV-u.js");
+const require_dist = require("./dist-DgPUarcs.js");
 const require_model_download_service = require("./model-download-service-Cpc6SWzV.js");
 const require_manifest_python_deps = require("./manifest-python-deps-d4acYXVV.js");
 const require_resource_monitor = require("./resource-monitor-DNNomR-i.js");
@@ -30,6 +30,8 @@ require("./builtins/device-manager/index.js");
 const require_custom_action_registry = require("./custom-action-registry-jY0NOZK8.js");
 let node_v8 = require("node:v8");
 node_v8 = require_chunk.__toESM(node_v8);
+let node_vm = require("node:vm");
+node_vm = require_chunk.__toESM(node_vm);
 let _camstack_types_node = require("@camstack/types/node");
 let zod = require("zod");
 let node_crypto = require("node:crypto");
@@ -43,8 +45,6 @@ let _camstack_types_addon = require("@camstack/types/addon");
 let node_child_process = require("node:child_process");
 let node_util = require("node:util");
 node_util = require_chunk.__toESM(node_util);
-let node_vm = require("node:vm");
-node_vm = require_chunk.__toESM(node_vm);
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs_promises = require("node:fs/promises");
@@ -60,13 +60,15 @@ path = require_chunk.__toESM(path, 1);
 let module$1 = require("module");
 //#region src/kernel/heap-watch.ts
 /**
-* heap-watch — hub-main's own memory, on the record.
+* heap-watch — hub-main's own memory, on the record, and returned to the OS.
 *
 * ## Why this exists
 *
-* hub-main is launched with `--max-old-space-size=1536` (docker-entrypoint) and
-* has logged NOTHING about its own heap. When it died on 2026-08-01/02 the only
-* trace was V8's own stderr line:
+* hub-main used to be launched with `--max-old-space-size=1536` (docker-entrypoint;
+* the cap was removed on 2026-08-02, so the live ceiling is now V8's own default —
+* 4288MB in this container — and this module reads it at runtime rather than
+* assuming a number). It logged NOTHING about its own heap. When it died on
+* 2026-08-01/02 the only trace was V8's own stderr line:
 *
 *     FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
 *
@@ -94,6 +96,41 @@ let module$1 = require("module");
 * `--max-old-space-size` and are most of the gap between a 1.5GB cap and the
 * ~2.05GB RSS observed live: a diagnosis that only looks at the JS heap
 * misreads that process by 500MB.
+*
+* ## And then the heartbeat explained the "off-heap leak", which was not one
+*
+* 2026-08-08, measured on the live hub over 1019 consecutive samples and seven
+* separate boots: **hub-main's RSS is a HIGH-WATER MARK, not a leak.** In every
+* one of those 1019 samples RSS was >= the running maximum of
+* `heapTotal + external`, never once below it, and
+* `RSS_peak - peak(heapTotal + external)` landed between 874MB and 1639MB on
+* every boot — a roughly constant native floor on top of a number that only
+* ever goes up. RSS tracked the highest point the process ever reached and
+* stayed there: 3.3GB -> 4.5GB -> 5.2GB, and 7.8GB on the worst boot.
+*
+* Two things push that peak, and neither is a retained object:
+*
+*  - the JS heap sawtooths to 2.0-2.8GB because the ceiling is 4288MB and
+*    nothing creates pressure before then;
+*  - `arrayBuffers` accumulates DEAD Buffers — up to 3.65GB — because V8 only
+*    sweeps them on a major GC. Eleven collapses were captured, and every
+*    single one coincides with `heapUsed` dropping to its ~650MB floor. No code
+*    released a reference at 13:23:03; a mark-compact ran.
+*
+* At the peak V8 has committed the pages, and **an ordinary major GC does not
+* give them back.** Proven on the production hub: `smaps` showed 10,819 mapped
+* 256KB pages (V8's `kRegularPageSize`) holding 2704MB while V8 itself reported
+* `total_physical_size` of only 846MB — ~7,800 pages committed, resident, and
+* outside V8's own accounting. One `gc({ flavor: 'last-resort' })` took 417ms
+* and returned RSS 3355MB -> 1237MB, pages 10,819 -> 2,963.
+*
+* So the fix for the "~3GB/2h off-heap growth" is not a retainer hunt. It is to
+* ask V8 for the pages back when the process is visibly holding more than it is
+* using — which is what `shouldReclaim` decides and what the heartbeat now does.
+*
+* The cost is a 250-450ms stop-the-world on the hub's router process, bounded to
+* once per `HEAP_RECLAIM_MIN_INTERVAL_MS`. The alternative, measured, is a
+* ratchet to 7.8GB and the OOM that ends it.
 */
 /** Heartbeat period. Slow enough to be free, fast enough that the sample before
 *  a fatal is recent. */
@@ -101,6 +138,20 @@ var HEAP_WATCH_INTERVAL_MS = 6e4;
 /** Warn above this share of the heap ceiling. Chosen so the warning precedes
 *  the fatal by more than one interval under realistic growth. */
 var HEAP_WATCH_WARN_RATIO = .8;
+/**
+* Reclaim once the process holds this many MB beyond what it is USING.
+*
+* Live calibration, both readings from the same hub minutes apart: 2491MB
+* stranded before the reclaim, 438MB after. 438MB is this process's irreducible
+* native floor (sqlite pages, libvips, sharp, thread stacks, node's own text) —
+* collecting against it would buy nothing and cost a stall every minute. 1536
+* sits clear of that floor and still fires ~1.1GB before the ratchet is worth
+* anything, so it triggers on the real condition and stops as soon as it is fixed.
+*/
+var HEAP_RECLAIM_TRIGGER_MB = 1536;
+/** Floor on how often the stop-the-world may run. 250-450ms measured, so ten
+*  minutes keeps the worst case under 0.1% of the router's time. */
+var HEAP_RECLAIM_MIN_INTERVAL_MS = 6e5;
 var MB = (bytes) => Math.round(bytes / 1048576);
 /**
 * Build a sample from raw readings. Pure so the thresholds are testable without
@@ -123,6 +174,47 @@ var consoleSink = {
 	info: (line) => console.log(line),
 	warn: (line) => console.warn(line)
 };
+/**
+* RSS the process is holding but not using.
+*
+* The subtrahend is heapUSED, not heapTotal, deliberately: the pages V8
+* committed at a sawtooth peak and no longer needs are counted inside heapTotal,
+* and they are precisely what this number exists to see.
+*/
+function strandedMb(s) {
+	return s.rssMb - s.heapUsedMb - s.externalMb;
+}
+/** Whether it is worth paying a stop-the-world to get those pages back. */
+function shouldReclaim(s, triggerMb = HEAP_RECLAIM_TRIGGER_MB) {
+	return strandedMb(s) > triggerMb;
+}
+function isGcFunction(value) {
+	return typeof value === "function";
+}
+/**
+* Build the reclaimer without requiring `--expose-gc` on argv.
+*
+* The flag is turned on, the function captured, and the flag turned straight
+* back off — a global `gc` left reachable by application code is a footgun, and
+* requiring an argv change would mean this cannot ship without a new image.
+* Verified against the live hub before being written: 266ms, RSS 1453 -> 1237.
+*
+* Returns undefined if V8 declines, so the caller keeps a heartbeat either way.
+*/
+function createV8Reclaimer() {
+	try {
+		node_v8.setFlagsFromString("--expose-gc");
+		const gc = node_vm.runInNewContext("gc");
+		node_v8.setFlagsFromString("--no-expose-gc");
+		if (!isGcFunction(gc)) return void 0;
+		return () => gc({
+			execution: "sync",
+			flavor: "last-resort"
+		});
+	} catch {
+		return;
+	}
+}
 function format$1(label, s) {
 	return `[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`;
 }
@@ -132,13 +224,38 @@ function format$1(label, s) {
 * `unref`ed so it can never hold the process open, and every read is wrapped:
 * a diagnostic that can crash the process it watches is worse than none.
 */
-function startHeapWatch(label = "hub-main", sink = consoleSink, intervalMs = HEAP_WATCH_INTERVAL_MS) {
+function startHeapWatch(label = "hub-main", sink = consoleSink, intervalMs = HEAP_WATCH_INTERVAL_MS, reclaimOptions) {
+	const readMemory = reclaimOptions?.readMemory ?? (() => process.memoryUsage());
+	const now = reclaimOptions?.now ?? (() => Date.now());
+	const triggerMb = reclaimOptions?.triggerMb ?? 1536;
+	const minIntervalMs = reclaimOptions?.minIntervalMs ?? 6e5;
+	let lastReclaimAt = Number.NEGATIVE_INFINITY;
+	const read = () => {
+		const limit = reclaimOptions?.heapLimitBytes ?? node_v8.getHeapStatistics().heap_size_limit;
+		return buildHeapSample(readMemory(), limit);
+	};
+	const maybeReclaim = (sample) => {
+		if (reclaimOptions === void 0) return;
+		if (!shouldReclaim(sample, triggerMb)) return;
+		if (now() - lastReclaimAt < minIntervalMs) return;
+		lastReclaimAt = now();
+		const startedAt = now();
+		try {
+			reclaimOptions.reclaim();
+		} catch (error) {
+			sink.warn(`[mem] reclaim failed — ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+		const after = read();
+		sink.info(`[mem] reclaim ${label} stranded=${strandedMb(sample)}MB rss=${sample.rssMb}MB→${after.rssMb}MB freed=${sample.rssMb - after.rssMb}MB arrayBuffers=${sample.arrayBuffersMb}MB→${after.arrayBuffersMb}MB took=${now() - startedAt}ms`);
+	};
 	const tick = () => {
 		try {
-			const sample = buildHeapSample(process.memoryUsage(), node_v8.getHeapStatistics().heap_size_limit);
+			const sample = read();
 			const line = format$1(label, sample);
 			if (sample.nearLimit) sink.warn(`${line} — APPROACHING HEAP LIMIT`);
 			else sink.info(line);
+			maybeReclaim(sample);
 		} catch {}
 	};
 	const timer = setInterval(tick, intervalMs);
@@ -3239,7 +3356,12 @@ var MANIFEST_VERSION = 1;
 * workspace source. Trusting the dirent there finds zero addons on disk, which
 * with pruning would empty a developer's manifest on the next boot.
 */
-function isDirLike(p) {
+/** `@camstack/system` → `system`: the directory a package must live in. */
+function packageDirName$1(declaredName) {
+	const slash = declaredName.lastIndexOf("/");
+	return slash === -1 ? declaredName : declaredName.slice(slash + 1);
+}
+function isDirLike$1(p) {
 	try {
 		return node_fs.statSync(p).isDirectory();
 	} catch {
@@ -3373,10 +3495,10 @@ var AddonManifest = class {
 		/** Package name → version, for every ADDON package actually installed. */
 		const onDisk = /* @__PURE__ */ new Map();
 		for (const scope of node_fs.readdirSync(addonsDir, { withFileTypes: true })) {
-			if (!scope.name.startsWith("@") || !isDirLike(node_path.join(addonsDir, scope.name))) continue;
+			if (!scope.name.startsWith("@") || !isDirLike$1(node_path.join(addonsDir, scope.name))) continue;
 			const scopeDir = node_path.join(addonsDir, scope.name);
 			for (const pkg of node_fs.readdirSync(scopeDir, { withFileTypes: true })) {
-				if (!isDirLike(node_path.join(scopeDir, pkg.name))) continue;
+				if (!isDirLike$1(node_path.join(scopeDir, pkg.name))) continue;
 				const pkgJsonPath = node_path.join(scopeDir, pkg.name, "package.json");
 				if (!node_fs.existsSync(pkgJsonPath)) continue;
 				let pkgJson;
@@ -3390,6 +3512,7 @@ var AddonManifest = class {
 				if (!pkgJson.name || !pkgJson.version) continue;
 				const addons = pkgJson.camstack?.addons;
 				if (!Array.isArray(addons) || addons.length === 0) continue;
+				if (packageDirName$1(pkgJson.name) !== pkg.name) continue;
 				onDisk.set(pkgJson.name, pkgJson.version);
 			}
 		}
@@ -4907,6 +5030,199 @@ function isDirEntry(entry, parentDir) {
 	return false;
 }
 //#endregion
+//#region src/kernel/addon-residue.ts
+/**
+* Residue quarantine for the ONE addon root.
+*
+* ── The bug class this closes ──────────────────────────────────────────────
+* `<dataDir>/addons/@camstack/<pkg>` is the only directory a node loads addons
+* from. Renaming a package inside it does NOT archive it — the directory name
+* is decoration, and three independent consumers key on the `package.json`
+* they find inside:
+*
+*   - `AddonLoader.loadFromDirectory` walks `@scope/*` and loads anything with
+*     a `package.json`; its skip list is keyed on the PACKAGE name, so
+*     `@camstack/system.bak-pre-unshadow` was never skipped;
+*   - the agent's `resolveAddonPackageDirs` scans on the same rule;
+*   - `AddonManifest.reconcileFromDisk` does `onDisk.set(pkgJson.name, …)`,
+*     so the backup's version becomes the version the manifest — and every
+*     surface reading it — REPORTS.
+*
+* Measured 2026-08-07/08 on the live cluster:
+*
+*   little-unraid  `@camstack/system.bak-pre-unshadow` — no package.json left,
+*                  so not loadable, but the agent main process held five live
+*                  mappings of `better_sqlite3.node` out of it (D87).
+*   macmini        `@camstack/system.bak-pre-1272-1786129145` — still declares
+*                  `@camstack/system@1.2.3` (17 days old, 97 MB). The data root
+*                  has NO `addons/@camstack/system` directory at all, yet the
+*                  manifest reports `@camstack/system 1.2.3` — read straight
+*                  out of the backup. The live process still had the backup's
+*                  `better_sqlite3.node` mapped `txt` against a 1.2.61 closure.
+*
+* ── Why quarantine and not delete ─────────────────────────────────────────
+* The same evening, a cleanup that DELETED what it judged to be a shadow copy
+* removed the only builtins an agent had and gutted the node. So this never
+* deletes: it renames out of the scanned root into `.quarantine/`, logs every
+* move by name, reason and both paths, and leaves the bytes recoverable. A
+* silent sweep reads as "nothing was here", which is the failure mode that
+* made the original one unobservable.
+*
+* `.quarantine` sits beside `.staging` / `.backups` / `.evicting` under the
+* addon root: dot-prefixed, carrying no `package.json` at its top level, so no
+* scanner descends into it.
+*/
+/** Where residue is moved to, relative to the addon root. */
+var QUARANTINE_DIRNAME = ".quarantine";
+/**
+* A backup marker: a `.bak` / `.old` / `.orig` segment, not merely those
+* letters. `.backups` — the installer's own rollback store — must NOT match,
+* and it is also excluded by the dot rule below; the pattern stays tight
+* anyway so the two guards are independent.
+*/
+var BACKUP_MARKER = /\.(bak|old|orig)(?![a-z])/i;
+/** Installer-owned stores and node's own tree. Never candidates. */
+function isReservedDir(dirName) {
+	return dirName.startsWith(".") || dirName === "node_modules";
+}
+/** `@camstack/system` → `system`; `foo` → `foo`. */
+function packageDirName(declaredName) {
+	const slash = declaredName.lastIndexOf("/");
+	return slash === -1 ? declaredName : declaredName.slice(slash + 1);
+}
+/**
+* Is this directory residue? Returns the verdict, or null to keep it.
+*
+* A directory with no `package.json` is NOT residue on that ground alone —
+* `models/`, a half-finished copy, a scratch dir are all absence, not a
+* rename. Only a backup marker condemns one.
+*/
+function classifyAddonDir(candidate) {
+	const { dirName, declaredName } = candidate;
+	if (isReservedDir(dirName)) return null;
+	if (BACKUP_MARKER.test(dirName)) return {
+		dirName,
+		declaredName,
+		reason: "backup-residue"
+	};
+	if (declaredName !== null && packageDirName(declaredName) !== dirName) return {
+		dirName,
+		declaredName,
+		reason: "name-mismatch"
+	};
+	return null;
+}
+function selectAddonResidue(candidates) {
+	const out = [];
+	for (const candidate of candidates) {
+		const verdict = classifyAddonDir(candidate);
+		if (verdict !== null) out.push(verdict);
+	}
+	return out;
+}
+function readDeclaredName(dir) {
+	try {
+		const parsed = JSON.parse(node_fs.readFileSync(node_path.join(dir, "package.json"), "utf-8"));
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const name = parsed.name;
+		return typeof name === "string" ? name : null;
+	} catch {
+		return null;
+	}
+}
+function readDeclaredVersion(dir) {
+	try {
+		const parsed = JSON.parse(node_fs.readFileSync(node_path.join(dir, "package.json"), "utf-8"));
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const version = parsed.version;
+		return typeof version === "string" ? version : null;
+	} catch {
+		return null;
+	}
+}
+function isDirLike(p) {
+	try {
+		return node_fs.statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+/** `<scope>__<dir>`, suffixed until free — two sweeps must not overwrite. */
+function freeQuarantineTarget(store, scope, dirName) {
+	const base = scope === null ? dirName : `${scope.replace("@", "")}__${dirName}`;
+	let candidate = node_path.join(store, base);
+	let n = 1;
+	while (node_fs.existsSync(candidate)) {
+		candidate = node_path.join(store, `${base}-${n}`);
+		n += 1;
+	}
+	return candidate;
+}
+/**
+* Move every residue directory under `addonsDir` into `addonsDir/.quarantine`.
+*
+* Runs at boot, BEFORE anything scans the root or seeds into it — a residue
+* that is still present when the loader walks has already been installed.
+* Never throws, never deletes; a move that fails is reported and left in
+* place, which is strictly better than a half-moved package.
+*/
+function quarantineAddonResidue(addonsDir, log) {
+	const quarantined = [];
+	const failed = [];
+	if (!node_fs.existsSync(addonsDir)) return {
+		quarantined,
+		failed
+	};
+	const store = node_path.join(addonsDir, QUARANTINE_DIRNAME);
+	const scan = (parent, scope) => {
+		let names;
+		try {
+			names = node_fs.readdirSync(parent);
+		} catch {
+			return;
+		}
+		for (const dirName of names) {
+			const full = node_path.join(parent, dirName);
+			if (!isDirLike(full)) continue;
+			if (scope === null && dirName.startsWith("@")) {
+				scan(full, dirName);
+				continue;
+			}
+			const verdict = classifyAddonDir({
+				dirName,
+				declaredName: readDeclaredName(full)
+			});
+			if (verdict === null) continue;
+			const version = readDeclaredVersion(full);
+			const to = freeQuarantineTarget(store, scope, dirName);
+			try {
+				node_fs.mkdirSync(store, { recursive: true });
+				node_fs.renameSync(full, to);
+			} catch (err) {
+				const error = err instanceof Error ? err.message : String(err);
+				failed.push({
+					...verdict,
+					from: full,
+					error
+				});
+				log(`[addons] residue quarantine FAILED for ${full} (${verdict.reason}) — ${error}. It stays on the addon root and will be loaded, scanned and reported as an install.`);
+				continue;
+			}
+			quarantined.push({
+				...verdict,
+				from: full,
+				to
+			});
+			log(`[addons] quarantined ${verdict.reason} ${full} → ${to} (declares ${verdict.declaredName ?? "no package name"}${version === null ? "" : `@${version}`}). A renamed package dir is INSTALLED, not archived — nothing was deleted.`);
+		}
+	};
+	scan(addonsDir, null);
+	return {
+		quarantined,
+		failed
+	};
+}
+//#endregion
 //#region src/kernel/workspace-detect.ts
 /**
 * Detect whether we're running inside the monorepo workspace.
@@ -94566,6 +94882,8 @@ exports.FsStorageBackend = FsStorageBackend;
 exports.HEALTH_MONITOR_GRACE_PERIOD_MS = HEALTH_MONITOR_GRACE_PERIOD_MS;
 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 = HEAP_RECLAIM_MIN_INTERVAL_MS;
+exports.HEAP_RECLAIM_TRIGGER_MB = HEAP_RECLAIM_TRIGGER_MB;
 exports.HEAP_WATCH_INTERVAL_MS = HEAP_WATCH_INTERVAL_MS;
 exports.HEAP_WATCH_WARN_RATIO = HEAP_WATCH_WARN_RATIO;
 exports.HUB_CAP_FWD_ACTION = require_manifest_python_deps.HUB_CAP_FWD_ACTION;
@@ -94604,6 +94922,7 @@ Object.defineProperty(exports, "PYTHON_VERSION", {
 exports.PipelineRunner = PipelineRunner;
 exports.PipelineValidator = PipelineValidator;
 exports.PythonEnvManager = PythonEnvManager;
+exports.QUARANTINE_DIRNAME = QUARANTINE_DIRNAME;
 exports.RESTART_MARKER_FILE = RESTART_MARKER_FILE;
 exports.RUNTIME_DEFAULTS = require_dist.RUNTIME_DEFAULTS;
 exports.ReadinessRegistry = require_dist.ReadinessRegistry;
@@ -94656,6 +94975,7 @@ exports.capActionName = require_manifest_python_deps.capActionName;
 exports.capActionSuffix = require_manifest_python_deps.capActionSuffix;
 exports.capBareAction = require_manifest_python_deps.capBareAction;
 exports.capServiceName = require_manifest_python_deps.capServiceName;
+exports.classifyAddonDir = classifyAddonDir;
 exports.classifyCapRoute = require_manifest_python_deps.classifyCapRoute;
 exports.clearPendingRestart = clearPendingRestart;
 exports.clusterEventTopic = require_manifest_python_deps.clusterEventTopic;
@@ -94687,6 +95007,7 @@ exports.createUdsEventBridge = require_manifest_python_deps.createUdsEventBridge
 exports.createUdsEventBus = require_manifest_python_deps.createUdsEventBus;
 exports.createUdsLogger = require_manifest_python_deps.createUdsLogger;
 exports.createUdsLoggerWithControl = require_manifest_python_deps.createUdsLoggerWithControl;
+exports.createV8Reclaimer = createV8Reclaimer;
 exports.deleteModelFromDisk = require_model_download_service.deleteModelFromDisk;
 exports.deriveAgentListenPort = deriveAgentListenPort;
 exports.describeProviderKindDrift = describeProviderKindDrift;
@@ -94796,6 +95117,7 @@ exports.parseCapAction = require_manifest_python_deps.parseCapAction;
 exports.parseRangeHeader = require_model_download_service.parseRangeHeader;
 exports.parseTokenizedUrl = require_model_download_service.parseTokenizedUrl;
 exports.proxyToUpstream = proxyToUpstream;
+exports.quarantineAddonResidue = quarantineAddonResidue;
 exports.readPendingRestart = readPendingRestart;
 exports.readinessKey = require_dist.readinessKey;
 exports.registerEventBusService = require_manifest_python_deps.registerEventBusService;
@@ -94806,10 +95128,13 @@ exports.runNpm = require_manifest_python_deps.runNpm;
 exports.scheduleSelfRestart = scheduleSelfRestart;
 exports.scopeKey = require_dist.scopeKey;
 exports.scopesAllowDeviceCap = scopesAllowDeviceCap;
+exports.selectAddonResidue = selectAddonResidue;
 exports.serializeTypedArrays = require_manifest_python_deps.serializeTypedArrays;
 exports.setHubConnected = require_manifest_python_deps.setHubConnected;
 exports.setNodeEventInterest = require_manifest_python_deps.setNodeEventInterest;
+exports.shouldReclaim = shouldReclaim;
 exports.startHeapWatch = startHeapWatch;
+exports.strandedMb = strandedMb;
 exports.stripCamstackDeps = stripCamstackDeps;
 exports.subscribePassthrough = require_manifest_python_deps.subscribePassthrough;
 exports.udsChildLogToWorkerEntry = require_manifest_python_deps.udsChildLogToWorkerEntry;