@camstack/addon-model-studio 1.1.201 → 1.1.203

package/dist/model-studio.addon.mjs

@@ -10900,6 +10900,478 @@ var ClipSearchStrictnessSchema = _enum([
 	"balanced",
 	"strict"
 ]);
+var COCO_80_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "bicycle",
+		name: "Bicycle"
+	},
+	{
+		id: "car",
+		name: "Car"
+	},
+	{
+		id: "motorcycle",
+		name: "Motorcycle"
+	},
+	{
+		id: "airplane",
+		name: "Airplane"
+	},
+	{
+		id: "bus",
+		name: "Bus"
+	},
+	{
+		id: "train",
+		name: "Train"
+	},
+	{
+		id: "truck",
+		name: "Truck"
+	},
+	{
+		id: "boat",
+		name: "Boat"
+	},
+	{
+		id: "traffic light",
+		name: "Traffic Light"
+	},
+	{
+		id: "fire hydrant",
+		name: "Fire Hydrant"
+	},
+	{
+		id: "stop sign",
+		name: "Stop Sign"
+	},
+	{
+		id: "parking meter",
+		name: "Parking Meter"
+	},
+	{
+		id: "bench",
+		name: "Bench"
+	},
+	{
+		id: "bird",
+		name: "Bird"
+	},
+	{
+		id: "cat",
+		name: "Cat"
+	},
+	{
+		id: "dog",
+		name: "Dog"
+	},
+	{
+		id: "horse",
+		name: "Horse"
+	},
+	{
+		id: "sheep",
+		name: "Sheep"
+	},
+	{
+		id: "cow",
+		name: "Cow"
+	},
+	{
+		id: "elephant",
+		name: "Elephant"
+	},
+	{
+		id: "bear",
+		name: "Bear"
+	},
+	{
+		id: "zebra",
+		name: "Zebra"
+	},
+	{
+		id: "giraffe",
+		name: "Giraffe"
+	},
+	{
+		id: "backpack",
+		name: "Backpack"
+	},
+	{
+		id: "umbrella",
+		name: "Umbrella"
+	},
+	{
+		id: "handbag",
+		name: "Handbag"
+	},
+	{
+		id: "tie",
+		name: "Tie"
+	},
+	{
+		id: "suitcase",
+		name: "Suitcase"
+	},
+	{
+		id: "frisbee",
+		name: "Frisbee"
+	},
+	{
+		id: "skis",
+		name: "Skis"
+	},
+	{
+		id: "snowboard",
+		name: "Snowboard"
+	},
+	{
+		id: "sports ball",
+		name: "Sports Ball"
+	},
+	{
+		id: "kite",
+		name: "Kite"
+	},
+	{
+		id: "baseball bat",
+		name: "Baseball Bat"
+	},
+	{
+		id: "baseball glove",
+		name: "Baseball Glove"
+	},
+	{
+		id: "skateboard",
+		name: "Skateboard"
+	},
+	{
+		id: "surfboard",
+		name: "Surfboard"
+	},
+	{
+		id: "tennis racket",
+		name: "Tennis Racket"
+	},
+	{
+		id: "bottle",
+		name: "Bottle"
+	},
+	{
+		id: "wine glass",
+		name: "Wine Glass"
+	},
+	{
+		id: "cup",
+		name: "Cup"
+	},
+	{
+		id: "fork",
+		name: "Fork"
+	},
+	{
+		id: "knife",
+		name: "Knife"
+	},
+	{
+		id: "spoon",
+		name: "Spoon"
+	},
+	{
+		id: "bowl",
+		name: "Bowl"
+	},
+	{
+		id: "banana",
+		name: "Banana"
+	},
+	{
+		id: "apple",
+		name: "Apple"
+	},
+	{
+		id: "sandwich",
+		name: "Sandwich"
+	},
+	{
+		id: "orange",
+		name: "Orange"
+	},
+	{
+		id: "broccoli",
+		name: "Broccoli"
+	},
+	{
+		id: "carrot",
+		name: "Carrot"
+	},
+	{
+		id: "hot dog",
+		name: "Hot Dog"
+	},
+	{
+		id: "pizza",
+		name: "Pizza"
+	},
+	{
+		id: "donut",
+		name: "Donut"
+	},
+	{
+		id: "cake",
+		name: "Cake"
+	},
+	{
+		id: "chair",
+		name: "Chair"
+	},
+	{
+		id: "couch",
+		name: "Couch"
+	},
+	{
+		id: "potted plant",
+		name: "Potted Plant"
+	},
+	{
+		id: "bed",
+		name: "Bed"
+	},
+	{
+		id: "dining table",
+		name: "Dining Table"
+	},
+	{
+		id: "toilet",
+		name: "Toilet"
+	},
+	{
+		id: "tv",
+		name: "TV"
+	},
+	{
+		id: "laptop",
+		name: "Laptop"
+	},
+	{
+		id: "mouse",
+		name: "Mouse"
+	},
+	{
+		id: "remote",
+		name: "Remote"
+	},
+	{
+		id: "keyboard",
+		name: "Keyboard"
+	},
+	{
+		id: "cell phone",
+		name: "Cell Phone"
+	},
+	{
+		id: "microwave",
+		name: "Microwave"
+	},
+	{
+		id: "oven",
+		name: "Oven"
+	},
+	{
+		id: "toaster",
+		name: "Toaster"
+	},
+	{
+		id: "sink",
+		name: "Sink"
+	},
+	{
+		id: "refrigerator",
+		name: "Refrigerator"
+	},
+	{
+		id: "book",
+		name: "Book"
+	},
+	{
+		id: "clock",
+		name: "Clock"
+	},
+	{
+		id: "vase",
+		name: "Vase"
+	},
+	{
+		id: "scissors",
+		name: "Scissors"
+	},
+	{
+		id: "teddy bear",
+		name: "Teddy Bear"
+	},
+	{
+		id: "hair drier",
+		name: "Hair Drier"
+	},
+	{
+		id: "toothbrush",
+		name: "Toothbrush"
+	}
+];
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
+/** Steps a root detector may declare it fills. */
+var FILLABLE_STEP_IDS = [
+	"animal-classifier",
+	"vehicle-classifier",
+	"package-detection"
+];
+/**
+* The EFFECT vocabulary of each fillable step: exactly the strings the step
+* itself emits, in its own spelling. A linked label is one of these and nothing
+* else, so a tier-1 value means the same thing whichever writer produced it.
+*
+* - `animal-classifier`: the PRIMARY model's `-labels.json` (Open Images V7,
+*   8 classes) — also the species allow-list the step offers.
+* - `vehicle-classifier`: `vehicle-type-v1-labels.json`, capitalised as the
+*   model emits them (the classifier writes `winner.class` verbatim).
+* - `package-detection`: its one output class.
+*
+* `scripts/check-label-link-vocabulary.ts` fails the build if a model entry's
+* `labelToEffect` names anything outside this table.
+*/
+var FILLABLE_STEP_VOCABULARIES = {
+	"animal-classifier": [
+		"bird",
+		"cat",
+		"cow",
+		"deer",
+		"dog",
+		"horse",
+		"sheep",
+		"squirrel"
+	],
+	"vehicle-classifier": [
+		"Ambulance",
+		"Bicycle",
+		"Bus",
+		"Car",
+		"Motorcycle",
+		"Taxi",
+		"Truck",
+		"Van"
+	],
+	"package-detection": ["package"]
+};
+/** The macro a detection must carry for the step to apply to it. */
+var FILLABLE_STEP_MACRO = {
+	"animal-classifier": "animal",
+	"vehicle-classifier": "vehicle",
+	"package-detection": "package"
+};
+/**
+* Raw detector labels that name a vocabulary entry under another spelling.
+* Case-insensitive equality covers the rest (`car` → `Car`).
+*/
+var EFFECT_ALIASES = {
+	"animal-classifier": {},
+	"vehicle-classifier": {
+		school_bus: "Bus",
+		garbage_truck: "Truck"
+	},
+	"package-detection": {}
+};
+/**
+* A labelmap is COCO when it carries at least half of the COCO-80 classes. A
+* COCO detector NEVER fills a step (operator decision, D715): its `dog` / `car`
+* is the generic class the classifier exists to refine, and its six animal
+* classes would otherwise read as "fills animal-classifier 6/8". Frigate+
+* shares about a dozen COCO names; a COCO-80 or COCO-91 labelmap carries ~80.
+*/
+function isCocoLabelmap(labels) {
+	const present = new Set(labels);
+	return COCO_80_LABELS.filter((l) => present.has(l.id)).length * 2 >= COCO_80_LABELS.length;
+}
+function effectFor(stepId, label) {
+	const alias = EFFECT_ALIASES[stepId][label];
+	if (alias !== void 0) return alias;
+	const folded = label.toLowerCase();
+	return FILLABLE_STEP_VOCABULARIES[stepId].find((v) => v.toLowerCase() === folded);
+}
+/**
+* Which steps a root detector fills, from its labelmap and classMap. A label
+* counts for a step only when the model's classMap sends it to that step's
+* macro AND it names a vocabulary entry. A step none of the labels reach is
+* not declared; a COCO labelmap declares nothing.
+*/
+function deriveClassifierFills(labels, classMap) {
+	if (classMap === void 0 || isCocoLabelmap(labels)) return [];
+	const fills = [];
+	for (const stepId of FILLABLE_STEP_IDS) {
+		const labelToEffect = {};
+		for (const label of labels) {
+			if (classMap.mapping[label] !== FILLABLE_STEP_MACRO[stepId]) continue;
+			const effect = effectFor(stepId, label);
+			if (effect !== void 0) labelToEffect[label] = effect;
+		}
+		const covered = new Set(Object.values(labelToEffect));
+		if (covered.size === 0) continue;
+		const uncovered = FILLABLE_STEP_VOCABULARIES[stepId].filter((v) => !covered.has(v));
+		fills.push({
+			stepId,
+			labelToEffect,
+			uncovered
+		});
+	}
+	return fills;
+}
 var MODEL_FORMATS = [
 	"onnx",
 	"coreml",
@@ -11032,6 +11504,12 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
 	/** True when the weights or their data forbid commercial use. */
 	nonCommercial: boolean().optional()
 }));
