@camstack/addon-pipeline 1.2.203 → 1.2.205

package/dist/motion-wasm/index.mjs

@@ -1,7 +1,182 @@
-import { Jt as hydrateSchema, Kt as DeviceType, Ut as BaseAddon, X as evaluateZoneRules, ft as motionDetectionCapability } from "../dist-B5x2ogXC.mjs";
+import { Jt as hydrateSchema, Kt as DeviceType, Ut as BaseAddon, X as evaluateZoneRules, ft as motionDetectionCapability } from "../dist-FaCzok3C.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
+//#region src/motion-wasm/region-grouping.ts
+/**
+* Default area bar, as a fraction of the motion view.
+*
+* Chosen from the measured separation between true-positive group areas and
+* quiet-footage group areas — see `docs/benchmarks/motion-region-area.md`.
+* On the 320×180 production motion view this is ~490 px, against the 1500 px
+* absolute filter it replaces.
+*/
+var DEFAULT_MIN_AREA_FRACTION = .0085;
+/**
+* The DEFAULT is the rule that shipped before D394: a 1500 px absolute bar per
+* component. The measured rule is per-camera opt-in (`minArea: 0`), because
+* the measurement says duty cycle rises between ×1.45 and ×2.82 and ten fleet
+* cameras turn that into recorded hours that cannot be measured from their own
+* footage. The end state is still one relative constant for the fleet; the
+* path there is one camera at a time.
+*/
+var DEFAULT_MIN_AREA = 1500;
+/**
+* Default storm bar. A group of changed pixels covering more than this
+* fraction of the view is not a subject — it is weather, an exposure step or
+* an IR cut. See the storm section of `docs/benchmarks/motion-region-area.md`.
+*/
+var DEFAULT_MAX_COVERAGE_FRACTION = .5;
+/** The bar in pixels: the absolute one when set, the relative rule otherwise. */
+function resolveMinGroupArea(config) {
+	if (config.minArea > 0) return config.minArea;
+	const area = Math.max(0, config.viewWidth) * Math.max(0, config.viewHeight);
+	return Math.round(config.minAreaFraction * area);
+}
+function grow(region, radius) {
+	const cx = region.x + region.w / 2;
+	const cy = region.y + region.h / 2;
+	const halfW = Math.max(region.w, radius) / 2;
+	const halfH = Math.max(region.h, radius) / 2;
+	return {
+		x0: cx - halfW,
+		y0: cy - halfH,
+		x1: cx + halfW,
+		y1: cy + halfH
+	};
+}
+function overlaps(a, b) {
+	return a.x0 < b.x1 && b.x0 < a.x1 && a.y0 < b.y1 && b.y0 < a.y1;
+}
+/**
+* Merge fragments into subjects and judge each subject on its own summed area.
+*
+* Groups come back in the order of their first member, so the frame's reading
+* order is stable across calls — a UI overlay does not reshuffle.
+*
+* A group over `maxCoverageFraction` is a storm and does not pass as a group;
+* its components are then judged individually, so a subject the storm merged
+* with is not silenced along with it.
+*
+* A positive `config.minArea` short-circuits all of it and runs the pre-D394
+* rule instead — see {@link RegionGroupingConfig.minArea}.
+*/
+function groupMotionRegions(regions, config) {
+	if (regions.length === 0) return {
+		groups: [],
+		passed: [],
+		suppressedByCoverage: 0
+	};
+	if (config.minArea > 0) {
+		const legacy = regions.map((r) => ({
+			x: r.x,
+			y: r.y,
+			w: r.w,
+			h: r.h,
+			pixels: r.pixels,
+			members: 1
+		}));
+		return {
+			groups: legacy,
+			passed: legacy.filter((g) => g.pixels >= config.minArea),
+			suppressedByCoverage: 0
+		};
+	}
+	const radius = Math.max(1, Math.floor(Math.min(config.viewWidth, config.viewHeight) / Math.max(1, config.mergeRadiusDivisor)));
+	const grown = regions.map((r) => grow(r, radius));
+	const parent = regions.map((_, i) => i);
+	const find = (i) => {
+		let root = i;
+		while (parent[root] !== root) root = parent[root];
+		let cur = i;
+		while (parent[cur] !== root) {
+			const next = parent[cur];
+			parent[cur] = root;
+			cur = next;
+		}
+		return root;
+	};
+	for (let i = 0; i < regions.length; i++) for (let j = i + 1; j < regions.length; j++) {
+		if (!overlaps(grown[i], grown[j])) continue;
+		const ri = find(i);
+		const rj = find(j);
+		if (ri !== rj) parent[rj] = ri;
+	}
+	const byRoot = /* @__PURE__ */ new Map();
+	const order = [];
+	for (let i = 0; i < regions.length; i++) {
+		const region = regions[i];
+		const root = find(i);
+		const existing = byRoot.get(root);
+		if (!existing) {
+			order.push(root);
+			byRoot.set(root, {
+				x0: region.x,
+				y0: region.y,
+				x1: region.x + region.w,
+				y1: region.y + region.h,
+				pixels: region.pixels,
+				members: 1
+			});
+			continue;
+		}
+		existing.x0 = Math.min(existing.x0, region.x);
+		existing.y0 = Math.min(existing.y0, region.y);
+		existing.x1 = Math.max(existing.x1, region.x + region.w);
+		existing.y1 = Math.max(existing.y1, region.y + region.h);
+		existing.pixels += region.pixels;
+		existing.members += 1;
+	}
+	const groups = order.map((root) => {
+		const a = byRoot.get(root);
+		return {
+			x: a.x0,
+			y: a.y0,
+			w: a.x1 - a.x0,
+			h: a.y1 - a.y0,
+			pixels: a.pixels,
+			members: a.members
+		};
+	});
+	const bar = resolveMinGroupArea(config);
+	const viewArea = Math.max(0, config.viewWidth) * Math.max(0, config.viewHeight);
+	const stormBar = config.maxCoverageFraction >= 1 ? Infinity : config.maxCoverageFraction * viewArea;
+	const membersByGroup = /* @__PURE__ */ new Map();
+	for (let i = 0; i < regions.length; i++) {
+		const root = find(i);
+		const list = membersByGroup.get(root) ?? [];
+		list.push(regions[i]);
+		membersByGroup.set(root, list);
+	}
+	const passed = [];
+	let suppressedByCoverage = 0;
+	for (let g = 0; g < groups.length; g++) {
+		const group = groups[g];
+		if (group.pixels < bar) continue;
+		if (group.pixels <= stormBar) {
+			passed.push(group);
+			continue;
+		}
+		suppressedByCoverage += 1;
+		for (const member of membersByGroup.get(order[g]) ?? []) {
+			if (member.pixels < bar || member.pixels > stormBar) continue;
+			passed.push({
+				x: member.x,
+				y: member.y,
+				w: member.w,
+				h: member.h,
+				pixels: member.pixels,
+				members: 1
+			});
+		}
+	}
+	return {
+		groups,
+		passed,
+		suppressedByCoverage
+	};
+}
+//#endregion
 //#region src/motion-wasm/wasm-motion-detector.ts
 /**
 * WasmMotionDetector — loads the AssemblyScript WASM module and provides
@@ -9,18 +184,33 @@ import { join } from "node:path";
 *
 * Pipeline: blur → diff → threshold → dilate → CCL → bounding boxes
 * All in one WASM call, ~3ms for 640×360 grayscale frames.
+*
+* The area filter that follows is NOT applied per connected component — see
+* {@link groupMotionRegions}. Fragments of one subject are merged first and the
+* bar is applied to the merged subject, relative to the motion view. D394.
+*/
+/**
+* The one place the motion defaults live. The addon's schema defaults read
+* from here — two copies of this object drifted apart once already (3000 here
+* against 1500 in the addon), and the addon's copy is the one that ran.
 */
