@camstack/addon-pipeline-orchestrator 1.2.1 → 1.2.3

package/dist/index.mjs

@@ -11581,7 +11581,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(),
@@ -12072,8 +12073,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(),
 	/**
@@ -12219,6 +12236,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.
@@ -12336,7 +12367,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()
 });
 /**
 * Per-device settings UI fields the runner cap owns. Co-located with
@@ -12516,7 +12556,18 @@ var RunnerLocalMetricsSchema = object({
 method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mutation" }), method(object({ deviceId: number() }), object({ success: literal(true) }), { kind: "mutation" }), method(ReportMotionInputSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), RunnerLocalLoadSchema), method(_void(), RunnerLocalMetricsSchema), method(object({ deviceId: number() }), CameraMetricsSchema.nullable()), method(_void(), array(CameraMetricsWithDeviceIdSchema).readonly()), method(_void(), array(number()).readonly()), 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()), method(object({
 	deviceId: number(),
 	frameHandle: FrameHandleSchema.optional(),
@@ -17428,7 +17479,8 @@ var MediaFileKindEnum = _enum([
 	"faceCrop",
 	"plateCrop",
 	"keyFrame",
-	"keyFrameSmall"
+	"keyFrameSmall",
+	"thumbnailSmall"
 ]);
 var MediaFileSchema = object({
 	key: string(),
@@ -17759,7 +17811,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),
@@ -26572,6 +26633,25 @@ function defaultModelIdForDevice(deviceKey) {
 	return "yolo26n";
 }
 /**
+* Step-tree device jump (phase 1): validate every `steps[step].jumpDeviceKey`
+* manual override in a to-be-saved `inferenceDevices` map. A jump target MUST be
+* an enabled∧available device on the SAME node and DIFFERENT from the owning
+* device. `enabledAvailableKeys` is the effective enabled∧available set (from
+* `mergeInferenceDevices(probe, submitted)`) so an absent/unplugged/disabled
+* target is rejected honestly (an operator can't route a step onto a dead pool).
+* Returns the FIRST human-readable error, or `null` when every override is
+* valid. Pure + deterministic.
+*/
+function validateJumpTargets(inferenceDevices, enabledAvailableKeys) {
+	for (const [deviceKey, entry] of Object.entries(inferenceDevices)) for (const [stepId, step] of Object.entries(entry.steps ?? {})) {
+		const target = step.jumpDeviceKey;
+		if (target === void 0) continue;
+		if (target === deviceKey) return `step "${stepId}" on "${deviceKey}" has a jumpDeviceKey pointing at its own device`;
+		if (!enabledAvailableKeys.has(target)) return `step "${stepId}" on "${deviceKey}" has a jumpDeviceKey "${target}" that is not an enabled, available device on this node`;
+	}
+	return null;
+}
+/**
 * Merge a node's live-probed inference devices with its stored per-device map.
 *
 * The default is **AUTO = all discovered ACCELERATORS enabled** (spec C2,
@@ -26640,6 +26720,23 @@ function eligibleInferenceDeviceWeights(probed, stored) {
 	for (const d of mergeInferenceDevices(probed, stored)) if (d.enabled && d.available) out[d.key] = d.weight;
 	return out;
 }
+/**
+* Step-tree device jump (phase 1): the attach-payload roster of a node's
+* enabled∧available inference devices with the balancer knobs (`weight`,
+* `maxSessions`) the runner uses to AUTO-jump an enrichment step off a device
+* whose format can't run it. Built from the SAME `eligible` (deviceKey→weight)
+* and `caps` (deviceKey→maxSessions) the dispatcher already computes, so the
+* roster the runner sees exactly matches the balancer's candidate set. Sorted
+* by key for determinism. Populated onto `RunnerCameraConfig.inferenceDevices`
+* ONLY when a `deviceKey` is elected and there are ≥2 entries.
+*/
+function buildInferenceDeviceRoster(eligible, caps) {
+	return Object.entries(eligible).map(([deviceKey, weight]) => ({
+		deviceKey,
+		weight: weight > 0 ? weight : 1,
+		maxSessions: caps[deviceKey] ?? null
+	})).toSorted((a, b) => a.deviceKey < b.deviceKey ? -1 : a.deviceKey > b.deviceKey ? 1 : 0);
+}
 //#endregion
 //#region src/orchestrator-types.ts
 var PHASE_MODE_VALUES = new Set([
@@ -28801,7 +28898,12 @@ function buildRunnerConfig(base, overrides) {
 }
 //#endregion
 //#region src/apply-device-provisioning.ts
-/** Merge base then override for one step. Override keys win; undefined = inherit. */
+/**
+* Merge base then override for one step. Override keys win; undefined = inherit.
+* `jumpDeviceKey` (step-tree device jump, phase 1) is a per-(node,device) BASE
+* concept ONLY — the per-camera override never carries it (spec: per-camera jump
+* is out of scope), so it is taken from `base` verbatim.
+*/
 function resolveStep(base, override) {
 	if (!base && !override) return void 0;
 	const modelId = override?.modelId ?? base?.modelId;
@@ -28809,9 +28911,11 @@ function resolveStep(base, override) {
 		...base?.settings,
 		...override?.settings
 	} : void 0;
+	const jumpDeviceKey = base?.jumpDeviceKey;
 	return {
 		...modelId !== void 0 ? { modelId } : {},
-		...settings ? { settings } : {}
+		...settings ? { settings } : {},
+		...jumpDeviceKey !== void 0 ? { jumpDeviceKey } : {}
 	};
 }
 /**
@@ -28829,6 +28933,7 @@ function applyDeviceProvisioning(steps, base, override) {
 			...step,
 			...cfg?.modelId !== void 0 ? { modelId: cfg.modelId } : {},
 			...cfg?.settings ? { settings: cfg.settings } : {},
+			...cfg?.jumpDeviceKey !== void 0 ? { jumpDeviceKey: cfg.jumpDeviceKey } : {},
 			...children !== void 0 ? { children } : {}
 		};
 	});
@@ -29813,17 +29918,21 @@ var PlacementService = class {
 			dispatchScore = decision.score;
 		}
 		const targetLoad = loads.find((load) => load.nodeId === targetNodeId);
+		const eligibleDevices = await this.deps.getEligibleInferenceDevices(targetNodeId);
+		const deviceCaps = await this.deps.getInferenceDeviceCaps(targetNodeId);
 		const deviceKey = pickInferenceDevice({
-			eligible: await this.deps.getEligibleInferenceDevices(targetNodeId),
+			eligible: eligibleDevices,
 			loads: targetLoad?.devices ?? [],
-			caps: await this.deps.getInferenceDeviceCaps(targetNodeId),
+			caps: deviceCaps,
 			pinnedDeviceKey: await this.deps.readPipelineDevicePin(runnerConfig.deviceId)
 		}) ?? void 0;
 		const deviceBase = deviceKey ? await this.deps.settingsStore.buildNodeInferenceDeviceSteps(targetNodeId, deviceKey) : {};
 		const deviceOverride = deviceKey ? await this.deps.settingsStore.readCameraDeviceOverride(runnerConfig.deviceId, targetNodeId, deviceKey) : {};
+		const inferenceDevices = deviceKey && Object.keys(eligibleDevices).length >= 2 ? buildInferenceDeviceRoster(eligibleDevices, deviceCaps) : void 0;
 		const attachConfig = {
 			...runnerConfig,
 			...deviceKey ? { deviceKey } : {},
+			...inferenceDevices ? { inferenceDevices } : {},
 			...runnerConfig.steps ? { steps: applyDeviceProvisioning(runnerConfig.steps, deviceBase, deviceOverride) } : {}
 		};
 		const dispatchGuard = this.deps.ledger.markDispatching(runnerConfig.deviceId);
@@ -31805,7 +31914,8 @@ var StoredAgentAddonConfigSchema = object({
 });
 var StoredDeviceStepConfigSchema = object({
 	modelId: string().optional(),
-	settings: record(string(), unknown()).readonly().optional()
+	settings: record(string(), unknown()).readonly().optional(),
+	jumpDeviceKey: string().optional()
 });
 var StoredAgentPipelineSettingsSchema = object({
 	addonDefaults: record(string(), StoredAgentAddonConfigSchema).optional(),
@@ -33266,10 +33376,12 @@ var SessionDispatchController = class {
 		const deviceBase = deviceKey ? await this.deps.settingsStore.buildNodeInferenceDeviceSteps(targetNodeId, deviceKey) : {};
 		const deviceOverride = deviceKey ? await this.deps.settingsStore.readCameraDeviceOverride(deviceId, targetNodeId, deviceKey) : {};
 		const steps = applyDeviceProvisioning(pipelineConfig.steps, deviceBase, deviceOverride);
+		const inferenceDevices = deviceKey && Object.keys(enabledDevices).length >= 2 ? buildInferenceDeviceRoster(enabledDevices, deviceCaps) : void 0;
 		const zones = await this.deps.listZones(deviceId);
 		const sessionConfig = {
 			deviceId,
 			...deviceKey ? { deviceKey } : {},
+			...inferenceDevices ? { inferenceDevices } : {},
 			motionCooldownMs: config.motionCooldownMs,
 			motionFps: config.motionFps,
 			detectionFps: config.detectionFps,
@@ -35316,6 +35428,10 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	* pending so a node newly given more capacity picks up stranded cameras.
 	*/
 	async setAgentInferenceDevices(input) {
+		const { probed } = await this.probeNodeInferenceDevices(input.agentNodeId);
+		const enabledAvailableKeys = new Set(mergeInferenceDevices(probed, input.inferenceDevices).filter((d) => d.enabled && d.available).map((d) => d.key));
+		const jumpError = validateJumpTargets(input.inferenceDevices, enabledAvailableKeys);
+		if (jumpError) throw new Error(`setAgentInferenceDevices: ${jumpError}`);
 		const existing = (await this.settingsStore.readAgentSettingsMap())[input.agentNodeId];
 		const next = existing ? {
 			...existing,

package/dist/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-D2fJDIWd.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_orchestrator_widgets-TbyFsMw6.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/addon-pipeline-orchestrator",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Hub-side camera-to-agent load balancer — tracks runner capacity and dispatches attachCamera calls to the optimal pipeline-runner instance",
   "keywords": [
     "camstack",