@camstack/addon-pipeline 1.2.1 → 1.2.3

package/dist/audio-analyzer/index.js

@@ -3,7 +3,7 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-E0K373T1.js");
+const require_dist = require("../dist-D7-LF079.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.js");
 const require_model_download_service_Cp9f4dk6 = require("../model-download-service-Cp9f4dk6-Dv-oFwjN.js");
 let node_fs = require("node:fs");

package/dist/audio-analyzer/index.mjs

@@ -1,5 +1,5 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { D as mapAudioLabelToMacro, H as errMsg, J as hydrateSchema, U as BaseAddon, _ as audioAnalysisCapability, d as HF_BASE_URL, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, v as audioAnalyzerCapability } from "../dist-C3cDjL49.mjs";
+import { D as mapAudioLabelToMacro, H as errMsg, J as hydrateSchema, U as BaseAddon, _ as audioAnalysisCapability, d as HF_BASE_URL, n as AUDIO_BACKEND_CHOICES, o as DEFAULT_AUDIO_ANALYZER_CONFIG, v as audioAnalyzerCapability } from "../dist-DVjpngiC.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { i as downloadFile } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import * as fs from "node:fs";

package/dist/detection-pipeline/index.js

@@ -3,8 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-E0K373T1.js");
-const require_step_definitions = require("../step-definitions-DMne6GHq.js");
+const require_dist = require("../dist-D7-LF079.js");
+const require_step_definitions = require("../step-definitions-BfXdDokR.js");
 const require_node_topology_platform = require("../node-topology-platform-CFZ7F4xW.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/detection-pipeline/index.mjs

@@ -1,6 +1,6 @@
 import { t as __require } from "../chunk-BdkLduGY.mjs";
-import { B as supportedRuntimes$1, C as detectionPipelineCapability, H as errMsg, J as hydrateSchema, L as runtimeDevices$1, M as pipelineExecutorCapability, Q as parseJsonUnknown, T as evaluateZoneRules, U as BaseAddon, dt as string, ft as union, h as YAMNET_TO_MACRO, j as nodePin, lt as object, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT, t as APPLE_SA_TO_MACRO, tt as sleep, w as enumerateInferenceDevices, x as defaultDeviceFor$1 } from "../dist-C3cDjL49.mjs";
-import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-ty97QrzE.mjs";
+import { B as supportedRuntimes$1, C as detectionPipelineCapability, H as errMsg, J as hydrateSchema, L as runtimeDevices$1, M as pipelineExecutorCapability, Q as parseJsonUnknown, T as evaluateZoneRules, U as BaseAddon, dt as string, ft as union, h as YAMNET_TO_MACRO, j as nodePin, lt as object, pt as EventCategory, q as createEvent, rt as array, s as DEVICE_BACKEND_TO_FORMAT, t as APPLE_SA_TO_MACRO, tt as sleep, w as enumerateInferenceDevices, x as defaultDeviceFor$1 } from "../dist-DVjpngiC.mjs";
+import { a as getStepDefinition, i as getStep, n as ALL_STEPS, o as resolveModelForFormat, r as getDefaultModelForFormat, t as ALL_PIPELINE_STEPS } from "../step-definitions-BPwND8Zg.mjs";
 import { t as pickNodePlatformArch } from "../node-topology-platform-BkR_k6WT.mjs";
 import { a as ensureModel, o as isModelDownloaded, r as deleteModelFromDisk } from "../model-download-service-Cp9f4dk6-CwUb5v3Y.mjs";
 import { spawn } from "node:child_process";

package/dist/{dist-E0K373T1.js → dist-D7-LF079.js}

@@ -11860,7 +11860,8 @@ var PipelineStepInputSchema = lazy(() => object({
 	modelId: string().optional(),
 	enabled: boolean().default(true),
 	children: array(PipelineStepInputSchema).optional(),
-	settings: record(string(), unknown()).optional()
+	settings: record(string(), unknown()).optional(),
+	jumpDeviceKey: string().optional()
 }));
 var ModelSubstitutionSchema = object({
 	addonId: string(),
@@ -12318,8 +12319,24 @@ var NativeCropBboxSchema = object({
 });
 /** Result of a best-effort native-resolution crop (`getNativeCrop`). */
 var NativeCropResultSchema = object({
-	/** Packed rgb (24-bit) pixels of the crop. */
-	bytes: _instanceof(Uint8Array),
+	/**
+	* Packed rgb (24-bit) pixels of the crop. Present on the DEFAULT (raw) path —
+	* same-node (in-process / UDS) callers get zero-copy RGB and encode locally.
+	* OMITTED when the caller requested `encodeJpeg` (the cross-node compressed
+	* path below), where shipping raw RGB is both an invariant violation and, for
+	* a native full frame (~26 MB at 4K), larger than Moleculer's 10 MB
+	* `maxPacketSize` → the packet is dropped and the call 60s-times-out. That is
+	* the cross-node native-media miss: `bytes` is replaced by `jpeg`.
+	*/
+	bytes: _instanceof(Uint8Array).optional(),
+	/**
+	* Base64 JPEG of the crop — the COMPRESSED cross-node payload. The OWNING node
+	* (which holds the native surface) encodes it in-process, so a native 4K frame
+	* ships as ~0.5–2 MB (well under `maxPacketSize`) and NO raw pixels ever cross
+	* a process boundary (CLAUDE.md invariant #21). Present ONLY when the request
+	* set `encodeJpeg: true`; `bytes` is then absent.
+	*/
+	jpeg: string().optional(),
 	width: number().int().positive(),
 	height: number().int().positive(),
 	/**
@@ -12465,6 +12482,20 @@ var RunnerFrameSourceSchema = discriminatedUnion("kind", [object({ kind: literal
 	hubHostnameOverride: string().optional()
 })]).describe("Per-camera frame-source mode for the runner (P2c)");
 /**
+* One ENABLED inference device on the runner's node, as the step-tree
+* device-jump resolver sees it (phase 1). The orchestrator populates this
+* roster on the attach payload whenever the camera is elected onto a specific
+* `deviceKey` and the node has ≥2 enabled devices — it is the candidate set the
+* runner auto-jumps an enrichment step to when the elected device's format
+* cannot run that step's model. `weight`/`maxSessions` mirror the balancer's
+* per-device knobs so the auto choice is weighted-least-loaded.
+*/
+var RunnerInferenceDeviceSchema = object({
+	deviceKey: string(),
+	weight: number().positive().default(1),
+	maxSessions: number().int().positive().nullable().default(null)
+});
+/**
 * Camera assignment payload sent by `addon-pipeline-orchestrator` to a
 * specific runner instance via `attachCamera`. Carries everything the
 * runner needs to subscribe to the local broker and execute inference.
@@ -12582,7 +12613,16 @@ var RunnerCameraConfigSchema = object({
 	* omitted ⇒ the runner's default device. The engine itself stays node-local —
 	* this only selects WHICH device pool of that node runs the session.
 	*/
-	deviceKey: string().optional()
+	deviceKey: string().optional(),
+	/**
+	* Step-tree device-jump roster (phase 1): the node's ENABLED inference
+	* devices, populated by the orchestrator ONLY when `deviceKey` is set and the
+	* node has ≥2 enabled devices. The runner uses it to AUTO-jump an enrichment
+	* step whose model has no build for the elected device's format onto another
+	* enabled device of the SAME node (weighted-least-loaded). Absent/single-entry
+	* ⇒ no jump possible; the step runs on `deviceKey`.
+	*/
+	inferenceDevices: array(RunnerInferenceDeviceSchema).readonly().optional()
 });
 motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
@@ -12702,7 +12742,18 @@ var pipelineRunnerCapability = {
 		getNativeCrop: method(object({
 			handle: FrameHandleSchema,
 			bbox: NativeCropBboxSchema,
-			maxWidth: number().int().positive().optional()
+			maxWidth: number().int().positive().optional(),
+			/**
+			* When `true`, the runner encodes the resolved crop to JPEG ON THE
+			* OWNING NODE and returns it in `jpeg` (base64) INSTEAD of raw `bytes`.
+			* Callers set this for CROSS-NODE fetches (`handle.nodeId` is a remote
+			* agent) so the compressed payload fits Moleculer's `maxPacketSize` and
+			* no raw pixels cross the process boundary. Same-node callers omit it
+			* and keep the zero-copy raw `bytes` path. Additive + optional: a
+			* pre-encode runner (version skew) ignores it and returns `bytes`, so
+			* the caller falls back to encoding locally.
+			*/
+			encodeJpeg: boolean().optional()
 		}), NativeCropResultSchema.nullable()),
 		/**
 		* Two-plane design: run the DETAIL subtree (crop children —
@@ -17726,7 +17777,8 @@ var MediaFileKindEnum = _enum([
 	"faceCrop",
 	"plateCrop",
 	"keyFrame",
-	"keyFrameSmall"
+	"keyFrameSmall",
+	"thumbnailSmall"
 ]);
 var MediaFileSchema = object({
 	key: string(),
@@ -18057,7 +18109,16 @@ var PipelineTemplateSchema = object({
 });
 var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
-	settings: record(string(), unknown()).optional()
+	settings: record(string(), unknown()).optional(),
+	/**
+	* Step-tree device jump (same-node, phase 1) — OPTIONAL manual override.
+	* When set, this step runs on the named enabled device of the SAME node
+	* (`<backend>:<device>`) instead of the camera's elected device, bypassing
+	* the runtime AUTO-jump. The orchestrator rejects a `jumpDeviceKey` pointing
+	* at a disabled/absent device on that node at save time. Absent ⇒ the runner
+	* auto-jumps only when the effective device's format cannot run the step.
+	*/
+	jumpDeviceKey: string().optional()
 });
 var AgentPipelineSettingsSchema = object({
 	maxCameras: number().int().nonnegative().nullable().default(null),

package/dist/{dist-C3cDjL49.mjs → dist-DVjpngiC.mjs}

@@ -11860,7 +11860,8 @@ var PipelineStepInputSchema = lazy(() => object({
 	modelId: string().optional(),
 	enabled: boolean().default(true),
 	children: array(PipelineStepInputSchema).optional(),
-	settings: record(string(), unknown()).optional()
+	settings: record(string(), unknown()).optional(),
+	jumpDeviceKey: string().optional()
 }));
 var ModelSubstitutionSchema = object({
 	addonId: string(),
@@ -12318,8 +12319,24 @@ var NativeCropBboxSchema = object({
 });
 /** Result of a best-effort native-resolution crop (`getNativeCrop`). */
 var NativeCropResultSchema = object({
-	/** Packed rgb (24-bit) pixels of the crop. */
-	bytes: _instanceof(Uint8Array),
+	/**
+	* Packed rgb (24-bit) pixels of the crop. Present on the DEFAULT (raw) path —
+	* same-node (in-process / UDS) callers get zero-copy RGB and encode locally.
+	* OMITTED when the caller requested `encodeJpeg` (the cross-node compressed
+	* path below), where shipping raw RGB is both an invariant violation and, for
+	* a native full frame (~26 MB at 4K), larger than Moleculer's 10 MB
+	* `maxPacketSize` → the packet is dropped and the call 60s-times-out. That is
+	* the cross-node native-media miss: `bytes` is replaced by `jpeg`.
+	*/
+	bytes: _instanceof(Uint8Array).optional(),
+	/**
+	* Base64 JPEG of the crop — the COMPRESSED cross-node payload. The OWNING node
+	* (which holds the native surface) encodes it in-process, so a native 4K frame
+	* ships as ~0.5–2 MB (well under `maxPacketSize`) and NO raw pixels ever cross
+	* a process boundary (CLAUDE.md invariant #21). Present ONLY when the request
+	* set `encodeJpeg: true`; `bytes` is then absent.
+	*/
+	jpeg: string().optional(),
 	width: number().int().positive(),
 	height: number().int().positive(),
 	/**
@@ -12465,6 +12482,20 @@ var RunnerFrameSourceSchema = discriminatedUnion("kind", [object({ kind: literal
 	hubHostnameOverride: string().optional()
 })]).describe("Per-camera frame-source mode for the runner (P2c)");
 /**
+* One ENABLED inference device on the runner's node, as the step-tree
+* device-jump resolver sees it (phase 1). The orchestrator populates this
+* roster on the attach payload whenever the camera is elected onto a specific
+* `deviceKey` and the node has ≥2 enabled devices — it is the candidate set the
+* runner auto-jumps an enrichment step to when the elected device's format
+* cannot run that step's model. `weight`/`maxSessions` mirror the balancer's
+* per-device knobs so the auto choice is weighted-least-loaded.
+*/
+var RunnerInferenceDeviceSchema = object({
+	deviceKey: string(),
+	weight: number().positive().default(1),
+	maxSessions: number().int().positive().nullable().default(null)
+});
+/**
 * Camera assignment payload sent by `addon-pipeline-orchestrator` to a
 * specific runner instance via `attachCamera`. Carries everything the
 * runner needs to subscribe to the local broker and execute inference.
@@ -12582,7 +12613,16 @@ var RunnerCameraConfigSchema = object({
 	* omitted ⇒ the runner's default device. The engine itself stays node-local —
 	* this only selects WHICH device pool of that node runs the session.
 	*/
-	deviceKey: string().optional()
+	deviceKey: string().optional(),
+	/**
+	* Step-tree device-jump roster (phase 1): the node's ENABLED inference
+	* devices, populated by the orchestrator ONLY when `deviceKey` is set and the
+	* node has ≥2 enabled devices. The runner uses it to AUTO-jump an enrichment
+	* step whose model has no build for the elected device's format onto another
+	* enabled device of the SAME node (weighted-least-loaded). Absent/single-entry
+	* ⇒ no jump possible; the step runs on `deviceKey`.
+	*/
+	inferenceDevices: array(RunnerInferenceDeviceSchema).readonly().optional()
 });
 motionFpsField.min, motionFpsField.max, motionFpsField.step, motionFpsField.default, detectionFpsField.min, detectionFpsField.max, detectionFpsField.step, detectionFpsField.default, motionCooldownMsField.min, motionCooldownMsField.max, motionCooldownMsField.step, motionCooldownMsField.default, occupancyRecheckSecField.min, occupancyRecheckSecField.max, occupancyRecheckSecField.step, occupancyRecheckSecField.default, occupancyRecheckFramesField.min, occupancyRecheckFramesField.max, occupancyRecheckFramesField.step, occupancyRecheckFramesField.default;
 /**
@@ -12702,7 +12742,18 @@ var pipelineRunnerCapability = {
 		getNativeCrop: method(object({
 			handle: FrameHandleSchema,
 			bbox: NativeCropBboxSchema,
-			maxWidth: number().int().positive().optional()
+			maxWidth: number().int().positive().optional(),
+			/**
+			* When `true`, the runner encodes the resolved crop to JPEG ON THE
+			* OWNING NODE and returns it in `jpeg` (base64) INSTEAD of raw `bytes`.
+			* Callers set this for CROSS-NODE fetches (`handle.nodeId` is a remote
+			* agent) so the compressed payload fits Moleculer's `maxPacketSize` and
+			* no raw pixels cross the process boundary. Same-node callers omit it
+			* and keep the zero-copy raw `bytes` path. Additive + optional: a
+			* pre-encode runner (version skew) ignores it and returns `bytes`, so
+			* the caller falls back to encoding locally.
+			*/
+			encodeJpeg: boolean().optional()
 		}), NativeCropResultSchema.nullable()),
 		/**
 		* Two-plane design: run the DETAIL subtree (crop children —
@@ -17726,7 +17777,8 @@ var MediaFileKindEnum = _enum([
 	"faceCrop",
 	"plateCrop",
 	"keyFrame",
-	"keyFrameSmall"
+	"keyFrameSmall",
+	"thumbnailSmall"
 ]);
 var MediaFileSchema = object({
 	key: string(),
@@ -18057,7 +18109,16 @@ var PipelineTemplateSchema = object({
 });
 var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
-	settings: record(string(), unknown()).optional()
+	settings: record(string(), unknown()).optional(),
+	/**
+	* Step-tree device jump (same-node, phase 1) — OPTIONAL manual override.
+	* When set, this step runs on the named enabled device of the SAME node
+	* (`<backend>:<device>`) instead of the camera's elected device, bypassing
+	* the runtime AUTO-jump. The orchestrator rejects a `jumpDeviceKey` pointing
+	* at a disabled/absent device on that node at save time. Absent ⇒ the runner
+	* auto-jumps only when the effective device's format cannot run the step.
+	*/
+	jumpDeviceKey: string().optional()
 });
 var AgentPipelineSettingsSchema = object({
 	maxCameras: number().int().nonnegative().nullable().default(null),

package/dist/motion-wasm/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-E0K373T1.js");
+const require_dist = require("../dist-D7-LF079.js");
 let node_fs = require("node:fs");
 let node_path = require("node:path");
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/motion-wasm/index.mjs

@@ -1,4 +1,4 @@
-import { A as motionDetectionCapability, J as hydrateSchema, K as DeviceType, T as evaluateZoneRules, U as BaseAddon } from "../dist-C3cDjL49.mjs";
+import { A as motionDetectionCapability, J as hydrateSchema, K as DeviceType, T as evaluateZoneRules, U as BaseAddon } from "../dist-DVjpngiC.mjs";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 //#region src/motion-wasm/wasm-motion-detector.ts

package/dist/pipeline-runner/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-D6vf50IK.js");
-const require_dist = require("../dist-E0K373T1.js");
+const require_dist = require("../dist-D7-LF079.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_sheet_geometry = require("../sheet-geometry-BR-ip0CP.js");
-const require_worker_protocol = require("../worker-protocol-PP4jKHHJ.js");
-const require_step_definitions = require("../step-definitions-DMne6GHq.js");
+const require_worker_protocol = require("../worker-protocol-DextwlTX.js");
+const require_step_definitions = require("../step-definitions-BfXdDokR.js");
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
 let sharp = require("sharp");
@@ -1680,11 +1680,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) {
@@ -2253,13 +2260,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 require_dist.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,
@@ -3224,18 +3311,48 @@ var PipelineRunnerAddon = class extends require_dist.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$3 = (await import("sharp")).default;
+			return {
+				jpeg: (await sharp$3(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
@@ -3250,10 +3367,72 @@ var PipelineRunnerAddon = class extends require_dist.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
@@ -3275,16 +3454,12 @@ var PipelineRunnerAddon = class extends require_dist.BaseAddon {
 	async getNativeCropForDetail(_deviceId, handle, paddedBbox) {
 		const native = await this.getNativeCrop({
 			handle,
-			bbox: paddedBbox
+			bbox: paddedBbox,
+			encodeJpeg: true
 		});
-		if (!native) return null;
-		const sharp$3 = (await import("sharp")).default;
+		if (!native?.jpeg) return null;
 		return {
-			jpeg: await sharp$3(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)
@@ -3344,10 +3519,10 @@ var PipelineRunnerAddon = class extends require_dist.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],
@@ -3424,6 +3599,8 @@ var PipelineRunnerAddon = class extends require_dist.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);