@camstack/addon-pipeline 1.2.203 → 1.2.205

package/dist/audio-analyzer/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_process_memory = require("../process-memory-D5JcMSDA.js");
+const require_dist = require("../dist-CR3_dWir.js");
+const require_process_memory = require("../process-memory-DNheSoSc.js");
 let node_fs = require("node:fs");
 node_fs = require_dist.__toESM(node_fs);
 let node_path = require("node:path");

package/dist/audio-analyzer/index.mjs

@@ -1,6 +1,6 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { Dt as resolvePoolMemoryPolicy, It as errMsg, Jt as hydrateSchema, M as audioAnalyzerCapability, S as PoolMemoryWatchdog, Ut as BaseAddon, j as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, ot as mapAudioLabelToMacro, s as DEFAULT_AUDIO_ANALYZER_CONFIG, v as HF_BASE_URL } from "../dist-B5x2ogXC.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-iiE4Q2mt.mjs";
+import { Dt as resolvePoolMemoryPolicy, It as errMsg, Jt as hydrateSchema, M as audioAnalyzerCapability, S as PoolMemoryWatchdog, Ut as BaseAddon, j as audioAnalysisCapability, n as AUDIO_BACKEND_CHOICES, ot as mapAudioLabelToMacro, s as DEFAULT_AUDIO_ANALYZER_CONFIG, v as HF_BASE_URL } from "../dist-FaCzok3C.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-MC7wcxqk.mjs";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
 import { downloadFile } from "@camstack/system/addon-utils";

package/dist/{default-detection-model-ClY8fk-K.mjs → default-detection-model-23wBHkOQ.mjs}

@@ -1,4 +1,4 @@
-import { N as audioKindId, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS, tt as hfModelUrl } from "./dist-B5x2ogXC.mjs";
+import { N as audioKindId, a as COCO_80_LABELS, o as COCO_TO_MACRO, r as AUDIO_MACRO_LABELS, tt as hfModelUrl } from "./dist-FaCzok3C.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/{default-detection-model-CfIEdJop.js → default-detection-model-BGsoboIK.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");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";

