@camstack/addon-pipeline 1.2.327 → 1.2.329

package/dist/detection-pipeline/index.mjs

@@ -1,9 +1,9 @@
 import { n as __require } from "../chunk-DnnnRqeS.mjs";
-import { A as PoolMemoryWatchdog, An as sleep, At as overlayClusterStepSettings, Dn as parseJsonUnknown, En as nodePin, Ft as pipelineExecutorCapability, Hn as union, Ht as resolveClusterStepModelId, Jt as runtimeDevices$1, Kt as resolvePoolMemoryPolicy, Mn as array, Mt as pickClusterStepSettings, Rn as object, Sn as hydrateSchema, Un as EventCategory, V as YAMNET_TO_MACRO, Vn as string, Yt as stepModelRunsOnFormat, bt as loadContributionCapability, ct as evaluateZoneRules, d as CLUSTER_MODEL_SCOPED_STEPS, en as supportedRuntimes$1, et as defaultDeviceFor$1, fn as errMsg, h as DEFAULT_CLUSTER_STEP_SETTINGS, it as detectionPipelineCapability, mn as BaseAddon, n as APPLE_SA_TO_MACRO, st as enumerateInferenceDevices, vn as createEvent, y as DEVICE_BACKEND_TO_FORMAT } from "../dist-B9LnBPz9.mjs";
-import { s as readProcessCost } from "../node-Ci0E-0VP.mjs";
-import { _ as getStep, a as buildSubtreeCanRun, b as landmarkPrecisionVerdict, c as macroGateVerdict, g as getDefaultModelForFormat, h as ALL_STEPS, i as mergeCustomModels, m as ALL_PIPELINE_STEPS, n as resolveDefaultDetectionModel, r as CustomModelCatalog, u as localFrameRegistry, v as getStepDefinition, x as resolveModelDefaultConfidence, y as resolveModelForFormat } from "../default-detection-model-hql6BX9-.mjs";
+import { An as hydrateSchema, Bn as array, Dt as loadContributionCapability, En as createEvent, F as PoolMemoryWatchdog, Fn as parseJsonUnknown, Ht as pipelineExecutorCapability, K as YAMNET_TO_MACRO, Kn as object, Lt as overlayClusterStepSettings, Pn as nodePin, Rn as sleep, Sn as BaseAddon, St as hfModelUrl, T as FILLABLE_STEP_MACRO, Tt as linkedLabelStepId, Xn as union, Yn as string, Yt as resolveClusterStepModelId, Zn as EventCategory, at as defaultDeviceFor$1, b as DEVICE_BACKEND_TO_FORMAT, bn as errMsg, cn as supportedRuntimes$1, d as CLUSTER_MODEL_SCOPED_STEPS, en as resolvePoolMemoryPolicy, ft as enumerateInferenceDevices, h as DEFAULT_CLUSTER_STEP_SETTINGS, lt as detectionPipelineCapability, n as APPLE_SA_TO_MACRO, nn as runtimeDevices$1, pt as evaluateZoneRules, rn as stepModelRunsOnFormat, zt as pickClusterStepSettings } from "../dist-0HoA3wAi.mjs";
+import { s as readProcessCost } from "../node-HOMWRPzW.mjs";
+import { _ as getStep, a as buildSubtreeCanRun, b as landmarkPrecisionVerdict, c as macroGateVerdict, g as getDefaultModelForFormat, h as ALL_STEPS, i as mergeCustomModels, m as ALL_PIPELINE_STEPS, n as resolveDefaultDetectionModel, r as CustomModelCatalog, u as localFrameRegistry, v as getStepDefinition, x as resolveModelDefaultConfidence, y as resolveModelForFormat } from "../default-detection-model-j0nBpRoB.mjs";
 import { t as getSharp } from "../lazy-sharp-DXsqwpph.mjs";
-import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-B63Jlpev.mjs";
+import { n as pickNodePlatformArch, t as readProcessMemory } from "../process-memory-DuF8pa2w.mjs";
 import * as os from "node:os";
 import * as fs from "node:fs";
 import * as path$1 from "node:path";
@@ -2809,6 +2809,8 @@ var PipelineModelManager = class {
 			stepId,
 			modelId,
 			poolIndex: index,
+			path: config.path,
+			...settings !== void 0 ? { settings } : {},
 			lruTick: ++this.lruClock,
 			decode
 		};
