@camstack/addon-pipeline 1.2.1 → 1.2.2

package/dist/pipeline-runner/index.mjs

@@ -1,8 +1,8 @@
-import { H as errMsg, N as pipelineRunnerCapability, S as defineCustomActions, U as BaseAddon, b as customAction, ct as number, dt as string, it as boolean, j as nodePin, lt as object, nt as _enum, ot as lazy, pt as EventCategory, q as createEvent, rt as array } from "../dist-C3cDjL49.mjs";
+import { H as errMsg, N as pipelineRunnerCapability, S as defineCustomActions, U as BaseAddon, b as customAction, ct as number, dt as string, it as boolean, j as nodePin, lt as object, nt as _enum, ot as lazy, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT } from "../dist-ClyAFBZk.mjs";
 import { n as profileForStreamId, t as isRemoteRestream } from "../remote-restream-BeHi78PZ.mjs";
 import { r as resolveHubHostname } from "../sheet-geometry-DcpuGTCm.mjs";
-import { t as isWorkerReply } from "../worker-protocol-CyVJTZEO.mjs";
-import { a as getStepDefinition } from "../step-definitions-ty97QrzE.mjs";
+import { t as isWorkerReply } from "../worker-protocol-D7RzZIla.mjs";
+import { a as getStepDefinition } from "../step-definitions-DMOw4fzn.mjs";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import sharp from "sharp";
@@ -1674,11 +1674,18 @@ var SessionDecodeSession = class {
 				});
 				return;
 			case "nativeCropMiss":
+				if (raw.reason !== void 0) this.logger.debug("session-decode: native crop miss", { meta: {
+					requestId: raw.requestId,
+					reason: raw.reason
+				} });
 				this.settleNativeCrop(raw.requestId, null);
 				return;
 			case "error":
 				this.settleError(raw.message, raw.frameId);
 				return;
+			case "log":
+				this.logger[raw.level](raw.message);
+				return;
 		}
 	}
 	handleExit(info) {
@@ -2247,13 +2254,93 @@ async function runDetailSubtree(deps, input) {
 	if (!crop) return null;
 	const details = [];
 	for (const step of steps) {
-		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId);
+		const deviceKey = deps.resolveStepDevice?.(input.deviceId, step);
+		const result = await deps.runPipeline([step], crop.jpeg, input.deviceId, deviceKey);
 		if (!result) continue;
 		for (const detection of result.detections) details.push(toDetailResult(detection, step.addonId, crop));
 	}
 	return { details };
 }
 //#endregion
