@camstack/addon-pipeline 1.2.333 → 1.2.334

package/dist/{default-detection-model-CDffuH2m.mjs → custom-model-catalog-DoOVE7kz.mjs}

@@ -1,4 +1,4 @@
-import { Tt as inferModelProvider, X as audioKindId, b as DEVICE_BACKEND_TO_FORMAT, f as COCO_80_LABELS, i as AUDIO_MACRO_LABELS, k as LABEL_SUPPLY_VOCABULARIES, on as stepModelRunsOnFormat, p as COCO_TO_MACRO, wt as hfModelUrl } from "./dist-BsT15i7i.mjs";
+import { Tt as inferModelProvider, X as audioKindId, b as DEVICE_BACKEND_TO_FORMAT, f as COCO_80_LABELS, i as AUDIO_MACRO_LABELS, k as LABEL_SUPPLY_VOCABULARIES, on as stepModelRunsOnFormat, p as COCO_TO_MACRO, wt as hfModelUrl } from "./dist-Dn3knu_K.mjs";
 import { t as isWorkerReply } from "./worker-protocol-D_NzPcnh.mjs";
 import { randomUUID } from "node:crypto";
 //#region src/detection-pipeline/registry/effective-confidence.ts
@@ -447,6 +447,10 @@ var yolo26Reduced = (tier, res, sizes) => {
 		formats: { openvino: ovFormat(hf(`objectDetection/yolo26/openvino/camstack-yolo26${tier}-${res}-int8.xml`), sizes.ovInt8) }
 	}];
 };
+/** Variant family of the YOLO26 builds with an instance-segmentation head. */
+var YOLO26_SEG_FAMILY = "yolo26-seg";
+/** What choosing a seg build as the root means, in the catalog's own words. */
+var YOLO26_SEG_ROOT_NOTE = "As the root model it detects like YOLO26 and also supplies the Segmentation step its masks (detection + masks, slightly heavier).";
 var OBJECT_DETECTION_MODELS = [
 	{
 		id: "yolo26n",
@@ -617,6 +621,102 @@ var OBJECT_DETECTION_MODELS = [
 			runtimes: ["python"]
 		} }
 	},
+	{
+		id: "yolo26n-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "n",
+			resolution: 640
+		},
+		name: "YOLO26-seg Nano",
+		description: `YOLO26 Nano with its instance-segmentation head — ultra-lightweight. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
+				sizeMB: 11
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
+				sizeMB: 6,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
+		}
+	},
+	{
+		id: "yolo26s-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "s",
+			resolution: 640
+		},
+		name: "YOLO26-seg Small",
+		description: `YOLO26 Small with its instance-segmentation head — balanced. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
+				sizeMB: 40
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
+				sizeMB: 20,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
+		}
+	},
+	{
+		id: "yolo26m-seg",
+		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
+		group: {
+			family: YOLO26_SEG_FAMILY,
+			tier: "m",
+			resolution: 640
+		},
+		name: "YOLO26-seg Medium",
+		description: `YOLO26 Medium with its instance-segmentation head — high accuracy. ${YOLO26_SEG_ROOT_NOTE}`,
+		inputSize: {
+			width: 640,
+			height: 640
+		},
+		labels: [],
+		preprocessMode: "letterbox",
+		postprocessor: "yolo-seg",
+		formats: {
+			onnx: {
+				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
+				sizeMB: 90
+			},
+			coreml: {
+				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
+				sizeMB: 45,
+				isDirectory: true,
+				files: [...MLPACKAGE_FILES],
+				runtimes: ["python"]
+			},
+			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
+		}
+	},
 	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "fp16", 5, true),
 	ovPrecisionVariant("yolo26n", "objectDetection/yolo26/openvino", "YOLO26 Nano", "int8", 3),
 	ovPrecisionVariant("yolo26s", "objectDetection/yolo26/openvino", "YOLO26 Small", "fp16", 19, true),
@@ -1030,86 +1130,13 @@ var SEGMENTATION_REFINER_MODELS = [{
 		openvino: ovFormat(hf("segmentationRefiner/u2netp/openvino/camstack-u2netp.xml"), 2.5)
 	}
 }];
