@camstack/types 1.2.307 → 1.2.309

package/dist/capabilities/pipeline-executor.cap.d.ts

@@ -4,6 +4,23 @@ import type { InferenceCapabilities, ModelAvailability } from '../interfaces/inf
 import type { AudioResult, FrameResult } from '../types/detection.js';
 import type { PipelineConfig } from '../types/pipeline.js';
 import { type InferProvider } from './capability-definition.js';
+/**
+ * A root model's boxes standing in for one crop-kind step's own inference
+ * (D730) — see `runPipeline.suppliedRoot`.
+ */
+export declare const SuppliedRootOutputSchema: z.ZodObject<{
+    stepId: z.ZodString;
+    modelId: z.ZodString;
+    detections: z.ZodArray<z.ZodObject<{
+        bbox: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        score: z.ZodNumber;
+        landmarks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SuppliedRootOutput = z.infer<typeof SuppliedRootOutputSchema>;
 /**
  * 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
@@ -204,7 +221,8 @@ declare const PipelineModelOptionSchema: z.ZodObject<{
         scrypted: "scrypted";
     }>>;
     defaultConfidence: z.ZodOptional<z.ZodNumber>;
-    fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+    suppliesSteps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"label">;
         stepId: z.ZodEnum<{
             "animal-classifier": "animal-classifier";
             "vehicle-classifier": "vehicle-classifier";
@@ -212,7 +230,23 @@ declare const PipelineModelOptionSchema: z.ZodObject<{
         }>;
         labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
         uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"crop">;
+        stepId: z.ZodEnum<{
+            "plate-detection": "plate-detection";
+            "face-detection": "face-detection";
+        }>;
+        rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        parentMacro: z.ZodEnum<{
+            person: "person";
+            vehicle: "vehicle";
+        }>;
+        childClass: z.ZodEnum<{
+            face: "face";
+            plate: "plate";
+        }>;
+        rootInputPx: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>], "kind">>>>;
 }, z.core.$strip>;
 declare const PipelineAddonSchemaSchema: z.ZodObject<{
     id: z.ZodString;
@@ -261,7 +295,8 @@ declare const PipelineAddonSchemaSchema: z.ZodObject<{
             scrypted: "scrypted";
         }>>;
         defaultConfidence: z.ZodOptional<z.ZodNumber>;
-        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        suppliesSteps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"label">;
             stepId: z.ZodEnum<{
                 "animal-classifier": "animal-classifier";
                 "vehicle-classifier": "vehicle-classifier";
@@ -269,7 +304,23 @@ declare const PipelineAddonSchemaSchema: z.ZodObject<{
             }>;
             labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
             uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"crop">;
+            stepId: z.ZodEnum<{
+                "plate-detection": "plate-detection";
+                "face-detection": "face-detection";
+            }>;
+            rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            parentMacro: z.ZodEnum<{
+                person: "person";
+                vehicle: "vehicle";
+            }>;
+            childClass: z.ZodEnum<{
+                face: "face";
+                plate: "plate";
+            }>;
+            rootInputPx: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>], "kind">>>>;
     }, z.core.$strip>>>;
     defaultModelId: z.ZodString;
     defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -343,7 +394,8 @@ declare const PipelineSlotSchemaSchema: z.ZodObject<{
                 scrypted: "scrypted";
             }>>;
             defaultConfidence: z.ZodOptional<z.ZodNumber>;
-            fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            suppliesSteps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"label">;
                 stepId: z.ZodEnum<{
                     "animal-classifier": "animal-classifier";
                     "vehicle-classifier": "vehicle-classifier";
@@ -351,7 +403,23 @@ declare const PipelineSlotSchemaSchema: z.ZodObject<{
                 }>;
                 labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
                 uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"crop">;
+                stepId: z.ZodEnum<{
+                    "plate-detection": "plate-detection";
+                    "face-detection": "face-detection";
+                }>;
+                rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                parentMacro: z.ZodEnum<{
+                    person: "person";
+                    vehicle: "vehicle";
+                }>;
+                childClass: z.ZodEnum<{
+                    face: "face";
+                    plate: "plate";
+                }>;
+                rootInputPx: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "kind">>>>;
         }, z.core.$strip>>>;
         defaultModelId: z.ZodString;
         defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -461,7 +529,8 @@ declare const PipelineSchemaSchema: z.ZodObject<{
                     scrypted: "scrypted";
                 }>>;
                 defaultConfidence: z.ZodOptional<z.ZodNumber>;
-                fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                suppliesSteps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"label">;
                     stepId: z.ZodEnum<{
                         "animal-classifier": "animal-classifier";
                         "vehicle-classifier": "vehicle-classifier";
@@ -469,7 +538,23 @@ declare const PipelineSchemaSchema: z.ZodObject<{
                     }>;
                     labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
                     uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-                }, z.core.$strip>>>>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"crop">;
+                    stepId: z.ZodEnum<{
+                        "plate-detection": "plate-detection";
+                        "face-detection": "face-detection";
+                    }>;
+                    rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                    parentMacro: z.ZodEnum<{
+                        person: "person";
+                        vehicle: "vehicle";
+                    }>;
+                    childClass: z.ZodEnum<{
+                        face: "face";
+                        plate: "plate";
+                    }>;
+                    rootInputPx: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>], "kind">>>>;
             }, z.core.$strip>>>;
             defaultModelId: z.ZodString;
             defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -825,7 +910,8 @@ export declare const pipelineExecutorCapability: {
                             scrypted: "scrypted";
                         }>>;
                         defaultConfidence: z.ZodOptional<z.ZodNumber>;
-                        fillsClassifierEffects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                        suppliesSteps: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                            kind: z.ZodLiteral<"label">;
                             stepId: z.ZodEnum<{
                                 "animal-classifier": "animal-classifier";
                                 "vehicle-classifier": "vehicle-classifier";
@@ -833,7 +919,23 @@ export declare const pipelineExecutorCapability: {
                             }>;
                             labelToEffect: z.ZodRecord<z.ZodString, z.ZodString>;
                             uncovered: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-                        }, z.core.$strip>>>>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"crop">;
+                            stepId: z.ZodEnum<{
+                                "plate-detection": "plate-detection";
+                                "face-detection": "face-detection";
+                            }>;
+                            rootLabels: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                            parentMacro: z.ZodEnum<{
+                                person: "person";
+                                vehicle: "vehicle";
+                            }>;
+                            childClass: z.ZodEnum<{
+                                face: "face";
+                                plate: "plate";
+                            }>;
+                            rootInputPx: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strip>], "kind">>>>;
                     }, z.core.$strip>>>;
                     defaultModelId: z.ZodString;
                     defaultModelIdByFormat: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -1113,6 +1215,18 @@ export declare const pipelineExecutorCapability: {
                 }, z.core.$strip>;
             }, z.core.$strip>>;
             replay: z.ZodOptional<z.ZodLiteral<true>>;
+            suppliedRoot: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodString;
+                detections: z.ZodArray<z.ZodObject<{
+                    bbox: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    score: z.ZodNumber;
+                    landmarks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodCustom<FrameResult, FrameResult>, "mutation">;
         /**
          * Batched run — N raw frames packed into one cap call. The provider

package/dist/capabilities/pipeline-runner.cap.d.ts

@@ -1085,6 +1085,19 @@ export declare const pipelineRunnerCapability: {
                 className: z.ZodString;
             }, z.core.$strip>;
             steps: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            supplied: z.ZodOptional<z.ZodObject<{
+                stepId: z.ZodString;
+                modelId: z.ZodString;
+                boxes: z.ZodArray<z.ZodObject<{
+                    bbox: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        w: z.ZodNumber;
+                        h: z.ZodNumber;
+                    }, z.core.$strip>;
+                    score: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
             details: z.ZodArray<z.ZodObject<{
                 stepId: z.ZodString;

package/dist/catalogs/frigate-plus-classmap.d.ts

@@ -1,5 +1,5 @@
 import { CLASS_MAP_MACRO_TARGETS, type DetectionCatalogClassMap } from '../types/labels.js';
-import { type ClassifierFillDeclaration } from './classifier-fill.js';
+import type { RootStepSupply } from '../types/models.js';
 /** A macro a detection catalog classMap may resolve to. */
 export type ClassMapMacroTarget = (typeof CLASS_MAP_MACRO_TARGETS)[number];
 /**
@@ -22,7 +22,9 @@ export declare const FRIGATE_PLUS_TO_MACRO: Readonly<Record<string, ClassMapMacr
  * - `attribute`: Frigate+ emits these INSIDE a parent box (a face inside a
  *   person, a plate or a carrier logo on a vehicle). Mapping one to its
  *   parent's macro would spawn a second, overlapping track for the same
- *   subject; CamStack derives faces and plates with its own detail steps.
+ *   subject. `face` and `license_plate` are instead declared as CROP supplies
+ *   (D730): the box becomes a detail child of the person / vehicle containing
+ *   it, when the face / plate step uses the root model.
  * - `no-macro`: an object with no detection macro to live under.
  */
 export declare const FRIGATE_PLUS_UNMAPPED_LABELS: Readonly<Record<string, 'attribute' | 'no-macro'>>;
@@ -38,12 +40,13 @@ export declare function buildFrigateClassMap(labels: readonly string[]): Detecti
 /** The label-derived fields of a Frigate catalog entry. */
 export interface FrigateLabelFields {
     readonly classMap: DetectionCatalogClassMap;
-    readonly fillsClassifierEffects?: readonly ClassifierFillDeclaration[];
+    readonly suppliesSteps?: readonly RootStepSupply[];
 }
 /**
- * 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.
  */
 export declare function frigateLabelFields(labels: readonly string[]): FrigateLabelFields;

package/dist/catalogs/index.d.ts

@@ -1,6 +1,6 @@
 export * from './coco-classmap.js';
 export * from './frigate-plus-classmap.js';
-export * from './classifier-fill.js';
+export * from './root-model-supply.js';
 export * from './sensor-active-state.js';
 export * from './audio-classmap.js';
 export * from './event-taxonomy.js';

package/dist/catalogs/root-model-supply.d.ts

@@ -0,0 +1,202 @@
+/**
+ * Root-model supply — the ONE place that says which pipeline steps a root
+ * detector can supply from its own output, how, and whether the camera uses it.
+ *
+ * A root detector's labels can already be the effect a step exists to produce:
+ * a Frigate+ model emits `deer`, `car`, `package`, a COCO model emits `dog`,
+ * `bus`. Some also emit the CHILD boxes a detail step exists to find: a
+ * Frigate+ `license_plate` inside a car, a `face` inside a person. Every root
+ * model DECLARES what it can supply (`ModelCatalogEntry.suppliesSteps`),
+ * derived from its own labelmap and classMap by {@link deriveRootSupplies} —
+ * never assumed per family. Whether a camera USES that is the step's own
+ * `useRootModel` flag, an operator intent kept beside the step's `modelId`
+ * and never touching it (D730). {@link resolveRootSupply} is the one decision
+ * the runner, the detail dispatcher and the admin UI all read.
+ *
+ * Two kinds of supply:
+ * - `label` — the root's raw class IS the step's answer (`deer` for the animal
+ *   classifier). The detection carries it as a linked label.
+ * - `crop` — the root draws the box the step would have found (a plate inside
+ *   a vehicle). The box becomes a detail child of the parent that contains it,
+ *   never a track of its own (D683).
+ *
+ * Pure — no I/O, no clock.
+ */
+import type { ModelCatalogEntry, RootStepSupply } from '../types/models.js';
+/** Steps whose effect a root label can BE. */
+export declare const LABEL_SUPPLY_STEP_IDS: readonly ["animal-classifier", "vehicle-classifier", "package-detection"];
+export type LabelSupplyStepId = (typeof LABEL_SUPPLY_STEP_IDS)[number];
+/** Steps whose box a root detection can BE. */
+export declare const CROP_SUPPLY_STEP_IDS: readonly ["plate-detection", "face-detection"];
+export type CropSupplyStepId = (typeof CROP_SUPPLY_STEP_IDS)[number];
+/** Every step a root model can supply. */
+export declare const ROOT_SUPPLIABLE_STEP_IDS: readonly ["animal-classifier", "vehicle-classifier", "package-detection", "plate-detection", "face-detection"];
+export type RootSuppliableStepId = LabelSupplyStepId | CropSupplyStepId;
+/** Narrow a step id to a suppliable one — type guard, not a cast. */
+export declare function isRootSuppliableStepId(value: string): value is RootSuppliableStepId;
+/** Narrow a step id to a label-kind one. */
+export declare function isLabelSupplyStepId(value: string): value is LabelSupplyStepId;
+/**
+ * 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`: 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 declared
+ * `labelToEffect` names anything outside this table.
+ */
+export declare const LABEL_SUPPLY_VOCABULARIES: Readonly<Record<LabelSupplyStepId, readonly string[]>>;
+/** The macro a detection must carry for a label-kind step to apply to it. */
+export declare const LABEL_SUPPLY_MACRO: Readonly<Record<LabelSupplyStepId, string>>;
+/** What a crop-kind supply is made of. */
+export interface CropSupplySource {
+    /** Raw root labels that ARE this step's box. */
+    readonly rootLabels: readonly string[];
+    /** The macro of the parent the box must lie inside. */
+    readonly parentMacro: 'vehicle' | 'person';
+    /** The detail class the box becomes. */
+    readonly childClass: 'plate' | 'face';
+    /**
+     * The step's own children that still run on the root's box: `plate-ocr`
+     * reads a root plate, `face-embedding` embeds a refined root face.
+     */
+    readonly servedChildSteps: readonly string[];
+    /**
+     * How the root's box stands in for the step's inference.
+     * - `as-output`: the box IS the step's output (a plate box goes straight to
+     *   the reader).
+     * - `refine`: the box is only a LOCATION. The step's own detector re-finds
+     *   the subject inside a square around it (`deriveRootFaceRefineRect`) so
+     *   its children get what they need — a face's landmarks — and nothing
+     *   unaligned ever reaches the embedder. No face found ⇒ nothing.
+     */
+    readonly use: 'as-output' | 'refine';
+    /**
+     * The root's smallest input side for the supply to be in force. A root that
+     * sees the frame smaller than this misses too many of these boxes to be the
+     * source (a 320 px root loses ~60% of the faces a 640 one finds on 4K
+     * cameras). Absent ⇒ any root.
+     */
+    readonly minRootInputPx?: number;
+}
+export declare const CROP_SUPPLY_SOURCES: Readonly<Record<CropSupplyStepId, CropSupplySource>>;
+/**
+ * Whether an operator intends a step to take the root's output when the
+ * root declares it — the default of the `useRootModel` flag. The label kinds
+ * default ON: the detector's answer is the cheaper one and the classifier
+ * keeps its model for the day the root changes. The crop kinds default OFF: a
+ * root plate box has an uncalibrated OCR margin, and root-face refinement has
+ * not run on live traffic yet.
+ */
+export declare const USE_ROOT_MODEL_DEFAULTS: Readonly<Record<RootSuppliableStepId, boolean>>;
+/** The step-settings key the flag is stored under (DeviceStepConfig.settings, camera overrides). */
+export declare const USE_ROOT_MODEL_SETTING_KEY = "useRootModel";
+/** `ScoredLabel.stepId` prefix of a label the detector wrote for a step. */
+export declare const LINKED_LABEL_STEP_PREFIX = "detector-link:";
+/** `detector-link:<stepId>` — the attribution of a linked label. */
+export declare function linkedLabelStepId(stepId: LabelSupplyStepId): string;
+/** The step a linked label stands in for, or `undefined` for any other attribution. */
+export declare function linkedStepOf(attributionStepId: string | undefined): LabelSupplyStepId | undefined;
+/** The classMap shape the derivation reads. */
+export interface SupplyClassMap {
+    readonly mapping: Readonly<Record<string, string>>;
+}
+/**
+ * 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).
+ */
+export declare function deriveRootSupplies(labels: readonly string[], classMap: SupplyClassMap | undefined): readonly RootStepSupply[];
+/** What a step definition contributes when a model entry carries no labels/classMap of its own. */
+export interface RootSupplyStepDefaults {
+    readonly labels: readonly string[];
+    readonly classMap?: SupplyClassMap;
+}
+/**
+ * The supplies a root model declares. A row registered with a declaration
+ * carries it (`suppliesSteps`, computed at import from the model's own
+ * labelmap); a row without one — a built-in entry, or a custom row registered
+ * before the field existed — is derived here, on read, from the same inputs.
+ */
+export declare function rootSuppliesOf(entry: Pick<ModelCatalogEntry, 'labels' | 'classMap' | 'suppliesSteps' | 'inputSize'> | undefined, stepDefaults: RootSupplyStepDefaults): readonly RootStepSupply[];
+/** The supply a root declares for one step, if any. */
+export declare function supplyFor(supplies: readonly RootStepSupply[] | undefined, stepId: string): RootStepSupply | undefined;
+/**
+ * Read the `useRootModel` flag off a step's settings bag. Absent ⇒ the
+ * retired `labelLink` value if one is stored, else the step's default.
+ */
+export declare function readUseRootModel(stepId: RootSuppliableStepId, settings: Readonly<Record<string, unknown>> | undefined): boolean;
+/** One step's root-supply state for one camera (or one node/device column). */
+export interface RootSupplyState {
+    readonly stepId: RootSuppliableStepId;
+    /** What the current root declares for this step, if anything. */
+    readonly supply: RootStepSupply | undefined;
+    /** The operator's `useRootModel` intent (stored or default). */
+    readonly intent: boolean;
+    /**
+     * The root's output IS this step's result: the step's own inference does
+     * not run and the root's linked label / child box is authoritative.
+     * `intent && supply && nothing blocks it`.
+     */
+    readonly effective: boolean;
+    /** Intent is on but the current root cannot supply the step. */
+    readonly inactive: boolean;
+    /** Why an intended supply is not in force — present iff `inactive`. */
+    readonly inactiveReason?: RootSupplyInactiveReason;
+}
+/**
+ * Why an intended root supply is not in force.
+ * - `root-does-not-declare`: the root's labels cannot supply the step.
+ * - `root-input-too-small`: they can, but the root sees the frame smaller than
+ *   the step's `minRootInputPx` (or its input size is unknown).
+ */
+export type RootSupplyInactiveReason = 'root-does-not-declare' | 'root-input-too-small';
+/**
+ * THE decision. Effective = the operator intends it AND the current root
+ * declares it. It never looks at, changes or clears the step's `modelId`: a
+ * root that cannot supply the step leaves the step running its own model, and
+ * switching back to a root that can re-activates the supply by itself.
+ */
+export declare function resolveRootSupply(stepId: RootSuppliableStepId, settings: Readonly<Record<string, unknown>> | undefined, rootSupplies: readonly RootStepSupply[] | undefined): RootSupplyState;
+/**
+ * The fine label a supplied root class becomes for a step whose supply is
+ * effective, or `undefined` when the step's `enabledClasses` switched it off —
+ * the detection then stays at its macro (`animal`). Empty / absent allow-list
+ * = every class.
+ */
+export declare function allowedSuppliedEffect(effect: string, settings: Readonly<Record<string, unknown>> | undefined): boolean;
+/** The child steps of a crop-kind step that still run on the root's box. */
+export declare function rootSupplyServes(stepId: CropSupplyStepId): readonly string[];
+/** Minimum fraction of a child box's area that must lie inside its parent. */
+export declare const ROOT_CHILD_CONTAINMENT_MIN = 0.9;
+/** An axis-aligned box in one pixel space. */
+export interface SupplyBox {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+/**
+ * The parent a root child box belongs to: among `parents`, the SMALLEST whose
+ * box holds at least {@link ROOT_CHILD_CONTAINMENT_MIN} of the child's area
+ * (a plate inside the car, not inside the bus behind it). `-1` when none does
+ * — the box then belongs to nobody and makes nothing.
+ */
+export declare function containingParentIndex(child: SupplyBox, parents: readonly SupplyBox[]): number;
+/** One short phrase per supply — `animals 6/8`, `plates`. */
+export declare function describeRootSupply(supply: RootStepSupply): string;
+/** `animals 6/8 · vehicles 5/8 · plates · faces` — empty string for none. */
+export declare function describeRootSupplies(supplies: readonly RootStepSupply[] | undefined): string;

package/dist/client.js

@@ -415,54 +415,6 @@ zod.z.object({
 	resolution: CamStreamResolutionSchema.optional()
 });
 //#endregion
-//#region src/catalogs/coco-classmap.ts
-var MACRO_LABELS = [
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-];
-new Set(MACRO_LABELS.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
-};
-//#endregion
 //#region src/catalogs/sensor-active-state.ts
 /**
 * THE table "which boolean of this device type counts as HIGH", and the
@@ -1044,6 +996,54 @@ method(zod.z.object({}), zod.z.array(TargetKindSchema)), method(zod.z.object({})
 	auth: "admin"
 });
 //#endregion
+//#region src/catalogs/coco-classmap.ts
+var MACRO_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+];
+new Set(MACRO_LABELS.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
+};
+//#endregion
 //#region src/catalogs/audio-classmap.ts
 var AUDIO_MACRO_LABELS = [
 	{
@@ -7305,6 +7305,8 @@ function createSystemProxy(api) {
 			setNotificationEndpoint: (input) => dispatch("localNetwork", "setNotificationEndpoint", "mutation", input),
 			getViewerEndpoints: (input) => dispatch("localNetwork", "getViewerEndpoints", "query", input),
 			setViewerEndpoints: (input) => dispatch("localNetwork", "setViewerEndpoints", "mutation", input),
+			getHubAddresses: (input) => dispatch("localNetwork", "getHubAddresses", "query", input),
+			setHubAddress: (input) => dispatch("localNetwork", "setHubAddress", "mutation", input),
 			getAllowedAddresses: (input) => dispatch("localNetwork", "getAllowedAddresses", "query", input),
 			setAllowedAddresses: (input) => dispatch("localNetwork", "setAllowedAddresses", "mutation", input),
 			resetAllowlistToBestMatch: (input) => dispatch("localNetwork", "resetAllowlistToBestMatch", "mutation", input),
@@ -9068,7 +9070,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"],