+//#region src/pipeline-runner/device-jump.ts
+/**
+* Step-tree device jump (same-node, phase 1) — the PURE resolution core.
+*
+* Given the camera's elected ("effective") inference device and the node's
+* enabled-device roster, decide which device ONE enrichment step should run on:
+*
+*   1. A manual `jumpDeviceKey` override wins when it names a candidate that can
+*      run the step (bypasses the auto choice; operator intent).
+*   2. Otherwise, if the effective device's format can run the step's model →
+*      NO jump (the step inherits the effective device — the common case).
+*   3. Otherwise AUTO-jump: among the node's OTHER enabled devices whose format
+*      can run the step (and that are under their `maxSessions` cap), pick the
+*      weighted-least-loaded one — mirroring the balancer's per-device core.
+*   4. If nothing on the node can run it → `no-candidate` (the caller emits the
+*      loud once-per-(camera,step) warn that replaces today's silent degrade).
+*
+* Framework-free + side-effect-free so the whole decision table is unit-testable
+* without a live runner/catalog. The `canRun(format)` predicate is injected by
+* the runner (which owns the model catalog); this module never imports it.
+*/
+/** The `ModelFormat` of a `<backend>:<device>` key, or `undefined` for an unknown backend. */
+function formatOf(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	return DEVICE_BACKEND_TO_FORMAT[colon >= 0 ? deviceKey.slice(0, colon) : deviceKey];
+}
+/** True when the step's model has a build for `deviceKey`'s format. */
+function canRunOn(deviceKey, canRun) {
+	const format = formatOf(deviceKey);
+	return format !== void 0 && canRun(format);
+}
+/** Effective weighted load of a device (session count ÷ weight); lower = preferred. */
+function weightedLoad(d) {
+	return d.attachedCameras / (d.weight > 0 ? d.weight : 1);
+}
+/**
+* Weighted-least-loaded pick with a deterministic `deviceKey` tie-break —
+* mirrors the node/device balancer's decision core (least `load/weight`, ties
+* broken stably). `devices` is assumed non-empty.
+*/
+function pickWeightedLeastLoaded(devices) {
+	return devices.reduce((best, d) => {
+		const dScore = weightedLoad(d);
+		const bScore = weightedLoad(best);
+		if (dScore < bScore) return d;
+		if (dScore > bScore) return best;
+		return d.deviceKey < best.deviceKey ? d : best;
+	});
+}
+/**
+* Resolve the device one enrichment step runs on. See the module header for the
+* decision table. Pure — never throws, no I/O.
+*/
+function resolveStepDevice(input) {
+	const { effectiveDeviceKey, manualJumpDeviceKey, canRun } = input;
+	if (manualJumpDeviceKey !== void 0 && manualJumpDeviceKey !== effectiveDeviceKey) {
+		const target = input.devices.find((d) => d.deviceKey === manualJumpDeviceKey);
+		if (target && canRunOn(target.deviceKey, canRun)) return {
+			kind: "jumped",
+			deviceKey: target.deviceKey,
+			reason: "manual"
+		};
+	}
+	if (canRunOn(effectiveDeviceKey, canRun)) return {
+		kind: "no-jump",
+		deviceKey: effectiveDeviceKey
+	};
+	const runnable = input.devices.filter((d) => d.deviceKey !== effectiveDeviceKey && (d.maxSessions === null || d.attachedCameras < d.maxSessions) && canRunOn(d.deviceKey, canRun));
+	if (runnable.length === 0) return {
+		kind: "no-candidate",
+		deviceKey: effectiveDeviceKey
+	};
+	return {
+		kind: "jumped",
+		deviceKey: pickWeightedLeastLoaded(runnable).deviceKey,
+		reason: "auto"
+	};
+}
+//#endregion
 //#region src/pipeline-runner/index.ts
 var DEFAULT_CONFIG = {
 	maxQueueDepth: 30,
@@ -3218,18 +3305,48 @@ var PipelineRunnerAddon = class extends BaseAddon {
 			}
 		}
 		const tier = resolveNativeCropSource(isFullFrame, nativeResult !== null);
-		if (tier === "native" && nativeResult) return {
-			...nativeResult,
-			tier
-		};
+		if (tier === "native" && nativeResult) return this.encodeNativeCropResult(nativeResult, tier, input.encodeJpeg);
 		if (tier !== "ram-fullframe") return null;
 		const crop = this.retainedFrames?.crop(input.handle, input.bbox, input.maxWidth);
