@camstack/addon-model-studio 1.1.202 → 1.1.204

package/dist/model-studio.addon.js

@@ -10926,394 +10926,30 @@ 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 = [
+/** Steps whose effect a root label can BE. */
+var LABEL_SUPPLY_STEP_IDS = [
 	"animal-classifier",
 	"vehicle-classifier",
 	"package-detection"
 ];
+/** Steps whose box a root detection can BE. */
+var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
+[...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
 /**
-* The EFFECT vocabulary of each fillable step: exactly the strings the step
+* The EFFECT vocabulary of each label-kind 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).
+* - `vehicle-classifier`: the classifier's labels, capitalised as it emits them
+*   (it writes `winner.class` verbatim).
 * - `package-detection`: its one output class.
 *
-* `scripts/check-label-link-vocabulary.ts` fails the build if a model entry's
+* `scripts/check-label-link-vocabulary.ts` fails the build if a declared
 * `labelToEffect` names anything outside this table.
 */
-var FILLABLE_STEP_VOCABULARIES = {
+var LABEL_SUPPLY_VOCABULARIES = {
 	"animal-classifier": [
 		"bird",
 		"cat",
@@ -11336,8 +10972,8 @@ var FILLABLE_STEP_VOCABULARIES = {
 	],
 	"package-detection": ["package"]
 };
-/** The macro a detection must carry for the step to apply to it. */
-var FILLABLE_STEP_MACRO = {
+/** The macro a detection must carry for a label-kind step to apply to it. */
+var LABEL_SUPPLY_MACRO = {
 	"animal-classifier": "animal",
 	"vehicle-classifier": "vehicle",
 	"package-detection": "package"
@@ -11354,49 +10990,75 @@ var EFFECT_ALIASES = {
 	},
 	"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;
-}
+var CROP_SUPPLY_SOURCES = {
+	"plate-detection": {
+		rootLabels: ["license_plate"],
+		parentMacro: "vehicle",
+		childClass: "plate",
+		servedChildSteps: ["plate-ocr"],
+		use: "as-output"
+	},
+	"face-detection": {
+		rootLabels: ["face"],
+		parentMacro: "person",
+		childClass: "face",
+		servedChildSteps: ["face-embedding"],
+		use: "refine",
+		minRootInputPx: 640
+	}
+};
 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);
+	return LABEL_SUPPLY_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.
+* Which steps a root detector can supply, from its labelmap and classMap.
+*
+* - label kind: a label counts for a step only when the classMap sends it to
+*   that step's macro AND it names a vocabulary entry. Every root is judged
+*   the same way — a COCO model supplies the animal classifier with the six
+*   species COCO names, exactly as a Frigate+ model supplies seven.
+* - crop kind: the labelmap carries one of the step's root labels. Those
+*   labels are deliberately left out of the classMap, so they never make a
+*   track of their own.
+*
+* No classMap ⇒ no label supply (nothing says which macro a label lives under).
 */
-function deriveClassifierFills(labels, classMap) {
-	if (classMap === void 0 || isCocoLabelmap(labels)) return [];
-	const fills = [];
-	for (const stepId of FILLABLE_STEP_IDS) {
+function deriveRootSupplies(labels, classMap) {
+	const supplies = [];
+	if (classMap !== void 0) for (const stepId of LABEL_SUPPLY_STEP_IDS) {
 		const labelToEffect = {};
 		for (const label of labels) {
-			if (classMap.mapping[label] !== FILLABLE_STEP_MACRO[stepId]) continue;
+			if (classMap.mapping[label] !== LABEL_SUPPLY_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({
+		const uncovered = LABEL_SUPPLY_VOCABULARIES[stepId].filter((v) => !covered.has(v));
+		supplies.push({
+			kind: "label",
 			stepId,
 			labelToEffect,
 			uncovered
 		});
 	}
-	return fills;
+	const present = new Set(labels);
+	for (const stepId of CROP_SUPPLY_STEP_IDS) {
+		const source = CROP_SUPPLY_SOURCES[stepId];
+		const rootLabels = source.rootLabels.filter((l) => present.has(l));
+		if (rootLabels.length === 0) continue;
+		supplies.push({
+			kind: "crop",
+			stepId,
+			rootLabels,
+			parentMacro: source.parentMacro,
+			childClass: source.childClass
+		});
+	}
+	return supplies;
 }
 var MODEL_FORMATS = [
 	"onnx",
@@ -11530,12 +11192,35 @@ 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),
+/**
+* One step a ROOT detector can supply from its own output (D730) — see
+* `ModelCatalogEntry.suppliesSteps`.
+*
+* - `label`: the root's raw class IS the step's answer. `labelToEffect` maps
+*   the root's label to the step's vocabulary; `uncovered` is the vocabulary
+*   the root cannot produce (shown as unavailable, never a blocker).
+* - `crop`: the root draws the box the step would have found (`license_plate`
+*   for plate-detection, `face` for face-detection). The box becomes a detail
+*   child of the `parentMacro` detection that contains it — never a track.
+*/
+var RootStepSupplySchema = discriminatedUnion("kind", [object({
+	kind: literal("label"),
+	stepId: _enum(LABEL_SUPPLY_STEP_IDS),
 	labelToEffect: record(string(), string()),
 	uncovered: array(string()).readonly()
-});
+}), object({
+	kind: literal("crop"),
+	stepId: _enum(CROP_SUPPLY_STEP_IDS),
+	rootLabels: array(string()).readonly(),
+	parentMacro: _enum(["vehicle", "person"]),
+	childClass: _enum(["plate", "face"]),
+	/**
+	* The root's smaller input side, stamped on read by `rootSuppliesOf` from
+	* the model entry — what a step's `minRootInputPx` gate judges. Never
+	* stored by an import.
+	*/
+	rootInputPx: number().int().positive().optional()
+})]);
 var ModelCatalogEntrySchema = object({
 	id: string(),
 	name: string(),
@@ -11662,15 +11347,15 @@ 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`).
+	* The pipeline steps this ROOT detector can supply from its own output
+	* (D730): its labels name a step's effect (`deer` for `animal-classifier`)
+	* or draw a step's box (`license_plate` for `plate-detection`). Computed at
+	* import from THIS model's labelmap by `deriveRootSupplies`, never written
+	* by hand and never assumed per family; a row without it is derived on read
+	* (`rootSuppliesOf`). Whether a camera uses it is the step's own
+	* `useRootModel` flag (`resolveRootSupply`).
 	*/
-	fillsClassifierEffects: array(FillsClassifierEffectSchema).readonly().optional(),
+	suppliesSteps: array(RootStepSupplySchema).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
@@ -18632,6 +18317,51 @@ 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",
@@ -19389,6 +19119,8 @@ var NcSystemEventKindSchema = _enum([
 	"stream-offline",
 	"node-online",
 	"node-offline",
+	"node-restarting",
+	"node-updating",
 	"node-inference-unavailable",
 	"detection-blind",
 	"addon-crash-loop",
@@ -23906,6 +23638,34 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	timestamp: number()
 });
 /**
+* A root model's boxes standing in for one crop-kind step's own inference
+* (D730) — see `runPipeline.suppliedRoot`.
+*/
+var SuppliedRootOutputSchema = object({
+	stepId: string(),
+	/** The root model that drew the boxes — stamped on the result. */
+	modelId: string(),
+	detections: array(object({
+		/** `[x1, y1, x2, y2]` in the pixels of the call's image. */
+		bbox: tuple([
+			number(),
+			number(),
+			number(),
+			number()
+		]),
+		score: number(),
+		/**
+		* Five facial landmarks in the same pixels — a face the step's own
+		* detector already re-found inside a root face box (D730), so its
+		* embedder child aligns it exactly as it aligns any detected face.
+		*/
+		landmarks: array(object({
+			x: number(),
+			y: number()
+		})).optional()
+	})).min(1)
+});
+/**
 * Reference to the frame's retained NATIVE surface + the parent crop's placement
 * within the frame, so the executor can re-cut a leaf child ROI at native
 * resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
@@ -24036,7 +23796,7 @@ var PipelineModelOptionSchema = object({
 	legacy: boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
 	defaultConfidence: number().optional(),
-	fillsClassifierEffects: array(FillsClassifierEffectSchema).readonly().optional()
+	suppliesSteps: array(RootStepSupplySchema).readonly().optional()
 });
 var ConfigFieldBridge = custom();
 var PipelineAddonSchemaSchema = object({
@@ -24304,7 +24064,16 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	* `device-not-servable`), and nothing reaches the camera's live
 	* trace stream. Absent ⇒ unchanged behaviour.
 	*/
-	replay: literal(true).optional()
+	replay: literal(true).optional(),
+	/**
+	* Root-supplied detections for the tree's ROOT step (D730). Set by
+	* `runDetailSubtree` when the camera's root model supplies a crop-kind
+	* step (a Frigate+ `license_plate` for `plate-detection`): the step is
+	* NOT inferred, these boxes are its output, and its children (the plate
+	* reader) run on them through their own crop policy. Boxes are in the
+	* PIXELS of the image this call carries. Absent ⇒ the root step runs.
+	*/
+	suppliedRoot: SuppliedRootOutputSchema.optional()
 }), PipelineRunResultBridge, { kind: "mutation" }), method(object({
 	steps: array(PipelineStepInputSchema).min(1),
 	frames: array(FrameInputSchema).min(1).max(255),
@@ -25406,7 +25175,22 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 	*/
 	cropJpeg: string().optional(),
 	parent: DetailParentSchema,
-	steps: array(string()).optional()
+	steps: array(string()).optional(),
+	/**
+	* The camera's root model already drew this step's boxes (D730): a
+	* `license_plate` inside the parent vehicle. The named step is NOT
+	* inferred — these FRAME-space boxes are its output — and its
+	* requested children (the plate reader) run on them. Absent ⇒ every
+	* requested step infers as before.
+	*/
+	supplied: object({
+		stepId: string(),
+		modelId: string(),
+		boxes: array(object({
+			bbox: NativeCropBboxSchema,
+			score: number()
+		})).min(1)
+	}).optional()
 }), object({ details: array(DetailResultSchema) }).nullable(), { kind: "mutation" }), method(object({
 	/** Catalog step id, e.g. `clip-embedding`. */
 	stepId: string(),
@@ -31484,6 +31268,27 @@ var ViewerEndpointsSchema = object({
 	/** What the ranking currently resolves to (may be empty if nothing is up). */
 	resolved: array(string()).readonly()
 });
+/**
+* One audience's hub address (see `hub-address.ts`): the operator's stored
+* override, the address in use, and where it came from.
+*/
+var HubAddressSnapshotSchema = object({
+	/** The operator's override, or null for automatic. */
+	override: string().nullable(),
+	/** The address in use, or null when nothing qualifies (never loopback). */
+	resolved: string().nullable(),
+	source: _enum([
+		"override",
+		"auto",
+		"none"
+	])
+});
+var HubAddressesSchema = object({
+	/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
+	cluster: HubAddressSnapshotSchema,
+	/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
+	browser: HubAddressSnapshotSchema
+});
 var AllowedAddressesSchema = object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -31530,7 +31335,13 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 	*  an address notification links can be flagged with, not a hub
 	*  route. Default `false`: racers and rankers never see it. */
 	includeAppLink: boolean().optional()
-}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
+}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(_void(), HubAddressesSchema), method(object({
+	audience: _enum(["cluster", "browser"]),
+	baseUrl: string().nullable()
+}), HubAddressesSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -31920,7 +31731,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.
@@ -37114,17 +36926,18 @@ function buildFrigateClassMap(labels) {
 	};
 }
 /**
-* 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.
+* Everything a Frigate / Frigate+ entry derives from ITS OWN labelmap: the
+* classMap and the steps it can supply (D730) — label and crop kinds alike.
+* Every Frigate builder spreads this at import, so the two cannot be derived
+* from different label lists, and no family is assumed to carry a label it
+* does not list.
 */
 function frigateLabelFields(labels) {
 	const classMap = buildFrigateClassMap(labels);
-	const fills = deriveClassifierFills(labels, classMap);
-	return fills.length > 0 ? {
+	const supplies = deriveRootSupplies(labels, classMap);
+	return supplies.length > 0 ? {
 		classMap,
-		fillsClassifierEffects: fills
+		suppliesSteps: supplies
 	} : { classMap };
 }
 /**
@@ -40073,6 +39886,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getHubAddresses": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -40127,6 +39946,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setHubAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.setNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -48526,6 +48351,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",
@@ -48603,6 +48430,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
@@ -48624,6 +48452,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Server & container updates",
 		kinds: [
 			"server-update-available",
+			"node-updating",
 			"server-updated",
 			"wrapper-update-available"
 		]
@@ -48771,6 +48600,7 @@ var STATE_SUMMARY_SECTION_VARS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
@@ -48792,6 +48622,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"
 		]
@@ -48824,7 +48655,7 @@ var STATE_SUMMARY_VARS = [
 	{
 		name: "summarySection",
 		label: "Summary: this section",
-		description: "The section a per-section summary row is about (D698); on a summary sent as one message, every section it reports, comma-separated.",
+		description: "The section a per-section summary row is about; on a summary sent as one message, every section it reports, comma-separated.",
 		example: "Batterie scariche",
 		group: "system",
 		families: ["rule"],