+/** One `fillsClassifierEffects` entry — see `ModelCatalogEntry.fillsClassifierEffects`. */
+var FillsClassifierEffectSchema = object({
+	stepId: _enum(FILLABLE_STEP_IDS),
+	labelToEffect: record(string(), string()),
+	uncovered: array(string()).readonly()
+});
 var ModelCatalogEntrySchema = object({
 	id: string(),
 	name: string(),
@@ -11158,6 +11636,16 @@ var ModelCatalogEntrySchema = object({
 	*/
 	classMap: DetectionCatalogClassMapSchema.optional(),
 	/**
+	* The pipeline steps this ROOT detector already does the work of (D715):
+	* its labels name the effect the step exists to produce (`deer` for
+	* `animal-classifier`, `package` for `package-detection`). Derived from the
+	* labelmap by `deriveClassifierFills`, never hand-written; a COCO model
+	* declares none. Whether a declaration is honoured is the step's own
+	* `labelLink` policy (`resolveLabelLink`). `labelToEffect` values are in
+	* `FILLABLE_STEP_VOCABULARIES` (guard `check-label-link-vocabulary`).
+	*/
+	fillsClassifierEffects: array(FillsClassifierEffectSchema).readonly().optional(),
+	/**
 	* The model's CLIP feature-space contract (text encoder, dimension, vector
 	* index, token window, search floor) — see `clip-model.ts`. Present ONLY on a
 	* CLIP image encoder; its absence is what "not a CLIP model" means to the
@@ -18118,51 +18606,6 @@ method(object({}), array(TargetKindSchema)), method(object({}), array(TargetSche
 	kind: "mutation",
 	auth: "admin"
 });
-new Set([
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-].map((l) => l.id));
-var COCO_TO_MACRO = {
-	mapping: {
-		person: "person",
-		bicycle: "vehicle",
-		car: "vehicle",
-		motorcycle: "vehicle",
-		airplane: "vehicle",
-		bus: "vehicle",
-		train: "vehicle",
-		truck: "vehicle",
-		boat: "vehicle",
-		bird: "animal",
-		cat: "animal",
-		dog: "animal",
-		horse: "animal",
-		sheep: "animal",
-		cow: "animal",
-		elephant: "animal",
-		bear: "animal",
-		zebra: "animal",
-		giraffe: "animal",
-		suitcase: "package",
-		backpack: "package",
-		handbag: "package"
-	},
-	preserveOriginal: false
-};
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
@@ -18920,6 +19363,8 @@ var NcSystemEventKindSchema = _enum([
 	"stream-offline",
 	"node-online",
 	"node-offline",
+	"node-restarting",
+	"node-updating",
 	"node-inference-unavailable",
 	"detection-blind",
 	"addon-crash-loop",
@@ -23566,7 +24011,8 @@ var PipelineModelOptionSchema = object({
 	group: ModelVariantGroupSchema.optional(),
 	legacy: boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
-	defaultConfidence: number().optional()
+	defaultConfidence: number().optional(),
+	fillsClassifierEffects: array(FillsClassifierEffectSchema).readonly().optional()
 });
 var ConfigFieldBridge = custom();
 var PipelineAddonSchemaSchema = object({
@@ -31450,7 +31896,8 @@ object({
 	*   writes this slice (not even a boot seed), and neither does the runner's
 	*   phase machine: its phase is "a session is attached" for every on-motion
 	*   session, not motion, and it now has its own `DetectionPhaseTransition`.
-	*   A provider's `isDetected` answers from the hub's slice.
+	*   A provider's `isDetected` and `getStatus` answer from the hub's slice
+	*   (`hubMotionNativeProvider`).
 	* - **Sensors** (Home Assistant binary sensors, Homematic, Matter, Alexa
 	*   imports) — the provider pushes both edges itself, from the upstream
 	*   system's own state change. That is the sensor's own fact.
@@ -36581,6 +37028,82 @@ DeviceType.Camera, method(object({
 	package: array(ZoneRuleSchema).readonly()
 });
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
+function isClassMapMacroTarget(value) {
+	return CLASS_MAP_MACRO_TARGETS.some((target) => target === value);
+}
+/**
+* Raw Frigate+ label → detection macro. Every label of the documented
+* Frigate+ base set (docs.frigate.video/plus, verified 2026-08-21) is either
+* here or in {@link FRIGATE_PLUS_UNMAPPED_LABELS}, with the reason it is not.
+*
+* Why this exists: a Frigate+ import used to carry NO classMap, so it inherited
+* the step's `COCO_TO_MACRO` (`preserveOriginal: false`) and the executor
+* dropped every label COCO does not name — deer, raccoon, fox, squirrel, goat,
+* rabbit, skunk, kangaroo, possum, rodent, school_bus, garbage_truck and even
+* `package` vanished as `class-filter` discards. The executor keeps the raw
+* label as `originalClass` whenever the map resolves it, so the fine identity
+* survives under the macro.
+*/
+var FRIGATE_PLUS_TO_MACRO = {
+	person: "person",
+	baby: "person",
+	car: "vehicle",
+	motorcycle: "vehicle",
+	bicycle: "vehicle",
+	boat: "vehicle",
+	school_bus: "vehicle",
+	garbage_truck: "vehicle",
+	dog: "animal",
+	cat: "animal",
+	deer: "animal",
+	horse: "animal",
+	bird: "animal",
+	raccoon: "animal",
+	fox: "animal",
+	bear: "animal",
+	cow: "animal",
+	squirrel: "animal",
+	goat: "animal",
+	rabbit: "animal",
+	skunk: "animal",
+	kangaroo: "animal",
+	possum: "animal",
+	rodent: "animal",
+	package: "package"
+};
+/**
+* The per-model classMap for a Frigate / Frigate+ detector, derived from ITS
+* labelmap: each label resolves through {@link FRIGATE_PLUS_TO_MACRO} first,
+* then `COCO_TO_MACRO` (Frigate's default model ships the COCO-91 labelmap, so
+* a preset import may carry either vocabulary). A label neither knows is left
+* out, and `preserveOriginal: false` drops it in the executor — the same
+* contract as the COCO map, now with the Frigate+ vocabulary in it.
+*/
+function buildFrigateClassMap(labels) {
+	const mapping = {};
+	for (const label of labels) {
+		const target = FRIGATE_PLUS_TO_MACRO[label] ?? COCO_TO_MACRO.mapping[label];
+		if (target !== void 0 && isClassMapMacroTarget(target)) mapping[label] = target;
+	}
+	return {
+		mapping,
+		preserveOriginal: false
+	};
+}
+/**
+* Everything a Frigate / Frigate+ entry derives from its labelmap: the classMap
+* and the steps it fills (D715). Every Frigate builder spreads this, so the two
+* cannot be derived from different label lists. A COCO labelmap gets its map
+* and no fill.
+*/
+function frigateLabelFields(labels) {
+	const classMap = buildFrigateClassMap(labels);
+	const fills = deriveClassifierFills(labels, classMap);
+	return fills.length > 0 ? {
+		classMap,
+		fillsClassifierEffects: fills
+	} : { classMap };
+}
 /**
 * Accessory device helpers — shared across drivers.
 *
@@ -47980,6 +48503,8 @@ new Map(Object.entries({
 	"detection-blind": "device-events",
 	"node-online": "system",
 	"node-offline": "system",
+	"node-restarting": "system",
+	"node-updating": "system",
 	"node-inference-unavailable": "system",
 	"addon-crash-loop": "system",
 	"addon-update-available": "system",
@@ -48057,6 +48582,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
@@ -48078,6 +48604,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Server & container updates",
 		kinds: [
 			"server-update-available",
+			"node-updating",
 			"server-updated",
 			"wrapper-update-available"
 		]
@@ -48225,6 +48752,7 @@ var STATE_SUMMARY_SECTION_VARS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
@@ -48246,6 +48774,7 @@ var STATE_SUMMARY_SECTION_VARS = [
 		example: "server 1.2.377 → 1.2.378",
 		kinds: [
 			"server-update-available",
+			"node-updating",
 			"server-updated",
 			"wrapper-update-available"
 		]
@@ -49329,6 +49858,7 @@ function buildFrigateCatalogDescriptor(catalogId, overrides) {
 				id: name,
 				name
 			})),
+			...frigateLabelFields(cat.labels),
 			preprocessMode: "letterbox",
 			provider: "frigate",
 			license: cat.license,
@@ -49478,6 +50008,24 @@ async function ensureFormatsThenDistribute(modelId, deps) {
 }
 //#endregion
 //#region src/frigate/frigate-plus.ts
+/**
+* Frigate+ API client — the REAL api.frigate.video contract, verified against
+* frigate/plus.py (dev branch, 2026-08-21):
+*
+*  - key format: `[uuid]:[40 hex]` (Frigate validates
+*    `[a-z0-9]{8}-…-[a-z0-9]{12}:[a-z0-9]{40}`)
+*  - GET /v1/auth/token with HTTP basic auth (key split on `:`) →
+*    `{ accessToken, expires }`
+*  - GET /v1/model/list with `Authorization: Bearer <accessToken>` → model list
+*  - GET /v1/model/{id} → model info (`type`, `width`, `height`, `labelMap`,
+*    `supportedDetectors`, …)
+*  - GET /v1/model/{id}/signed_url → `{ url }` (presigned, plain GET)
+*
+* SECURITY: everything here runs SERVER-SIDE on the hub. The key comes from
+* the addon's settings store, is sent only to api.frigate.video, and is never
+* logged, never echoed in errors, never shipped to the browser. The fetch
+* function is injected so the contract is unit-testable offline.
+*/
 var PLUS_API_HOST = "https://api.frigate.video";
 var PLUS_KEY_RE = /^[a-z0-9]{8}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{12}:[a-z0-9]{40}$/;
 function isValidPlusApiKey(key) {
@@ -49652,6 +50200,7 @@ function plusInfoToDescriptor(info, opts) {
 				id: name,
 				name
 			})),
+			...frigateLabelFields(labels),
 			preprocessMode: "letterbox",
 			provider: "frigate",
 			group: frigateVariantGroup(info.type, info.width),