package/dist/detection-pipeline/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_lazy_sharp = require("../lazy-sharp-AhHg_Hb-.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_lazy_sharp = require("../lazy-sharp-CKXcDP-V.js");
 const require_event_loop_stall_monitor = require("../event-loop-stall-monitor-DaUBcb13.js");
-const require_process_memory = require("../process-memory-D5JcMSDA.js");
+const require_process_memory = require("../process-memory-DNheSoSc.js");
 let node_os = require("node:os");
 node_os = require_dist.__toESM(node_os);
 let node_fs = require("node:fs");

package/dist/detection-pipeline/index.mjs

@@ -1,10 +1,10 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { $t as parseJsonUnknown, B as defaultDeviceFor$1, Dt as resolvePoolMemoryPolicy, G as detectionPipelineCapability, It as errMsg, J as enumerateInferenceDevices, Jt as hydrateSchema, Pt as supportedRuntimes$1, Qt as nodePin, S as PoolMemoryWatchdog, Ut as BaseAddon, X as evaluateZoneRules, c as DEFAULT_CLUSTER_STEP_MODELS, gt as pickClusterStepSettings, hn as EventCategory, ht as pickClusterStepModels, in as array, it as loadContributionCapability, k as YAMNET_TO_MACRO, kt as runtimeDevices$1, l as DEFAULT_CLUSTER_STEP_SETTINGS, m as DEVICE_BACKEND_TO_FORMAT, mn as union, nn as sleep, nt as inferModelProvider, pn as string, pt as overlayClusterStepSettings, qt as createEvent, t as APPLE_SA_TO_MACRO, un as object, wt as resolveClusterStepModelId, yt as pipelineExecutorCapability } from "../dist-B5x2ogXC.mjs";
-import { o as readProcessCost } from "../node-Bx76sJbU.mjs";
-import { a as ALL_PIPELINE_STEPS, c as getStep, d as landmarkPrecisionVerdict, l as getStepDefinition, n as resolveDefaultDetectionModel, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as resolveModelForFormat } from "../default-detection-model-ClY8fk-K.mjs";
+import { $t as parseJsonUnknown, B as defaultDeviceFor$1, Dt as resolvePoolMemoryPolicy, G as detectionPipelineCapability, It as errMsg, J as enumerateInferenceDevices, Jt as hydrateSchema, Pt as supportedRuntimes$1, Qt as nodePin, S as PoolMemoryWatchdog, Ut as BaseAddon, X as evaluateZoneRules, c as DEFAULT_CLUSTER_STEP_MODELS, gt as pickClusterStepSettings, hn as EventCategory, ht as pickClusterStepModels, in as array, it as loadContributionCapability, k as YAMNET_TO_MACRO, kt as runtimeDevices$1, l as DEFAULT_CLUSTER_STEP_SETTINGS, m as DEVICE_BACKEND_TO_FORMAT, mn as union, nn as sleep, nt as inferModelProvider, pn as string, pt as overlayClusterStepSettings, qt as createEvent, t as APPLE_SA_TO_MACRO, un as object, wt as resolveClusterStepModelId, yt as pipelineExecutorCapability } from "../dist-FaCzok3C.mjs";
+import { o as readProcessCost } from "../node-f4fUlGHQ.mjs";
+import { a as ALL_PIPELINE_STEPS, c as getStep, d as landmarkPrecisionVerdict, l as getStepDefinition, n as resolveDefaultDetectionModel, o as ALL_STEPS, r as localFrameRegistry, s as getDefaultModelForFormat, u as resolveModelForFormat } from "../default-detection-model-23wBHkOQ.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
 import { n as startEventLoopStallMonitor } from "../event-loop-stall-monitor-DXLNBMkY.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-iiE4Q2mt.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-MC7wcxqk.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";

package/dist/{dist-Czm3CW8M.js → dist-CR3_dWir.js}

@@ -14074,6 +14074,9 @@ var QueryFilterSchema = object({
 	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
 	/** NULL-safe exclusion: matches rows whose field is NULL OR != the value. */
 	whereNot: record(string(), unknown()).optional(),
+	/** NULL-safe exclusion of a SET — `whereNot` for more than one value. An
+	*  empty list excludes nothing. See `QueryFilter.whereNotIn`. */
+	whereNotIn: record(string(), array(unknown())).optional(),
 	orderBy: object({
 		field: string(),
 		direction: _enum(["asc", "desc"])
@@ -14094,7 +14097,8 @@ var MutationFilterSchema = object({
 	where: record(string(), unknown()).optional(),
 	whereIn: record(string(), array(unknown())).optional(),
 	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
-	whereNot: record(string(), unknown()).optional()
+	whereNot: record(string(), unknown()).optional(),
+	whereNotIn: record(string(), array(unknown())).optional()
 });
 /**
 * One scalar an {@link settingsStoreCapability.methods.aggregate} call asks for.
@@ -21196,10 +21200,12 @@ var TrackSourceSchema = _enum([
 *    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
 *    a deliberate action of the retrain page, not a side effect of a checkbox.
 *
-* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
-* the store's filter language has only positive equality and `whereIn` — no
-* negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
-* would make the entire pre-column history immortal in one deploy.
+* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` so that
+* every row is selectable by a positive predicate. (The filter language has
+* since grown the NULL-safe `whereNot` / `whereNotIn` and an `IS NULL` reading
+* of `where: { f: null }`, which is how {@link TrackSourceSchema} can be
+* filtered on a NULLABLE column — see `excludeSources`. It did not when this
+* column was designed, and a NOT NULL column is still the better shape.)
 */
 var RetrainStatusSchema = _enum([
 	"none",
@@ -21935,7 +21941,9 @@ var RecentTracksQueryInput = object({
 	* whose class list is unreadable are kept, and the client's rule stays the
 	* exact one.
 	*/
-	classes: array(string()).optional()
+	classes: array(string()).optional(),
+	/** See {@link ExcludeSourcesDoc}. */
+	excludeSources: array(TrackSourceSchema).optional()
 });
 /**
 * A Summary (D359): the per-camera session envelope that references tracks.
@@ -22363,7 +22371,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	* selected is an operator who has not narrowed anything, and an empty
 	* timeline would read as a camera that saw nothing.
 	*/
-	classes: array(string()).optional()
+	classes: array(string()).optional(),
+	/** See {@link ExcludeSourcesDoc}. */
+	excludeSources: array(TrackSourceSchema).optional()
 }), array(TrackSchema).readonly()), method(RecentTracksQueryInput, RecentTracksPageSchema), method(SummariesQueryInput, SummariesPageSchema), method(object({ id: string() }), SummaryDetailSchema.nullable()), method(object({ deviceId: number() }), _void(), {
 	kind: "mutation",
 	auth: "admin"

package/dist/{dist-B5x2ogXC.mjs → dist-FaCzok3C.mjs}

@@ -14051,6 +14051,9 @@ var QueryFilterSchema = object({
 	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
 	/** NULL-safe exclusion: matches rows whose field is NULL OR != the value. */
 	whereNot: record(string(), unknown()).optional(),
+	/** NULL-safe exclusion of a SET — `whereNot` for more than one value. An
+	*  empty list excludes nothing. See `QueryFilter.whereNotIn`. */
+	whereNotIn: record(string(), array(unknown())).optional(),
 	orderBy: object({
 		field: string(),
 		direction: _enum(["asc", "desc"])
@@ -14071,7 +14074,8 @@ var MutationFilterSchema = object({
 	where: record(string(), unknown()).optional(),
 	whereIn: record(string(), array(unknown())).optional(),
 	whereBetween: record(string(), tuple([unknown(), unknown()])).optional(),
-	whereNot: record(string(), unknown()).optional()
+	whereNot: record(string(), unknown()).optional(),
+	whereNotIn: record(string(), array(unknown())).optional()
 });
 /**
 * One scalar an {@link settingsStoreCapability.methods.aggregate} call asks for.
@@ -21173,10 +21177,12 @@ var TrackSourceSchema = _enum([
 *    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
 *    a deliberate action of the retrain page, not a side effect of a checkbox.
 *
-* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
-* the store's filter language has only positive equality and `whereIn` — no
-* negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
-* would make the entire pre-column history immortal in one deploy.
+* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` so that
+* every row is selectable by a positive predicate. (The filter language has
+* since grown the NULL-safe `whereNot` / `whereNotIn` and an `IS NULL` reading
+* of `where: { f: null }`, which is how {@link TrackSourceSchema} can be
+* filtered on a NULLABLE column — see `excludeSources`. It did not when this
+* column was designed, and a NOT NULL column is still the better shape.)
 */
 var RetrainStatusSchema = _enum([
 	"none",
@@ -21912,7 +21918,9 @@ var RecentTracksQueryInput = object({
 	* whose class list is unreadable are kept, and the client's rule stays the
 	* exact one.
 	*/
-	classes: array(string()).optional()
+	classes: array(string()).optional(),
+	/** See {@link ExcludeSourcesDoc}. */
+	excludeSources: array(TrackSourceSchema).optional()
 });
 /**
 * A Summary (D359): the per-camera session envelope that references tracks.
@@ -22340,7 +22348,9 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	* selected is an operator who has not narrowed anything, and an empty
 	* timeline would read as a camera that saw nothing.
 	*/
-	classes: array(string()).optional()
+	classes: array(string()).optional(),
+	/** See {@link ExcludeSourcesDoc}. */
+	excludeSources: array(TrackSourceSchema).optional()
 }), array(TrackSchema).readonly()), method(RecentTracksQueryInput, RecentTracksPageSchema), method(SummariesQueryInput, SummariesPageSchema), method(object({ id: string() }), SummaryDetailSchema.nullable()), method(object({ deviceId: number() }), _void(), {
 	kind: "mutation",
 	auth: "admin"

package/dist/{lazy-sharp-AhHg_Hb-.js → lazy-sharp-CKXcDP-V.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-Czm3CW8M.js");
+const require_dist = require("./dist-CR3_dWir.js");
 let node_path = require("node:path");
 node_path = require_dist.__toESM(node_path);
 let node_url = require("node:url");

package/dist/motion-wasm/index.js

@@ -2,10 +2,185 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-Czm3CW8M.js");
-const require_lazy_sharp = require("../lazy-sharp-AhHg_Hb-.js");
+const require_dist = require("../dist-CR3_dWir.js");
+const require_lazy_sharp = require("../lazy-sharp-CKXcDP-V.js");
 let node_fs = require("node:fs");
 let node_path = require("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
@@ -13,18 +188,33 @@ let node_path = require("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 = (0, node_fs.readFileSync)((0, node_path.join)(__dirname, "..", "..", "wasm", "motion.wasm"));
@@ -48,10 +238,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();
@@ -62,12 +267,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);
@@ -76,7 +281,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 = [];
@@ -90,9 +297,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
 		};
 	}
 };
@@ -121,25 +338,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 require_dist.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`
@@ -256,7 +475,16 @@ var MotionWasmAddon = class MotionWasmAddon extends require_dist.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: {
@@ -347,28 +575,48 @@ var MotionWasmAddon = class MotionWasmAddon extends require_dist.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;
 	}
@@ -395,11 +643,26 @@ var MotionWasmAddon = class MotionWasmAddon extends require_dist.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,
@@ -410,6 +673,21 @@ var MotionWasmAddon = class MotionWasmAddon extends require_dist.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",