-var DEFAULT_CONFIG$1 = {
+var DEFAULT_CONFIG = {
 	threshold: 45,
 	blurRadius: 1,
 	dilateRadius: 4,
-	minArea: 3e3
+	minArea: DEFAULT_MIN_AREA,
+	minAreaFraction: DEFAULT_MIN_AREA_FRACTION,
+	mergeRadiusDivisor: 6,
+	maxCoverageFraction: DEFAULT_MAX_COVERAGE_FRACTION
 };
 var WasmMotionDetector = class {
 	wasm = null;
 	prevOffset = 0;
 	currOffset = 0;
 	regionOffset = 0;
+	/** The motion view the regions are expressed in — the relative bar's denominator. */
+	width = 0;
+	height = 0;
 	/** Load the WASM module. Call once before detect(). */
 	async load() {
 		const wasmBytes = readFileSync(join(__dirname, "..", "..", "wasm", "motion.wasm"));
@@ -44,10 +234,25 @@ var WasmMotionDetector = class {
 		}
 		this.wasm = exports;
 	}
+	/**
+	* Initialize for these frame dimensions when they are not already the ones
+	* the WASM is sized for. One detector instance serves every camera on the
+	* node, so two cameras with different views interleaving would otherwise
+	* leave the WASM sized for whichever one called `init` last — and, since
+	* D394, would divide the relative area bar by the wrong view. `init` only
+	* recomputes offsets and grows memory, so a call that changes nothing is
+	* skipped and a call that does is cheap.
+	*/
+	ensureSize(w, h) {
+		if (this.width === w && this.height === h) return;
+		this.init(w, h);
+	}
 	/** Initialize for given frame dimensions. Call when resolution changes. */
 	init(w, h) {
 		if (!this.wasm) throw new Error("WASM not loaded — call load() first");
 		this.wasm.init(w, h);
+		this.width = w;
+		this.height = h;
 		this.prevOffset = this.wasm.getPrevOffset();
 		this.currOffset = this.wasm.getCurrOffset();
 		this.regionOffset = this.wasm.getRegionOffset();
@@ -58,12 +263,12 @@ var WasmMotionDetector = class {
 	* @param prevGray - previous frame (Uint8Array, width×height)
 	* @param currGray - current frame (Uint8Array, width×height)
 	* @param config - detection parameters (optional, uses defaults)
-	* @returns raw (all CCL regions) + filtered (passing minArea) regions
+	* @returns raw CCL regions, the subjects they merge into, and the survivors
 	*/
 	detect(prevGray, currGray, config = {}) {
 		if (!this.wasm) throw new Error("WASM not loaded");
 		const cfg = {
-			...DEFAULT_CONFIG$1,
+			...DEFAULT_CONFIG,
 			...config
 		};
 		const mem = new Uint8Array(this.wasm.memory.buffer);
@@ -72,7 +277,9 @@ var WasmMotionDetector = class {
 		const numRegions = this.wasm.detectMotion(cfg.threshold, cfg.blurRadius, cfg.dilateRadius, 0);
 		if (numRegions === 0) return {
 			raw: [],
-			filtered: []
+			filtered: [],
+			groups: [],
+			suppressedByCoverage: 0
 		};
 		const view = new DataView(this.wasm.memory.buffer);
 		const raw = [];
@@ -86,9 +293,19 @@ var WasmMotionDetector = class {
 				pixels: view.getInt32(base + 16, true)
 			});
 		}
+		const grouped = groupMotionRegions(raw, {
+			viewWidth: this.width,
+			viewHeight: this.height,
+			mergeRadiusDivisor: cfg.mergeRadiusDivisor,
+			minAreaFraction: cfg.minAreaFraction,
+			minArea: cfg.minArea,
+			maxCoverageFraction: cfg.maxCoverageFraction
+		});
 		return {
 			raw,
-			filtered: raw.filter((r) => r.pixels >= cfg.minArea)
+			filtered: grouped.passed,
+			groups: grouped.groups,
+			suppressedByCoverage: grouped.suppressedByCoverage
 		};
 	}
 };
@@ -117,25 +334,27 @@ function gateMotionRegions(regions, zones, rules, frameWidth, frameHeight) {
 *
 * Settings redesign Phase 3: motion-wasm has ONLY device-level settings
 * (all four fields were `scope: 'device'` in the legacy schema — every
-* camera tunes threshold/minArea/blurRadius/dilateRadius independently
+* camera tunes threshold/subject size/blurRadius/dilateRadius independently
 * for its scene). So the addon implements `getDeviceSettings` /
 * `updateDeviceSettings` and nothing else. Fresh cameras with no
 * overrides get the schema defaults via `hydrateSchema()` at read time.
 * There is no cluster-wide "default threshold" knob — if operators want
 * to change the baseline, they edit the schema defaults in code.
 */
-var DEFAULT_CONFIG = {
-	threshold: 45,
-	blurRadius: 1,
-	dilateRadius: 4,
-	minArea: 1500
-};
 var MotionWasmAddon = class MotionWasmAddon extends BaseAddon {
 	detector = null;
 	cameras = /* @__PURE__ */ new Map();
 	deviceConfigCache = /* @__PURE__ */ new Map();
 	static DEVICE_CONFIG_TTL_MS = 6e4;
 	/**
+	* Last logged "which rule is this camera on" signature, per camera. The
+	* operator's gesture for D394 is a settings write, and a settings write is
+	* invisible: this is how they confirm it took, on the next analysed frame.
+	* Keyed and logged only on CHANGE, so it costs one line per camera per
+	* change rather than one per TTL expiry.
+	*/
+	loggedRule = /* @__PURE__ */ new Map();
+	/**
 	* Per-device {@link DeviceProxy} used for zone gating. Built lazily
 	* on first analyze() for a device; the proxy's reactive state
 	* handles (`state.zones`, `state.zoneRules`) keep their `.value`
@@ -252,7 +471,16 @@ var MotionWasmAddon = class MotionWasmAddon extends BaseAddon {
 		}
 		state = this.cameras.get(cameraId);
 		const deviceCfg = await this.getDeviceConfig(cameraId);
-		const { raw, filtered } = this.detector.detect(state.prevGray, gray, deviceCfg);
+		this.detector.ensureSize(width, height);
+		const { raw, filtered, suppressedByCoverage } = this.detector.detect(state.prevGray, gray, deviceCfg);
+		if (suppressedByCoverage > 0) this.ctx.logger.info("motion storm suppressed", {
+			tags: { deviceId: Number(cameraId) },
+			meta: {
+				groups: suppressedByCoverage,
+				maxCoverageFraction: deviceCfg.maxCoverageFraction,
+				view: `${width}x${height}`
+			}
+		});
 		state.prevGray = Buffer.from(gray);
 		const toRegion = (r) => ({
 			bbox: {
@@ -343,28 +571,48 @@ var MotionWasmAddon = class MotionWasmAddon extends BaseAddon {
 			threshold: typeof flat["threshold"] === "number" ? flat["threshold"] : DEFAULT_CONFIG.threshold,
 			blurRadius: typeof flat["blurRadius"] === "number" ? flat["blurRadius"] : DEFAULT_CONFIG.blurRadius,
 			dilateRadius: typeof flat["dilateRadius"] === "number" ? flat["dilateRadius"] : DEFAULT_CONFIG.dilateRadius,
-			minArea: typeof flat["minArea"] === "number" ? flat["minArea"] : DEFAULT_CONFIG.minArea
+			minArea: typeof flat["minArea"] === "number" ? flat["minArea"] : DEFAULT_CONFIG.minArea,
+			minAreaFraction: typeof flat["minAreaFraction"] === "number" ? flat["minAreaFraction"] : DEFAULT_CONFIG.minAreaFraction,
+			mergeRadiusDivisor: typeof flat["mergeRadiusDivisor"] === "number" ? flat["mergeRadiusDivisor"] : DEFAULT_CONFIG.mergeRadiusDivisor,
+			maxCoverageFraction: typeof flat["maxCoverageFraction"] === "number" ? flat["maxCoverageFraction"] : DEFAULT_CONFIG.maxCoverageFraction
 		};
 		this.deviceConfigCache.set(cameraId, {
 			config: resolved,
 			fetchedAt: now
 		});
+		const rule = resolved.minArea > 0 ? "legacy-per-region" : "merged-relative";
+		const signature = rule === "legacy-per-region" ? `${rule}:${resolved.minArea}` : `${rule}:${resolved.minAreaFraction}:${resolved.maxCoverageFraction}`;
+		if (this.loggedRule.get(cameraId) !== signature) {
+			this.loggedRule.set(cameraId, signature);
+			this.ctx.logger.info("motion area rule resolved", {
+				tags: { deviceId: Number(cameraId) },
+				meta: {
+					rule,
+					minArea: resolved.minArea,
+					minAreaFraction: resolved.minAreaFraction,
+					maxCoverageFraction: resolved.maxCoverageFraction
+				}
+			});
+		}
 		return resolved;
 	}
 	async removeCamera({ deviceId }) {
 		const key = String(deviceId);
 		this.cameras.delete(key);
 		this.deviceConfigCache.delete(key);
+		this.loggedRule.delete(key);
 		this.releaseProxy(deviceId);
 	}
 	async reset() {
 		this.cameras.clear();
 		this.deviceConfigCache.clear();
+		this.loggedRule.clear();
 		for (const id of this.proxies.keys()) this.releaseProxy(id);
 	}
 	async onShutdown() {
 		this.cameras.clear();
 		this.deviceConfigCache.clear();
+		this.loggedRule.clear();
 		for (const id of this.proxies.keys()) this.releaseProxy(id);
 		this.detector = null;
 	}
@@ -391,11 +639,26 @@ var MotionWasmAddon = class MotionWasmAddon extends BaseAddon {
 						includes: "analyzer"
 					}
 				},
+				{
+					type: "slider",
+					key: "minAreaFraction",
+					label: "Min Subject Size",
+					description: "Smallest subject that triggers motion, as a share of the analysed view. Fragments of one subject are merged before this is applied, so a partly hidden animal counts once at its full size. Only in effect when Min Area is 0.",
+					min: .001,
+					max: .05,
+					step: 5e-4,
+					default: DEFAULT_CONFIG.minAreaFraction,
+					showValue: true,
+					showWhen: {
+						field: "motionSources",
+						includes: "analyzer"
+					}
+				},
 				{
 					type: "number",
 					key: "minArea",
 					label: "Min Area",
-					description: "Minimum pixel area of a motion region to trigger detection",
+					description: "Absolute pixel bar, applied to each motion region on its own. This is how motion has always worked, and it stays the default. Set it to 0 to move THIS camera to Min Subject Size, which merges the fragments of one subject before measuring it and keeps its meaning at any resolution — expect more motion, so move one camera at a time.",
 					min: 0,
 					max: 5e4,
 					step: 100,
@@ -406,6 +669,21 @@ var MotionWasmAddon = class MotionWasmAddon extends BaseAddon {
 						includes: "analyzer"
 					}
 				},
+				{
+					type: "slider",
+					key: "maxCoverageFraction",
+					label: "Storm Cutoff",
+					description: "A merged region whose changed pixels cover more of the view than this is weather, an IR cut or an exposure step, not a subject, and does not fire motion. A real mover inside the storm still fires on its own region. Only in effect when Min Area is 0; 1 disables the cutoff.",
+					min: .2,
+					max: 1,
+					step: .05,
+					default: DEFAULT_CONFIG.maxCoverageFraction,
+					showValue: true,
+					showWhen: {
+						field: "motionSources",
+						includes: "analyzer"
+					}
+				},
 				{
 					type: "slider",
 					key: "blurRadius",

package/dist/{node-u0M7kQe-.js → node-Re3uLz8K.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-Czm3CW8M.js");
+const require_dist = require("./dist-CR3_dWir.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs, 1);

package/dist/{node-Bx76sJbU.mjs → node-f4fUlGHQ.mjs}

@@ -1,4 +1,4 @@
-import { It as errMsg, Rt as Fmp4BoxSplitter, Vt as isSoftwareDecode, zt as buildFfmpegArgs } from "./dist-B5x2ogXC.mjs";
+import { It as errMsg, Rt as Fmp4BoxSplitter, Vt as isSoftwareDecode, zt as buildFfmpegArgs } from "./dist-FaCzok3C.mjs";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import path from "node:path";

package/dist/pipeline-runner/index.js

@@ -2,12 +2,12 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Czm3CW8M.js");
-const require_node = require("../node-u0M7kQe-.js");
-const require_default_detection_model = require("../default-detection-model-CfIEdJop.js");
-const require_worker_protocol = require("../worker-protocol-B4C4seRh.js");
+const require_dist = require("../dist-CR3_dWir.js");
+const require_node = require("../node-Re3uLz8K.js");
+const require_default_detection_model = require("../default-detection-model-BGsoboIK.js");
+const require_worker_protocol = require("../worker-protocol-lIjbPNbH.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
-const require_lazy_sharp = require("../lazy-sharp-AhHg_Hb-.js");
+const require_lazy_sharp = require("../lazy-sharp-CKXcDP-V.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");

package/dist/pipeline-runner/index.mjs

@@ -1,7 +1,7 @@
-import { $ as failureContributionCapability, It as errMsg, Qt as nodePin, R as customAction, U as deriveDetailCropRect, Ut as BaseAddon, V as defineCustomActions, _ as FailureCounters, _t as pickDetailCropConvention, an as boolean, bt as pipelineRunnerCapability, cn as literal, hn as EventCategory, in as array, it as loadContributionCapability, ln as number, m as DEVICE_BACKEND_TO_FORMAT, p as DEFAULT_NATIVE_LEASE_SETTINGS, pn as string, qt as createEvent, rn as _enum, sn as lazy, u as DEFAULT_DETAIL_CROP_CONVENTION, un as object, vt as pickNativeLeaseOverride } from "../dist-B5x2ogXC.mjs";
-import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-Bx76sJbU.mjs";
-import { i as resolveFrameViewGeometry, l as getStepDefinition, r as localFrameRegistry } from "../default-detection-model-ClY8fk-K.mjs";
-import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-ClwpoGoP.mjs";
+import { $ as failureContributionCapability, It as errMsg, Qt as nodePin, R as customAction, U as deriveDetailCropRect, Ut as BaseAddon, V as defineCustomActions, _ as FailureCounters, _t as pickDetailCropConvention, an as boolean, bt as pipelineRunnerCapability, cn as literal, hn as EventCategory, in as array, it as loadContributionCapability, ln as number, m as DEVICE_BACKEND_TO_FORMAT, p as DEFAULT_NATIVE_LEASE_SETTINGS, pn as string, qt as createEvent, rn as _enum, sn as lazy, u as DEFAULT_DETAIL_CROP_CONVENTION, un as object, vt as pickNativeLeaseOverride } from "../dist-FaCzok3C.mjs";
+import { i as NO_COST_CLAIM, t as ChildCostRegistry } from "../node-f4fUlGHQ.mjs";
+import { i as resolveFrameViewGeometry, l as getStepDefinition, r as localFrameRegistry } from "../default-detection-model-23wBHkOQ.mjs";
+import { a as nativeLeaseSettingEnv, t as isWorkerReply } from "../worker-protocol-Dz6_u2y6.mjs";
 import { t as resolveHubHostname } from "../hub-hostname-cCknRYKj.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { a as preRollRequestOf, o as withDetectionIntent, t as DETECTION_PRE_ROLL_REQUEST_MS } from "../restream-intent-DWe2kInY.mjs";

package/dist/{process-memory-D5JcMSDA.js → process-memory-DNheSoSc.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-Czm3CW8M.js");
+const require_dist = require("./dist-CR3_dWir.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);
 let node_child_process = require("node:child_process");

package/dist/{process-memory-iiE4Q2mt.mjs → process-memory-MC7wcxqk.mjs}

@@ -1,4 +1,4 @@
-import { mt as parseProcStatus } from "./dist-B5x2ogXC.mjs";
+import { mt as parseProcStatus } from "./dist-FaCzok3C.mjs";
 import * as fs from "node:fs";
 import { execFile } from "node:child_process";
 //#region src/shared/node-topology-platform.ts

package/dist/recorder/index.js

@@ -2,8 +2,8 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Czm3CW8M.js");
-const require_node = require("../node-u0M7kQe-.js");
+const require_dist = require("../dist-CR3_dWir.js");
+const require_node = require("../node-Re3uLz8K.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_restream_intent = require("../restream-intent-B1Difcnq.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
@@ -11498,11 +11498,13 @@ function weightOfUnmeasured(demands) {
 	return measured.length % 2 === 1 ? measured[mid] : (measured[mid - 1] + measured[mid]) / 2;
 }
 /** Normalised weight per location: headroom share, or an even split when no
-*  location reports any headroom (nothing is known yet — never divide by 0). */
+*  location reports any headroom (nothing is known yet — never divide by 0).
+*  An UNMEASURABLE location (`headroomBytes: null`) contributes nothing and
+*  weighs nothing: it keeps what it already holds and attracts no new work. */
 function weightsFor(pool) {
-	const total = pool.reduce((sum, c) => sum + Math.max(0, c.headroomBytes), 0);
+	const total = pool.reduce((sum, c) => sum + Math.max(0, c.headroomBytes ?? 0), 0);
 	const weights = /* @__PURE__ */ new Map();
-	for (const c of pool) weights.set(c.locationId, total > 0 ? Math.max(0, c.headroomBytes) / total : 1 / pool.length);
+	for (const c of pool) weights.set(c.locationId, total > 0 ? Math.max(0, c.headroomBytes ?? 0) / total : 1 / pool.length);
 	return weights;
 }
 /** The location with the largest unmet share of the target, ties broken by the
@@ -12036,6 +12038,9 @@ var PlacementService = class {
 	verified = /* @__PURE__ */ new Set();
 	/** Locations the probe declared unusable — re-probed after a change. */
 	unusable = /* @__PURE__ */ new Set();
+	/** Locations whose capacity could not be read, by reason. One line per
+	*  distinct fault (this is on the 30 s tick) and one when it clears. */
+	capacityFaults = /* @__PURE__ */ new Map();
 	/** Cameras that have already announced "every location is unusable". One line
 	*  per camera per episode: the fault is asked per-camera, and repeating it per
 	*  attach is the noise this state exists to end. */
@@ -12238,7 +12243,7 @@ var PlacementService = class {
 		const byId = new Map(candidates.map((c) => [c.locationId, c.headroomBytes]));
 		return pool.map((location) => {
 			const headroomBytes = byId.get(location.id);
-			return headroomBytes === void 0 ? location : {
+			return headroomBytes === void 0 || headroomBytes === null ? location : {
 				...location,
 				headroomBytes
 			};
@@ -12281,7 +12286,7 @@ var PlacementService = class {
 			return NO_PLAN;
 		}
 		const current = new Map(Object.entries(blob.assignments));
-		const evacuate = new Set(candidates.filter((c) => c.headroomBytes <= 0).map((c) => c.locationId));
+		const evacuate = new Set(candidates.filter((c) => c.headroomBytes !== null && c.headroomBytes <= 0).map((c) => c.locationId));
 		for (const location of pool) if (location.readOnly) evacuate.add(location.id);
 		const plan = planPlacement({
 			candidates,
@@ -12441,8 +12446,20 @@ var PlacementService = class {
 	* `min(free − minFree floor, maxUsedGb − used)`, clamped at zero: the first
 	* term is the per-location free-space guard the storage pressure manager also
 	* enforces, the second an optional operator cap on what recordings may take.
-	* Nothing measurable → zero headroom everywhere, which the planner reads as
-	* "no signal" and splits evenly rather than pretending to know.
+	*
+	* **Nothing measurable is `null`, not zero.** `readLocationCapacity` models
+	* its failure — a NAS that stops answering `statfs` returns nulls AND the
+	* reason. This method used to discard the reason and fold the whole case into
+	* `headroomBytes: 0`, which `recompute` reads as "at its limit" and puts in
+	* `evacuate`: one failed `statfs` moved every camera off a healthy disk, and
+	* not one line was written about it. (The comment that used to sit here
+	* claimed the opposite — "no signal → the planner splits evenly" — which is
+	* true of the PLANNER's weights and was never true of the evacuation set.)
+	*
+	* So an unmeasurable location gets `null`, which is not evacuated and wins no
+	* new work, and the reason is logged against the location — once per distinct
+	* fault, since this runs on the 30 s placement tick, plus one line when it
+	* recovers.
 	*/
 	async candidatesFor(pool) {
 		const out = [];
@@ -12450,7 +12467,8 @@ var PlacementService = class {
 			if (location.readOnly) continue;
 			const capacity = await this.deps.capacityFor?.(location) ?? {
 				availableBytes: null,
-				totalBytes: null
+				totalBytes: null,
+				error: "no capacity source is wired on this node"
 			};
 			const limits = [];
 			if (capacity.availableBytes !== null && capacity.totalBytes !== null) {
@@ -12461,15 +12479,45 @@ var PlacementService = class {
 				const used = await this.deps.usedOnLocation?.(location.id) ?? 0;
 				limits.push(require_dist.gbToBytes(location.maxUsedGb) - used);
 			}
+			const headroomBytes = limits.length === 0 ? null : Math.max(0, Math.min(...limits));
+			this.reportCapacitySignal(location, headroomBytes, capacity.error);
 			out.push({
 				locationId: location.id,
 				type: location.type,
-				headroomBytes: limits.length === 0 ? 0 : Math.max(0, Math.min(...limits))
+				headroomBytes
 			});
 		}
 		return out;
 	}
 	/**
+	* Say it out loud when a location's capacity cannot be read, and say it again
+	* when it comes back. Deduplicated by reason because `candidatesFor` runs on
+	* every placement tick — a line per tick is a line nobody reads, and no line
+	* at all is what let a dead NAS look like a full one.
+	*/
+	reportCapacitySignal(location, headroomBytes, error) {
+		const previous = this.capacityFaults.get(location.id);
+		if (headroomBytes !== null) {
+			if (previous !== void 0) {
+				this.capacityFaults.delete(location.id);
+				this.deps.logger.info("recorder placement: capacity readable again — this location is a write target once more", { meta: {
+					locationId: location.id,
+					root: location.root,
+					previousError: previous
+				} });
+			}
+			return;
+		}
+		const reason = error ?? "the capacity read returned no bytes and no reason";
+		if (previous === reason) return;
+		this.capacityFaults.set(location.id, reason);
+		this.deps.logger.warn("recorder placement: capacity UNMEASURABLE — headroom is unknown, so this location is neither evacuated nor given new cameras", { meta: {
+			locationId: location.id,
+			root: location.root,
+			error: reason
+		} });
+	}
+	/**
 	* Volume-check the chosen location, failing the assignment over to a sibling
 	* when the bytes under its root are not the bytes we wrote. The probe runs
 	* ONCE per location per location-set generation — it is a claim, not a poll.
@@ -18304,10 +18352,10 @@ var RecorderV2Addon = class extends require_dist.BaseAddon {
 		const [assignments, candidates] = await Promise.all([placement.currentAssignments(), placement.candidates()]);
 		return {
 			assignments,
-			headroom: candidates.map((candidate) => ({
+			headroom: candidates.flatMap((candidate) => candidate.headroomBytes === null ? [] : [{
 				locationId: candidate.locationId,
 				headroomBytes: candidate.headroomBytes
-			}))
+			}])
 		};
 	}
 	/**