@camstack/addon-pipeline 0.1.20 → 0.2.0

package/dist/motion-wasm/index.mjs

@@ -1,452 +1,470 @@
-import { j as evaluateZoneRules, B as BaseAddon, v as motionDetectionCapability, r as hydrateSchema, D as DeviceType } from "../index-5aYef068.mjs";
+import { B as motionDetectionCapability, M as evaluateZoneRules, P as hydrateSchema, d as DeviceType, i as BaseAddon } from "../dist-C5jnNl0n.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
-const DEFAULT_CONFIG$1 = {
-  threshold: 45,
-  blurRadius: 1,
-  dilateRadius: 4,
-  minArea: 3e3
+//#region src/motion-wasm/wasm-motion-detector.ts
+/**
+* WasmMotionDetector — loads the AssemblyScript WASM module and provides
+* a typed interface for motion detection.
+*
+* Pipeline: blur → diff → threshold → dilate → CCL → bounding boxes
+* All in one WASM call, ~3ms for 640×360 grayscale frames.
+*/
+var DEFAULT_CONFIG$1 = {
+	threshold: 45,
+	blurRadius: 1,
+	dilateRadius: 4,
+	minArea: 3e3
 };
-class WasmMotionDetector {
-  wasm = null;
-  prevOffset = 0;
-  currOffset = 0;
-  regionOffset = 0;
-  /** Load the WASM module. Call once before detect(). */
-  async load() {
-    const wasmPath = join(__dirname, "..", "..", "wasm", "motion.wasm");
-    const wasmBytes = readFileSync(wasmPath);
-    const { instance } = await WebAssembly.instantiate(wasmBytes, {
-      env: { abort: () => {
-        throw new Error("WASM abort");
-      } }
-    });
-    const exports = instance.exports;
-    const required = [
-      "memory",
-      "init",
-      "getPrevOffset",
-      "getCurrOffset",
-      "getRegionOffset",
-      "detectMotion"
-    ];
-    for (const name of required) {
-      const v = exports[name];
-      if (v === void 0) {
-        throw new Error(`motion.wasm contract violation: missing export "${String(name)}"`);
-      }
-      if (name === "memory") {
-        if (!(v instanceof WebAssembly.Memory)) {
-          throw new Error('motion.wasm contract violation: "memory" is not a WebAssembly.Memory');
-        }
-      } else if (typeof v !== "function") {
-        throw new Error(`motion.wasm contract violation: "${String(name)}" is not callable`);
-      }
-    }
-    this.wasm = exports;
-  }
-  /** 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.prevOffset = this.wasm.getPrevOffset();
-    this.currOffset = this.wasm.getCurrOffset();
-    this.regionOffset = this.wasm.getRegionOffset();
-  }
-  /**
-   * Detect motion between previous and current grayscale frames.
-   *
-   * @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
-   */
-  detect(prevGray, currGray, config = {}) {
-    if (!this.wasm) throw new Error("WASM not loaded");
-    const cfg = { ...DEFAULT_CONFIG$1, ...config };
-    const mem = new Uint8Array(this.wasm.memory.buffer);
-    mem.set(prevGray, this.prevOffset);
-    mem.set(currGray, this.currOffset);
-    const numRegions = this.wasm.detectMotion(
-      cfg.threshold,
-      cfg.blurRadius,
-      cfg.dilateRadius,
-      0
-    );
-    if (numRegions === 0) return { raw: [], filtered: [] };
-    const view = new DataView(this.wasm.memory.buffer);
-    const raw = [];
-    for (let i = 0; i < numRegions; i++) {
-      const base = this.regionOffset + i * 20;
-      raw.push({
-        x: view.getInt32(base, true),
-        y: view.getInt32(base + 4, true),
-        w: view.getInt32(base + 8, true),
-        h: view.getInt32(base + 12, true),
-        pixels: view.getInt32(base + 16, true)
-      });
-    }
-    const filtered = raw.filter((r) => r.pixels >= cfg.minArea);
-    return { raw, filtered };
-  }
-}
+var WasmMotionDetector = class {
+	wasm = null;
+	prevOffset = 0;
+	currOffset = 0;
+	regionOffset = 0;
+	/** Load the WASM module. Call once before detect(). */
+	async load() {
+		const wasmBytes = readFileSync(join(__dirname, "..", "..", "wasm", "motion.wasm"));
+		const { instance } = await WebAssembly.instantiate(wasmBytes, { env: { abort: () => {
+			throw new Error("WASM abort");
+		} } });
+		const exports = instance.exports;
+		for (const name of [
+			"memory",
+			"init",
+			"getPrevOffset",
+			"getCurrOffset",
+			"getRegionOffset",
+			"detectMotion"
+		]) {
+			const v = exports[name];
+			if (v === void 0) throw new Error(`motion.wasm contract violation: missing export "${String(name)}"`);
+			if (name === "memory") {
+				if (!(v instanceof WebAssembly.Memory)) throw new Error("motion.wasm contract violation: \"memory\" is not a WebAssembly.Memory");
+			} else if (typeof v !== "function") throw new Error(`motion.wasm contract violation: "${String(name)}" is not callable`);
+		}
+		this.wasm = exports;
+	}
+	/** 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.prevOffset = this.wasm.getPrevOffset();
+		this.currOffset = this.wasm.getCurrOffset();
+		this.regionOffset = this.wasm.getRegionOffset();
+	}
+	/**
+	* Detect motion between previous and current grayscale frames.
+	*
+	* @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
+	*/
+	detect(prevGray, currGray, config = {}) {
+		if (!this.wasm) throw new Error("WASM not loaded");
+		const cfg = {
+			...DEFAULT_CONFIG$1,
+			...config
+		};
+		const mem = new Uint8Array(this.wasm.memory.buffer);
+		mem.set(prevGray, this.prevOffset);
+		mem.set(currGray, this.currOffset);
+		const numRegions = this.wasm.detectMotion(cfg.threshold, cfg.blurRadius, cfg.dilateRadius, 0);
+		if (numRegions === 0) return {
+			raw: [],
+			filtered: []
+		};
+		const view = new DataView(this.wasm.memory.buffer);
+		const raw = [];
+		for (let i = 0; i < numRegions; i++) {
+			const base = this.regionOffset + i * 20;
+			raw.push({
+				x: view.getInt32(base, true),
+				y: view.getInt32(base + 4, true),
+				w: view.getInt32(base + 8, true),
+				h: view.getInt32(base + 12, true),
+				pixels: view.getInt32(base + 16, true)
+			});
+		}
+		return {
+			raw,
+			filtered: raw.filter((r) => r.pixels >= cfg.minArea)
+		};
+	}
+};
+//#endregion
+//#region src/motion-wasm/zone-gate.ts
 function gateMotionRegions(regions, zones, rules, frameWidth, frameHeight) {
-  if (frameWidth === 0 || frameHeight === 0) {
-    return { passed: regions, excluded: [] };
-  }
-  return evaluateZoneRules(regions, zones, rules, (region) => ({
-    x: (region.bbox.x + region.bbox.w / 2) / frameWidth,
-    y: (region.bbox.y + region.bbox.h / 2) / frameHeight
-  }));
+	if (frameWidth === 0 || frameHeight === 0) return {
+		passed: regions,
+		excluded: []
+	};
+	return evaluateZoneRules(regions, zones, rules, (region) => ({
+		x: (region.bbox.x + region.bbox.w / 2) / frameWidth,
+		y: (region.bbox.y + region.bbox.h / 2) / frameHeight
+	}));
 }
-const DEFAULT_CONFIG = { threshold: 45, blurRadius: 1, dilateRadius: 4, minArea: 1500 };
-class MotionWasmAddon extends BaseAddon {
-  detector = null;
-  cameras = /* @__PURE__ */ new Map();
-  deviceConfigCache = /* @__PURE__ */ new Map();
-  static DEVICE_CONFIG_TTL_MS = 6e4;
-  /**
-   * 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`
-   * fresh via the kernel's runtime-state mirror, so the gate reads
-   * are sync and free of bus plumbing inside this addon.
-   */
-  proxies = /* @__PURE__ */ new Map();
-  /** Unsubscribe pins kept so the slice handles stay subscribed for
-   *  the camera's lifetime — `.value` only flows through the cache
-   *  when at least one watcher is active. */
-  proxyUnsubs = /* @__PURE__ */ new Map();
-  constructor() {
-    super({});
-  }
-  async onInitialize() {
-    this.detector = new WasmMotionDetector();
-    await this.detector.load();
-    this.ctx.logger.info("WASM motion detector loaded");
-    return [{
-      capability: motionDetectionCapability,
-      provider: this
-    }];
-  }
-  // Sentinel key used by the pipeline-step `process()` path, which owns a
-  // dedicated per-addon instance (one per camera via AddonEngineManager)
-  // and therefore does not need a real deviceId.
-  static PIPELINE_STEP_KEY = "__pipeline__";
-  /**
-   * Pipeline step interface — called by PipelineRunner.
-   * Uses single-camera state (one instance per camera via AddonEngineManager).
-   */
-  async process(input) {
-    const start = performance.now();
-    const result = await this.analyzeInternal(MotionWasmAddon.PIPELINE_STEP_KEY, input);
-    const toSpatial = (r) => ({
-      class: "motion",
-      originalClass: "motion",
-      score: Math.min(1, r.intensity / 128),
-      bbox: r.bbox
-    });
-    const detections = result.regions.map(toSpatial);
-    const rawDetections = result.rawRegions.map(toSpatial);
-    return { detections, rawDetections, inferenceMs: performance.now() - start, modelId: "wasm-motion" };
-  }
-  /**
-   * motion-detection cap: analyze a frame, return regions + stats.
-   * Per-device state keyed by the numeric deviceId (stringified internally
-   * so the pipeline-step sentinel shares the same Map).
-   */
-  async analyze({ deviceId, frame }) {
-    return this.analyzeInternal(String(deviceId), frame);
-  }
-  async analyzeInternal(cameraId, frame) {
-    if (!this.detector) {
-      return { detected: false, regionCount: 0, regions: [], rawRegions: [], frameWidth: 0, frameHeight: 0, analysisMs: 0 };
-    }
-    const start = performance.now();
-    let gray;
-    let width;
-    let height;
-    if (frame.format === "jpeg") {
-      const sharp = (await import("sharp")).default;
-      const { data, info } = await sharp(Buffer.from(frame.data)).grayscale().raw().toBuffer({ resolveWithObject: true });
-      gray = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-      width = info.width;
-      height = info.height;
-    } else {
-      gray = frame.data instanceof Uint8Array ? frame.data : new Uint8Array(frame.data);
-      width = frame.width;
-      height = frame.height;
-    }
-    let state = this.cameras.get(cameraId);
-    if (!state || state.width !== width || state.height !== height) {
-      this.detector.init(width, height);
-      this.cameras.set(cameraId, { prevGray: gray, width, height });
-      return {
-        detected: false,
-        regionCount: 0,
-        regions: [],
-        rawRegions: [],
-        frameWidth: width,
-        frameHeight: height,
-        analysisMs: performance.now() - start
-      };
-    }
-    state = this.cameras.get(cameraId);
-    const deviceCfg = await this.getDeviceConfig(cameraId);
-    const { raw, filtered } = this.detector.detect(state.prevGray, gray, deviceCfg);
-    state.prevGray = Buffer.from(gray);
-    const toRegion = (r) => ({
-      bbox: { x: r.x, y: r.y, w: r.w, h: r.h },
-      pixelCount: r.pixels,
-      intensity: Math.min(255, Math.round(r.pixels / (r.w * r.h) * 255))
-    });
-    let regions = filtered.map(toRegion);
-    const rawRegions = raw.map(toRegion);
-    const numericDeviceId = Number(cameraId);
-    if (Number.isFinite(numericDeviceId)) {
-      const proxy = await this.ensureProxy(numericDeviceId);
-      if (proxy) {
-        const zones = proxy.state.zones.value?.zones ?? [];
-        const rules = proxy.state.zoneRules.value?.motion ?? [];
-        if (rules.length > 0 && zones.length > 0) {
-          const gated = gateMotionRegions(regions, zones, rules, width, height);
-          regions = [...gated.passed];
-        }
-      }
-    }
-    return {
-      detected: regions.length > 0,
-      regionCount: regions.length,
-      regions,
-      rawRegions,
-      frameWidth: width,
-      frameHeight: height,
-      analysisMs: performance.now() - start
-    };
-  }
-  /**
-   * Resolve (and cache) a {@link DeviceProxy} for the given device.
-   * Pins the `state.zones` + `state.zoneRules` slice handles so the
-   * kernel runtime-state mirror keeps `.value` warm — subsequent
-   * analyze() calls read both slices synchronously without any bus
-   * plumbing or per-frame cap query. Returns null on first-call
-   * failure (logged) so motion analysis never blocks on zone
-   * resolution.
-   */
-  async ensureProxy(deviceId) {
-    const cached = this.proxies.get(deviceId);
-    if (cached) return cached;
-    try {
-      const proxy = await this.ctx.fetchDevice(deviceId);
-      this.proxies.set(deviceId, proxy);
-      const unsubs = [
-        proxy.state.zones.subscribe(() => {
-        }),
-        proxy.state.zoneRules.subscribe(() => {
-        })
-      ];
-      this.proxyUnsubs.set(deviceId, unsubs);
-      return proxy;
-    } catch (err) {
-      this.ctx.logger.debug("ensureProxy failed — gating skipped", {
-        tags: { deviceId },
-        meta: { error: err instanceof Error ? err.message : String(err) }
-      });
-      return null;
-    }
-  }
-  /** Drop the proxy + slice subscriptions for a device. */
-  releaseProxy(deviceId) {
-    const unsubs = this.proxyUnsubs.get(deviceId);
-    if (unsubs) {
-      for (const u of unsubs) {
-        try {
-          u();
-        } catch {
-        }
-      }
-    }
-    this.proxyUnsubs.delete(deviceId);
-    this.proxies.delete(deviceId);
-  }
-  /**
-   * Resolve the effective per-device config for a camera. Reads the raw
-   * device store and overlays it on top of the schema defaults via
-   * `hydrateSchema()`, then narrows to the typed `WasmMotionConfig` shape.
-   * Cached with a TTL to avoid hammering the settings store on every frame.
-   */
-  async getDeviceConfig(cameraId) {
-    const now = Date.now();
-    const cached = this.deviceConfigCache.get(cameraId);
-    if (cached && now - cached.fetchedAt < MotionWasmAddon.DEVICE_CONFIG_TTL_MS) {
-      return cached.config;
-    }
-    if (!this.ctx?.settings) return DEFAULT_CONFIG;
-    const raw = await this.ctx.settings.readDeviceStore(Number(cameraId));
-    const hydrated = hydrateSchema(this.deviceSettingsSchema(), raw);
-    const flat = {};
-    for (const section of hydrated.sections) {
-      for (const field of section.fields) {
-        if (field.type === "separator" || field.type === "info" || field.type === "button") continue;
-        if (field.type === "group") continue;
-        flat[field.key] = field.value;
-      }
-    }
-    const resolved = {
-      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
-    };
-    this.deviceConfigCache.set(cameraId, { config: resolved, fetchedAt: now });
-    return resolved;
-  }
-  async removeCamera({ deviceId }) {
-    const key = String(deviceId);
-    this.cameras.delete(key);
-    this.deviceConfigCache.delete(key);
-    this.releaseProxy(deviceId);
-  }
-  async reset() {
-    this.cameras.clear();
-    this.deviceConfigCache.clear();
-    for (const id of this.proxies.keys()) this.releaseProxy(id);
-  }
-  async onShutdown() {
-    this.cameras.clear();
-    this.deviceConfigCache.clear();
-    for (const id of this.proxies.keys()) this.releaseProxy(id);
-    this.detector = null;
-  }
-  // ── Standard ICamstackAddon — three-level settings API (Phase 3) ─────
-  //
-  // motion-wasm is a pure per-device addon: every parameter is tuned on
-  // a per-camera basis. It implements only `getDeviceSettings` /
-  // `updateDeviceSettings`. No addon-level, no node-global.
-  deviceSettingsSchema() {
-    return this.schema({
-      sections: [
-        {
-          id: "motion-wasm-settings",
-          title: "",
-          tab: "motion",
-          order: 10,
-          columns: 2,
-          fields: [
-            // Every motion-wasm knob is an analyzer-side tuning param —
-            // when the operator picks `onboard`-only on the orchestrator's
-            // motionSources field, the wasm analyzer doesn't run, so
-            // exposing the threshold/minArea/blur/dilate fields would be
-            // misleading. Gate on the same key the orchestrator reads
-            // (`motionSources`) so all four hide together.
-            {
-              type: "slider",
-              key: "threshold",
-              label: "Threshold",
-              description: "Pixel intensity difference to count as changed (higher = less sensitive)",
-              min: 1,
-              max: 255,
-              step: 1,
-              default: DEFAULT_CONFIG.threshold,
-              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",
-              min: 0,
-              max: 5e4,
-              step: 100,
-              default: DEFAULT_CONFIG.minArea,
-              unit: "px",
-              showWhen: { field: "motionSources", includes: "analyzer" }
-            },
-            {
-              type: "slider",
-              key: "blurRadius",
-              label: "Blur Radius",
-              description: "Gaussian blur before diff (reduces noise)",
-              min: 0,
-              max: 10,
-              step: 1,
-              default: DEFAULT_CONFIG.blurRadius,
-              showValue: true,
-              showWhen: { field: "motionSources", includes: "analyzer" }
-            },
-            {
-              type: "slider",
-              key: "dilateRadius",
-              label: "Dilation Radius",
-              description: "Expand motion regions to merge nearby changes",
-              min: 0,
-              max: 10,
-              step: 1,
-              default: DEFAULT_CONFIG.dilateRadius,
-              showValue: true,
-              showWhen: { field: "motionSources", includes: "analyzer" }
-            }
-          ]
-        }
-      ]
-    });
-  }
-  async getDeviceSettings(deviceId) {
-    const ctx = this.ctxIfReady;
-    const raw = await ctx?.settings?.readDeviceStore(deviceId) ?? {};
-    return hydrateSchema(this.deviceSettingsSchema(), raw);
-  }
-  async updateDeviceSettings(deviceId, patch) {
-    await this.ctx.settings?.writeDeviceStore(deviceId, patch);
-    this.deviceConfigCache.delete(String(deviceId));
-  }
-  // ── Device-details aggregator contribution (motion-detection cap) ────────
-  //
-  // motion-wasm contributes its 4 tuning knobs (threshold, blurRadius,
-  // dilateRadius, minArea) to the `detection` tab for every camera. Live
-  // info is skipped — motion runtime stats are already streamed via the
-  // pipeline-orchestrator live contribution.
-  async getDeviceSettingsContribution(input) {
-    if (!await this.isCameraDevice(input.deviceId)) return null;
-    const schema = this.deviceSettingsSchema();
-    if (!schema) return null;
-    const raw = await this.ctx?.settings?.readDeviceStore(input.deviceId) ?? {};
-    const withTab = {
-      ...schema,
-      sections: schema.sections.map((s) => ({ ...s, tab: s.tab ?? "detection" }))
-    };
-    return hydrateSchema(withTab, raw);
-  }
-  async getDeviceLiveContribution(_input) {
-    return null;
-  }
-  async applyDeviceSettingsPatch(input) {
-    await this.updateDeviceSettings(input.deviceId, input.patch);
-    return { success: true };
-  }
-  /**
-   * Best-effort camera-type check. Used by the settings/live contribution
-   * methods to short-circuit on non-camera devices (Lights, Switches,
-   * Sensors, Buttons). Returns `true` on lookup failure so a transient
-   * device-manager hiccup never silently hides legitimate camera
-   * sections.
-   */
-  async isCameraDevice(deviceId) {
-    const api = this.ctx?.api;
-    if (!api) return true;
-    try {
-      const dev = await api.deviceManager.getDevice.query({ deviceId });
-      if (!dev) return true;
-      return dev.type === DeviceType.Camera;
-    } catch {
-      return true;
-    }
-  }
-}
-export {
-  MotionWasmAddon,
-  WasmMotionDetector,
-  MotionWasmAddon as default
+//#endregion
+//#region src/motion-wasm/addon/index.ts
+/**
+* Motion detection addon using WebAssembly.
+*
+* Drop-in replacement for addon-motion-detection. Same IMotionDetector interface,
+* but uses WASM blur+diff+dilate+CCL instead of JS pixel loop.
+*
+* Produces bounding box regions (not just changed pixel count).
+* ~3ms/frame at 640×360 with full pipeline.
+*
+* 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
+* 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;
+	/**
+	* 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`
+	* fresh via the kernel's runtime-state mirror, so the gate reads
+	* are sync and free of bus plumbing inside this addon.
+	*/
+	proxies = /* @__PURE__ */ new Map();
+	/** Unsubscribe pins kept so the slice handles stay subscribed for
+	*  the camera's lifetime — `.value` only flows through the cache
+	*  when at least one watcher is active. */
+	proxyUnsubs = /* @__PURE__ */ new Map();
+	constructor() {
+		super({});
+	}
+	async onInitialize() {
+		this.detector = new WasmMotionDetector();
+		await this.detector.load();
+		this.ctx.logger.info("WASM motion detector loaded");
+		return [{
+			capability: motionDetectionCapability,
+			provider: this
+		}];
+	}
+	static PIPELINE_STEP_KEY = "__pipeline__";
+	/**
+	* Pipeline step interface — called by PipelineRunner.
+	* Uses single-camera state (one instance per camera via AddonEngineManager).
+	*/
+	async process(input) {
+		const start = performance.now();
+		const result = await this.analyzeInternal(MotionWasmAddon.PIPELINE_STEP_KEY, input);
+		const toSpatial = (r) => ({
+			class: "motion",
+			originalClass: "motion",
+			score: Math.min(1, r.intensity / 128),
+			bbox: r.bbox
+		});
+		return {
+			detections: result.regions.map(toSpatial),
+			rawDetections: result.rawRegions.map(toSpatial),
+			inferenceMs: performance.now() - start,
+			modelId: "wasm-motion"
+		};
+	}
+	/**
+	* motion-detection cap: analyze a frame, return regions + stats.
+	* Per-device state keyed by the numeric deviceId (stringified internally
+	* so the pipeline-step sentinel shares the same Map).
+	*/
+	async analyze({ deviceId, frame }) {
+		return this.analyzeInternal(String(deviceId), frame);
+	}
+	async analyzeInternal(cameraId, frame) {
+		if (!this.detector) return {
+			detected: false,
+			regionCount: 0,
+			regions: [],
+			rawRegions: [],
+			frameWidth: 0,
+			frameHeight: 0,
+			analysisMs: 0
+		};
+		const start = performance.now();
+		let gray;
+		let width;
+		let height;
+		if (frame.format === "jpeg") {
+			const sharp = (await import("sharp")).default;
+			const { data, info } = await sharp(Buffer.from(frame.data)).grayscale().raw().toBuffer({ resolveWithObject: true });
+			gray = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+			width = info.width;
+			height = info.height;
+		} else {
+			gray = frame.data instanceof Uint8Array ? frame.data : new Uint8Array(frame.data);
+			width = frame.width;
+			height = frame.height;
+		}
+		let state = this.cameras.get(cameraId);
+		if (!state || state.width !== width || state.height !== height) {
+			this.detector.init(width, height);
+			this.cameras.set(cameraId, {
+				prevGray: gray,
+				width,
+				height
+			});
+			return {
+				detected: false,
+				regionCount: 0,
+				regions: [],
+				rawRegions: [],
+				frameWidth: width,
+				frameHeight: height,
+				analysisMs: performance.now() - start
+			};
+		}
+		state = this.cameras.get(cameraId);
+		const deviceCfg = await this.getDeviceConfig(cameraId);
+		const { raw, filtered } = this.detector.detect(state.prevGray, gray, deviceCfg);
+		state.prevGray = Buffer.from(gray);
+		const toRegion = (r) => ({
+			bbox: {
+				x: r.x,
+				y: r.y,
+				w: r.w,
+				h: r.h
+			},
+			pixelCount: r.pixels,
+			intensity: Math.min(255, Math.round(r.pixels / (r.w * r.h) * 255))
+		});
+		let regions = filtered.map(toRegion);
+		const rawRegions = raw.map(toRegion);
+		const numericDeviceId = Number(cameraId);
+		if (Number.isFinite(numericDeviceId)) {
+			const proxy = await this.ensureProxy(numericDeviceId);
+			if (proxy) {
+				const zones = proxy.state.zones.value?.zones ?? [];
+				const rules = proxy.state.zoneRules.value?.motion ?? [];
+				if (rules.length > 0 && zones.length > 0) regions = [...gateMotionRegions(regions, zones, rules, width, height).passed];
+			}
+		}
+		return {
+			detected: regions.length > 0,
+			regionCount: regions.length,
+			regions,
+			rawRegions,
+			frameWidth: width,
+			frameHeight: height,
+			analysisMs: performance.now() - start
+		};
+	}
+	/**
+	* Resolve (and cache) a {@link DeviceProxy} for the given device.
+	* Pins the `state.zones` + `state.zoneRules` slice handles so the
+	* kernel runtime-state mirror keeps `.value` warm — subsequent
+	* analyze() calls read both slices synchronously without any bus
+	* plumbing or per-frame cap query. Returns null on first-call
+	* failure (logged) so motion analysis never blocks on zone
+	* resolution.
+	*/
+	async ensureProxy(deviceId) {
+		const cached = this.proxies.get(deviceId);
+		if (cached) return cached;
+		try {
+			const proxy = await this.ctx.fetchDevice(deviceId);
+			this.proxies.set(deviceId, proxy);
+			const unsubs = [proxy.state.zones.subscribe(() => {}), proxy.state.zoneRules.subscribe(() => {})];
+			this.proxyUnsubs.set(deviceId, unsubs);
+			return proxy;
+		} catch (err) {
+			this.ctx.logger.debug("ensureProxy failed — gating skipped", {
+				tags: { deviceId },
+				meta: { error: err instanceof Error ? err.message : String(err) }
+			});
+			return null;
+		}
+	}
+	/** Drop the proxy + slice subscriptions for a device. */
+	releaseProxy(deviceId) {
+		const unsubs = this.proxyUnsubs.get(deviceId);
+		if (unsubs) for (const u of unsubs) try {
+			u();
+		} catch {}
+		this.proxyUnsubs.delete(deviceId);
+		this.proxies.delete(deviceId);
+	}
+	/**
+	* Resolve the effective per-device config for a camera. Reads the raw
+	* device store and overlays it on top of the schema defaults via
+	* `hydrateSchema()`, then narrows to the typed `WasmMotionConfig` shape.
+	* Cached with a TTL to avoid hammering the settings store on every frame.
+	*/
+	async getDeviceConfig(cameraId) {
+		const now = Date.now();
+		const cached = this.deviceConfigCache.get(cameraId);
+		if (cached && now - cached.fetchedAt < MotionWasmAddon.DEVICE_CONFIG_TTL_MS) return cached.config;
+		if (!this.ctx?.settings) return DEFAULT_CONFIG;
+		const raw = await this.ctx.settings.readDeviceStore(Number(cameraId));
+		const hydrated = hydrateSchema(this.deviceSettingsSchema(), raw);
+		const flat = {};
+		for (const section of hydrated.sections) for (const field of section.fields) {
+			if (field.type === "separator" || field.type === "info" || field.type === "button") continue;
+			if (field.type === "group") continue;
+			flat[field.key] = field.value;
+		}
+		const resolved = {
+			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
+		};
+		this.deviceConfigCache.set(cameraId, {
+			config: resolved,
+			fetchedAt: now
+		});
+		return resolved;
+	}
+	async removeCamera({ deviceId }) {
+		const key = String(deviceId);
+		this.cameras.delete(key);
+		this.deviceConfigCache.delete(key);
+		this.releaseProxy(deviceId);
+	}
+	async reset() {
+		this.cameras.clear();
+		this.deviceConfigCache.clear();
+		for (const id of this.proxies.keys()) this.releaseProxy(id);
+	}
+	async onShutdown() {
+		this.cameras.clear();
+		this.deviceConfigCache.clear();
+		for (const id of this.proxies.keys()) this.releaseProxy(id);
+		this.detector = null;
+	}
+	deviceSettingsSchema() {
+		return this.schema({ sections: [{
+			id: "motion-wasm-settings",
+			title: "",
+			tab: "motion",
+			order: 10,
+			columns: 2,
+			fields: [
+				{
+					type: "slider",
+					key: "threshold",
+					label: "Threshold",
+					description: "Pixel intensity difference to count as changed (higher = less sensitive)",
+					min: 1,
+					max: 255,
+					step: 1,
+					default: DEFAULT_CONFIG.threshold,
+					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",
+					min: 0,
+					max: 5e4,
+					step: 100,
+					default: DEFAULT_CONFIG.minArea,
+					unit: "px",
+					showWhen: {
+						field: "motionSources",
+						includes: "analyzer"
+					}
+				},
+				{
+					type: "slider",
+					key: "blurRadius",
+					label: "Blur Radius",
+					description: "Gaussian blur before diff (reduces noise)",
+					min: 0,
+					max: 10,
+					step: 1,
+					default: DEFAULT_CONFIG.blurRadius,
+					showValue: true,
+					showWhen: {
+						field: "motionSources",
+						includes: "analyzer"
+					}
+				},
+				{
+					type: "slider",
+					key: "dilateRadius",
+					label: "Dilation Radius",
+					description: "Expand motion regions to merge nearby changes",
+					min: 0,
+					max: 10,
+					step: 1,
+					default: DEFAULT_CONFIG.dilateRadius,
+					showValue: true,
+					showWhen: {
+						field: "motionSources",
+						includes: "analyzer"
+					}
+				}
+			]
+		}] });
+	}
+	async getDeviceSettings(deviceId) {
+		const raw = await this.ctxIfReady?.settings?.readDeviceStore(deviceId) ?? {};
+		return hydrateSchema(this.deviceSettingsSchema(), raw);
+	}
+	async updateDeviceSettings(deviceId, patch) {
+		await this.ctx.settings?.writeDeviceStore(deviceId, patch);
+		this.deviceConfigCache.delete(String(deviceId));
+	}
+	async getDeviceSettingsContribution(input) {
+		if (!await this.isCameraDevice(input.deviceId)) return null;
+		const schema = this.deviceSettingsSchema();
+		if (!schema) return null;
+		const raw = await this.ctx?.settings?.readDeviceStore(input.deviceId) ?? {};
+		return hydrateSchema({
+			...schema,
+			sections: schema.sections.map((s) => ({
+				...s,
+				tab: s.tab ?? "detection"
+			}))
+		}, raw);
+	}
+	async getDeviceLiveContribution(_input) {
+		return null;
+	}
+	async applyDeviceSettingsPatch(input) {
+		await this.updateDeviceSettings(input.deviceId, input.patch);
+		return { success: true };
+	}
+	/**
+	* Best-effort camera-type check. Used by the settings/live contribution
+	* methods to short-circuit on non-camera devices (Lights, Switches,
+	* Sensors, Buttons). Returns `true` on lookup failure so a transient
+	* device-manager hiccup never silently hides legitimate camera
+	* sections.
+	*/
+	async isCameraDevice(deviceId) {
+		const api = this.ctx?.api;
+		if (!api) return true;
+		try {
+			const dev = await api.deviceManager.getDevice.query({ deviceId });
+			if (!dev) return true;
+			return dev.type === DeviceType.Camera;
+		} catch {
+			return true;
+		}
+	}
 };
-//# sourceMappingURL=index.mjs.map
+//#endregion
+export { MotionWasmAddon, MotionWasmAddon as default, WasmMotionDetector };