@@ -2816,6 +2818,56 @@ var PipelineModelManager = class {
 		return entry;
 	}
 	/**
+	* Reload every resident slot whose model FILE is no longer the one
+	* `buildConfig` names — a Coral pool that switched co-compiled set (D724).
+	* The new slot is loaded BEFORE the old one is unloaded and the entry is
+	* replaced in between, so a lookup always finds a loaded index. Returns the
+	* `(step, model)` pairs reloaded. A failed reload keeps the old slot (it
+	* still serves, from the file it was loaded from) and is logged.
+	*/
+	async reloadChangedPaths() {
+		const reloaded = [];
+		for (const [stepId, perStep] of this.loaded) for (const entry of perStep.values()) {
+			const config = this.source.buildConfig(stepId, entry.modelId, entry.settings);
+			if (config.path === entry.path) continue;
+			const index = this.pool.allocateIndex();
+			try {
+				await this.pool.loadModel(index, config);
+			} catch (err) {
+				this.pool.releaseIndex(index);
+				this.log.error("Step variant reload from another model file failed — the old file keeps serving", { meta: {
+					step: stepId,
+					modelId: entry.modelId,
+					deviceKey: this.deviceKey,
+					from: entry.path,
+					to: config.path,
+					error: err instanceof Error ? err.message : String(err)
+				} });
+				continue;
+			}
+			perStep.set(entry.modelId, {
+				...entry,
+				poolIndex: index,
+				path: config.path,
+				decode: poolDecodeSettingsOf(config)
+			});
+			await this.pool.unloadModel(entry.poolIndex);
+			this.log.info("Step variant reloaded from another model file", { meta: {
+				step: stepId,
+				modelId: entry.modelId,
+				deviceKey: this.deviceKey,
+				from: entry.path,
+				to: config.path,
+				poolIndex: index
+			} });
+			reloaded.push({
+				stepId,
+				modelId: entry.modelId
+			});
+		}
+		return reloaded;
+	}
+	/**
 	* Push a retuned decode setting into ONE already-loaded slot.
 	*
 	* Scope is the point: `reconfigure` names a single pool index, so a slider
@@ -2974,6 +3026,251 @@ function deviceKeyOf(engine) {
 	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
 }
 //#endregion
+//#region src/detection-pipeline/engine/coral-cocompiled-set.ts
+var ROOT_DETECTOR_STEP_ID = "object-detection";
+/** The models a dispatch places on the pool that runs it: every enabled video step. */
+function placedModelsOf(steps) {
+	return flattenEnabledVideoSteps(steps).map((s) => ({
+		stepId: s.addonId,
+		modelId: s.modelId
+	}));
+}
+var sameModel = (a, b) => a.stepId === b.stepId && a.modelId === b.modelId;
+/**
+* The set for `placed`, or why there is none.
+*
+* 1. A set that reserves the cache for the root detector is eligible only when
+*    the root is placed here, and a rootless set only when it is not: a root
+*    set on a pool without the root wastes the cache the root would have had,
+*    and a rootless set beside a root makes the root swap.
+* 2. A set must stand for at least two placed models — one model alone is
+*    better off with the whole cache (its separately compiled file).
+* 3. Most placed models covered wins; then the set with fewest members nobody
+*    placed (they hold cache for nothing); then declaration order.
+*/
+function selectCoCompiledSet(placed, sets) {
+	if (placed.length === 0) return {
+		kind: "separate",
+		reason: "nothing-placed"
+	};
+	if (placed.length === 1) return {
+		kind: "separate",
+		reason: "single-model"
+	};
+	const hostsRoot = placed.some((p) => p.stepId === ROOT_DETECTOR_STEP_ID);
+	let best = null;
+	for (const set of sets) {
+		if (set.hostsRoot !== hostsRoot) continue;
+		const covered = placed.filter((p) => set.members.some((m) => sameModel(m, p)));
+		if (covered.length < 2) continue;
+		const idle = set.members.length - covered.length;
+		if (best === null || covered.length > best.covered.length || covered.length === best.covered.length && idle < best.idle) best = {
+			set,
+			covered,
+			idle
+		};
+	}
+	if (best === null) return {
+		kind: "separate",
+		reason: "no-set-covers-two"
+	};
+	const { set, covered } = best;
+	return {
+		kind: "set",
+		set,
+		covered,
+		uncovered: placed.filter((p) => !covered.some((c) => sameModel(c, p)))
+	};
+}
+/** The member a selection loads `(stepId, modelId)` from, or `null` (its own `formats.tflite`). */
+function setMemberFor(selection, stepId, modelId) {
+	if (selection.kind !== "set") return null;
+	return selection.set.members.find((m) => m.stepId === stepId && m.modelId === modelId) ?? null;
+}
+/**
+* `entry` with its `tflite` build pointed at the set's file. Everything else —
+* labels, postprocessor, input contract, licence — is the entry's own: a
+* member is the same model, compiled together with others.
+*/
+function withSetBuild(entry, member) {
+	return {
+		...entry,
+		formats: {
+			...entry.formats,
+			tflite: {
+				url: member.url,
+				sizeMB: member.sizeMB,
+				runtimes: ["python"]
+			}
+		}
+	};
+}
+/** Identity of a selection for change detection: the set AND what it leaves out. */
+var selectionKey = (s) => s.kind === "set" ? `${s.set.id}|${s.uncovered.map((u) => `${u.stepId}/${u.modelId}`).toSorted().join(",")}` : `separate:${s.reason}`;
+/**
+* The placement of ONE Coral pool and the set it loads. Lives exactly as long
+* as the pool (the factory owns it).
+*/
+var CoralSetPlanner = class {
+	sets;
+	placed = [];
+	current = {
+		kind: "separate",
+		reason: "nothing-placed"
+	};
+	constructor(sets) {
+		this.sets = sets;
+	}
+	/** Add the models a dispatch places on this pool; say whether the set changed. */
+	note(models) {
+		let grew = false;
+		for (const m of models) {
+			if (this.placed.some((p) => sameModel(p, m))) continue;
+			this.placed.push({
+				stepId: m.stepId,
+				modelId: m.modelId
+			});
+			grew = true;
+		}
+		if (!grew) return { kind: "unchanged" };
+		const next = selectCoCompiledSet(this.placed, this.sets);
+		if (selectionKey(next) === selectionKey(this.current)) {
+			this.current = next;
+			return { kind: "unchanged" };
+		}
+		const from = this.current;
+		this.current = next;
+		return {
+			kind: "changed",
+			from,
+			to: next,
+			placed: [...this.placed]
+		};
+	}
+	selection() {
+		return this.current;
+	}
+	/** `entry` as this pool must load it: from the set when the set stands for it. */
+	entryFor(stepId, entry) {
+		const member = setMemberFor(this.current, stepId, entry.id);
+		return member === null ? entry : withSetBuild(entry, member);
+	}
+};
+//#endregion
+//#region src/detection-pipeline/registry/edgetpu-cocompiled-sets.ts
+/**
+* Co-compiled Edge TPU sets — pool-level artifacts, not models (D724).
+*
+* A Coral holds ~6.9 MiB of parameter cache. Two separately compiled models
+* carry two different cache tokens, so every alternation between them on one
+* Coral flushes the cache and re-streams the incoming model's parameters over
+* USB (D710). `edgetpu_compiler` given several models at once allocates the
+* cache between them, in command-line order, under ONE token: loaded from the
+* same set, they never evict each other — whatever does not fit is streamed on
+* every invoke of THAT model instead.
+*
+* Each member is the SAME model as its catalog entry's `formats.tflite` (same
+* `modelId`, same int8 graph, same labels and licence record), compiled
+* together with the other members (D710: a Coral build is a format of the
+* survivor; the set is where it is placed, not a new model). A Coral pool picks
+* at most one set from the models placed on it (`coral-cocompiled-set.ts`) and
+* falls back to the separately compiled `formats.tflite` for everything else.
+*
+* Built by `scripts/build-edgetpu-sets.py` (compile order = `members` order =
+* cache priority) and hosted under `edgetpuSets/<id>/`. Only sets whose
+* measured cost is acceptable are listed here: a set that would make the root
+* detector stream parameters on every frame (root + YuNet at 640: the root
+* keeps 3.34 of its 6.39 MiB, YuNet's activations take the rest) is
+* deliberately absent.
+*/
+var HF_REPO = "camstack/camstack-models";
+var setFile = (setId, file) => hfModelUrl(HF_REPO, `edgetpuSets/${setId}/${setId}__${file}`);
+var SSD = "ssd-mobilenet-v2-coco-edgetpu";
+var YUNET = "yunet-2023mar";
+var YOLOX = "yolox-tiny-plate";
+var BIRD = "bird-classifier";
+var EDGETPU_COCOMPILED_SETS = [
+	{
+		id: "root-plate-bird",
+		hostsRoot: true,
+		members: [
+			{
+				stepId: "object-detection",
+				modelId: SSD,
+				url: setFile("root-plate-bird", "ssd_mobilenet_v2_coco_quant_postprocess_edgetpu.tflite"),
+				sizeMB: 6.9,
+				onChipMiB: 6.39,
+				streamedMiB: 0
+			},
+			{
+				stepId: "plate-detection",
+				modelId: YOLOX,
+				url: setFile("root-plate-bird", "camstack-yolox-tiny-plate_int8_edgetpu.tflite"),
+				sizeMB: 6.9,
+				onChipMiB: .08,
+				streamedMiB: 5.41
+			},
+			{
+				stepId: "bird-classifier",
+				modelId: BIRD,
+				url: setFile("root-plate-bird", "mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite"),
+				sizeMB: 4.9,
+				onChipMiB: 0,
+				streamedMiB: 4.54
+			}
+		]
+	},
+	{
+		id: "face-plate-bird",
+		hostsRoot: false,
+		members: [
+			{
+				stepId: "face-detection",
+				modelId: YUNET,
+				url: setFile("face-plate-bird", "camstack-yunet-2023mar_int8_edgetpu.tflite"),
+				sizeMB: .7,
+				onChipMiB: .11,
+				streamedMiB: 0
+			},
+			{
+				stepId: "plate-detection",
+				modelId: YOLOX,
+				url: setFile("face-plate-bird", "camstack-yolox-tiny-plate_int8_edgetpu.tflite"),
+				sizeMB: 6.9,
+				onChipMiB: 3.23,
+				streamedMiB: 2.27
+			},
+			{
+				stepId: "bird-classifier",
+				modelId: BIRD,
+				url: setFile("face-plate-bird", "mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite"),
+				sizeMB: 4.9,
+				onChipMiB: 0,
+				streamedMiB: 4.54
+			}
+		]
+	},
+	{
+		id: "plate-bird",
+		hostsRoot: false,
+		members: [{
+			stepId: "plate-detection",
+			modelId: YOLOX,
+			url: setFile("plate-bird", "camstack-yolox-tiny-plate_int8_edgetpu.tflite"),
+			sizeMB: 6.9,
+			onChipMiB: 5.55,
+			streamedMiB: 0
+		}, {
+			stepId: "bird-classifier",
+			modelId: BIRD,
+			url: setFile("plate-bird", "mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite"),
+			sizeMB: 4.1,
+			onChipMiB: .92,
+			streamedMiB: 2.8
+		}]
+	}
+];
+//#endregion
 //#region src/detection-pipeline/engine/engine-factory.ts
 var BACKEND_TO_POOL_RUNTIME = {
 	coreml: "coreml",
@@ -3067,11 +3364,45 @@ var EngineFactory = class {
 	* trying to be.
 	*/
 	resolvedProvisioning;
+	/**
+	* A Coral pool's placement and the co-compiled set it loads (D724); `null`
+	* on every other runtime. Lives exactly as long as this factory — a new
+	* pool starts from nothing placed.
+	*/
+	coralSets;
 	constructor(opts) {
 		this.opts = opts;
 		this.log = opts.logger;
 		this.deviceKey = deviceKeyOf(opts.engine);
 		this.resolvedProvisioning = resolvePoolProvisioning(opts.engine, opts.provisioning);
+		this.coralSets = BACKEND_TO_POOL_RUNTIME[opts.engine.backend] === "edgetpu" ? new CoralSetPlanner(opts.coCompiledSets ?? EDGETPU_COCOMPILED_SETS) : null;
+	}
+	/**
+	* Record the models a dispatch places on this pool. On a Coral pool the
+	* answer says whether the co-compiled set it loads from changed; on any
+	* other pool nothing is placed and nothing changes.
+	*/
+	notePlacement(models) {
+		return this.coralSets?.note(models) ?? { kind: "unchanged" };
+	}
+	/** The co-compiled set this pool loads from, or why none (`null`: not a Coral pool). */
+	coralSetSelection() {
+		return this.coralSets?.selection() ?? null;
+	}
+	/**
+	* The catalog entry as THIS pool must download and load it: on a Coral pool
+	* whose set stands for the model, the `tflite` build is the set's file.
+	* Every other entry is returned unchanged.
+	*/
+	entryForPool(stepId, entry) {
+		return this.coralSets?.entryFor(stepId, entry) ?? entry;
+	}
+	/**
+	* Reload every resident model whose file this pool no longer names — after
+	* the Coral set changed. The caller has already downloaded the new files.
+	*/
+	async reloadChangedModelFiles() {
+		return this.poolManager?.reloadChangedPaths() ?? [];
 	}
 	/**
 	* The provisioning this factory's pool runs with — resolved from the pool's
@@ -3333,6 +3664,7 @@ var EngineFactory = class {
 			stepSettings,
 			device: this.opts.engine.device,
 			resolveCustomModel: this.opts.resolveCustomModel,
+			entryForPool: (sid, entry) => this.entryForPool(sid, entry),
 			onClassMapDrop: ({ stepId: sid, modelId: mid, unmappedLabels }) => {
 				const key = `${sid}::${mid}`;
 				if (this.classMapDropLogged.has(key)) return;
@@ -3358,8 +3690,9 @@ var EngineFactory = class {
 function buildPoolModelConfigForStep(inputs) {
 	const { stepId, modelId, poolRuntime, modelsDir } = inputs;
 	const def = getStepDefinition(stepId);
-	const modelEntry = def.models.find((m) => m.id === modelId) ?? inputs.resolveCustomModel?.(stepId, modelId);
-	if (!modelEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog (static or custom registry)`);
+	const resolvedEntry = def.models.find((m) => m.id === modelId) ?? inputs.resolveCustomModel?.(stepId, modelId);
+	if (!resolvedEntry) throw new Error(`Model "${modelId}" not found in step "${stepId}" catalog (static or custom registry)`);
+	const modelEntry = inputs.entryForPool?.(stepId, resolvedEntry) ?? resolvedEntry;
 	const format = RUNTIME_TO_FORMAT[poolRuntime];
 	if (!format) throw new Error(`No format mapping for pool runtime "${poolRuntime}"`);
 	const dropWarning = collectClassMapDropWarning(def, modelEntry);
@@ -5437,7 +5770,7 @@ var PLATE_OCR_CROP_POLICIES = {
 		minLongSidePx: 85
 	},
 	"plate-slots": {
-		marginFraction: .15,
+		marginFraction: .05,
 		rectify: false,
 		minLongSidePx: 70
 	}
@@ -6127,6 +6460,41 @@ function toMutableRootDetection(det, rootStep, idGen, rootStepLatencyMs) {
 	};
 }
 //#endregion
+//#region src/detection-pipeline/pipeline/linked-label.ts
+/**
+* The detector's linked label (D715): when the model that RAN declares it
+* fills a step, a detection whose raw class names that step's effect carries
+* the effect as a `ScoredLabel` attributed to `detector-link:<stepId>` — in
+* the step's own vocabulary and tier, so tier 1 means one thing whichever
+* writer produced it.
+*
+* Written at score 0 here, always: the executor cannot see the camera's whole
+* step tree (a detail step placed on another pool is pruned from the dispatch),
+* so it cannot know who the writer is. The runner, which holds the attach
+* config, raises the score to the detection's own when the detector is
+* authoritative (`pipeline-runner/label-link.ts`). Score 0 is the fallback any
+* scored answer of the step outranks.
+*/
+/** The linked labels one mapped root detection carries. Pure. */
+function linkedLabelsFor(fills, rawClass, macroClass, modelId) {
+	if (fills === void 0 || fills.length === 0) return [];
+	const out = [];
+	for (const fill of fills) {
+		if (FILLABLE_STEP_MACRO[fill.stepId] !== macroClass) continue;
+		const effect = fill.labelToEffect[rawClass];
+		if (effect === void 0 || effect === macroClass) continue;
+		const tier = getStepDefinition(fill.stepId).labelTier;
+		out.push({
+			label: effect,
+			score: 0,
+			...tier !== void 0 ? { tier } : {},
+			stepId: linkedLabelStepId(fill.stepId),
+			modelId
+		});
+	}
+	return out;
+}
+//#endregion
 //#region src/detection-pipeline/pipeline/executor.ts
 /**
 * Default minimum short-side (px, source-frame resolution) of a face bbox for
@@ -6396,6 +6764,7 @@ var PipelineExecutor = class {
 						continue;
 					}
 				}
+				for (const linked of linkedLabelsFor(rootStep.fillsClassifierEffects, det.class, mutable.macroClass, rootStep.modelId)) mutable.ownLabels.push(linked);
 				const filterVerdict = this.macroFilterVerdict(mutable.macroClass, mutable.score, rootStep.settings);
 				if (filterVerdict !== "pass") {
 					(discarded ??= []).push({
@@ -6964,7 +7333,8 @@ function buildNode(step, getEngine, resolveModel, onMissingVariant, resolved) {
 		enabled: step.enabled,
 		children,
 		...Object.keys(mergedSettings).length > 0 ? { settings: mergedSettings } : {},
-		...effectiveClassMap !== void 0 ? { effectiveClassMap } : {}
+		...effectiveClassMap !== void 0 ? { effectiveClassMap } : {},
+		...modelEntry?.fillsClassifierEffects !== void 0 ? { fillsClassifierEffects: modelEntry.fillsClassifierEffects } : {}
 	};
 }
 /**
@@ -7750,7 +8120,9 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	* The rebuild is not cheap — `ensureModelsForSteps` loads EVERY enabled step
 	* into the fresh factory, which on the hub is seven models
 	* (yolov9m-320-int8, scrfd-2.5g, arcface-r100, yolov8n-plate,
-	* vgg_english_g2, mobileclip-s1-vision, yolov8n-package). The hub log shows
+	* vgg_english_g2, mobileclip-s1-vision, yolov8n-package — the set of that
+	* date; all but the root detector have since been replaced, D703/D719).
+	* The hub log shows
 	* the cycle plainly: `COMPILE ×7` → shed within 7-15s → `EVICT` ~2.5 min
 	* later → repeat. So the first seconds of a motion event — precisely when
 	* detection matters — were spent recompiling models that had just been
@@ -9386,6 +9758,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	*/
 	async loadDispatchModels(steps, factory, format, context, policy) {
 		const failures = [];
+		if (factory !== null) await this.noteCoralPlacement(steps, factory, format, context);
 		const walk = async (nodes, root) => {
 			for (const step of nodes) {
 				if (!step.enabled || step.slot === "audio-classifier") continue;
@@ -9410,6 +9783,69 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		await walk(steps, true);
 		return failures;
 	}
+	/**
+	* Tell a Coral pool which models this dispatch places on it, and act on a
+	* change of the co-compiled set it loads from (D724): download the set's
+	* files for the models already resident and reload them — queued behind the
+	* pool's other loads, so nothing loads from the old file meanwhile. Logged
+	* once per change, tagged with the camera whose dispatch moved it.
+	*/
+	async noteCoralPlacement(steps, factory, format, context) {
+		const change = factory.notePlacement(placedModelsOf(steps));
+		if (change.kind === "unchanged") return;
+		const deviceKey = context.deviceKey ?? deviceKeyOf(this.currentEngine);
+		const tags = context.deviceId !== void 0 ? { tags: { deviceId: context.deviceId } } : {};
+		const placed = change.placed.map((p) => `${p.stepId}/${p.modelId}`);
+		if (change.to.kind === "set") this.log.info("Coral pool loads a co-compiled set — the models placed on it share the parameter cache", {
+			...tags,
+			meta: {
+				deviceKey,
+				set: change.to.set.id,
+				placed,
+				fromSet: change.to.covered.map((p) => `${p.stepId}/${p.modelId}`),
+				separatelyCompiled: change.to.uncovered.map((p) => `${p.stepId}/${p.modelId}`),
+				previous: change.from.kind === "set" ? change.from.set.id : null
+			}
+		});
+		else if (change.to.reason === "no-set-covers-two") this.log.warn("Coral pool has no co-compiled set for the models placed on it — each is compiled alone, so they evict each other from the parameter cache on every alternation", {
+			...tags,
+			meta: {
+				deviceKey,
+				placed,
+				previous: change.from.kind === "set" ? change.from.set.id : null,
+				hint: "keep the extra step off this Coral with its jumpDeviceKey, or place a combination a published set covers"
+			}
+		});
+		const pool = factory;
+		const previous = this.modelLoadTail.get(pool) ?? Promise.resolve();
+		const tail = (async () => {
+			await previous;
+			for (const loaded of factory.listLoaded()) {
+				const resolved = await this.resolveModelEntry(loaded.stepId, loaded.modelId);
+				if (resolved === void 0) continue;
+				const entry = factory.entryForPool(loaded.stepId, resolved);
+				if (!isModelDownloaded(this.modelsDir, entry, format)) await this.downloadWithRetry(entry, format, 3);
+			}
+			const reloaded = await factory.reloadChangedModelFiles();
+			if (reloaded.length > 0) this.log.info("Coral pool reloaded its resident models from the new set", {
+				...tags,
+				meta: {
+					deviceKey,
+					reloaded: reloaded.map((r) => `${r.stepId}/${r.modelId}`)
+				}
+			});
+		})().catch((err) => {
+			this.log.error("Coral pool could not move its resident models to the new set — they keep serving from the old files", {
+				...tags,
+				meta: {
+					deviceKey,
+					error: errMsg(err)
+				}
+			});
+		});
+		this.modelLoadTail.set(pool, tail);
+		await tail;
+	}
 	/** Ensure all models needed by steps are downloaded and loaded in the engine pool.
 	* `factory`/`format` default to the node's engine; a per-device dispatch passes
 	* that device's factory + format (Phase 2 multi-device). `context` names the
@@ -9507,7 +9943,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 			const refusal = this.loadRefusal(pool, deviceKey, models);
 			if (refusal !== null) throw refusal;
 			try {
-				await this.downloadNeededModels(needed, format);
+				await this.downloadNeededModels(needed, format, factory);
 				this.log.info("Loading additional models for benchmark", { meta: {
 					count: needed.length,
 					models,
@@ -9571,16 +10007,21 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		});
 	}
 	/** Download any model of `needed` missing in `format` (the device's). */
-	async downloadNeededModels(needed, format) {
+	async downloadNeededModels(needed, format, factory = null) {
 		for (const step of needed) try {
-			await this.ensureStepModelArtifact(step, format);
+			await this.ensureStepModelArtifact(step, format, factory);
 		} catch (err) {
 			throw new StepModelArtifactError(step.addonId, step.modelId, err);
 		}
 	}
-	/** Make one step's model artifact present on disk for `format`, or say why it cannot be. */
-	async ensureStepModelArtifact(step, format) {
-		const modelEntry = await this.resolveModelEntry(step.addonId, step.modelId);
+	/**
+	* Make one step's model artifact present on disk for `format`, or say why it
+	* cannot be. The entry is the one `factory`'s pool will LOAD — on a Coral
+	* pool, a co-compiled set's file when the set stands for the model (D724).
+	*/
+	async ensureStepModelArtifact(step, format, factory = null) {
+		const resolved = await this.resolveModelEntry(step.addonId, step.modelId);
+		const modelEntry = resolved && factory !== null ? factory.entryForPool(step.addonId, resolved) : resolved;
 		if (modelEntry && !isModelDownloaded(this.modelsDir, modelEntry, format)) {
 			if (modelEntry.formats[format] === void 0) throw new Error(`Model "${modelEntry.id}" has no ${format} format build (available: ${Object.keys(modelEntry.formats).join(", ") || "none"}) — not retrying a permanent format mismatch`);
 			if (modelEntry.formats[format]?.url.startsWith("camstack-local://") === true) throw new Error(`Custom model "${modelEntry.id}" (${format}) is not present in this node's models directory — distribute it to this node from Model Studio before selecting it here`);
@@ -10601,7 +11042,8 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 				...m.group ? { group: m.group } : {},
 				...m.legacy !== void 0 ? { legacy: m.legacy } : {},
 				provider: m.provider ?? "camstack",
-				defaultConfidence: resolveModelDefaultConfidence(step, m)
+				defaultConfidence: resolveModelDefaultConfidence(step, m),
+				...m.fillsClassifierEffects !== void 0 ? { fillsClassifierEffects: m.fillsClassifierEffects } : {}
 			})),
 			defaultModelId: step.defaultModelId,
 			...step.defaultModelIdByFormat ? { defaultModelIdByFormat: { ...step.defaultModelIdByFormat } } : {},