-		return crop ? {
+		if (!crop) return null;
+		return this.encodeNativeCropResult({
+			bytes: crop.bytes,
+			width: crop.width,
+			height: crop.height
+		}, tier, input.encodeJpeg);
+	}
+	/**
+	* Shape a resolved RGB crop into a `getNativeCrop` result. Raw path (default):
+	* return the zero-copy `bytes` — same-node callers encode locally. Compressed
+	* path (`encodeJpeg`, the CROSS-NODE case): encode to JPEG in-process, on the
+	* OWNING node, and return `jpeg` (base64) with NO `bytes` — the payload then
+	* fits Moleculer's `maxPacketSize` and no raw pixels cross the process
+	* boundary (CLAUDE.md invariant #21). On an encode failure the crop is a miss
+	* (`null`) — the caller retries — never a silent raw-RGB cross-node fallback.
+	*/
+	async encodeNativeCropResult(crop, tier, encodeJpeg) {
+		if (encodeJpeg !== true) return {
 			bytes: crop.bytes,
 			width: crop.width,
 			height: crop.height,
 			tier
-		} : null;
+		};
+		try {
+			const sharp = (await import("sharp")).default;
+			return {
+				jpeg: (await sharp(Buffer.from(crop.bytes), { raw: {
+					width: crop.width,
+					height: crop.height,
+					channels: 3
+				} }).jpeg({ quality: 90 }).toBuffer()).toString("base64"),
+				width: crop.width,
+				height: crop.height,
+				tier
+			};
+		} catch (err) {
+			this.ctx.logger.warn("getNativeCrop: cross-node JPEG encode failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
+			return null;
+		}
 	}
 	/**
 	* Two-plane design: run the DETAIL subtree (crop children) for a single
@@ -3244,10 +3361,72 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		return runDetailSubtree({
 			resolveChildSteps: (deviceId, parentClassName, filter) => this.resolveDetailChildSteps(deviceId, parentClassName, filter),
 			getNativeCrop: (deviceId, handle, paddedBbox) => this.getNativeCropForDetail(deviceId, handle, paddedBbox),
-			runPipeline: (steps, imageJpeg, deviceId) => this.runDetailPipeline(steps, imageJpeg, deviceId)
+			runPipeline: (steps, imageJpeg, deviceId, deviceKey) => this.runDetailPipeline(steps, imageJpeg, deviceId, deviceKey),
+			resolveStepDevice: (deviceId, step) => this.resolveDetailStepDevice(deviceId, step)
 		}, input);
 	}
 	/**
+	* Step-tree device jump (phase 1) — pick which same-node inference device an
+	* enrichment `step` runs on. AUTO-jumps only when the camera's elected device
+	* cannot run the step's model (its format has no build); an operator
+	* `step.jumpDeviceKey` overrides. Returns the resolved `<backend>:<device>`
+	* key, or `undefined` (⇒ the runner's per-camera default pool) when there is
+	* nothing to route: no elected device, or no jump roster on the attach.
+	*
+	* When NO enabled device on the node can run the step, logs a LOUD warn once
+	* per (camera, step) — killing the historical SILENT per-child degrade (an
+	* `edgetpu` root would otherwise drop faces/plates/clip with no signal).
+	*/
+	resolveDetailStepDevice(deviceId, step) {
+		const config = this.attached.get(deviceId)?.config;
+		const effectiveDeviceKey = config?.deviceKey;
+		if (!effectiveDeviceKey) return void 0;
+		const roster = config?.inferenceDevices;
+		if (!roster || roster.length < 2) return effectiveDeviceKey;
+		const attachedByKey = this.perDeviceAttachedCounts();
+		const devices = roster.map((d) => ({
+			deviceKey: d.deviceKey,
+			weight: d.weight,
+			maxSessions: d.maxSessions,
+			attachedCameras: attachedByKey.get(d.deviceKey) ?? 0
+		}));
+		const def = tryGetStepDefinition(step.addonId);
+		const canRun = (format) => def === null || def.models.some((m) => m.formats[format]);
+		const result = resolveStepDevice({
+			effectiveDeviceKey,
+			devices,
+			...step.jumpDeviceKey !== void 0 ? { manualJumpDeviceKey: step.jumpDeviceKey } : {},
+			canRun
+		});
+		if (result.kind === "no-candidate") this.warnStepHasNoRunnableDevice(deviceId, step.addonId, effectiveDeviceKey);
+		return result.deviceKey;
+	}
+	/** Live attached-camera count per inference `deviceKey` on this runner. */
+	perDeviceAttachedCounts() {
+		const counts = /* @__PURE__ */ new Map();
+		for (const cam of this.attached.values()) {
+			const key = cam.config.deviceKey;
+			if (key === void 0) continue;
+			counts.set(key, (counts.get(key) ?? 0) + 1);
+		}
+		return counts;
+	}
+	/** `${deviceId}:${addonId}` pairs already warned about a no-runnable-device step. */
+	warnedNoJumpDevice = /* @__PURE__ */ new Set();
+	warnStepHasNoRunnableDevice(deviceId, addonId, effectiveDeviceKey) {
+		const key = `${deviceId}:${addonId}`;
+		if (this.warnedNoJumpDevice.has(key)) return;
+		this.warnedNoJumpDevice.add(key);
+		this.ctx?.logger.warn("enrichment step has no runnable inference device on this node — producing NO results for it", {
+			tags: { deviceId },
+			meta: {
+				step: addonId,
+				electedDeviceKey: effectiveDeviceKey,
+				hint: "the elected device format has no build of this step, and no enabled same-node device can run it — enable a compatible accelerator or add a jumpDeviceKey"
+			}
+		});
+	}
+	/**
 	* Real `resolveChildSteps` dep: `null` when the camera isn't attached
 	* (matches the cap doc — "camera not attached" is a distinct case from
 	* "attached but no matching child steps", which returns an empty array
@@ -3269,16 +3448,12 @@ var PipelineRunnerAddon = class extends BaseAddon {
 	async getNativeCropForDetail(_deviceId, handle, paddedBbox) {
 		const native = await this.getNativeCrop({
 			handle,
-			bbox: paddedBbox
+			bbox: paddedBbox,
+			encodeJpeg: true
 		});
-		if (!native) return null;
-		const sharp = (await import("sharp")).default;
+		if (!native?.jpeg) return null;
 		return {
-			jpeg: await sharp(Buffer.from(native.bytes), { raw: {
-				width: native.width,
-				height: native.height,
-				channels: 3
-			} }).jpeg({ quality: 90 }).toBuffer(),
+			jpeg: Buffer.from(native.jpeg, "base64"),
 			width: native.width,
 			height: native.height,
 			frameSpace: denormalizeRect(paddedBbox, handle.width, handle.height)
@@ -3338,10 +3513,10 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		})();
 	}
 	/** Real `runPipeline` dep: node-local `pipelineExecutor.runPipeline` on the `'full'` plane. */