-var INSTANCE_SEGMENTATION_MODELS = [
-	{
-		id: "yolo26n-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Nano Seg",
-		description: "YOLO26 Nano Segmentation — ultra-lightweight instance segmentation with masks",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26n-seg.onnx"),
-				sizeMB: 11
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26n-seg.mlpackage"),
-				sizeMB: 6,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26n-seg.xml"), 11)
-		}
-	},
-	{
-		id: "yolo26s-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Small Seg",
-		description: "YOLO26 Small Segmentation — balanced instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26s-seg.onnx"),
-				sizeMB: 40
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26s-seg.mlpackage"),
-				sizeMB: 20,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26s-seg.xml"), 40)
-		}
-	},
-	{
-		id: "yolo26m-seg",
-		license: licensed(ULTRALYTICS_AGPL, { modifications: "exported to ONNX, OpenVINO IR and CoreML" }),
-		name: "YOLO26 Medium Seg",
-		description: "YOLO26 Medium Segmentation — high-accuracy instance segmentation",
-		inputSize: {
-			width: 640,
-			height: 640
-		},
-		labels: [],
-		preprocessMode: "letterbox",
-		formats: {
-			onnx: {
-				url: hf("segmentation/yolo26-seg/onnx/camstack-yolo26m-seg.onnx"),
-				sizeMB: 90
-			},
-			coreml: {
-				url: hf("segmentation/yolo26-seg/coreml/camstack-yolo26m-seg.mlpackage"),
-				sizeMB: 45,
-				isDirectory: true,
-				files: [...MLPACKAGE_FILES],
-				runtimes: ["python"]
-			},
-			openvino: ovFormat(hf("segmentation/yolo26-seg/openvino/camstack-yolo26m-seg.xml"), 90)
-		}
-	}
-];
+/**
+* The dormant `instance-segmentation` step's catalog: the YOLO26-seg entries of
+* {@link OBJECT_DETECTION_MODELS}, by reference. One entry per model (D703) —
+* the artifact lives once, in the root's catalog, where it can be selected as
+* the camera root and supply the `segmentation` step's masks (D737).
+*/
+var INSTANCE_SEGMENTATION_MODELS = OBJECT_DETECTION_MODELS.filter((m) => m.group?.family === YOLO26_SEG_FAMILY);
 var CLIP_EMBEDDING_MODELS = [{
 	id: "siglip2-b16-224",
 	license: SIGLIP2_APACHE,
@@ -1391,7 +1418,7 @@ var AnimalClassifierStep = class {
 		labelTier: 1,
 		models: [...ANIMAL_CLASSIFIER_MODELS],
 		defaultModelId: "animal-classifier",
-		enabledByDefault: false,
+		enabledByDefault: true,
 		defaultConfidence: .5,
 		labels: [...ANIMAL_10_LABELS],
 		cadence: {
@@ -1705,7 +1732,7 @@ var STEP_VEHICLE_CLASSIFIER = new VehicleClassifierStep({
 	labelTier: 1,
 	models: [...VEHICLE_CLASSIFIER_MODELS],
 	defaultModelId: "vehicle-type-v1",
-	enabledByDefault: false,
+	enabledByDefault: true,
 	defaultConfidence: .5,
 	cadence: {
 		trigger: "once",
@@ -2959,6 +2986,120 @@ function rootObjectGate(steps) {
 	return (steps?.find((s) => s.enabled !== false))?.settings;
 }
 //#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";
+/**
+* Balanced default object-detection model per accelerator class. `'cpu'` maps to
+* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
+* INTEL NPU + iGPU default to the Ultralytics YOLOv9 re-export (int8 @320): yolo26 does NOT compile on
+* the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
+* measured). Apple ANE uses the CoreML yolov9 @320 build.
+*
+* Do **not** promote these ids to `yolov9m-640` / `*-640`. The controlled
+* evaluation recovered 0/3 misses at the current 0.50 threshold and failed the
+* false-positive and capacity gates — see
+* `docs/benchmarks/pipeline-frame-model-eval.md`. 640 remains an explicit
+* operator pick, not a hardware-aware default.
+*/
+var MODEL_BY_CLASS = {
+	"apple-ane": "yolov9m-320",
+	"intel-npu": "yolov9m-320-int8",
+	"intel-gpu": "yolov9m-320-int8",
+	cpu: null
+};
+/**
+* Classify a node's engine into an {@link AcceleratorClass} from its resolved
+* `backend` + `device`. Pure, total, never throws.
+*
+* OpenVINO's default device is `'auto'` (the python pool resolves NPU > GPU >
+* CPU at load). Because OpenVINO is only ever OFFERED when an Intel iGPU is
+* present, the GPU is the guaranteed accelerator while the NPU is an explicit
+* opt-in — so `'auto'` (and any non-cpu/non-npu device) is treated as
+* GPU-class conservatively. An operator who explicitly pins `device: 'npu'`
+* gets the NPU-tuned m-320.
+*
+* Also accepts the accelerator carried in the `backend` slot (e.g. `'ane'`,
+* `'mps'`, `'npu'`, `'intel-gpu'`) so a caller passing a device-style backend
+* still classifies correctly — real callers pass onnx/openvino/coreml.
+*/
+function classifyAccelerator(backend, device) {
+	const b = backend.toLowerCase();
+	const d = device?.toLowerCase() ?? null;
+	if (b === "coreml" || b === "ane" || b === "mps") return "apple-ane";
+	if (b === "openvino") {
+		if (d === "npu") return "intel-npu";
+		if (d === "cpu") return "cpu";
+		return "intel-gpu";
+	}
+	if (b === "npu" || b === "intel-npu") return "intel-npu";
+	if (b === "gpu" || b === "intel-gpu" || b === "gpu-openvino") return "intel-gpu";
+	return "cpu";
+}
+/**
+* Resolve the hardware-aware default object-detection model id for a node's
+* engine `(backend, device, format)`.
+*
+* Guarantees:
+*   - never throws (hot default-tree path);
+*   - never returns a model id without a build for `format` (unless the step
+*     has ZERO builds for `format`, which is unloadable regardless of pick and
+*     flagged by `collectZeroBuildIssues`) — an unmapped backend, a `'cpu'`
+*     class, a mapped id missing from the catalog, or a mapped id without a
+*     `format` build all fall back to the step's PER-FORMAT default
+*     (`getDefaultModelForFormatFromDef`), NOT the bare `defaultModelId`.
+*
+* `getStepDef` is injectable (defaults to the real catalog lookup) so the
+* missing-build fallback branch is unit-testable without a live catalog —
+* mirrors `collectZeroBuildIssues`' injection seam.
+*/
+function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
+	let def;
+	try {
+		def = getStepDef(OBJECT_DETECTION_STEP_ID);
+	} catch {
+		return "yolo26n";
+	}
+	const candidate = MODEL_BY_CLASS[classifyAccelerator(backend, device)];
+	if (candidate !== null) {
+		const entry = def.models.find((m) => m.id === candidate);
+		if (entry && entry.formats[format] !== void 0) return candidate;
+	}
+	return getDefaultModelForFormatFromDef(def, format);
+}
+//#endregion
+//#region src/detection-pipeline/engine/resolve-device-engine.ts
+/**
+* Resolve a Phase-1 device key (`<backend>:<device>`, or bare `cpu`) into the
+* {@link PipelineEngineChoice} used to build that device's inference pool.
+* Throws on an unknown backend token so a bad `deviceKey` fails loud rather
+* than silently building a wrong pool. Format comes from the shared
+* {@link DEVICE_BACKEND_TO_FORMAT} SSOT (`@camstack/types`) — no local copy.
+*/
+function resolveDeviceEngine(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	const backend = colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
+	const device = colon >= 0 ? deviceKey.slice(colon + 1) : deviceKey;
+	const format = DEVICE_BACKEND_TO_FORMAT[backend];
+	if (format === void 0) throw new Error(`resolveDeviceEngine: unknown backend "${backend}" in deviceKey "${deviceKey}"`);
+	return {
+		runtime: "python",
+		backend,
+		format,
+		device
+	};
+}
+/**
+* The inverse of {@link resolveDeviceEngine}: the `<backend>:<device>` key that
+* names the pool an engine belongs to. Every pool-level log line carries this —
+* without it a default pool logs anonymously and six hours of logs cannot tell
+* "the NPU is unused" from "the NPU IS the anonymous default pool".
+* Falls back to the bare backend when the engine carries no device.
+*/
+function deviceKeyOf(engine) {
+	return engine.device ? `${engine.backend}:${engine.device}` : engine.backend;
+}
+//#endregion
 //#region src/pipeline-runner/device-jump.ts
 /**
 * Step-tree device jump (same-node, phase 1) — the PURE resolution core.
@@ -3268,86 +3409,4 @@ var CustomModelCatalog = class {
 	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";
-/**
-* Balanced default object-detection model per accelerator class. `'cpu'` maps to
-* `null` → the caller substitutes the step's own `defaultModelId` (`yolo26n`).
-* INTEL NPU + iGPU default to the Ultralytics YOLOv9 re-export (int8 @320): yolo26 does NOT compile on
-* the Intel NPU (arch incompat → 0 frames), while yolov9 runs on it (~298 fps
-* measured). Apple ANE uses the CoreML yolov9 @320 build.
-*
-* Do **not** promote these ids to `yolov9m-640` / `*-640`. The controlled
-* evaluation recovered 0/3 misses at the current 0.50 threshold and failed the
-* false-positive and capacity gates — see
-* `docs/benchmarks/pipeline-frame-model-eval.md`. 640 remains an explicit
-* operator pick, not a hardware-aware default.
-*/
-var MODEL_BY_CLASS = {
-	"apple-ane": "yolov9m-320",
-	"intel-npu": "yolov9m-320-int8",
-	"intel-gpu": "yolov9m-320-int8",
-	cpu: null
-};
-/**
-* Classify a node's engine into an {@link AcceleratorClass} from its resolved
-* `backend` + `device`. Pure, total, never throws.
-*
-* OpenVINO's default device is `'auto'` (the python pool resolves NPU > GPU >
-* CPU at load). Because OpenVINO is only ever OFFERED when an Intel iGPU is
-* present, the GPU is the guaranteed accelerator while the NPU is an explicit
-* opt-in — so `'auto'` (and any non-cpu/non-npu device) is treated as
-* GPU-class conservatively. An operator who explicitly pins `device: 'npu'`
-* gets the NPU-tuned m-320.
-*
-* Also accepts the accelerator carried in the `backend` slot (e.g. `'ane'`,
-* `'mps'`, `'npu'`, `'intel-gpu'`) so a caller passing a device-style backend
-* still classifies correctly — real callers pass onnx/openvino/coreml.
-*/
-function classifyAccelerator(backend, device) {
-	const b = backend.toLowerCase();
-	const d = device?.toLowerCase() ?? null;
-	if (b === "coreml" || b === "ane" || b === "mps") return "apple-ane";
-	if (b === "openvino") {
-		if (d === "npu") return "intel-npu";
-		if (d === "cpu") return "cpu";
-		return "intel-gpu";
-	}
-	if (b === "npu" || b === "intel-npu") return "intel-npu";
-	if (b === "gpu" || b === "intel-gpu" || b === "gpu-openvino") return "intel-gpu";
-	return "cpu";
-}
-/**
-* Resolve the hardware-aware default object-detection model id for a node's
-* engine `(backend, device, format)`.
-*
-* Guarantees:
-*   - never throws (hot default-tree path);
-*   - never returns a model id without a build for `format` (unless the step
-*     has ZERO builds for `format`, which is unloadable regardless of pick and
-*     flagged by `collectZeroBuildIssues`) — an unmapped backend, a `'cpu'`
-*     class, a mapped id missing from the catalog, or a mapped id without a
-*     `format` build all fall back to the step's PER-FORMAT default
-*     (`getDefaultModelForFormatFromDef`), NOT the bare `defaultModelId`.
-*
-* `getStepDef` is injectable (defaults to the real catalog lookup) so the
-* missing-build fallback branch is unit-testable without a live catalog —
-* mirrors `collectZeroBuildIssues`' injection seam.
-*/
-function resolveDefaultDetectionModel(backend, device, format, getStepDef = getStepDefinition) {
-	let def;
-	try {
-		def = getStepDef(OBJECT_DETECTION_STEP_ID);
-	} catch {
-		return "yolo26n";
-	}
-	const candidate = MODEL_BY_CLASS[classifyAccelerator(backend, device)];
-	if (candidate !== null) {
-		const entry = def.models.find((m) => m.id === candidate);
-		if (entry && entry.formats[format] !== void 0) return candidate;
-	}
-	return getDefaultModelForFormatFromDef(def, format);
-}
-//#endregion
-export { getStep as _, buildSubtreeCanRun as a, landmarkPrecisionVerdict as b, macroGateVerdict as c, isSessionDecodeReadGone as d, createSessionDecodeCoordinator as f, getDefaultModelForFormat as g, ALL_STEPS as h, mergeCustomModels as i, rootObjectGate as l, ALL_PIPELINE_STEPS as m, resolveDefaultDetectionModel as n, placeDetailStep as o, resolveFrameViewGeometry as p, CustomModelCatalog as r, stepsForElectedPool as s, OBJECT_DETECTION_STEP_ID as t, localFrameRegistry as u, getStepDefinition as v, resolveModelDefaultConfidence as x, resolveModelForFormat as y };
+export { resolveModelDefaultConfidence as C, landmarkPrecisionVerdict as S, ALL_STEPS as _, stepsForElectedPool as a, getStepDefinition as b, OBJECT_DETECTION_STEP_ID as c, rootObjectGate as d, localFrameRegistry as f, ALL_PIPELINE_STEPS as g, resolveFrameViewGeometry as h, placeDetailStep as i, resolveDefaultDetectionModel as l, createSessionDecodeCoordinator as m, mergeCustomModels as n, deviceKeyOf as o, isSessionDecodeReadGone as p, buildSubtreeCanRun as r, resolveDeviceEngine as s, CustomModelCatalog as t, macroGateVerdict as u, getDefaultModelForFormat as v, resolveModelForFormat as x, getStep as y };