@camstack/addon-pipeline 1.2.296 → 1.2.298

package/dist/{node-lpQgHes9.js → node-CmzZ_-zB.js}

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-emK7D4bc.js");
-const require_dist = require("./dist-8up-f2TX.js");
+const require_dist = require("./dist-L_HlB0At.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs, 1);

package/dist/{node-DgMSXSWP.mjs → node-Cr8Ch1ZN.mjs}

@@ -1,4 +1,4 @@
-import { in as buildFfmpegArgs, on as isSoftwareDecode, rn as Fmp4BoxSplitter, tn as errMsg } from "./dist-CCd0Q3nr.mjs";
+import { an as isSoftwareDecode, en as errMsg, nn as Fmp4BoxSplitter, rn as buildFfmpegArgs } from "./dist-DVz_88D_.mjs";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
 import path from "node:path";

package/dist/pipeline-runner/index.js

@@ -3,9 +3,9 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-8up-f2TX.js");
-const require_node = require("../node-lpQgHes9.js");
-const require_default_detection_model = require("../default-detection-model-D1daTtqT.js");
+const require_dist = require("../dist-L_HlB0At.js");
+const require_node = require("../node-CmzZ_-zB.js");
+const require_default_detection_model = require("../default-detection-model-BTJZvSr_.js");
 const require_worker_protocol = require("../worker-protocol-C-G8qmye.js");
 const require_hub_hostname = require("../hub-hostname-DAJXlOgV.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
@@ -638,6 +638,28 @@ function positiveOrUndefined(value) {
 	return Number.isFinite(value) && value > 0 ? value : void 0;
 }
 //#endregion
+//#region src/pipeline-runner/retained-reader-hold.ts
+/**
+* Run `read` with `handle`'s parked frame held as a CONSUMER for its whole
+* duration (D656).
+*
+* `getNativeCrop` has two rungs: a native crop, then — on a miss — the retained
+* full-frame fallback. Between them nothing is in flight: the crop's reply
+* settles the worker's last pending request in the same turn, and the fallback's
+* `toBuffer` is only sent on a later microtask. A parked frame does not keep a
+* draining worker alive, so without this hold the drain killed the worker in
+* that gap and the fallback was lost. One rule instead of a timing trick: a
+* read in progress is a consumer.
+*/
+async function withRetainedReader(store, handle, read) {
+	const release = store?.holdReader(handle) ?? null;
+	try {
+		return await read();
+	} finally {
+		release?.();
+	}
+}
+//#endregion
 //#region src/session-decode/native-crop-lease-age.ts
 /**
 * THE age bound on a native crop lease (ADR-0419).
@@ -980,6 +1002,8 @@ function createRetainedContentFallback(registry, ref) {
 				timestamp: ref.timestamp,
 				...ref.capturedAt !== void 0 ? { capturedAt: ref.capturedAt } : {}
 			};
+		} catch {
+			return null;
 		} finally {
 			lease.release(reason);
 		}
@@ -1422,6 +1446,14 @@ var RetainedFrameStore = class RetainedFrameStore {
 			if (current) current.hydrating = void 0;
 		}
 	}
+	/**
+	* Hold `handle`'s parked frame as a reader until the returned release runs
+	* (D656). `null` when the handle has no un-hydrated fallback — bytes already
+	* in RAM need no worker.
+	*/
+	holdReader(handle) {
+		return this.entries.get(keyOf(handle))?.fallback?.holdReader?.() ?? null;
+	}
 	/** Drop every retained frame (node/addon shutdown). */
 	clear() {
 		for (const entry of this.entries.values()) entry.fallback?.release?.();
@@ -1588,6 +1620,25 @@ var SESSION_DECODE_DRAIN_BOUND_MS = 1500;
 */
 var NATIVE_CROP_REFUSED_DRAINING = "session draining — crop requested after teardown";
 /**
+* The refusal for a `toBuffer` asked for once the worker has been told to exit
+* (D656). A read during a DRAIN is served — that is what the drain is for — but
+* after the kill no reply can come, and a raw rejection read as a worker fault.
+*/
+var TO_BUFFER_REFUSED_KILLED = "session killed — read requested after the worker was told to exit";
+/** The refusal for a `toBuffer` the worker is no longer there to answer. */
+var TO_BUFFER_REFUSED_EXITED = "worker already exited";
+/** A read the session declined to send, by name — never a worker fault. */
+var SessionDecodeReadRefusedError = class extends Error {
+	reason;
+	frameId;
+	constructor(reason, frameId) {
+		super(`session-decode-coordinator: ${reason} (frameId=${frameId})`);
+		this.reason = reason;
+		this.frameId = frameId;
+		this.name = "SessionDecodeReadRefusedError";
+	}
+};
+/**
 * How often the cold-start wait REPORTS that it is still waiting. Task 0
 * live-measured cold-start (restream dial + hwaccel context + keyframe wait) at
 * 5-8s, so this must tolerate a slow-but-healthy start.
@@ -1671,11 +1722,18 @@ var SessionDecodeSession = class {
 	/** Set when `kill()` is sent, so handleExit can tell an intentional stop from a death. */
 	killSent = false;
 	/**
-	* Images yielded to the consumer and not yet closed. Each is a frame the
-	* consumer still holds a reference to — queued, in flight, or being read —
-	* and each dies with the worker. This is what a drain waits on.
+	* Images yielded and not yet closed that a CONSUMER still holds — queued,
+	* in flight, or being read. Each dies with the worker and somebody was going
+	* to read it first. This is what a drain waits on.
+	*/
+	consumerImages = 0;
+	/**
+	* Images yielded and not yet closed that only a RETENTION holder keeps —
+	* parked for a read that may come later (the on-demand JPEG fallback, D656).
+	* They die with the worker too, but nobody reads them inside any bound worth
+	* holding a worker for, so a drain does NOT wait on them.
 	*/
-	openImages = 0;
+	retainedImages = 0;
 	/** Armed while a drain waits; its expiry kills with frames still held. */
 	drainTimer = null;
 	sigkillTimer = null;
@@ -1729,7 +1787,8 @@ var SessionDecodeSession = class {
 	}
 	/** Send `toBuffer` for `frameId` and resolve with the matching `buffer` reply's bytes. */
 	requestBuffer(frameId, opts) {
-		if (this.exited) return Promise.reject(/* @__PURE__ */ new Error(`session-decode-coordinator: worker already exited (frameId=${frameId})`));
+		if (this.exited) return Promise.reject(new SessionDecodeReadRefusedError(TO_BUFFER_REFUSED_EXITED, frameId));
+		if (this.killSent) return Promise.reject(new SessionDecodeReadRefusedError(TO_BUFFER_REFUSED_KILLED, frameId));
 		return new Promise((resolve, reject) => {
 			const waiter = {
 				resolve,
@@ -1818,13 +1877,28 @@ var SessionDecodeSession = class {
 			frameId
 		});
 	}
-	/** A yielded image the consumer now holds — see {@link openImages}. */
+	/** A yielded image the consumer now holds — see {@link consumerImages}. */
 	noteImageOpened() {
-		this.openImages += 1;
+		this.consumerImages += 1;
 	}
-	/** The consumer let go of a yielded image; a waiting drain may now be done. */
-	noteImageClosed() {
-		this.openImages = Math.max(0, this.openImages - 1);
+	/**
+	* An open image moved between a consumer and a retention-only holder
+	* (D656). Losing its last consumer may complete a waiting drain.
+	*/
+	noteImageHolder(pendingConsumer) {
+		if (pendingConsumer) {
+			this.retainedImages = Math.max(0, this.retainedImages - 1);
+			this.consumerImages += 1;
+			return;
+		}
+		this.consumerImages = Math.max(0, this.consumerImages - 1);
+		this.retainedImages += 1;
+		this.settleDrainIfDone();
+	}
+	/** A yielded image was closed; a waiting drain may now be done. */
+	noteImageClosed(pendingConsumer) {
+		if (pendingConsumer) this.consumerImages = Math.max(0, this.consumerImages - 1);
+		else this.retainedImages = Math.max(0, this.retainedImages - 1);
 		this.settleDrainIfDone();
 	}
 	/**
@@ -1875,15 +1949,29 @@ var SessionDecodeSession = class {
 		this.tryKill("SIGKILL");
 	}
 	/**
-	* Frames the consumer still holds, reads still waiting on the worker, and
+	* Frames a CONSUMER still holds, reads still waiting on the worker, and
 	* native crops already REQUESTED. A crop asked for before the teardown
 	* request is waited for; one asked for after it is refused by name — post-analysis's
 	* ordinary crop arrives 2.2–9.9 s after the frame, past any bound worth
 	* holding a worker for, and is served from subject tiles that die with the
 	* worker either way.
+	*
+	* A frame only PARKED for such a late read ({@link retainedImages}) is not
+	* counted, for the same reason (D656): counting it made nearly every
+	* teardown wait the full bound for frames nobody was going to read. Its read,
+	* once STARTED, is a pending read like any other and is waited for.
 	*/
 	unsettledCount() {
-		return this.openImages + this.pendingReadCount() + this.pendingNativeCrops.size;
+		return this.consumerImages + this.pendingReadCount() + this.pendingNativeCrops.size;
+	}
+	/** What the session still holds, per category — every drain line carries it. */
+	heldCounts() {
+		return {
+			consumerFrames: this.consumerImages,
+			retainedFrames: this.retainedImages,
+			pendingReads: this.pendingReadCount(),
+			pendingCrops: this.pendingNativeCrops.size
+		};
 	}
 	pendingReadCount() {
 		let n = 0;
@@ -1907,9 +1995,7 @@ var SessionDecodeSession = class {
 		this.logger.warn("session-decode-coordinator: drain bound expired — killing the worker with frames still held", {
 			tags: { deviceId: this.deviceId },
 			meta: {
-				unsettledFrames: this.openImages,
-				pendingReads: this.pendingReadCount(),
-				pendingCrops: this.pendingNativeCrops.size,
+				...this.heldCounts(),
 				boundMs: SESSION_DECODE_DRAIN_BOUND_MS
 			}
 		});
@@ -1931,6 +2017,13 @@ var SessionDecodeSession = class {
 	killNow(mode) {
 		if (this.killSent) return;
 		this.killSent = true;
+		if (this.retainedImages > 0) this.logger.debug("session-decode-coordinator: retained frames die with the worker", {
+			tags: { deviceId: this.deviceId },
+			meta: {
+				mode,
+				...this.heldCounts()
+			}
+		});
 		this.trySend({ kind: "stop" });
 		if (mode === "immediate") {
 			this.tryKill("SIGKILL");
@@ -2032,10 +2125,7 @@ var SessionDecodeSession = class {
 			meta: {
 				code: info?.code ?? null,
 				signal: info?.signal ?? null,
-				...this.stopRequested ? {
-					unsettledFrames: this.openImages,
-					pendingReads: this.pendingReadCount()
-				} : {}
+				...this.stopRequested ? this.heldCounts() : {}
 			}
 		});
 		this.exited = true;
@@ -2233,6 +2323,7 @@ var SessionDecodeSession = class {
 /** Build the {@link FrameImage} adapter for one `frame` reply. */
 function buildFrameImage(session, reply) {
 	let closed = false;
+	let pendingConsumer = true;
 	session.noteImageOpened();
 	return {
 		width: reply.width,
@@ -2247,10 +2338,15 @@ function buildFrameImage(session, reply) {
 		cutTiles: (bboxes) => session.cutTiles(reply.frameId, bboxes),
 		releaseNativeLease: () => session.releaseLease(reply.frameId),
 		markInferred: () => session.markInferred(reply.frameId),
+		setPendingConsumer: (pending) => {
+			if (closed || pending === pendingConsumer) return;
+			pendingConsumer = pending;
+			session.noteImageHolder(pending);
+		},
 		close: () => {
 			if (closed) return;
 			closed = true;
-			session.noteImageClosed();
+			session.noteImageClosed(pendingConsumer);
 		}
 	};
 }
@@ -3927,173 +4023,6 @@ async function runDetailSubtree(deps, input) {
 	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;
-	});
-}
-/**
-* Build the `canRun` predicate for ONE enrichment dispatch. The step and its
-* enabled descendants ride the SAME `runPipeline` call — one pool, one format
-* (detail-subtree contract: "its inherited children ride the same call → same
-* device") — so a format can run the dispatch only when EVERY catalog-known
-* step in the subtree ships a build for it. Gating only the subtree TOP let a
-* `face-detection` with a tflite build stay on the Coral while its
-* `face-embedding` child (no tflite build anywhere) doomed the call.
-* Unknown/custom addonIds (`getStepDef` → null) have no catalog to gate on
-* and never block. `getStepDef` is injected — this module stays catalog-free.
-*/
-function buildSubtreeCanRun(step, getStepDef) {
-	const defs = [];
-	const walk = (s) => {
-		if (s.enabled === false) return;
-		const def = getStepDef(s.addonId);
-		if (def !== null) defs.push(def);
-		for (const child of s.children ?? []) walk(child);
-	};
-	walk(step);
-	return (format) => defs.every((def) => def.models.some((m) => m.formats[format]));
-}
-/**
-* 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"
-	};
-}
-/**
-* Re-provision a jumped subtree for its TARGET device (D650): every step's
-* `modelId` / `settings` are REPLACED by the target's entry — the orchestrator
-* computed it as what the step would carry had the camera been elected onto
-* that device (its per-(node,device) base with the camera's override for it).
-* A step absent from the map runs with neither, i.e. the target format's
-* default model. The elected device's provisioning never follows a step across:
-* it was chosen for a format this subtree does not run on.
-*/
-function provisionSubtreeForDevice(step, provisioning) {
-	const own = provisioning[step.addonId];
-	const { modelId: _electedModelId, settings: _electedSettings, ...rest } = step;
-	return {
-		...rest,
-		...own?.modelId !== void 0 ? { modelId: own.modelId } : {},
-		...own?.settings !== void 0 ? { settings: own.settings } : {},
-		...step.children !== void 0 ? { children: step.children.map((c) => provisionSubtreeForDevice(c, provisioning)) } : {}
-	};
-}
-/**
-* Place ONE detail subtree (D650): which same-node device runs it
-* ({@link resolveStepDevice}) and, when it jumps, the provisioning it runs
-* with there ({@link provisionSubtreeForDevice}). Pure — the caller logs.
-*
-* A roster entry without `steps` came from an orchestrator that predates D650:
-* the step keeps what it was sent with, as it did before.
-*/
-function placeDetailStep(input) {
-	const { step, effectiveDeviceKey, roster } = input;
-	if (!effectiveDeviceKey) return {
-		deviceKey: void 0,
-		step,
-		decision: null,
-		provisioned: false
-	};
-	if (!roster || roster.length < 2) return {
-		deviceKey: effectiveDeviceKey,
-		step,
-		decision: null,
-		provisioned: false
-	};
-	const decision = resolveStepDevice({
-		effectiveDeviceKey,
-		devices: roster.map((d) => ({
-			deviceKey: d.deviceKey,
-			weight: d.weight,
-			maxSessions: d.maxSessions,
-			attachedCameras: input.attachedByKey.get(d.deviceKey) ?? 0
-		})),
-		...step.jumpDeviceKey !== void 0 ? { manualJumpDeviceKey: step.jumpDeviceKey } : {},
-		canRun: buildSubtreeCanRun(step, input.getStepDef)
-	});
-	if (decision.kind !== "jumped") return {
-		deviceKey: decision.deviceKey,
-		step,
-		decision,
-		provisioned: false
-	};
-	const provisioning = roster.find((d) => d.deviceKey === decision.deviceKey)?.steps;
-	return {
-		deviceKey: decision.deviceKey,
-		step: provisioning === void 0 ? step : provisionSubtreeForDevice(step, provisioning),
-		decision,
-		provisioned: provisioning !== void 0
-	};
-}
-//#endregion
 //#region src/pipeline-runner/device-load.ts
 /** The backend prefix of a `<backend>:<device>` key (bare `cpu` → `cpu`). */
 function backendOf(deviceKey) {
@@ -5377,7 +5306,7 @@ var ON_DEMAND_JPEG_VIEW = {
 	format: "jpeg"
 };
 function createOnDemandJpegFallback(registry, ref) {
-	const lease = registry.acquire(ref);
+	const lease = registry.acquire(ref, "retention");
 	let cached;
 	let released = false;
 	const releaseLease = (reason) => {
@@ -5417,6 +5346,11 @@ function createOnDemandJpegFallback(registry, ref) {
 		},
 		release() {
 			releaseLease("eviction");
+		},
+		holdReader() {
+			if (released || cached !== void 0) return null;
+			const reader = registry.acquire(ref);
+			return reader ? () => reader.release("success") : null;
 		}
 	};
 }
@@ -7262,11 +7196,14 @@ async function runStatelessStep(deps, input) {
 		return refuse(deps, input, "execution-failed", errorMessage(err));
 	}
 	if (result === null) return refuse(deps, input, "execution-failed", "the executor returned no frame result for the crop");
+	const ranModelId = result.rootModelId;
+	if (ranModelId === void 0 || ranModelId === "") return refuse(deps, input, "execution-failed", `the executor result names no model — refusing rather than assuming "${input.modelId}" ran`);
+	if (ranModelId !== input.modelId) return refuse(deps, input, "model-not-servable", `the executor ran "${ranModelId}" for a call pinned to "${input.modelId}" — its output would not be comparable with the pass`);
 	const details = result.detections.map((detection) => toDetailResult(detection, input.stepId, crop));
 	return {
 		kind: "ran",
 		nodeId: deps.nodeId,
-		modelId: input.modelId,
+		modelId: ranModelId,
 		details
 	};
 }
@@ -7675,6 +7612,15 @@ function tryGetStepDefinition(stepId) {
 	}
 }
 /**
+* A detail-plane step: its catalog definition consumes a parent class
+* (`inputClasses` non-null). Unknown/custom addonIds are root-plane — the
+* same reading as the executor's frame-plane skip and `deriveDetailSteps`.
+*/
+function isDetailPlaneStepId(stepId) {
+	const def = tryGetStepDefinition(stepId);
+	return def !== null && def.inputClasses !== null;
+}
+/**
 * Precomputes the `detailSteps` announce (two-plane design) for a camera's
 * configured step tree: every ENABLED step whose catalog definition is a
 * detail/child step (`inputClasses !== null` — a root step like
@@ -8507,14 +8453,16 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				height: cached.height,
 				format: cached.format
 			}, pin)).frameId;
-			await api.pipelineExecutor.runPipeline.mutate({ ...buildBenchRunPipelineInput({
+			const benchModelId = (await api.pipelineExecutor.runPipeline.mutate({ ...buildBenchRunPipelineInput({
 				steps: stepsToRun,
 				frame: sharedFrame
-			}) }, pin);
+			}) }, pin)).rootModelId;
+			if (benchModelId === void 0 || benchModelId === "") throw new Error(`synthetic bench: the warmup of "${rootStep.addonId}" named no model — refusing to time an unnamed variant`);
 			const warmupCount = input.warmup ?? 1;
 			for (let w = 0; w < warmupCount; w++) await api.pipelineExecutor.inferCached.mutate({
 				stepId: rootStep.addonId,
-				frameId: poolFrameId
+				frameId: poolFrameId,
+				modelId: benchModelId
 			}, pin);
 			const wallTimings = [];
 			const inferTimings = [];
@@ -8532,7 +8480,8 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 					const t0 = performance.now();
 					const result = await api.pipelineExecutor.inferCached.mutate({
 						stepId: rootStep.addonId,
-						frameId: poolFrameId
+						frameId: poolFrameId,
+						modelId: benchModelId
 					}, pin);
 					const wallMs = performance.now() - t0;
 					const r = result;
@@ -9207,6 +9156,10 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* resolve legitimately want the lower-RES honest frame).
 	*/
 	async getNativeCrop(input) {
+		return withRetainedReader(this.retainedFrames, input.handle, () => this.resolveNativeCropBothRungs(input));
+	}
+	/** {@link getNativeCrop}'s two rungs, run under its reader hold. */
+	async resolveNativeCropBothRungs(input) {
 		const deviceId = this.nativeCropRegistry.deviceIdFor(input.handle) ?? 0;
 		const isFullFrame = input.bbox.x <= .001 && input.bbox.y <= .001 && input.bbox.w >= .999 && input.bbox.h >= .999;
 		this.frameLazy.noteOnDemandRequest({
@@ -9722,6 +9675,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	async runDetailSubtree(input) {
 		const convention = await this.cropConvention.refresh(this.ctxIfReady?.api);
+		await this.customModels.refresh(this.ctxIfReady?.api);
 		const outcome = await runDetailSubtree({
 			resolveChildSteps: (deviceId, parentClassName, filter) => this.resolveDetailChildSteps(deviceId, parentClassName, filter),
 			getNativeCrop: (deviceId, handle, paddedBbox) => this.getNativeCropForDetail(deviceId, handle, paddedBbox),
@@ -9850,6 +9804,13 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	* global settings, NOT from the attach config. See `crop-convention-source.ts`
 	* for why eleven attach builders make the attach config the wrong carrier.
 	*/
+	/**
+	* The custom-model registry, merged into the catalog the device jump judges
+	* (D657): a custom model with a tflite build, pinned on a Coral, runs there.
+	* Refreshed on the async boundaries (`runInference`, `runDetailSubtree`),
+	* read synchronously by the placement.
+	*/
+	customModels = new require_default_detection_model.CustomModelCatalog({ warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras) });
 	cropConvention = new CropConventionSource({ logger: {
 		info: (message, extras) => this.ctxIfReady?.logger.info(message, extras),
 		warn: (message, extras) => this.ctxIfReady?.logger.warn(message, extras)
@@ -9953,18 +9914,63 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 	*/
 	placeDetailStepForCamera(deviceId, step) {
 		const config = this.attached.get(deviceId)?.config;
-		const placement = placeDetailStep({
-			step,
-			effectiveDeviceKey: config?.deviceKey,
-			roster: config?.inferenceDevices,
-			attachedByKey: this.perDeviceAttachedCounts(),
-			getStepDef: tryGetStepDefinition
-		});
+		const placement = this.placementOf(config, step, this.perDeviceAttachedCounts());
 		const decision = placement.decision;
 		if (decision?.kind === "no-candidate") this.warnStepHasNoRunnableDevice(deviceId, step.addonId, decision.deviceKey);
 		else if (decision?.kind === "jumped" && config?.deviceKey) this.logStepJumped(deviceId, config.deviceKey, decision, placement);
 		return placement;
 	}
+	/**
+	* Where one detail subtree of this camera runs — the ONE decision both the
+	* detail plane (which dispatches it) and the frame plane (which decides what
+	* the elected pool pre-warms, D657) read. Pure: nothing is logged here.
+	*/
+	placementOf(config, step, attachedByKey) {
+		return require_default_detection_model.placeDetailStep({
+			step,
+			effectiveDeviceKey: config?.deviceKey,
+			roster: config?.inferenceDevices,
+			attachedByKey,
+			getStepDef: this.customModels.stepDefinition
+		});
+	}
+	/**
+	* The tree this camera's frame-plane dispatch carries (D657): a detail
+	* subtree the placement sends to another device (or to none) is left out,
+	* so its model is never loaded on the elected pool — it loads on its
+	* target, with the target's provisioning, when the detail plane dispatches
+	* it there. Said once per (camera, elected device, set left out).
+	*/
+	stepsForElectedPoolOf(deviceId, steps) {
+		const config = this.attached.get(deviceId)?.config;
+		if (config?.deviceKey === void 0 || (config.inferenceDevices?.length ?? 0) < 2) {
+			this.noteElectedPoolDelegation(deviceId, void 0, []);
+			return steps;
+		}
+		const attachedByKey = this.perDeviceAttachedCounts();
+		const result = require_default_detection_model.stepsForElectedPool(steps, isDetailPlaneStepId, (step) => this.placementOf(config, step, attachedByKey));
+		this.noteElectedPoolDelegation(deviceId, config.deviceKey, result.delegated);
+		return result.delegated.length === 0 ? steps : result.steps;
+	}
+	/**
+	* Say once per STATE CHANGE which detail steps a camera's elected pool no
+	* longer loads: a camera moving A → B → A says so again on A.
+	*/
+	noteElectedPoolDelegation(deviceId, electedDeviceKey, delegated) {
+		const state = `${electedDeviceKey ?? ""}|${delegated.join(",")}`;
+		if (this.electedPoolDelegationState.get(deviceId) === state) return;
+		this.electedPoolDelegationState.set(deviceId, state);
+		if (delegated.length === 0) return;
+		this.ctx?.logger.info("detail steps not loaded on the elected pool — they run elsewhere", {
+			tags: { deviceId },
+			meta: {
+				electedDeviceKey: electedDeviceKey ?? null,
+				steps: [...delegated]
+			}
+		});
+	}
+	/** Per camera, the last (elected device, steps left out) state that was logged. */
+	electedPoolDelegationState = /* @__PURE__ */ new Map();
 	/** `${deviceId}:${addonId}:${target}` triples whose jump has been logged. */
 	loggedStepJumps = /* @__PURE__ */ new Set();
 	logStepJumped(deviceId, electedDeviceKey, decision, placement) {
@@ -10201,6 +10207,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		const warnPrefix = `${deviceId}:`;
 		for (const key of this.warnedNoJumpDevice) if (key.startsWith(warnPrefix)) this.warnedNoJumpDevice.delete(key);
 		this.attached.delete(deviceId);
+		this.electedPoolDelegationState.delete(deviceId);
 		this.lastMotionAt.delete(deviceId);
 		this.lastEmittedCameraMetrics.delete(deviceId);
 		this.retention?.forgetDevice(deviceId);
@@ -10911,6 +10918,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 		}
 		const camConfig = this.attached.get(deviceId)?.config;
 		const steps = camConfig?.steps;
+		await this.customModels.refresh(api);
 		if (!steps) {
 			log.warn("runInference: no steps in attach config — skipping frame (legacy attach?)");
 			return null;
@@ -10945,6 +10953,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				});
 			}
 		}
+		dispatchSteps = this.stepsForElectedPoolOf(deviceId, dispatchSteps);
 		let image;
 		const executorCoLocated = this.executorCoLocated();
 		if (!executorCoLocated) {
@@ -11074,6 +11083,7 @@ var PipelineRunnerAddon = class PipelineRunnerAddon extends require_dist.BaseAdd
 				const cropResult = await api.pipelineExecutor.runPipeline.mutate({
 					steps: [step],
 					image: view.jpeg,
+					deviceId,
 					plane: "frame",
 					...deviceKey ? { deviceKey } : {}
 				});