@camstack/addon-pipeline 1.2.296 → 1.2.297

package/dist/{default-detection-model-Co578D8C.mjs → default-detection-model-D6DypCkI.mjs}

@@ -1,4 +1,4 @@
-import { K as audioKindId, d as COCO_TO_MACRO, ht as hfModelUrl, r as AUDIO_MACRO_LABELS, u as COCO_80_LABELS } from "./dist-CCd0Q3nr.mjs";
+import { K as audioKindId, Kt as stepModelRunsOnFormat, d as COCO_80_LABELS, f as COCO_TO_MACRO, gt as inferModelProvider, ht as hfModelUrl, r as AUDIO_MACRO_LABELS, y as DEVICE_BACKEND_TO_FORMAT } from "./dist-CxHIpsQs.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/detection-pipeline/pipeline/landmark-precision-gate.ts
 /**
@@ -1655,7 +1655,6 @@ var STEP_FACE_DETECTION = new PipelineStepBase({
 	outputClasses: ["face"],
 	models: [...FACE_DETECTION_MODELS],
 	defaultModelId: "yunet-2023mar",
-	defaultModelIdByFormat: { tflite: "scrfd-2.5g" },
 	defaultConfidence: .5,
 	defaultMinParentScore: .7,
 	cadence: {
@@ -2080,17 +2079,24 @@ var LocalFrameRegistry = class {
 			image,
 			estimatedBytes,
 			refs: 1,
+			consumerRefs: 1,
 			releaseNativeOnClose: false
 		});
 		this.bytes += estimatedBytes;
 		this.evictToBounds();
 		return this.entries.has(ref.id) ? ref : null;
 	}
-	acquire(ref) {
+	/**
+	* Take a lease on `ref`. `holder` says why (D656): a reader that resolves a
+	* view now is a `consumer` (the default); a lease PARKED for a read that may
+	* come later is `retention`, and does not keep a draining worker alive.
+	*/
+	acquire(ref, holder = "consumer") {
 		if (ref.registryId === this.registryId && !this.entries.has(ref.id)) this.staleMissCount += 1;
 		const entry = this.getEntry(ref);
 		if (!entry) return null;
 		entry.refs += 1;
+		if (holder === "consumer") this.addConsumer(entry);
 		this.touch(entry);
 		let released = false;
 		return {
@@ -2098,17 +2104,40 @@ var LocalFrameRegistry = class {
 			release: (reason) => {
 				if (released) return;
 				released = true;
-				this.release(ref, reason);
+				this.releaseRef(ref, reason, holder);
 			}
 		};
 	}
+	/** Release the OWNER reference {@link register} took — a consumer reference. */
 	release(ref, reason) {
+		this.releaseRef(ref, reason, "consumer");
+	}
+	releaseRef(ref, reason, holder) {
 		const entry = this.getEntry(ref);
 		if (!entry) return;
 		this.releaseCount += 1;
 		if (releasesNative(reason)) entry.releaseNativeOnClose = true;
 		entry.refs = Math.max(0, entry.refs - 1);
-		if (entry.refs === 0) this.drop(entry);
+		if (entry.refs === 0) {
+			this.drop(entry);
+			return;
+		}
+		if (holder === "consumer") this.removeConsumer(entry);
+	}
+	/**
+	* The frame's source learns whether a consumer still holds it, on each
+	* transition only: the last consumer letting go of a frame that stays
+	* PARKED, and a consumer coming back to one. A drop needs no signal — the
+	* image is closed.
+	*/
+	addConsumer(entry) {
+		entry.consumerRefs += 1;
+		if (entry.consumerRefs === 1) entry.image.setPendingConsumer?.(true);
+	}
+	removeConsumer(entry) {
+		if (entry.consumerRefs === 0) return;
+		entry.consumerRefs -= 1;
+		if (entry.consumerRefs === 0) entry.image.setPendingConsumer?.(false);
 	}
 	clear(reason = "detach") {
 		for (const entry of [...this.entries.values()]) {
@@ -2207,6 +2236,310 @@ function rootObjectGate(steps) {
 	return (steps?.find((s) => s.enabled !== false))?.settings;
 }
 //#endregion
+//#region src/pipeline-runner/device-jump.ts
+/**
+* Step-tree device jump (same-node, phase 1) — the PURE resolution core.
+*
+* Given the camera's elected ("effective") inference device and the node's
+* enabled-device roster, decide which device ONE enrichment step should run on:
+*
+*   1. A manual `jumpDeviceKey` override wins when it names a candidate that can
+*      run the step (bypasses the auto choice; operator intent).
+*   2. Otherwise, if the effective device's format can run the step's model →
+*      NO jump (the step inherits the effective device — the common case).
+*   3. Otherwise AUTO-jump: among the node's OTHER enabled devices whose format
+*      can run the step (and that are under their `maxSessions` cap), pick the
+*      weighted-least-loaded one — mirroring the balancer's per-device core.
+*   4. If nothing on the node can run it → `no-candidate` (the caller emits the
+*      loud once-per-(camera,step) warn that replaces today's silent degrade).
+*
+* Framework-free + side-effect-free so the whole decision table is unit-testable
+* without a live runner/catalog. The `canRun(format)` predicate is injected by
+* the runner (which owns the model catalog); this module never imports it.
+*/
+/** The `ModelFormat` of a `<backend>:<device>` key, or `undefined` for an unknown backend. */
+function formatOf(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	return DEVICE_BACKEND_TO_FORMAT[colon >= 0 ? deviceKey.slice(0, colon) : deviceKey];
+}
+/** True when the step's model has a build for `deviceKey`'s format. */
+function canRunOn(deviceKey, canRun) {
+	const format = formatOf(deviceKey);
+	return format !== void 0 && canRun(format, deviceKey);
+}
+/** 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.
+* Each step is judged by `stepModelRunsOnFormat` (`@camstack/types`), the one
+* rule every placement reads: a legacy stub build counts only when named (D657).
+*/
+function buildSubtreeCanRun(step, getStepDef) {
+	const judged = [];
+	const walk = (s) => {
+		if (s.enabled === false) return;
+		const def = getStepDef(s.addonId);
+		if (def !== null) judged.push({
+			def,
+			modelId: s.modelId
+		});
+		for (const child of s.children ?? []) walk(child);
+	};
+	walk(step);
+	return (format) => judged.every(({ def, modelId }) => stepModelRunsOnFormat(def.models, modelId, 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)) } : {}
+	};
+}
+/** The subtree as `deviceKey` would run it: the elected device runs it as sent; another takes its roster entry. */
+function provisionedFor(step, deviceKey, effectiveDeviceKey, roster) {
+	if (deviceKey === effectiveDeviceKey) return step;
+	const provisioning = roster.find((d) => d.deviceKey === deviceKey)?.steps;
+	return provisioning === void 0 ? step : provisionSubtreeForDevice(step, 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: (format, deviceKey) => buildSubtreeCanRun(provisionedFor(step, deviceKey, effectiveDeviceKey, roster), input.getStepDef)(format)
+	});
+	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
+	};
+}
+/**
+* The steps whose models a camera's elected pool loads (D657).
+*
+* The frame-plane dispatch executes only root-plane steps; a detail subtree
+* rides it solely so its model pre-warms the elected pool. That is right only
+* when the subtree RUNS there. The decision is {@link placeDetailStep}'s — the
+* one the detail plane takes for the same subtree — so the pool that loads a
+* model and the pool that runs it cannot disagree:
+*  - no decision (no elected device, or a roster of one) or `no-jump`: kept;
+*  - `jumped` (auto or manual): left out — the detail dispatch loads it on the
+*    TARGET pool, with the target's provisioning;
+*  - `no-candidate`: left out — nothing on the node can load it, so a
+*    pre-warm could only fail (the detail plane still says so, loudly).
+* Roots are the elected device's job and always stay. Root-plane children
+* stay and are walked; a detail subtree is judged whole at its top, because
+* its children ride its call. Pure — the caller logs.
+*/
+function stepsForElectedPool(steps, isDetailStep, place) {
+	const delegated = [];
+	const walk = (nodes, topLevel) => {
+		const kept = [];
+		for (const step of nodes) {
+			if (!topLevel && step.enabled !== false && isDetailStep(step.addonId)) {
+				const decision = place(step).decision;
+				if (decision === null || decision.kind === "no-jump") kept.push(step);
+				else delegated.push(step.addonId);
+				continue;
+			}
+			kept.push(step.children !== void 0 && step.children.length > 0 ? {
+				...step,
+				children: walk(step.children, false)
+			} : step);
+		}
+		return kept;
+	};
+	return {
+		steps: walk(steps, true),
+		delegated
+	};
+}
+//#endregion
+//#region src/detection-pipeline/registry/custom-models.ts
+/**
+* Group a flat list of custom-model descriptors (as returned by the
+* `custom-model-registry` collection cap) into a `stepId → entries` map for
+* the picker / resolution union. Pure; order within a step preserved.
+*/
+function groupCustomModelsByStep(descriptors) {
+	const byStep = /* @__PURE__ */ new Map();
+	for (const d of descriptors) {
+		const arr = byStep.get(d.stepId) ?? [];
+		arr.push(d.entry);
+		byStep.set(d.stepId, arr);
+	}
+	return byStep;
+}
+/**
+* Union a step's static catalog models with operator-registered custom
+* models. On an `id` collision the static catalog entry wins — a custom
+* model can never shadow a built-in one.
+*
+* Pure + side-effect-free so it can be unit-tested in isolation and called
+* from the (free) `buildSchemaSlots` builder without any addon context.
+*/
+function mergeCustomModels(staticModels, customModels) {
+	const seen = new Set(staticModels.map((m) => m.id));
+	const merged = [...staticModels];
+	for (const m of customModels) {
+		if (seen.has(m.id)) continue;
+		seen.add(m.id);
+		merged.push({
+			...m,
+			provider: inferModelProvider(m)
+		});
+	}
+	return merged;
+}
+/**
+* A step's definition with its custom models merged in (static wins on an id
+* collision), or `null` for an unknown addonId. Pure.
+*/
+function mergedStepDefinition(stepId, customByStep) {
+	let def;
+	try {
+		def = getStepDefinition(stepId);
+	} catch {
+		return null;
+	}
+	const custom = customByStep.get(stepId);
+	if (custom === void 0 || custom.length === 0) return def;
+	return {
+		...def,
+		models: mergeCustomModels(def.models, custom)
+	};
+}
+/** TTL-cached read of the custom-model registry, with a synchronous merged view. */
+var CustomModelCatalog = class {
+	logger;
+	now;
+	byStep = /* @__PURE__ */ new Map();
+	readAtMs = Number.NEGATIVE_INFINITY;
+	constructor(logger, now = Date.now) {
+		this.logger = logger;
+		this.now = now;
+	}
+	/** Re-read the registry when the snapshot is older than the TTL; answer the snapshot. */
+	async refresh(api) {
+		const now = this.now();
+		if (now - this.readAtMs < 5e3) return this.byStep;
+		this.readAtMs = now;
+		if (api === void 0) return this.byStep;
+		try {
+			const providers = await api.addons.listCapabilityProviders.query({ capName: "custom-model-registry" });
+			this.byStep = providers.some((p) => p.isActive) ? groupCustomModelsByStep(await api.customModelRegistry.listModels.query()) : /* @__PURE__ */ new Map();
+		} catch (err) {
+			this.logger.warn("custom-model-registry query failed — keeping the last custom-model snapshot", { meta: { error: err instanceof Error ? err.message : String(err) } });
+		}
+		return this.byStep;
+	}
+	/** The snapshot, synchronously. */
+	current() {
+		return this.byStep;
+	}
+	/** A step's merged definition from the snapshot, synchronously. */
+	stepDefinition = (stepId) => mergedStepDefinition(stepId, this.byStep);
+};
+//#endregion
 //#region src/detection-pipeline/default-detection-model.ts
 /** The object-detection step id — the only slot this resolver applies to. */
 var OBJECT_DETECTION_STEP_ID = "object-detection";
