@camstack/types 1.2.307 → 1.2.309

package/dist/index.js

@@ -5346,424 +5346,40 @@ function resolveClipSearchMinScore(meta, request) {
 	return Math.min(1, Math.round(meta.searchMinScore * factor * 1e3) / 1e3);
 }
 //#endregion
-//#region src/catalogs/coco-classmap.ts
-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"
-	}
-];
-var MACRO_LABELS = [
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-];
-/**
-* The class names a per-class COUNT can ever be keyed on — the macro ids, and
-* only those.
-*
-* `preserveOriginal: false` below is the whole reason this set exists: the
-* executor maps each raw COCO label onto its macro and DROPS everything else,
-* so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
-* Any surface that indexes counts by class name — the ZoneAnalytics occupancy
-* snapshot's `byClass`, and therefore every occupancy rule — can match nothing
-* else. Derived from the catalog, never hand-listed, so a new macro joins it by
-* being declared once.
-*
-* Cost of not having it, 2026-08-12: the notification rule editor offered the
-* full taxonomy for an occupancy class (occupancy is the one condition that
-* does not go through the engine's macro-expanding `expandClassSelector`), two
-* live rules were authored on `car`, and both counters read 0 forever.
-*/
-var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
-/** True when `className` is a macro the detector can actually emit (and hence a
-*  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
-function isDetectionMacroClass(className) {
-	return DETECTION_MACRO_CLASSES.has(className.trim().toLowerCase());
-}
-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/classifier-fill.ts
-/** Steps a root detector may declare it fills. */
-var FILLABLE_STEP_IDS = [
+//#region src/catalogs/root-model-supply.ts
+/** Steps whose effect a root label can BE. */
+var LABEL_SUPPLY_STEP_IDS = [
 	"animal-classifier",
 	"vehicle-classifier",
 	"package-detection"
 ];
-/** Narrow a step id to a fillable one — type guard, not a cast. */
-function isFillableStepId(value) {
-	return FILLABLE_STEP_IDS.some((id) => id === value);
+/** Steps whose box a root detection can BE. */
+var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
+/** Every step a root model can supply. */
+var ROOT_SUPPLIABLE_STEP_IDS = [...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
+/** Narrow a step id to a suppliable one — type guard, not a cast. */
+function isRootSuppliableStepId(value) {
+	return ROOT_SUPPLIABLE_STEP_IDS.some((id) => id === value);
+}
+/** Narrow a step id to a label-kind one. */
+function isLabelSupplyStepId(value) {
+	return LABEL_SUPPLY_STEP_IDS.some((id) => id === value);
 }
 /**
-* 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",
@@ -5786,8 +5402,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"
@@ -5804,12 +5420,46 @@ var EFFECT_ALIASES = {
 	},
 	"package-detection": {}
 };
-/** The policy values of a step's `labelLink` setting. */
-var LABEL_LINK_POLICIES = ["run", "skip-when-filled"];
-/** Absent setting ⇒ this. It changes nothing unless the root model declares a fill. */
-var DEFAULT_LABEL_LINK_POLICY = "skip-when-filled";
-/** The step-settings key the policy is stored under (DeviceStepConfig.settings). */
-var LABEL_LINK_SETTING_KEY = "labelLink";
+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
+	}
+};
+/**
+* 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.
+*/
+var USE_ROOT_MODEL_DEFAULTS = {
+	"animal-classifier": true,
+	"vehicle-classifier": true,
+	"package-detection": true,
+	"plate-detection": false,
+	"face-detection": false
+};
+/** The step-settings key the flag is stored under (DeviceStepConfig.settings, camera overrides). */
+var USE_ROOT_MODEL_SETTING_KEY = "useRootModel";
+/**
+* The retired D715 policy key. A `skip-when-filled` / `run` value still
+* stored under it reads as the flag (`true` / `false`) when no flag is stored
+* — the normal read path, not a migration.
+*/
+var RETIRED_LABEL_LINK_KEY = "labelLink";
 /** `ScoredLabel.stepId` prefix of a label the detector wrote for a step. */
 var LINKED_LABEL_STEP_PREFIX = "detector-link:";
 /** `detector-link:<stepId>` — the attribution of a linked label. */
@@ -5821,91 +5471,175 @@ function linkedStepOf(attributionStepId) {
 	if (attributionStepId === void 0) return void 0;
 	if (!attributionStepId.startsWith("detector-link:")) return void 0;
 	const stepId = attributionStepId.slice(14);
-	return isFillableStepId(stepId) ? stepId : void 0;
-}
-/**
-* 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;
+	return isLabelSupplyStepId(stepId) ? stepId : void 0;
 }
 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;
-}
-/** The fill a model declares for one step, if any. */
-function fillFor(entry, stepId) {
-	return entry?.fillsClassifierEffects?.find((f) => f.stepId === stepId);
-}
-/** Read the `labelLink` policy off a step's settings bag; anything else ⇒ the default. */
-function readLabelLinkPolicy(settings) {
-	const raw = settings?.[LABEL_LINK_SETTING_KEY];
-	return LABEL_LINK_POLICIES.find((p) => p === raw) ?? "skip-when-filled";
-}
-/**
-* Decide the writer of one filled effect for one camera.
-*
-* - The step is not running (disabled, or not in the camera's tree): the
-*   detector is the only writer — authoritative, nothing to skip.
-* - The step runs, the policy is `skip-when-filled` and every coverage gap is
-*   switched off in `enabledClasses`: the detector is authoritative and the
-*   step is skipped.
-* - Otherwise the step runs and is the writer; the linked label is a score-0
-*   fallback.
-*/
-function resolveLabelLink(fill, step) {
-	const policy = readLabelLinkPolicy(step?.settings);
-	const rawEnabled = step?.settings?.["enabledClasses"];
-	const allowList = Array.isArray(rawEnabled) && rawEnabled.length > 0 ? rawEnabled.filter((v) => typeof v === "string") : null;
-	const openGaps = fill.uncovered.filter((g) => allowList === null || allowList.includes(g));
-	if (step === void 0 || !step.enabled) return {
-		authoritative: true,
-		skip: false,
-		policy,
-		openGaps
-	};
-	const skip = policy === "skip-when-filled" && openGaps.length === 0;
+	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;
+}
+/**
+* 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.
+*/
+function rootSuppliesOf(entry, stepDefaults) {
+	const declared = entry?.suppliesSteps ?? deriveRootSupplies(entry !== void 0 && entry.labels.length > 0 ? entry.labels.map((l) => l.id) : stepDefaults.labels, entry?.classMap ?? stepDefaults.classMap);
+	const inputPx = entry !== void 0 ? Math.min(entry.inputSize.width, entry.inputSize.height) : void 0;
+	if (inputPx === void 0) return declared;
+	return declared.map((s) => s.kind === "crop" ? {
+		...s,
+		rootInputPx: inputPx
+	} : s);
+}
+/** The supply a root declares for one step, if any. */
+function supplyFor(supplies, stepId) {
+	return supplies?.find((s) => s.stepId === stepId);
+}
+/**
+* Read the `useRootModel` flag off a step's settings bag. Absent ⇒ the
+* retired `labelLink` value if one is stored, else the step's default.
+*/
+function readUseRootModel(stepId, settings) {
+	const raw = settings?.[USE_ROOT_MODEL_SETTING_KEY];
+	if (typeof raw === "boolean") return raw;
+	const retired = settings?.[RETIRED_LABEL_LINK_KEY];
+	if (retired === "skip-when-filled") return true;
+	if (retired === "run") return false;
+	return USE_ROOT_MODEL_DEFAULTS[stepId];
+}
+/** Why a DECLARED supply is still not usable, or `undefined` when it is. */
+function supplyBlocker(supply) {
+	if (supply.kind !== "crop") return void 0;
+	const min = CROP_SUPPLY_SOURCES[supply.stepId].minRootInputPx;
+	if (min === void 0) return void 0;
+	return supply.rootInputPx !== void 0 && supply.rootInputPx >= min ? void 0 : "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.
+*/
+function resolveRootSupply(stepId, settings, rootSupplies) {
+	const supply = supplyFor(rootSupplies, stepId);
+	const intent = readUseRootModel(stepId, settings);
+	const blocker = supply === void 0 ? "root-does-not-declare" : supplyBlocker(supply);
 	return {
-		authoritative: skip,
-		skip,
-		policy,
-		openGaps
+		stepId,
+		supply,
+		intent,
+		effective: intent && blocker === void 0,
+		inactive: intent && blocker !== void 0,
+		...intent && blocker !== void 0 ? { inactiveReason: blocker } : {}
 	};
 }
+/**
+* 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.
+*/
+function allowedSuppliedEffect(effect, settings) {
+	const raw = settings?.["enabledClasses"];
+	if (!Array.isArray(raw) || raw.length === 0) return true;
+	return raw.some((v) => v === effect);
+}
+/** The child steps of a crop-kind step that still run on the root's box. */
+function rootSupplyServes(stepId) {
+	return CROP_SUPPLY_SOURCES[stepId].servedChildSteps;
+}
+/** Minimum fraction of a child box's area that must lie inside its parent. */
+var ROOT_CHILD_CONTAINMENT_MIN = .9;
+/**
+* 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.
+*/
+function containingParentIndex(child, parents) {
+	const childArea = child.w * child.h;
+	if (!(childArea > 0)) return -1;
+	let best = -1;
+	let bestArea = Number.POSITIVE_INFINITY;
+	parents.forEach((p, i) => {
+		if (Math.max(0, Math.min(child.x + child.w, p.x + p.w) - Math.max(child.x, p.x)) * Math.max(0, Math.min(child.y + child.h, p.y + p.h) - Math.max(child.y, p.y)) / childArea < .9) return;
+		const area = p.w * p.h;
+		if (area < bestArea) {
+			best = i;
+			bestArea = area;
+		}
+	});
+	return best;
+}
+var SUPPLY_NOUN = {
+	"animal-classifier": "animals",
+	"vehicle-classifier": "vehicles",
+	"package-detection": "packages",
+	"plate-detection": "plates",
+	"face-detection": "faces"
+};
+/** One short phrase per supply — `animals 6/8`, `plates`. */
+function describeRootSupply(supply) {
+	const noun = SUPPLY_NOUN[supply.stepId];
+	if (supply.kind === "crop") return noun;
+	const total = LABEL_SUPPLY_VOCABULARIES[supply.stepId].length;
+	if (total <= 1) return noun;
+	return `${noun} ${String(total - supply.uncovered.length)}/${String(total)}`;
+}
+/** `animals 6/8 · vehicles 5/8 · plates · faces` — empty string for none. */
+function describeRootSupplies(supplies) {
+	return (supplies ?? []).map(describeRootSupply).join(" · ");
+}
 //#endregion
 //#region src/types/models.ts
 var MODEL_FORMATS = [
@@ -6062,12 +5796,35 @@ var ModelLicenseRecordSchema = zod.z.object({
 * `camstack/docs` → `/docs/detection/models`.
 */
 var ModelLicenseSchema = zod.z.preprocess((value) => typeof value === "string" ? { weights: value } : value, ModelLicenseRecordSchema);
-/** One `fillsClassifierEffects` entry — see `ModelCatalogEntry.fillsClassifierEffects`. */
-var FillsClassifierEffectSchema = zod.z.object({
-	stepId: zod.z.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 = zod.z.discriminatedUnion("kind", [zod.z.object({
+	kind: zod.z.literal("label"),
+	stepId: zod.z.enum(LABEL_SUPPLY_STEP_IDS),
 	labelToEffect: zod.z.record(zod.z.string(), zod.z.string()),
 	uncovered: zod.z.array(zod.z.string()).readonly()
-});
+}), zod.z.object({
+	kind: zod.z.literal("crop"),
+	stepId: zod.z.enum(CROP_SUPPLY_STEP_IDS),
+	rootLabels: zod.z.array(zod.z.string()).readonly(),
+	parentMacro: zod.z.enum(["vehicle", "person"]),
+	childClass: zod.z.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: zod.z.number().int().positive().optional()
+})]);
 var ModelCatalogEntrySchema = zod.z.object({
 	id: zod.z.string(),
 	name: zod.z.string(),
@@ -6194,15 +5951,15 @@ var ModelCatalogEntrySchema = zod.z.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: zod.z.array(FillsClassifierEffectSchema).readonly().optional(),
+	suppliesSteps: zod.z.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
@@ -10995,7 +10752,7 @@ function unavailableFor(tf, role, mode, cap, at) {
 	};
 	return {
 		ok: false,
-		problem: problem("not-replaceable", at, `\`${cap}.${tf.path}\` reads a source but can say neither null nor 'unknown', and an ADDED capability has no native reading to fall back to (D393, D663)`)
+		problem: problem("not-replaceable", at, `\`${cap}.${tf.path}\` reads a source but can say neither null nor 'unknown', and an ADDED capability has no native reading to fall back to`)
 	};
 }
 //#endregion
@@ -16359,6 +16116,151 @@ var filesystemBrowseCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/hub-address.ts
+var IPV4_LITERAL = /^\d{1,3}(?:\.\d{1,3}){3}$/;
+function hostnameOf(baseUrl) {
+	try {
+		const host = new URL(baseUrl).hostname;
+		return host.length > 0 ? host : null;
+	} catch {
+		return null;
+	}
+}
+function isMesh(endpoint) {
+	return endpoint.kind === "public" && endpoint.interfaceKind === "vpn";
+}
+function isTunnel(endpoint) {
+	return endpoint.kind === "public" && endpoint.interfaceKind === "public";
+}
+function isPlausibleLan(endpoint) {
+	return (endpoint.kind === "lan-ipv4" || endpoint.kind === "lan-ipv6") && endpoint.plausible;
+}
+function isLanIpv4Literal(endpoint) {
+	if (endpoint.kind !== "lan-ipv4" || !endpoint.plausible) return false;
+	const host = hostnameOf(endpoint.baseUrl);
+	return host !== null && IPV4_LITERAL.test(host);
+}
+/** Lower = better; `null` = never this audience's answer. */
+function rankFor(audience, endpoint) {
+	if (endpoint.kind === "loopback" || endpoint.kind === "app-link") return null;
+	if (hostnameOf(endpoint.baseUrl) === null) return null;
+	if (audience === "cluster") {
+		if (isLanIpv4Literal(endpoint)) return 0;
+		if (isPlausibleLan(endpoint)) return 1;
+		if (isMesh(endpoint)) return 2;
+		return null;
+	}
+	if (isTunnel(endpoint)) return 0;
+	if (isMesh(endpoint)) return 1;
+	if (isLanIpv4Literal(endpoint)) return 2;
+	if (isPlausibleLan(endpoint)) return 3;
+	return null;
+}
+var LOOPBACK_HOSTS = new Set([
+	"localhost",
+	"0.0.0.0",
+	"::1",
+	"[::1]",
+	"::",
+	"[::]"
+]);
+function isLoopbackHost(hostname) {
+	const h = hostname.toLowerCase();
+	if (LOOPBACK_HOSTS.has(h) || h.endsWith(".localhost")) return true;
+	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
+/**
+* Validate an operator-typed override: an http(s) URL with a host, no
+* credentials, no path, and never loopback (it would name whoever dials it).
+* Answers the normalised origin (`scheme://host[:port]`).
+*/
+function validateHubAddressOverride(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") return {
+		ok: false,
+		reason: "Enter an address, e.g. https://192.168.1.50:4443."
+	};
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return {
+			ok: false,
+			reason: "Not a URL — include http:// or https://."
+		};
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return {
+		ok: false,
+		reason: "Use an http:// or https:// address."
+	};
+	if (parsed.username !== "" || parsed.password !== "") return {
+		ok: false,
+		reason: "The address must not carry a user name or password."
+	};
+	if (parsed.hostname === "") return {
+		ok: false,
+		reason: "The address has no host."
+	};
+	if (isLoopbackHost(parsed.hostname)) return {
+		ok: false,
+		reason: "A loopback address names whoever dials it, never this hub — use an address other machines reach."
+	};
+	if (parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "") return {
+		ok: false,
+		reason: "Enter only the address (scheme, host and port), without a path."
+	};
+	return {
+		ok: true,
+		baseUrl: parsed.origin
+	};
+}
+/**
+* The hub's base URL for `audience`, without a trailing slash, or `null` when
+* the palette holds nothing that audience can reach. A valid operator
+* `override` wins outright; an empty one means automatic. Ties inside a rank
+* go to the palette's own `priority` (its preferred interface first).
+*/
+function pickHubBaseUrl(endpoints, audience, override = null) {
+	return resolveHubAddress(endpoints, audience, override).resolved;
+}
+/** {@link pickHubBaseUrl}, saying where the answer came from. */
+function resolveHubAddress(endpoints, audience, override) {
+	if (override !== null && override !== "") {
+		const check = validateHubAddressOverride(override);
+		if (check.ok) return {
+			override,
+			resolved: check.baseUrl,
+			source: "override"
+		};
+	}
+	const auto = pickFromPalette(endpoints, audience);
+	return {
+		override: override === null || override === "" ? null : override,
+		resolved: auto,
+		source: auto === null ? "none" : "auto"
+	};
+}
+function pickFromPalette(endpoints, audience) {
+	const best = endpoints.flatMap((endpoint) => {
+		const rank = rankFor(audience, endpoint);
+		return rank === null ? [] : [{
+			rank,
+			priority: endpoint.priority,
+			endpoint
+		}];
+	}).toSorted((a, b) => a.rank - b.rank || a.priority - b.priority)[0];
+	return best === void 0 ? null : best.endpoint.baseUrl.replace(/\/+$/, "");
+}
+/** The bare hostname of {@link pickHubBaseUrl}'s answer, or `null`. */
+function pickHubHostname(endpoints, audience, override = null) {
+	const baseUrl = pickHubBaseUrl(endpoints, audience, override);
+	return baseUrl === null ? null : hostnameOf(baseUrl);
+}
+/** The bare hostname of a base URL, or `null` when it does not parse. */
+function hubAddressHostname(baseUrl) {
+	return baseUrl === null ? null : hostnameOf(baseUrl);
+}
+//#endregion
 //#region src/capabilities/ai-cap-timeouts.ts
 /**
 * Transport bounds for AI capability methods.
@@ -18591,6 +18493,398 @@ var notificationOutputCapability = {
 	}
 };
 //#endregion
+//#region src/catalogs/coco-classmap.ts
+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"
+	}
+];
+var MACRO_LABELS = [
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+];
+/**
+* The class names a per-class COUNT can ever be keyed on — the macro ids, and
+* only those.
+*
+* `preserveOriginal: false` below is the whole reason this set exists: the
+* executor maps each raw COCO label onto its macro and DROPS everything else,
+* so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
+* Any surface that indexes counts by class name — the ZoneAnalytics occupancy
+* snapshot's `byClass`, and therefore every occupancy rule — can match nothing
+* else. Derived from the catalog, never hand-listed, so a new macro joins it by
+* being declared once.
+*
+* Cost of not having it, 2026-08-12: the notification rule editor offered the
+* full taxonomy for an occupancy class (occupancy is the one condition that
+* does not go through the engine's macro-expanding `expandClassSelector`), two
+* live rules were authored on `car`, and both counters read 0 forever.
+*/
+var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
+/** True when `className` is a macro the detector can actually emit (and hence a
+*  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
+function isDetectionMacroClass(className) {
+	return DETECTION_MACRO_CLASSES.has(className.trim().toLowerCase());
+}
+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 = [
 	{
@@ -21248,7 +21542,7 @@ var NC_CONDITION_CATALOG = [
 		operator: "in",
 		appliesTo: ["immediate", "track-end"],
 		phase: "P1",
-		description: "Only recognised people. Selecting NOBODY means every identity in the face gallery; selecting some narrows to those. Matched on the gallery id, so renaming a person does not break the rule. On Immediate delivery the name must already be known when an event is written — choose Immediate, grouped to wait for it (D692)."
+		description: "Only recognised people. Selecting NOBODY means every identity in the face gallery; selecting some narrows to those. Matched on the gallery id, so renaming a person does not break the rule. On Immediate delivery the name must already be known when an event is written — choose Immediate, grouped to wait for it."
 	},
 	{
 		id: "plates",
@@ -25848,6 +26142,34 @@ var pipelineAnalyticsCapability = {
 //#endregion
 //#region src/capabilities/pipeline-executor.cap.ts
 /**
+* A root model's boxes standing in for one crop-kind step's own inference
+* (D730) — see `runPipeline.suppliedRoot`.
+*/
+var SuppliedRootOutputSchema = zod.z.object({
+	stepId: zod.z.string(),
+	/** The root model that drew the boxes — stamped on the result. */
+	modelId: zod.z.string(),
+	detections: zod.z.array(zod.z.object({
+		/** `[x1, y1, x2, y2]` in the pixels of the call's image. */
+		bbox: zod.z.tuple([
+			zod.z.number(),
+			zod.z.number(),
+			zod.z.number(),
+			zod.z.number()
+		]),
+		score: zod.z.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: zod.z.array(zod.z.object({
+			x: zod.z.number(),
+			y: zod.z.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.
@@ -25979,7 +26301,7 @@ var PipelineModelOptionSchema = zod.z.object({
 	legacy: zod.z.boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
 	defaultConfidence: zod.z.number().optional(),
-	fillsClassifierEffects: zod.z.array(FillsClassifierEffectSchema).readonly().optional()
+	suppliesSteps: zod.z.array(RootStepSupplySchema).readonly().optional()
 });
 var ConfigFieldBridge = zod.z.custom();
 var PipelineAddonSchemaSchema = zod.z.object({
@@ -26383,7 +26705,16 @@ var pipelineExecutorCapability = {
 			* `device-not-servable`), and nothing reaches the camera's live
 			* trace stream. Absent ⇒ unchanged behaviour.
 			*/
-			replay: zod.z.literal(true).optional()
+			replay: zod.z.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" }),
 		/**
 		* Batched run — N raw frames packed into one cap call. The provider
@@ -27896,7 +28227,22 @@ var pipelineRunnerCapability = {
 			*/
 			cropJpeg: zod.z.string().optional(),
 			parent: DetailParentSchema,
-			steps: zod.z.array(zod.z.string()).optional()
+			steps: zod.z.array(zod.z.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: zod.z.object({
+				stepId: zod.z.string(),
+				modelId: zod.z.string(),
+				boxes: zod.z.array(zod.z.object({
+					bbox: NativeCropBboxSchema,
+					score: zod.z.number()
+				})).min(1)
+			}).optional()
 		}), zod.z.object({ details: zod.z.array(DetailResultSchema) }).nullable(), { kind: "mutation" }),
 		/**
 		* Run ONE enrichment step against caller-supplied pixels, with NO camera
@@ -37596,6 +37942,27 @@ var ViewerEndpointsSchema = zod.z.object({
 	/** What the ranking currently resolves to (may be empty if nothing is up). */
 	resolved: zod.z.array(zod.z.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 = zod.z.object({
+	/** The operator's override, or null for automatic. */
+	override: zod.z.string().nullable(),
+	/** The address in use, or null when nothing qualifies (never loopback). */
+	resolved: zod.z.string().nullable(),
+	source: zod.z.enum([
+		"override",
+		"auto",
+		"none"
+	])
+});
+var HubAddressesSchema = zod.z.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 = zod.z.object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -37728,6 +38095,26 @@ var localNetworkCapability = {
 		*/
 		setViewerEndpoints: require_sleep.method(zod.z.object({ baseUrls: zod.z.array(zod.z.string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }),
 		/**
+		* The hub's address for each audience — agents (`cluster`) and sign-in
+		* links (`browser`) — as every consumer must read it: the operator's
+		* override when set, else the automatic pick from this cap's palette,
+		* never loopback. The ONE answer to "at which address is this hub
+		* reached?"; there is no environment variable for it.
+		*/
+		getHubAddresses: require_sleep.method(zod.z.void(), HubAddressesSchema),
+		/**
+		* Set or clear (`baseUrl: null`) one audience's override. Validated: an
+		* http(s) origin with a host, no credentials, no path, never loopback —
+		* an invalid value is refused with the reason, nothing is stored.
+		*/
+		setHubAddress: require_sleep.method(zod.z.object({
+			audience: zod.z.enum(["cluster", "browser"]),
+			baseUrl: zod.z.string().nullable()
+		}), HubAddressesSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Read the operator's allowlist. Empty = "auto" (no filter). Used
 		* by the admin UI's address selector to seed its checkbox state.
 		*/
@@ -47869,7 +48256,9 @@ var FRIGATE_PLUS_TO_MACRO = {
 * - `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.
 */
 var FRIGATE_PLUS_UNMAPPED_LABELS = {
@@ -47915,17 +48304,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 };
 }
 //#endregion
@@ -53385,6 +53775,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getHubAddresses": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -53439,6 +53835,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setHubAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.setNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -66001,6 +66403,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),
@@ -68962,7 +69366,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"],
@@ -71005,6 +71409,72 @@ function stepModelRunsOnFormat(models, modelId, format) {
 	return models.some((m) => m.legacy !== true && hasBuild(m, format));
 }
 //#endregion
+//#region src/pipeline/removed-model-ids.ts
+/**
+* Model ids DELETED from a step's catalog (D703, D710, D719), per step — and
+* the one question asked of them: is a stored pin to this id a pin to a model
+* that no longer exists? (D725)
+*
+* This is NOT a resolver input. `resolveModelForFormat` still returns an
+* unknown id unchanged (a custom model), and a bulk pass pinned to one still
+* refuses rather than substitutes (D54). The ONE reader is the orchestrator's
+* stored-pin reset (`removed-model-pin-reset.ts`), which clears such a pin from
+* the store so the step follows its default again — unless a registered custom
+* model carries the same id.
+*
+* `removed-model-ids.spec.ts` (addon-pipeline) pins that every id here is
+* really absent from its step's catalog. A model deleted from a catalog is
+* added here in the same change, or its stored pins stay behind as custom ids.
+*/
+/** `stepId → ids deleted from that step's catalog`. */
+var REMOVED_MODEL_IDS = {
+	"object-detection": ["efficientdet-lite0-edgetpu", "ssdlite-mobiledet-coco-edgetpu"],
+	"face-detection": [
+		"scrypted-yolov9t-face",
+		"scrfd-2.5g",
+		"ssd-mobilenet-v2-face-edgetpu"
+	],
+	"face-embedding": ["arcface-r100", "inception-resnet-v1"],
+	"plate-detection": ["yolov8n-plate"],
+	"plate-ocr": ["vgg-english-g2"],
+	"clip-embedding": ["mobileclip-s1", "mobileclip-s2"],
+	"package-detection": ["yolov8n-package"],
+	"bird-classifier": ["bird-classifier-aiy-edgetpu", "bird-nabirds-404"],
+	"animal-classifier": ["animals-10"],
+	"vehicle-classifier": ["vehicle-type-efficientnet"]
+};
+/** True when `modelId` was deleted from `stepId`'s catalog. */
+function isRemovedModelId(stepId, modelId) {
+	return REMOVED_MODEL_IDS[stepId]?.includes(modelId) ?? false;
+}
+//#endregion
+//#region src/pipeline/root-face-crop.ts
+/** Side of the square, as a multiple of the face box's longer side. */
+var ROOT_FACE_REFINE_SCALE = 1.6;
+/**
+* The input the face detector sees the square at, in pixels. A face that
+* fills ~60% of a 160 px input is in the detector's measured sweet spot; the
+* same square fed at 640 puts a ~400 px face in front of a detector whose
+* largest anchors are far smaller.
+*/
+var ROOT_FACE_REFINE_INPUT_PX = 160;
+/**
+* The square (frame-space pixels) a root face box is refined in: centred on
+* the box, side `ROOT_FACE_REFINE_SCALE ×` its longer side, slid inside the
+* frame, and shrunk only when the frame's shorter side is smaller. Pure.
+*/
+function deriveRootFaceRefineRect(face, frameWidth, frameHeight) {
+	const side = Math.min(Math.max(face.w, face.h) * ROOT_FACE_REFINE_SCALE, Math.min(frameWidth, frameHeight));
+	const cx = face.x + face.w / 2;
+	const cy = face.y + face.h / 2;
+	return {
+		x: Math.min(Math.max(0, cx - side / 2), frameWidth - side),
+		y: Math.min(Math.max(0, cy - side / 2), frameHeight - side),
+		w: side,
+		h: side
+	};
+}
+//#endregion
 //#region src/pipeline/detail-crop.ts
 /**
 * THE detail-crop convention — the single derivation of the rectangle a
@@ -73284,6 +73754,8 @@ exports.CONNECTION_TEST_TIMEOUT_MS = CONNECTION_TEST_TIMEOUT_MS;
 exports.CONTAINER_CHILD_PRIORITY = CONTAINER_CHILD_PRIORITY;
 exports.CORE_BLOCKS_ADDON_ID = CORE_BLOCKS_ADDON_ID;
 exports.CORE_BLOCK_ADDON_PREFIX = CORE_BLOCK_ADDON_PREFIX;
+exports.CROP_SUPPLY_SOURCES = CROP_SUPPLY_SOURCES;
+exports.CROP_SUPPLY_STEP_IDS = CROP_SUPPLY_STEP_IDS;
 exports.CUSTOMIZATION_BLOCK_NAME_PREFIX = require_composition.CUSTOMIZATION_BLOCK_NAME_PREFIX;
 exports.CalendarColorSchema = CalendarColorSchema;
 exports.CalendarEntrySchema = CalendarEntrySchema;
@@ -73476,7 +73948,6 @@ exports.DEFAULT_EVENTS_BAND_BUFFER_SEC = DEFAULT_EVENTS_BAND_BUFFER_SEC;
 exports.DEFAULT_EVENT_COLOR = DEFAULT_EVENT_COLOR;
 exports.DEFAULT_FEATURES = DEFAULT_FEATURES;
 exports.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS = require_composition.DEFAULT_FIRST_SIGHTING_FRESHNESS_MS;
-exports.DEFAULT_LABEL_LINK_POLICY = DEFAULT_LABEL_LINK_POLICY;
 exports.DEFAULT_MIN_LANDMARK_FACE_SIZE_PX = DEFAULT_MIN_LANDMARK_FACE_SIZE_PX;
 exports.DEFAULT_NATIVE_LEASE_SETTINGS = DEFAULT_NATIVE_LEASE_SETTINGS;
 exports.DEFAULT_OVERLAY_LAYERS = DEFAULT_OVERLAY_LAYERS;
@@ -73653,9 +74124,6 @@ exports.ExtensionSourceSchema = ExtensionSourceSchema;
 exports.FEEDER_EXAMPLE_ADDON_ID = FEEDER_EXAMPLE_ADDON_ID;
 exports.FEEDER_EXAMPLE_HA_DEVICE_ID = FEEDER_EXAMPLE_HA_DEVICE_ID;
 exports.FFMPEG_PATH_ENV = require_composition.FFMPEG_PATH_ENV;
-exports.FILLABLE_STEP_IDS = FILLABLE_STEP_IDS;
-exports.FILLABLE_STEP_MACRO = FILLABLE_STEP_MACRO;
-exports.FILLABLE_STEP_VOCABULARIES = FILLABLE_STEP_VOCABULARIES;
 exports.FIRST_LEVEL_MACRO_CLASSES = FIRST_LEVEL_MACRO_CLASSES;
 exports.FRIGATE_PLUS_TO_MACRO = FRIGATE_PLUS_TO_MACRO;
 exports.FRIGATE_PLUS_UNMAPPED_LABELS = FRIGATE_PLUS_UNMAPPED_LABELS;
@@ -73669,7 +74137,6 @@ exports.FeatureManifestSchema = FeatureManifestSchema;
 exports.FeatureProbeStatusSchema = FeatureProbeStatusSchema;
 exports.FieldClaimModeSchema = FieldClaimModeSchema;
 exports.FieldClaimSchema = FieldClaimSchema;
-exports.FillsClassifierEffectSchema = FillsClassifierEffectSchema;
 exports.FloodStatusSchema = FloodStatusSchema;
 exports.Fmp4BoxSplitter = require_composition.Fmp4BoxSplitter;
 exports.FrameHandleFormatSchema = require_sleep.FrameHandleFormatSchema;
@@ -73718,8 +74185,9 @@ exports.IntercomAbilitySchema = IntercomAbilitySchema;
 exports.IntercomStatusSchema = IntercomStatusSchema;
 exports.KNOWN_CAP_NAMES = KNOWN_CAP_NAMES;
 exports.KeyEventSchema = KeyEventSchema;
-exports.LABEL_LINK_POLICIES = LABEL_LINK_POLICIES;
-exports.LABEL_LINK_SETTING_KEY = LABEL_LINK_SETTING_KEY;
+exports.LABEL_SUPPLY_MACRO = LABEL_SUPPLY_MACRO;
+exports.LABEL_SUPPLY_STEP_IDS = LABEL_SUPPLY_STEP_IDS;
+exports.LABEL_SUPPLY_VOCABULARIES = LABEL_SUPPLY_VOCABULARIES;
 exports.LEGACY_READ_ONLY_CONFIG_KEY = LEGACY_READ_ONLY_CONFIG_KEY;
 exports.LINKED_DEVICES_SLOT = LINKED_DEVICES_SLOT;
 exports.LINKED_LABEL_STEP_PREFIX = LINKED_LABEL_STEP_PREFIX;
@@ -74235,6 +74703,7 @@ exports.RECORDING_SOURCE_CAMSTACK = RECORDING_SOURCE_CAMSTACK;
 exports.RECORDING_SOURCE_CAMSTACK_ADDON = RECORDING_SOURCE_CAMSTACK_ADDON;
 exports.RECORDING_TIMELINE_BATCH_MAX = RECORDING_TIMELINE_BATCH_MAX;
 exports.REDACTED_SECRET = REDACTED_SECRET;
+exports.REMOVED_MODEL_IDS = REMOVED_MODEL_IDS;
 exports.RESERVED_BINDING_NAMES = require_composition.RESERVED_BINDING_NAMES;
 exports.RESERVED_COLLECTION_SOURCES = RESERVED_COLLECTION_SOURCES;
 exports.RESTORED_CAP_NAMES = RESTORED_CAP_NAMES;
@@ -74242,6 +74711,10 @@ exports.ROOM_EXAMPLE_MOTION_SOURCES = ROOM_EXAMPLE_MOTION_SOURCES;
 exports.ROOM_EXAMPLE_TEMPERATURE_SOURCES = ROOM_EXAMPLE_TEMPERATURE_SOURCES;
 exports.ROOM_OCCUPANCY_WINDOW_MS = ROOM_OCCUPANCY_WINDOW_MS;
 exports.ROOT_BUCKET_KEY = ROOT_BUCKET_KEY;
+exports.ROOT_CHILD_CONTAINMENT_MIN = ROOT_CHILD_CONTAINMENT_MIN;
+exports.ROOT_FACE_REFINE_INPUT_PX = ROOT_FACE_REFINE_INPUT_PX;
+exports.ROOT_FACE_REFINE_SCALE = ROOT_FACE_REFINE_SCALE;
+exports.ROOT_SUPPLIABLE_STEP_IDS = ROOT_SUPPLIABLE_STEP_IDS;
 exports.RUNTIME_DEFAULTS = RUNTIME_DEFAULTS;
 exports.RUNTIME_STATE_POLICY = RUNTIME_STATE_POLICY;
 exports.RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS = RUNTIME_STATE_REFRESH_MISS_COOLDOWN_MS;
@@ -74326,6 +74799,7 @@ exports.RetrainStatusSchema = RetrainStatusSchema;
 exports.RetrainTrackSchema = RetrainTrackSchema;
 exports.RetrainTransitionResultSchema = RetrainTransitionResultSchema;
 exports.RingBuffer = RingBuffer;
+exports.RootStepSupplySchema = RootStepSupplySchema;
 exports.RtpSourceSchema = RtpSourceSchema;
 exports.RtspRestreamEntrySchema = RtspRestreamEntrySchema;
 exports.RunnerCameraConfigSchema = RunnerCameraConfigSchema;
@@ -74477,6 +74951,7 @@ exports.SubscribeAudioChunksInputSchema = require_sleep.SubscribeAudioChunksInpu
 exports.SubscribeAudioChunksResultSchema = require_sleep.SubscribeAudioChunksResultSchema;
 exports.SubscribeFramesInputSchema = require_sleep.SubscribeFramesInputSchema;
 exports.SubscribeFramesResultSchema = require_sleep.SubscribeFramesResultSchema;
+exports.SuppliedRootOutputSchema = SuppliedRootOutputSchema;
 exports.SwitchStatusSchema = SwitchStatusSchema;
 exports.SystemMetricsSchema = SystemMetricsSchema;
 exports.SystemMirror = SystemMirror;
@@ -74534,6 +75009,8 @@ exports.TransportPlaneSchema = TransportPlaneSchema;
 exports.TurnServerSchema = TurnServerSchema;
 exports.UNATTRIBUTED_BUCKET_KEY = UNATTRIBUTED_BUCKET_KEY;
 exports.UNIT_TABLE = UNIT_TABLE;
+exports.USE_ROOT_MODEL_DEFAULTS = USE_ROOT_MODEL_DEFAULTS;
+exports.USE_ROOT_MODEL_SETTING_KEY = USE_ROOT_MODEL_SETTING_KEY;
 exports.UnifiedBrokerInfoSchema = BrokerInfoSchema;
 exports.UnitConversionError = UnitConversionError;
 exports.UnstampedEventMediaCountSchema = UnstampedEventMediaCountSchema;
@@ -74628,6 +75105,7 @@ exports.alarmPatchLanded = alarmPatchLanded;
 exports.alarmProfileById = alarmProfileById;
 exports.alertsCapability = alertsCapability;
 exports.allDoActions = allDoActions;
+exports.allowedSuppliedEffect = allowedSuppliedEffect;
 exports.ambientLightSensorCapability = ambientLightSensorCapability;
 exports.applyBlockingEdit = applyBlockingEdit;
 exports.applyModeDelaysEdits = applyModeDelaysEdits;
@@ -74734,6 +75212,7 @@ exports.connectivityCapability = connectivityCapability;
 exports.consumableLowPercentOf = consumableLowPercentOf;
 exports.consumablesCapability = consumablesCapability;
 exports.contactCapability = contactCapability;
+exports.containingParentIndex = containingParentIndex;
 exports.controlCapability = controlCapability;
 exports.convertPresetFeature = convertPresetFeature;
 exports.convertUnit = convertUnit;
@@ -74777,15 +75256,18 @@ exports.defineExtensionSlotProvider = defineExtensionSlotProvider;
 exports.deleteAlarmProfile = deleteAlarmProfile;
 exports.deriveBatteryPresence = deriveBatteryPresence;
 exports.deriveCameraSwitches = deriveCameraSwitches;
-exports.deriveClassifierFills = deriveClassifierFills;
 exports.deriveDetailCropRect = deriveDetailCropRect;
 exports.derivePostTriggeredAction = derivePostTriggeredAction;
 exports.deriveRecordingMode = deriveRecordingMode;
+exports.deriveRootFaceRefineRect = deriveRootFaceRefineRect;
+exports.deriveRootSupplies = deriveRootSupplies;
 exports.describeComposableCaps = describeComposableCaps;
 exports.describeCustomActions = require_sleep.describeCustomActions;
 exports.describeModelVariant = describeModelVariant;
 exports.describeOnboardClamp = describeOnboardClamp;
 exports.describeOnboardRefusal = describeOnboardRefusal;
+exports.describeRootSupplies = describeRootSupplies;
+exports.describeRootSupply = describeRootSupply;
 exports.describeStateField = describeStateField;
 exports.describeSystemEventDeliveryProblem = describeSystemEventDeliveryProblem;
 exports.describeSystemEventFamilyProblem = describeSystemEventFamilyProblem;
@@ -74869,7 +75351,6 @@ exports.feederExampleSources = feederExampleSources;
 exports.ffmpegRate = ffmpegRate;
 exports.fieldReads = require_composition.fieldReads;
 exports.filesystemBrowseCapability = filesystemBrowseCapability;
-exports.fillFor = fillFor;
 exports.findCandidateCycles = findCandidateCycles;
 exports.findCompositionCycles = findCompositionCycles;
 exports.findTimezone = findTimezone;
@@ -74894,6 +75375,7 @@ exports.gifFromMp4Args = gifFromMp4Args;
 exports.hasMotionTrigger = hasMotionTrigger;
 exports.hfModelUrl = hfModelUrl;
 exports.htmlToText = htmlToText;
+exports.hubAddressHostname = hubAddressHostname;
 exports.hubMotionNativeProvider = hubMotionNativeProvider;
 exports.humidifierCapability = humidifierCapability;
 exports.humiditySensorCapability = humiditySensorCapability;
@@ -74920,7 +75402,6 @@ exports.isAudioRule = isAudioRule;
 exports.isBaseConditionKey = isBaseConditionKey;
 exports.isBatteryPresenceFault = isBatteryPresenceFault;
 exports.isClusterScopedStep = isClusterScopedStep;
-exports.isCocoLabelmap = isCocoLabelmap;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDefaultAlarmProfileId = isDefaultAlarmProfileId;
 exports.isDeployableToAgent = isDeployableToAgent;
@@ -74934,19 +75415,21 @@ exports.isEmbeddingModelFailed = isEmbeddingModelFailed;
 exports.isEvent = require_sleep.isEvent;
 exports.isEventKindLabelKey = isEventKindLabelKey;
 exports.isEventOwnerType = isEventOwnerType;
-exports.isFillableStepId = isFillableStepId;
 exports.isFirstLevelMacroClass = isFirstLevelMacroClass;
 exports.isHeldBackTemplateVar = isHeldBackTemplateVar;
 exports.isIsolatedBuiltin = isIsolatedBuiltin;
 exports.isKnownTemplateVar = isKnownTemplateVar;
+exports.isLabelSupplyStepId = isLabelSupplyStepId;
 exports.isLocationEnabled = isLocationEnabled;
 exports.isMediaOwnerType = isMediaOwnerType;
 exports.isNode = isNode;
 exports.isObjectInput = isObjectInput;
 exports.isOccupancyRule = isOccupancyRule;
 exports.isOwnerOnlyEventCategory = require_event_category.isOwnerOnlyEventCategory;
+exports.isRemovedModelId = isRemovedModelId;
 exports.isRestoredCap = isRestoredCap;
 exports.isRetiredClearKey = isRetiredClearKey;
+exports.isRootSuppliableStepId = isRootSuppliableStepId;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
 exports.isSecretConfigField = isSecretConfigField;
@@ -75066,6 +75549,8 @@ exports.pickAppLinkHub = pickAppLinkHub;
 exports.pickClusterStepModels = pickClusterStepModels;
 exports.pickClusterStepSettings = pickClusterStepSettings;
 exports.pickDetailCropConvention = pickDetailCropConvention;
+exports.pickHubBaseUrl = pickHubBaseUrl;
+exports.pickHubHostname = pickHubHostname;
 exports.pickInvalidClusterStepModels = pickInvalidClusterStepModels;
 exports.pickNativeLeaseOverride = pickNativeLeaseOverride;
 exports.pickPreferredRtspEntry = pickPreferredRtspEntry;
@@ -75102,11 +75587,11 @@ exports.readDetailCropConvention = readDetailCropConvention;
 exports.readDeviceStateFrom = readDeviceStateFrom;
 exports.readHubMotionDetected = readHubMotionDetected;
 exports.readHubMotionStatus = readHubMotionStatus;
-exports.readLabelLinkPolicy = readLabelLinkPolicy;
 exports.readMotionTriggeredBy = readMotionTriggeredBy;
 exports.readNativeLeaseOverride = readNativeLeaseOverride;
 exports.readNodePin = require_sleep.readNodePin;
 exports.readTimelapseGeneratedAt = readTimelapseGeneratedAt;
+exports.readUseRootModel = readUseRootModel;
 exports.readinessKey = require_sleep.readinessKey;
 exports.rebootCapability = rebootCapability;
 exports.reconcileBlockDevices = reconcileBlockDevices;
@@ -75139,8 +75624,8 @@ exports.resolveDeviceProfile = resolveDeviceProfile;
 exports.resolveEgressDecodeHwAccel = resolveEgressDecodeHwAccel;
 exports.resolveExportProfiles = resolveExportProfiles;
 exports.resolveFormat = resolveFormat;
+exports.resolveHubAddress = resolveHubAddress;
 exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
-exports.resolveLabelLink = resolveLabelLink;
 exports.resolveLocationIcon = resolveLocationIcon;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
@@ -75149,12 +75634,15 @@ exports.resolveModeNotifyPolicy = resolveModeNotifyPolicy;
 exports.resolveMutate = resolveMutate;
 exports.resolvePoolMemoryPolicy = resolvePoolMemoryPolicy;
 exports.resolveRecordingProfiles = resolveRecordingProfiles;
+exports.resolveRootSupply = resolveRootSupply;
 exports.resolveRunnerId = resolveRunnerId;
 exports.resolveStreamMaps = require_composition.resolveStreamMaps;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
 exports.roleSpec = roleSpec;
 exports.roomCompositionExample = roomCompositionExample;
+exports.rootSuppliesOf = rootSuppliesOf;
+exports.rootSupplyServes = rootSupplyServes;
 exports.ruleAutoTriggersAlarm = ruleAutoTriggersAlarm;
 exports.ruleBelongsToAlarm = ruleBelongsToAlarm;
 exports.ruleDeviceCompatCapNames = ruleDeviceCompatCapNames;
@@ -75224,6 +75712,7 @@ exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
 exports.subKindsOf = subKindsOf;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
 exports.summarizeEffectiveScope = summarizeEffectiveScope;
+exports.supplyFor = supplyFor;
 exports.supportedRuntimes = supportedRuntimes;
 exports.switchCapability = switchCapability;
 exports.switchedOffIds = switchedOffIds;
@@ -75275,6 +75764,7 @@ exports.userPasskeysCapability = userPasskeysCapability;
 exports.vacuumControlCapability = vacuumControlCapability;
 exports.validateComposition = validateComposition;
 exports.validateExpressionSource = require_composition.validateExpressionSource;
+exports.validateHubAddressOverride = validateHubAddressOverride;
 exports.validateRecipeBounds = validateRecipeBounds;
 exports.valveCapability = valveCapability;
 exports.vectorDimFromBase64 = vectorDimFromBase64;