-	async runDetailPipeline(steps, imageJpeg, deviceId) {
+	async runDetailPipeline(steps, imageJpeg, deviceId, stepDeviceKey) {
 		const api = this.ctxIfReady?.api;
 		if (!api) return null;
-		const detailDeviceKey = this.attached.get(deviceId)?.config?.deviceKey;
+		const detailDeviceKey = stepDeviceKey ?? this.attached.get(deviceId)?.config?.deviceKey;
 		try {
 			return await api.pipelineExecutor.runPipeline.mutate({
 				steps: [...steps],
@@ -3418,6 +3593,8 @@ var PipelineRunnerAddon = class extends BaseAddon {
 		this.lastDecodeUnexpectedEndAt.delete(deviceId);
 		this.thumbSampler?.forget(deviceId);
 		this.packageGovernor.forget(deviceId);
+		const warnPrefix = `${deviceId}:`;
+		for (const key of this.warnedNoJumpDevice) if (key.startsWith(warnPrefix)) this.warnedNoJumpDevice.delete(key);
 		this.attached.delete(deviceId);
 		this.lastMotionAt.delete(deviceId);
 		this.lastEmittedCameraMetrics.delete(deviceId);

package/dist/recorder/index.js

@@ -1,5 +1,5 @@
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-E0K373T1.js");
+const require_dist = require("../dist-CVjqvU8G.js");
 const require_sheet_geometry = require("../sheet-geometry-BR-ip0CP.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_child_process = require("node:child_process");

package/dist/recorder/index.mjs

@@ -1,4 +1,4 @@
-import { F as recordingExportCapability, H as errMsg, I as resolveScrubThumbnailGeometry, J as hydrateSchema, K as DeviceType, P as recordingCapability, R as storageEvictableCapability, U as BaseAddon, Y as isEvent, c as EVENT_PAD_MS, dt as string, et as selectAssignedProfileSlots, f as OpsLogEntrySchema, j as nodePin, k as migrateConfigToBands, p as RecordingConfigSchema, pt as EventCategory, rt as array, u as ExportRecordSchema, ut as record } from "../dist-C3cDjL49.mjs";
+import { F as recordingExportCapability, H as errMsg, I as resolveScrubThumbnailGeometry, J as hydrateSchema, K as DeviceType, P as recordingCapability, R as storageEvictableCapability, U as BaseAddon, Y as isEvent, c as EVENT_PAD_MS, dt as string, et as selectAssignedProfileSlots, f as OpsLogEntrySchema, j as nodePin, k as migrateConfigToBands, p as RecordingConfigSchema, pt as EventCategory, rt as array, u as ExportRecordSchema, ut as record } from "../dist-ClyAFBZk.mjs";
 import { n as computeSheetGeometry, r as resolveHubHostname, t as allTilePlacements } from "../sheet-geometry-DcpuGTCm.mjs";
 import { n as createFileDataPlaneHandler, s as parseRangeHeader, t as contentTypeFor } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import { spawn } from "node:child_process";

package/dist/session-decode/decode-worker-child.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_worker_protocol = require("../worker-protocol-PP4jKHHJ.js");
+const require_worker_protocol = require("../worker-protocol-DextwlTX.js");
 let node_url = require("node:url");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);
@@ -597,6 +597,44 @@ function retainedFrameBytes(width, height, rgb24) {
 function rgbCropSourceOffset(top, left, stride) {
 	return top * stride + left * 3;
 }
+/**
+* Resolve the SOURCE the RGB native-crop scaler reads.
+*
+* The fast path is a zero-copy view: offset the packed RGB24 plane to the crop
+* origin and let the scaler stride over it ({@link rgbCropSourceOffset}). That
+* view is safe ONLY while it still holds `stride * height + slack` bytes — the
+* conservative span libswscale reads (full rows + a SIMD overshoot on the last
+* row). For a ROI whose bottom edge sits at (or near) the frame bottom AND whose
+* left offset is > 0, the tail of the plane is `left*3` bytes short of that span,
+* so the scaler reads past the allocation and THROWS — the crop is reported as a
+* native miss. A FULL-frame crop (left=0, full height) is always exactly sized,
+* which is why full-frame keyFrames landed while small offset ROIs missed
+* (the subject-ROI-vs-full-frame asymmetry).
+*
+* When the zero-copy view is too short, repack the ROI into a tightly-packed
+* buffer (stride = `width*3`) with the SIMD tail slack — identical pixels, but
+* guaranteed in-bounds for every ROI position. Pure + exported so the bounds
+* math is unit-testable without node-av.
+*/
+function resolveRgbCropSource(plane, planeStride, region) {
+	const offset = rgbCropSourceOffset(region.top, region.left, planeStride);
+	const rowBytes = region.width * 3;
+	const requiredSpan = planeStride * region.height + 64;
+	if (plane.length - offset >= requiredSpan) return {
+		src: plane.subarray(offset),
+		stride: planeStride
+	};
+	const tightStride = rowBytes;
+	const packed = new Uint8Array(tightStride * region.height + 64);
+	for (let row = 0; row < region.height; row++) {
+		const srcRowStart = offset + row * planeStride;
+		packed.set(plane.subarray(srcRowStart, srcRowStart + rowBytes), row * tightStride);
+	}
+	return {
+		src: packed,
+		stride: tightStride
+	};
+}
 //#endregion
 //#region src/session-decode/decode-worker-child.ts
 /**
@@ -1201,7 +1239,8 @@ var DecodeWorkerChild = class {
 			this.nativeCropMisses++;
 			this.send({
 				kind: "nativeCropMiss",
-				requestId
+				requestId,
+				reason: `frame ${frameId} not retained (lease/ring evicted before crop)`
 			});
 			return;
 		}
@@ -1218,10 +1257,12 @@ var DecodeWorkerChild = class {
 			});
 		} catch (err) {
 			this.nativeCropMisses++;
-			this.emitStderr(`decode-worker-child: native crop failed (requestId ${requestId}) — ${errMessage(err)}\n`);
+			const reason = errMessage(err);
+			this.emitStderr(`decode-worker-child: native crop failed (requestId ${requestId}) — ${reason}\n`);
 			this.send({
 				kind: "nativeCropMiss",
-				requestId
+				requestId,
+				reason: `crop failed — ${reason}`
 			});
 		}
 	}
@@ -1389,13 +1430,13 @@ var DecodeWorkerChild = class {
 		const { region, target } = resolved;
 		const plane = frame.data?.[0];
 		if (!plane) throw new Error("decode-worker-child: retained RGB frame missing packed plane data");
-		const srcStride = frame.linesize[0] ?? 0;
-		const srcSlice = plane.subarray(rgbCropSourceOffset(region.top, region.left, srcStride));
+		const { src: srcRgb, stride: srcSliceStride } = resolveRgbCropSource(plane, frame.linesize[0] ?? 0, region);
+		const srcSlice = Buffer.from(srcRgb.buffer, srcRgb.byteOffset, srcRgb.byteLength);
 		const scaler = this.ensureNativeCropScaler(nav, C, region.width, region.height, target.width, target.height, C.AV_PIX_FMT_RGB24);
 		const tightStride = target.width * 3;
 		const dstStride = tightStride + 63 & -64;
 		const dstBuffer = Buffer.allocUnsafe(dstStride * target.height + 64);
-		const scaledHeight = scaler.scaleSync([srcSlice], [srcStride], 0, region.height, [dstBuffer], [dstStride]);
+		const scaledHeight = scaler.scaleSync([srcSlice], [srcSliceStride], 0, region.height, [dstBuffer], [dstStride]);
 		if (scaledHeight < 0) throw new Error(`native rgb crop sws_scale failed: ${scaledHeight}`);
 		if (scaledHeight !== target.height) throw new Error(`native rgb crop scaler produced ${scaledHeight} of ${target.height} rows`);
 		if (dstStride === tightStride) return dstBuffer.subarray(0, tightStride * target.height);
@@ -1857,6 +1898,13 @@ var DecodeWorkerChild = class {
 	emitStderr(line) {
 		const tag = this.deviceId === null ? "[dev:?]" : `[dev:${this.deviceId}]`;
 		process.stderr.write(`${tag} ${line}`);
+		try {
+			this.send({
+				kind: "log",
+				level: require_worker_protocol.logLevelForLine(line),
+				message: `${tag} ${line.trimEnd()}`
+			});
+		} catch {}
 	}
 	sendError(message, frameId) {
 		this.emitStderr(`${message}\n`);

package/dist/session-decode/decode-worker-child.mjs

@@ -1,4 +1,4 @@
-import { n as isWorkerRequest } from "../worker-protocol-CyVJTZEO.mjs";
+import { n as isWorkerRequest, r as logLevelForLine } from "../worker-protocol-D7RzZIla.mjs";
 import { pathToFileURL } from "node:url";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -593,6 +593,44 @@ function retainedFrameBytes(width, height, rgb24) {
 function rgbCropSourceOffset(top, left, stride) {
 	return top * stride + left * 3;
 }
+/**
+* Resolve the SOURCE the RGB native-crop scaler reads.
+*
+* The fast path is a zero-copy view: offset the packed RGB24 plane to the crop
+* origin and let the scaler stride over it ({@link rgbCropSourceOffset}). That
+* view is safe ONLY while it still holds `stride * height + slack` bytes — the
+* conservative span libswscale reads (full rows + a SIMD overshoot on the last
+* row). For a ROI whose bottom edge sits at (or near) the frame bottom AND whose
+* left offset is > 0, the tail of the plane is `left*3` bytes short of that span,
+* so the scaler reads past the allocation and THROWS — the crop is reported as a
+* native miss. A FULL-frame crop (left=0, full height) is always exactly sized,
+* which is why full-frame keyFrames landed while small offset ROIs missed
+* (the subject-ROI-vs-full-frame asymmetry).
+*
+* When the zero-copy view is too short, repack the ROI into a tightly-packed
+* buffer (stride = `width*3`) with the SIMD tail slack — identical pixels, but
+* guaranteed in-bounds for every ROI position. Pure + exported so the bounds
+* math is unit-testable without node-av.
+*/
+function resolveRgbCropSource(plane, planeStride, region) {
+	const offset = rgbCropSourceOffset(region.top, region.left, planeStride);
+	const rowBytes = region.width * 3;
+	const requiredSpan = planeStride * region.height + 64;
+	if (plane.length - offset >= requiredSpan) return {
+		src: plane.subarray(offset),
+		stride: planeStride
+	};
+	const tightStride = rowBytes;
+	const packed = new Uint8Array(tightStride * region.height + 64);
+	for (let row = 0; row < region.height; row++) {
+		const srcRowStart = offset + row * planeStride;
+		packed.set(plane.subarray(srcRowStart, srcRowStart + rowBytes), row * tightStride);
+	}
+	return {
+		src: packed,
+		stride: tightStride
+	};
+}
 //#endregion
 //#region src/session-decode/decode-worker-child.ts
 /**
@@ -1197,7 +1235,8 @@ var DecodeWorkerChild = class {
 			this.nativeCropMisses++;
 			this.send({
 				kind: "nativeCropMiss",
-				requestId
+				requestId,
+				reason: `frame ${frameId} not retained (lease/ring evicted before crop)`
 			});
 			return;
 		}
@@ -1214,10 +1253,12 @@ var DecodeWorkerChild = class {
 			});
 		} catch (err) {
 			this.nativeCropMisses++;
-			this.emitStderr(`decode-worker-child: native crop failed (requestId ${requestId}) — ${errMessage(err)}\n`);
+			const reason = errMessage(err);
+			this.emitStderr(`decode-worker-child: native crop failed (requestId ${requestId}) — ${reason}\n`);
 			this.send({
 				kind: "nativeCropMiss",
-				requestId
+				requestId,
+				reason: `crop failed — ${reason}`
 			});
 		}
 	}
@@ -1385,13 +1426,13 @@ var DecodeWorkerChild = class {
 		const { region, target } = resolved;
 		const plane = frame.data?.[0];
 		if (!plane) throw new Error("decode-worker-child: retained RGB frame missing packed plane data");
-		const srcStride = frame.linesize[0] ?? 0;
-		const srcSlice = plane.subarray(rgbCropSourceOffset(region.top, region.left, srcStride));
+		const { src: srcRgb, stride: srcSliceStride } = resolveRgbCropSource(plane, frame.linesize[0] ?? 0, region);
+		const srcSlice = Buffer.from(srcRgb.buffer, srcRgb.byteOffset, srcRgb.byteLength);
 		const scaler = this.ensureNativeCropScaler(nav, C, region.width, region.height, target.width, target.height, C.AV_PIX_FMT_RGB24);
 		const tightStride = target.width * 3;
 		const dstStride = tightStride + 63 & -64;
 		const dstBuffer = Buffer.allocUnsafe(dstStride * target.height + 64);
-		const scaledHeight = scaler.scaleSync([srcSlice], [srcStride], 0, region.height, [dstBuffer], [dstStride]);
+		const scaledHeight = scaler.scaleSync([srcSlice], [srcSliceStride], 0, region.height, [dstBuffer], [dstStride]);
 		if (scaledHeight < 0) throw new Error(`native rgb crop sws_scale failed: ${scaledHeight}`);
 		if (scaledHeight !== target.height) throw new Error(`native rgb crop scaler produced ${scaledHeight} of ${target.height} rows`);
 		if (dstStride === tightStride) return dstBuffer.subarray(0, tightStride * target.height);
@@ -1853,6 +1894,13 @@ var DecodeWorkerChild = class {
 	emitStderr(line) {
 		const tag = this.deviceId === null ? "[dev:?]" : `[dev:${this.deviceId}]`;
 		process.stderr.write(`${tag} ${line}`);
+		try {
+			this.send({
+				kind: "log",
+				level: logLevelForLine(line),
+				message: `${tag} ${line.trimEnd()}`
+			});
+		} catch {}
 	}
 	sendError(message, frameId) {
 		this.emitStderr(`${message}\n`);

package/dist/{step-definitions-DMne6GHq.js → step-definitions-D76MMwbo.js}

@@ -1,4 +1,4 @@
-const require_dist = require("./dist-E0K373T1.js");
+const require_dist = require("./dist-CVjqvU8G.js");
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";
 var HF_SCRYPTED = "scrypted/plugin-models";

package/dist/{step-definitions-ty97QrzE.mjs → step-definitions-DMOw4fzn.mjs}

@@ -1,4 +1,4 @@
-import { E as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-C3cDjL49.mjs";
+import { E as hfModelUrl, a as COCO_TO_MACRO, i as COCO_80_LABELS, r as AUDIO_MACRO_LABELS } from "./dist-ClyAFBZk.mjs";
 //#region src/detection-pipeline/registry/model-catalogs.ts
 var HF_REPO = "camstack/camstack-models";
 var HF_SCRYPTED = "scrypted/plugin-models";

package/dist/stream-broker/_stub.js

@@ -2,7 +2,7 @@ import { a as e, c as t, d as n, i as r, l as i, n as a, o, r as s, s as c, t as
 import { a as d, i as f, n as p, o as m, r as h, t as g } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react__loadShare__.js-C9j-2lBe.mjs";
 import { n as _, r as v, t as y } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-XO0-Pyu6.mjs";
 import { n as b, t as x } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_tanstack_mf_1_react_mf_2_query__loadShare__.js-BO7TIbJV.mjs";
-import { t as S } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-UGa9yj7_.mjs";
+import { t as S } from "./_virtual_mf___mfe_internal__addon_stream_broker_widgets__loadShare___mf_0_camstack_mf_1_types__loadShare__.js-CQC_f4Yv.mjs";
 //#region ../../node_modules/lucide-react/dist/esm/shared/src/utils.js
 var C = (e) => e.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase(), w = (e) => e.replace(/^([A-Z])|[\s-_]+(\w)/g, (e, t, n) => n ? n.toUpperCase() : t.toLowerCase()), T = (e) => {
 	let t = w(e);

package/dist/stream-broker/{_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-B2g-vEQt.mjs → _virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-7jRy3Uzr.mjs}

@@ -3,7 +3,7 @@ import "./dist-CYZr2fwk.mjs";
 var e = {
 	"@camstack/sdk": {
 		name: "@camstack/sdk",
-		version: "1.2.1",
+		version: "1.2.2",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -18,7 +18,7 @@ var e = {
 	},
 	"@camstack/types": {
 		name: "@camstack/types",
-		version: "1.2.1",
+		version: "1.2.2",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",
@@ -33,7 +33,7 @@ var e = {
 	},
 	"@camstack/ui-library": {
 		name: "@camstack/ui-library",
-		version: "1.2.1",
+		version: "1.2.2",
 		scope: ["default"],
 		loaded: !1,
 		from: "addon_stream_broker_widgets",