@@ -2289,4 +2622,4 @@ function resolveDefaultDetectionModel(backend, device, format, getStepDef = getS
 	return getDefaultModelForFormatFromDef(def, format);
 }
 //#endregion
-export { localFrameRegistry as a, ALL_STEPS as c, getStepDefinition as d, resolveModelForFormat as f, rootObjectGate as i, getDefaultModelForFormat as l, landmarkPrecisionVerdict as m, resolveDefaultDetectionModel as n, resolveFrameViewGeometry as o, RETIRED_MODEL_IDS as p, macroGateVerdict as r, ALL_PIPELINE_STEPS as s, OBJECT_DETECTION_STEP_ID as t, getStep as u };
+export { resolveModelForFormat as _, buildSubtreeCanRun as a, macroGateVerdict as c, resolveFrameViewGeometry as d, ALL_PIPELINE_STEPS as f, getStepDefinition as g, getStep as h, mergeCustomModels as i, rootObjectGate as l, getDefaultModelForFormat as m, resolveDefaultDetectionModel as n, placeDetailStep as o, ALL_STEPS as p, CustomModelCatalog as r, stepsForElectedPool as s, OBJECT_DETECTION_STEP_ID as t, localFrameRegistry as u, RETIRED_MODEL_IDS as v, landmarkPrecisionVerdict as y };