@camstack/addon-pipeline 1.2.338 → 1.2.340

package/dist/detection-pipeline/index.js

@@ -3,11 +3,11 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-WIL4yeyi.js");
-const require_node = require("../node-DCFClFJ1.js");
-const require_custom_model_catalog = require("../custom-model-catalog-BYJyfhgj.js");
+const require_dist = require("../dist-BWigCRRN.js");
+const require_node = require("../node-D52HHrVZ.js");
+const require_custom_model_catalog = require("../custom-model-catalog-Cjbll1Sf.js");
 const require_lazy_sharp = require("../lazy-sharp-BuwKlQLR.js");
-const require_process_memory = require("../process-memory-Bsj_b---.js");
+const require_process_memory = require("../process-memory-C9U6dKxS.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_fs = require("node:fs");
@@ -346,6 +346,138 @@ function normalizeEngineNodeId(rawNodeId) {
 	return raw.includes("/") ? raw.split("/")[0] ?? "hub" : raw;
 }
 //#endregion
+//#region src/detection-pipeline/model-bound-device-overrides.ts
+/**
+* Best settings (D745), the executor leg: list — and optionally remove — the
+* MODEL-BOUND thresholds stored in this addon's per-camera settings (the
+* object-detection root's `bindsToModel` keys and their binding keys, D738).
+* Every other key of a camera's store is kept.
+*
+* The device store only MERGES on write, so a removal is clear + write of the
+* kept keys — the idiom `migrate-hardware-state.ts` uses. Both run in this
+* process, serialized per camera; a write that fails after the clear restores
+* the original row, and the camera is reported `refused` rather than clean. A
+* store that cannot be read is `refused` too: a failed read is never "nothing
+* to clear" (D393).
+*/
+function errMsg(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+/** The stored keys among `boundKeys` (values and bindings), sorted. */
+function presentBoundKeys(row, boundKeys) {
+	return boundKeys.flatMap((k) => [k, require_dist.modelBindingKey(k)]).filter((k) => k in row).toSorted();
+}
+async function clearModelBoundDeviceOverrides(deps, input) {
+	const ids = input.deviceIds ?? await deps.listDeviceIds();
+	const entries = [];
+	const refused = [];
+	for (const deviceId of [...ids].toSorted((a, b) => a - b)) {
+		let row;
+		try {
+			row = await deps.readDeviceStore(deviceId);
+		} catch (err) {
+			refused.push({
+				deviceId,
+				reason: `read failed: ${errMsg(err)}`
+			});
+			continue;
+		}
+		const keys = presentBoundKeys(row, deps.boundKeys);
+		if (keys.length === 0) continue;
+		if (input.dryRun) {
+			entries.push({
+				deviceId,
+				keys
+			});
+			continue;
+		}
+		const kept = { ...row };
+		for (const k of keys) delete kept[k];
+		try {
+			await deps.clearDeviceStore(deviceId);
+		} catch (err) {
+			refused.push({
+				deviceId,
+				reason: `clear failed: ${errMsg(err)}`
+			});
+			continue;
+		}
+		try {
+			if (Object.keys(kept).length > 0) await deps.writeDeviceStore(deviceId, kept);
+			entries.push({
+				deviceId,
+				keys
+			});
+		} catch (err) {
+			await deps.writeDeviceStore(deviceId, row).catch(() => void 0);
+			refused.push({
+				deviceId,
+				reason: `write failed, row restored: ${errMsg(err)}`
+			});
+		} finally {
+			deps.invalidate(deviceId);
+		}
+	}
+	return {
+		entries,
+		refused
+	};
+}
+//#endregion
+//#region src/detection-pipeline/model-format-facts.ts
+/**
+* Two per-format facts `getSchema` reports beside `downloaded`, for Model
+* Studio → Installed (one row per model × format on a node).
+*
+* - {@link modelOnDiskState} — `current` / `stale` / `missing`. `downloaded`
+*   alone is `current`; it cannot tell a copy that is on disk but not proven
+*   at its catalog revision (D743/D744) from no copy at all, and those are
+*   different answers to "what does this node hold" — a stale copy is still
+*   bytes on the disk, still reclaimable, and is replaced on its next ensure.
+* - {@link formatPrecision} — the numeric precision of the BUILD, only when
+*   the build says so. An unsuffixed OpenVINO IR is FP16 for one family and
+*   FP32 for another (`scripts/build-camstack-models.py`), so this answers
+*   `undefined` rather than guess.
+*
+* Kept in the addon, not in `@camstack/system` / `@camstack/types`: both are
+* host-resolved at runtime, so a new value there would reach an addon only
+* with a server release, and this addon would fail to load on an older hub.
+*/
+/** What this node holds for one (model, format). */
+function modelOnDiskState(modelsDir, entry, format) {
+	if (entry.formats[format] === void 0) return "missing";
+	if ((0, _camstack_system_addon_utils.isModelDownloaded)(modelsDir, entry, format)) return "current";
+	const modelPath = (0, _camstack_system_addon_utils.getModelFilePath)(modelsDir, entry, format);
+	return modelPath !== null && node_fs.existsSync(modelPath) ? "stale" : "missing";
+}
+var PRECISION_TOKEN = /(?:^|[-_.])(int8|fp16|fp32)(?=[-_.]|$)/i;
+/** The artefact's file name, without the directory. */
+function artefactName(url) {
+	return url.split("/").pop() ?? url;
+}
+/** Precision a token in the artefact name states (`…-int8.xml`, `…_int8_edgetpu.tflite`). */
+function precisionFromName(name) {
+	const token = PRECISION_TOKEN.exec(name)?.[1]?.toLowerCase();
+	if (token === "int8" || token === "fp16" || token === "fp32") return token;
+}
+/**
+* The precision of one format's build, or `undefined` when nothing states it.
+* In order: a token in the file name; an `int8` variant group (every format of
+* an INT8 variant is quantised); an EdgeTPU build (the compiler accepts only
+* full-integer models); a Core ML build hosted on the CamStack mirror (every
+* CamStack Core ML export is FP16 — D743). Nothing else is assumed.
+*/
+function formatPrecision(entry, format) {
+	const formatEntry = entry.formats[format];
+	if (formatEntry === void 0) return void 0;
+	const name = artefactName(formatEntry.url);
+	const named = precisionFromName(name);
+	if (named !== void 0) return named;
+	if (entry.group?.precision === "int8") return "int8";
+	if (format === "tflite" && /edgetpu/i.test(name)) return "int8";
+	if (format === "coreml" && formatEntry.url.startsWith(require_dist.hfModelUrl("camstack/camstack-models", ""))) return "fp16";
+}
+//#endregion
 //#region src/shared/cluster-model-source.ts
 /**
 * Where the runner gets the ONE cluster model choice per cluster-scoped step.
@@ -7521,7 +7653,7 @@ function buildNode(step, getEngine, resolveModel, onMissingVariant, resolved) {
 	const modelEntry = resolveModelEntry(definition, variant.modelId, resolveModel);
 	const schema = require_custom_model_catalog.getStep(step.addonId).getConfigSchema(modelEntry);
 	const schemaDefaults = collectSchemaDefaults(schema);
-	const operatorSettings = require_dist.applyModelBoundSettings(step.settings, collectModelBoundKeys(schema), variant.modelId);
+	const operatorSettings = require_dist.applyModelBoundSettings(step.settings, require_dist.collectModelBoundKeys(schema), variant.modelId);
 	const mergedSettings = {
 		...schemaDefaults,
 		...operatorSettings
@@ -7560,13 +7692,6 @@ function collectSchemaDefaults(schema) {
 	walkFieldsForDefaults(schema, out);
 	return out;
 }
-/** The keys of every `bindsToModel` field of a schema, groups flattened (D738). */
-function collectModelBoundKeys(fields) {
-	return fields.flatMap((field) => {
-		if (field.type === "group") return collectModelBoundKeys(field.fields);
-		return "key" in field && "bindsToModel" in field && field.bindsToModel === true ? [field.key] : [];
-	});
-}
 /**
 * The operator settings of `stepId` as the model that RUNS sees them (D738):
 * a model-bound value made for another model is dropped and binding keys are
@@ -7575,7 +7700,7 @@ function collectModelBoundKeys(fields) {
 * same binding as the layers `buildNode` merges.
 */
 function resolveOperatorSettingsForModel(stepId, settings, runningModelId) {
-	return require_dist.applyModelBoundSettings(settings, collectModelBoundKeys(require_custom_model_catalog.getStep(stepId).getConfigSchema()), runningModelId) ?? {};
+	return require_dist.applyModelBoundSettings(settings, require_dist.collectModelBoundKeys(require_custom_model_catalog.getStep(stepId).getConfigSchema()), runningModelId) ?? {};
 }
 function walkFieldsForDefaults(fields, out) {
 	for (const field of fields) {
@@ -8429,6 +8554,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	readDeviceStore;
 	/** Delete all per-device settings for a device (used by `clearDeviceOverrides`). */
 	clearDeviceStore;
+	/** Merge a patch into one device's settings (Best settings' keep-the-rest rewrite, D745). */
+	writeDeviceStore;
 	/**
 	* The per-device overrides the FRAME path reads, kept fresh off that path.
 	*
@@ -8448,6 +8575,8 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		this.readDeviceStore = settings.readDeviceStore ?? (async () => ({}));
 		const clearDeviceStore = settings.clearDeviceStore;
 		this.clearDeviceStore = clearDeviceStore ? (deviceId) => clearDeviceStore.call(settings, deviceId) : async () => void 0;
+		const writeDeviceStore = settings.writeDeviceStore;
+		this.writeDeviceStore = writeDeviceStore ? (deviceId, patch) => writeDeviceStore.call(settings, deviceId, patch) : async () => void 0;
 		this.deviceOverrides = new DeviceOverrideMirror({
 			read: (deviceId) => this.readDeviceStore(deviceId),
 			onRefreshFailed: (deviceId, err) => this.log.warn("per-device detection overrides refresh failed — serving the last value", {
@@ -8463,6 +8592,25 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		} });
 	}
 	/**
+	* Record the revision of every catalog model already on this node whose
+	* weight file hashes to it (D744), so the model listing reports those copies
+	* as downloaded without fetching them again. Background and offline: it
+	* reads files only. A copy holding other bytes is left for `ensureModel`,
+	* which fetches it the next time something needs it.
+	*/
+	adoptHostedModelRevisions() {
+		const entries = require_custom_model_catalog.ALL_PIPELINE_STEPS.flatMap((s) => s.definition.models);
+		(0, _camstack_system_addon_utils.adoptModelRevisions)(this.modelsDir, entries).then((report) => {
+			if (report.adopted.length === 0 && report.stale.length === 0) return;
+			this.log.info("Model copies checked against their mirror revision", { meta: {
+				adopted: report.adopted.length,
+				stale: report.stale
+			} });
+		}, (err) => {
+			this.log.warn("Model revision check failed — copies are proven on their next download", { meta: { error: require_dist.errMsg(err) } });
+		});
+	}
+	/**
 	* Call after construction. The node-default engine is always DERIVED live
 	* from this node's own hardware (there is no persisted operator override
 	* anymore — the elected single-engine cascade was removed). Defer the derive
@@ -8471,6 +8619,7 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 	async init() {
 		this.needsAutoPick = true;
 		this.log.info("Node-default engine derive deferred to setApi()");
+		this.adoptHostedModelRevisions();
 		if (!this.poolMemoryGuard) {
 			this.poolMemoryGuard = createDetectionPoolMemoryGuard({
 				listPools: () => this.listGuardedPools(),
@@ -11006,6 +11155,41 @@ var DetectionPipelineProvider = class DetectionPipelineProvider {
 		};
 	}
 	/**
+	* Best settings (D745): list — or, unless `dryRun`, remove — the model-bound
+	* thresholds of the per-camera detector store. See
+	* `model-bound-device-overrides.ts`.
+	*/
+	async clearModelBoundDeviceOverrides(input) {
+		const result = await clearModelBoundDeviceOverrides({
+			listDeviceIds: async () => {
+				const api = this.addonCtx?.api;
+				if (!api) throw new Error("clearModelBoundDeviceOverrides: ctx.api unavailable");
+				return (await api.deviceManager.listAll.query({ projection: "slim" })).map((d) => d.id);
+			},
+			readDeviceStore: (deviceId) => this.readDeviceStore(deviceId),
+			clearDeviceStore: (deviceId) => this.clearDeviceStore(deviceId),
+			writeDeviceStore: (deviceId, patch) => this.writeDeviceStore(deviceId, patch),
+			invalidate: (deviceId) => this.deviceOverrides.invalidate(deviceId),
+			boundKeys: require_dist.collectModelBoundKeys(require_custom_model_catalog.getStep("object-detection").getConfigSchema())
+		}, input);
+		if (!input.dryRun) for (const entry of result.entries) this.log.info("best settings: per-camera detector thresholds cleared", {
+			tags: { deviceId: entry.deviceId },
+			meta: {
+				deviceId: entry.deviceId,
+				keys: entry.keys
+			}
+		});
+		for (const r of result.refused) this.log.warn("best settings: per-camera detector thresholds not cleared", {
+			tags: { deviceId: r.deviceId },
+			meta: {
+				deviceId: r.deviceId,
+				reason: r.reason,
+				dryRun: input.dryRun
+			}
+		});
+		return result;
+	}
+	/**
 	* Clear the per-device pipeline-step overrides for every known device.
 	* Returns the count of devices whose store was cleared. There is no
 	* bulk-list primitive over the per-device store, so devices are
@@ -11266,10 +11450,17 @@ function buildSchemaSlots(formats, modelsDir, customByStep) {
 			models: availableModels.map((m) => ({
 				id: m.id,
 				name: m.name,
-				formats: Object.fromEntries(Object.entries(m.formats).map(([f, entry]) => [f, {
-					downloaded: (0, _camstack_system_addon_utils.isModelDownloaded)(modelsDir, m, f),
-					sizeMB: entry.sizeMB
-				}])),
+				formats: Object.fromEntries(Object.entries(m.formats).map(([f, entry]) => {
+					const format = f;
+					const onDisk = modelOnDiskState(modelsDir, m, format);
+					const precision = formatPrecision(m, format);
+					return [f, {
+						downloaded: onDisk === "current",
+						sizeMB: entry.sizeMB,
+						onDisk,
+						...precision !== void 0 ? { precision } : {}
+					}];
+				})),
 				...m.group ? { group: m.group } : {},
 				...m.legacy !== void 0 ? { legacy: m.legacy } : {},
 				provider: m.provider ?? "camstack",