@camstack/types 1.2.308 → 1.2.310

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-C3gDpn7G.js");
+const require_sleep = require("./sleep-DyF95STh.js");
 const require_event_category = require("./event-category-DmS_tLsU.js");
 const require_composition = require("./composition-BLWAivB2.js");
 const require_err_msg = require("./err-msg-Dx2Kor0g.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,368 @@ var filesystemBrowseCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/viewer-link-url.ts
+/** The central link domain the viewer app claims (Universal Links / App Links). */
+var CAMSTACK_APP_LINK_ORIGIN = "https://camstack.zentik.app";
+/** Where the hub serves the viewer SPA. */
+var HUB_VIEWER_MOUNT = "/viewer/camstack";
+/** True when `baseUrl` names the CamStack app link rather than a hub address. */
+function isAppLinkBase(baseUrl) {
+	if (baseUrl === null || baseUrl === void 0 || baseUrl === "") return false;
+	try {
+		return new URL(baseUrl).origin === CAMSTACK_APP_LINK_ORIGIN;
+	} catch {
+		return false;
+	}
+}
+/**
+* The base a viewer link is built on, from the flagged notification address:
+* the effective address is the explicit choice, else AUTO's `resolved`. The
+* one reading of that answer — the NC's tap and the Network page's preview
+* both go through it.
+*/
+function viewerLinkBaseOf(endpoint) {
+	const flagged = endpoint.baseUrl ?? endpoint.resolved;
+	return isAppLinkBase(flagged) ? {
+		form: "app",
+		hubBaseUrl: endpoint.appLinkHub ?? null
+	} : {
+		form: "hub",
+		hubBaseUrl: flagged
+	};
+}
+/**
+* Reduce a base URL to the bare origin the central page accepts as `hub=`,
+* or `null` when it cannot be one: not http(s), carries credentials, or does
+* not parse. A path/query/fragment is dropped — the central page mounts the
+* viewer under the origin itself.
+*/
+function toAppLinkHubOrigin(baseUrl) {
+	let parsed;
+	try {
+		parsed = new URL(baseUrl);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
+	if (parsed.username !== "" || parsed.password !== "") return null;
+	if (parsed.hostname === "") return null;
+	return parsed.origin;
+}
+/**
+* The hub address an app link carries as `hub=`, chosen from the hub's OWN
+* advertised palette so it always agrees with what the Network page lists:
+* the public tunnel first, then the mesh (Tailscale MagicDNS) — HTTPS only,
+* because the app and the hosted viewer reach it from off the LAN. `null`
+* when the hub advertises neither.
+*/
+function pickAppLinkHub(endpoints) {
+	const rank = (e) => {
+		if (e.kind !== "public" || !e.baseUrl.startsWith("https://")) return null;
+		if (e.interfaceKind === "public") return 0;
+		if (e.interfaceKind === "vpn") return 1;
+		return null;
+	};
+	return endpoints.flatMap((e) => {
+		const r = rank(e);
+		const origin = toAppLinkHubOrigin(e.baseUrl);
+		return r === null || origin === null ? [] : [{
+			r,
+			p: e.priority,
+			origin
+		}];
+	}).toSorted((a, b) => a.r - b.r || a.p - b.p)[0]?.origin ?? null;
+}
+/** The viewer route for a destination, or null when it names nothing. */
+function viewerRoute(destination) {
+	switch (destination.kind) {
+		case "camera": {
+			if (!Number.isInteger(destination.deviceId) || destination.deviceId <= 0) return null;
+			const at = destination.atMs;
+			return {
+				path: `/camera/${String(destination.deviceId)}`,
+				query: at !== void 0 && Number.isFinite(at) ? [["at", String(Math.trunc(at))]] : []
+			};
+		}
+		case "events": return {
+			path: "/events",
+			query: []
+		};
+		case "notifications": return {
+			path: "/notifications",
+			query: []
+		};
+	}
+}
+function encodeQuery(query) {
+	if (query.length === 0) return "";
+	return `?${query.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&")}`;
+}
+/**
+* The link for a viewer destination, or `null` when none can be minted: an
+* unknown destination, or the `hub` form with no reachable base (a dead link
+* is worse than none).
+*/
+function buildViewerLink(input) {
+	const route = viewerRoute(input.destination);
+	if (route === null) return null;
+	const raw = input.base.hubBaseUrl;
+	const base = raw === null ? "" : raw.replace(/\/+$/, "");
+	if (input.base.form === "app") {
+		const origin = base === "" ? null : toAppLinkHubOrigin(base);
+		const query = origin === null ? route.query : [...route.query, ["hub", origin]];
+		return `${CAMSTACK_APP_LINK_ORIGIN}${route.path}${encodeQuery(query)}`;
+	}
+	if (base === "" || isAppLinkBase(base)) return null;
+	return `${base}${HUB_VIEWER_MOUNT}${route.path}${encodeQuery(route.query)}`;
+}
+//#endregion
+//#region src/capabilities/hub-address.ts
+var HUB_ADDRESS_ROLES = [
+	"viewer",
+	"notifications",
+	"agents",
+	"signIn"
+];
+var SINGLE_HUB_ADDRESS_ROLES = [
+	"notifications",
+	"agents",
+	"signIn"
+];
+function isSingleHubAddressRole(role) {
+	return role !== "viewer";
+}
+var AUTOMATIC_HUB_ADDRESS_FLAGS = {
+	viewer: [],
+	notifications: null,
+	agents: null,
+	signIn: null
+};
+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 trimSlash(baseUrl) {
+	return baseUrl.replace(/\/+$/, "");
+}
+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 role's AUTOMATIC answer. */
+function autoRankFor(role, endpoint) {
+	if (endpoint.kind === "loopback" || endpoint.kind === "app-link" || endpoint.kind === "custom") return null;
+	if (hostnameOf(endpoint.baseUrl) === null) return null;
+	if (role === "agents") {
+		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 address: 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 validateCustomAddress(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 reason a plain-http sign-in address is refused unless accepted. */
+var SIGN_IN_HTTP_REASON = "Sign-in needs an https:// address: passkeys and most identity providers refuse a plain-http origin. Accept http only for a sign-in that never leaves your own network.";
+/**
+* May `baseUrl` carry `role`? The address check above, plus two role rules:
+* the app link carries `notifications` only (it is not a hub address), and a
+* plain-http address carries `signIn` only when the operator explicitly
+* accepted it (`acceptInsecureHttp`) — a LAN-only password or magic-link
+* sign-in works over http, a passkey or an OIDC callback does not.
+*/
+function checkRoleAddress(role, baseUrl, options = {}) {
+	if (isAppLinkBase(baseUrl)) return role === "notifications" ? {
+		ok: true,
+		baseUrl: CAMSTACK_APP_LINK_ORIGIN
+	} : {
+		ok: false,
+		reason: "The CamStack app link is not a hub address — only notifications can use it."
+	};
+	const check = validateCustomAddress(baseUrl);
+	if (!check.ok) return check;
+	if (role === "signIn" && check.baseUrl.startsWith("http:") && options.acceptInsecureHttp !== true) return {
+		ok: false,
+		reason: SIGN_IN_HTTP_REASON
+	};
+	return check;
+}
+/** A stored flag that still validates (stored values are external data). */
+function validFlag(role, flag) {
+	if (flag === null || flag === "") return null;
+	const check = checkRoleAddress(role, flag, { acceptInsecureHttp: true });
+	return check.ok ? check.baseUrl : null;
+}
+function pickAuto(endpoints, role) {
+	const best = endpoints.flatMap((endpoint) => {
+		const rank = autoRankFor(role, 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 : trimSlash(best.endpoint.baseUrl);
+}
+function resolveHubRole(endpoints, role, flag) {
+	const flagged = validFlag(role, flag);
+	if (flagged !== null) return {
+		flagged,
+		resolved: flagged,
+		source: "flagged"
+	};
+	const auto = pickAuto(endpoints, role);
+	return {
+		flagged: null,
+		resolved: auto,
+		source: auto === null ? "none" : "auto"
+	};
+}
+/** `agents`: what agents and LAN devices pull from. */
+function resolveAgentsAddress(endpoints, flags) {
+	return resolveHubRole(endpoints, "agents", flags.agents);
+}
+/** `signIn`: sign-in links, OIDC callbacks, the relying party, OAuth2. */
+function resolveSignInAddress(endpoints, flags) {
+	return resolveHubRole(endpoints, "signIn", flags.signIn);
+}
+/** `notifications`: the flagged address, else the CamStack app link (D709). */
+function resolveNotificationsAddress(flags) {
+	const flagged = validFlag("notifications", flags.notifications);
+	if (flagged !== null && !isAppLinkBase(flagged)) return {
+		flagged,
+		resolved: flagged,
+		source: "flagged"
+	};
+	return {
+		flagged: null,
+		resolved: CAMSTACK_APP_LINK_ORIGIN,
+		source: "auto"
+	};
+}
+/** AUTO viewer race: LAN IPv4 + the public tunnel. Never IPv6, mesh, loopback or custom. */
+function isDefaultViewerEndpoint(endpoint) {
+	if (endpoint.kind === "lan-ipv4") return true;
+	return endpoint.kind === "public" && endpoint.interfaceKind === "public";
+}
+/**
+* The endpoints the apps race: the flagged ones that are in `endpoints`
+* (which carries the custom addresses flagged `viewer`), else AUTO. A flagged
+* set none of which is currently up falls back to AUTO rather than racing
+* nothing.
+*/
+function selectViewerEndpoints(endpoints, flags) {
+	const auto = endpoints.filter(isDefaultViewerEndpoint);
+	if (flags.viewer.length === 0) return auto;
+	const wanted = new Set(flags.viewer);
+	const explicit = endpoints.filter((e) => wanted.has(e.baseUrl));
+	return explicit.length > 0 ? explicit : auto;
+}
+/** `viewer`: what the apps race and connect to. */
+function resolveViewerAddresses(endpoints, flags) {
+	const wanted = new Set(flags.viewer);
+	const selected = selectViewerEndpoints(endpoints, flags);
+	const usedFlags = selected.some((e) => wanted.has(e.baseUrl));
+	return {
+		flagged: flags.viewer,
+		resolved: selected.map((e) => e.baseUrl),
+		source: selected.length === 0 ? "none" : usedFlags ? "flagged" : "auto"
+	};
+}
+/**
+* Every role at once, each through its own resolver. `viewerPalette` is what
+* the apps race (it carries the custom addresses flagged `viewer`);
+* `hubPalette` is the detected HTTPS palette agents and sign-in resolve over.
+*/
+function resolveHubAddressRoles(viewerPalette, hubPalette, flags) {
+	return {
+		viewer: resolveViewerAddresses(viewerPalette, flags),
+		notifications: resolveNotificationsAddress(flags),
+		agents: resolveAgentsAddress(hubPalette, flags),
+		signIn: resolveSignInAddress(hubPalette, flags)
+	};
+}
+/** 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 +18710,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 +21759,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 +26359,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 +26518,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 +26922,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 +28444,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
@@ -32450,122 +33013,6 @@ var CLIP_PLAYBACK_OPTIONS = {
 	}
 };
 //#endregion
-//#region src/capabilities/viewer-link-url.ts
-/** The central link domain the viewer app claims (Universal Links / App Links). */
-var CAMSTACK_APP_LINK_ORIGIN = "https://camstack.zentik.app";
-/** Where the hub serves the viewer SPA. */
-var HUB_VIEWER_MOUNT = "/viewer/camstack";
-/** True when `baseUrl` names the CamStack app link rather than a hub address. */
-function isAppLinkBase(baseUrl) {
-	if (baseUrl === null || baseUrl === void 0 || baseUrl === "") return false;
-	try {
-		return new URL(baseUrl).origin === CAMSTACK_APP_LINK_ORIGIN;
-	} catch {
-		return false;
-	}
-}
-/**
-* The base a viewer link is built on, from the flagged notification address:
-* the effective address is the explicit choice, else AUTO's `resolved`. The
-* one reading of that answer — the NC's tap and the Network page's preview
-* both go through it.
-*/
-function viewerLinkBaseOf(endpoint) {
-	const flagged = endpoint.baseUrl ?? endpoint.resolved;
-	return isAppLinkBase(flagged) ? {
-		form: "app",
-		hubBaseUrl: endpoint.appLinkHub ?? null
-	} : {
-		form: "hub",
-		hubBaseUrl: flagged
-	};
-}
-/**
-* Reduce a base URL to the bare origin the central page accepts as `hub=`,
-* or `null` when it cannot be one: not http(s), carries credentials, or does
-* not parse. A path/query/fragment is dropped — the central page mounts the
-* viewer under the origin itself.
-*/
-function toAppLinkHubOrigin(baseUrl) {
-	let parsed;
-	try {
-		parsed = new URL(baseUrl);
-	} catch {
-		return null;
-	}
-	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return null;
-	if (parsed.username !== "" || parsed.password !== "") return null;
-	if (parsed.hostname === "") return null;
-	return parsed.origin;
-}
-/**
-* The hub address an app link carries as `hub=`, chosen from the hub's OWN
-* advertised palette so it always agrees with what the Network page lists:
-* the public tunnel first, then the mesh (Tailscale MagicDNS) — HTTPS only,
-* because the app and the hosted viewer reach it from off the LAN. `null`
-* when the hub advertises neither.
-*/
-function pickAppLinkHub(endpoints) {
-	const rank = (e) => {
-		if (e.kind !== "public" || !e.baseUrl.startsWith("https://")) return null;
-		if (e.interfaceKind === "public") return 0;
-		if (e.interfaceKind === "vpn") return 1;
-		return null;
-	};
-	return endpoints.flatMap((e) => {
-		const r = rank(e);
-		const origin = toAppLinkHubOrigin(e.baseUrl);
-		return r === null || origin === null ? [] : [{
-			r,
-			p: e.priority,
-			origin
-		}];
-	}).toSorted((a, b) => a.r - b.r || a.p - b.p)[0]?.origin ?? null;
-}
-/** The viewer route for a destination, or null when it names nothing. */
-function viewerRoute(destination) {
-	switch (destination.kind) {
-		case "camera": {
-			if (!Number.isInteger(destination.deviceId) || destination.deviceId <= 0) return null;
-			const at = destination.atMs;
-			return {
-				path: `/camera/${String(destination.deviceId)}`,
-				query: at !== void 0 && Number.isFinite(at) ? [["at", String(Math.trunc(at))]] : []
-			};
-		}
-		case "events": return {
-			path: "/events",
-			query: []
-		};
-		case "notifications": return {
-			path: "/notifications",
-			query: []
-		};
-	}
-}
-function encodeQuery(query) {
-	if (query.length === 0) return "";
-	return `?${query.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&")}`;
-}
-/**
-* The link for a viewer destination, or `null` when none can be minted: an
-* unknown destination, or the `hub` form with no reachable base (a dead link
-* is worse than none).
-*/
-function buildViewerLink(input) {
-	const route = viewerRoute(input.destination);
-	if (route === null) return null;
-	const raw = input.base.hubBaseUrl;
-	const base = raw === null ? "" : raw.replace(/\/+$/, "");
-	if (input.base.form === "app") {
-		const origin = base === "" ? null : toAppLinkHubOrigin(base);
-		const query = origin === null ? route.query : [...route.query, ["hub", origin]];
-		return `${CAMSTACK_APP_LINK_ORIGIN}${route.path}${encodeQuery(query)}`;
-	}
-	if (base === "" || isAppLinkBase(base)) return null;
-	return `${base}${HUB_VIEWER_MOUNT}${route.path}${encodeQuery(route.query)}`;
-}
-//#endregion
 //#region src/capabilities/webrtc-session.cap.ts
 /**
 * Optional client-side hints sent at session creation to help the provider
@@ -33073,6 +33520,35 @@ var webrtcSessionCapability = {
 			alive: zod.z.boolean()
 		})),
 		/**
+		* The viewer's downlink probe, for ONE live session (D733).
+		*
+		* The player measures `/adaptive-probe` after the session's first decoded
+		* frame (D635). It used to act on the reading itself, by opening a SECOND
+		* session with `hints.downlinkMbps` — every adaptive live open became two
+		* sessions, two ICE + DTLS handshakes and two server pipelines. It now
+		* hands the measurement to the session it already has; the provider picks
+		* the rung exactly as it would from an offer's hints (same viewport
+		* ceiling) and moves the session there — in place when the negotiated
+		* codec carries the new rendition, by the existing re-offer
+		* (`getSessionState.pendingRenegotiation`) when it cannot.
+		*
+		* A MEASUREMENT, never a tier: the client does not choose. A probe only
+		* raises the rung; lowering it stays the ladder's call on delivery.
+		* `held` answers why nothing moved (`not-adaptive`, `pinned`,
+		* `already-there`, `recorded`, …) — a client that gets ANY answer must not
+		* fall back to a reconnect; only a provider that does not know the method
+		* (an older hub) leaves the client its legacy second session.
+		*/
+		applyDownlinkProbe: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number().int().nonnegative(),
+			sessionId: zod.z.string(),
+			downlinkMbps: zod.z.number().nonnegative()
+		}), zod.z.object({
+			outcome: zod.z.enum(["switching", "held"]),
+			tier: require_sleep.CamProfileSchema.nullable(),
+			reason: zod.z.string()
+		}), { kind: "mutation" }),
+		/**
 		* The SERVER's half of the stream-debug overlay, for one live session.
 		*
 		* The client can measure its own transport (`getStats()`); it cannot see
@@ -37494,7 +37970,8 @@ var ConnectionEndpointSchema = zod.z.object({
 		"lan-ipv6",
 		"public",
 		"loopback",
-		"app-link"
+		"app-link",
+		"custom"
 	]),
 	/**
 	* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
@@ -37596,6 +38073,82 @@ 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()
 });
+/**
+* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
+* one release for addons built against it): `cluster` is the `agents` role,
+* `browser` the `signIn` role; `override` is the flagged address.
+*/
+var HubAddressSnapshotSchema = zod.z.object({
+	override: zod.z.string().nullable(),
+	resolved: zod.z.string().nullable(),
+	source: zod.z.enum([
+		"override",
+		"auto",
+		"none"
+	])
+});
+var HubAddressesSchema = zod.z.object({
+	cluster: HubAddressSnapshotSchema,
+	browser: HubAddressSnapshotSchema
+});
+/**
+* What an address is used for (`hub-address.ts`). `viewer` is many-valued;
+* `notifications`, `agents` and `signIn` are carried by at most one address.
+*/
+var HubAddressRoleSchema = zod.z.enum([
+	"viewer",
+	"notifications",
+	"agents",
+	"signIn"
+]);
+var RoleSourceSchema = zod.z.enum([
+	"flagged",
+	"auto",
+	"none"
+]);
+/** One single-valued role: the flagged address, the one in use, and why. */
+var HubAddressRoleResolutionSchema = zod.z.object({
+	/** The address carrying the flag, or null = automatic. */
+	flagged: zod.z.string().nullable(),
+	/** The address in use, or null when nothing qualifies (never loopback). */
+	resolved: zod.z.string().nullable(),
+	source: RoleSourceSchema
+});
+var HubViewerResolutionSchema = zod.z.object({
+	/** The addresses flagged `viewer`, or empty = automatic. */
+	flagged: zod.z.array(zod.z.string()).readonly(),
+	/** What the apps race right now. */
+	resolved: zod.z.array(zod.z.string()).readonly(),
+	source: RoleSourceSchema
+});
+/**
+* One row of the Network page's Addresses table: a detected endpoint, an
+* operator-entered custom address, or the CamStack app link — flagged the
+* same way. A URL that is both detected and entered is ONE row.
+*/
+var HubAddressRowSchema = ConnectionEndpointSchema.extend({
+	/** In the hub's detected palette right now. */
+	detected: zod.z.boolean(),
+	/** Entered by the operator (removable). */
+	custom: zod.z.boolean(),
+	/** The roles explicitly flagged on this address. */
+	flags: zod.z.array(HubAddressRoleSchema).readonly(),
+	/** The roles this address serves right now — flagged or automatic. */
+	inUse: zod.z.array(HubAddressRoleSchema).readonly(),
+	/** The roles this address may be flagged with. */
+	eligible: zod.z.array(HubAddressRoleSchema).readonly()
+});
+var HubAddressBookSchema = zod.z.object({
+	rows: zod.z.array(HubAddressRowSchema).readonly(),
+	roles: zod.z.object({
+		viewer: HubViewerResolutionSchema,
+		notifications: HubAddressRoleResolutionSchema,
+		agents: HubAddressRoleResolutionSchema,
+		signIn: HubAddressRoleResolutionSchema
+	}),
+	/** The `hub=` an app link carries (D709), or null. */
+	appLinkHub: zod.z.string().nullable()
+});
 var AllowedAddressesSchema = zod.z.object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -37708,26 +38261,78 @@ var localNetworkCapability = {
 		*/
 		getNotificationEndpoint: require_sleep.method(zod.z.void(), NotificationEndpointSchema),
 		/**
-		* Mark which endpoint notification artifacts use. `baseUrl: null` restores
-		* AUTO. The value is stored verbatim (not an index into the candidate
-		* list): interfaces come and go, and an index would silently re-point at a
-		* different address after a reboot.
+		* @deprecated Use `setAddressRole({ role: 'notifications', … })`. Kept so
+		* an older admin UI keeps working: it writes the same `notifications`
+		* flag, with the same validation. `baseUrl: null` restores automatic; an
+		* address that is not detected becomes a custom address.
 		*/
 		setNotificationEndpoint: require_sleep.method(zod.z.object({ baseUrl: zod.z.string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }),
 		/**
-		* The endpoints the SDK / viewer races for API access. Empty `baseUrls`
-		* means AUTO: every LAN IPv4 address plus the public tunnel, never IPv6,
-		* never mesh, never loopback. `resolved` is that set (or the operator's
-		* explicit subset) as it stands right now.
+		* The `viewer` role as shipped apps read it: the flagged addresses
+		* (detected or custom), or empty for AUTO — every LAN IPv4 address plus
+		* the public tunnel, never IPv6, mesh, loopback or a custom address.
+		* `resolved` is the set as it stands right now; the custom ones in it are
+		* also in `getConnectionEndpoints`, which the apps filter by it.
 		*/
 		getViewerEndpoints: require_sleep.method(zod.z.void(), ViewerEndpointsSchema),
 		/**
-		* Replace the viewer race set. Empty `baseUrls` restores AUTO. Stored
-		* verbatim (not indices) so a temporarily-down tunnel is not silently
-		* dropped from the operator's choice.
+		* @deprecated Use `setAddressRole({ role: 'viewer', … })`. Kept so an
+		* older admin UI keeps working: it replaces the same `viewer` flags.
+		* Empty `baseUrls` restores automatic.
 		*/
 		setViewerEndpoints: require_sleep.method(zod.z.object({ baseUrls: zod.z.array(zod.z.string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }),
 		/**
+		* The Network page's Addresses table and every role's answer — the ONE
+		* reading of "which address is this hub reached at, for what": detected
+		* endpoints and custom addresses with their role flags, and per role the
+		* flagged address, the one in use and whether it is automatic. Agent
+		* deliveries, sign-in and LAN devices read `roles.agents` / `roles.signIn`
+		* here; nothing ranks the palette itself. `scheme` is the one the caller
+		* shows LAN rows in (as `getConnectionEndpoints`); agents and sign-in are
+		* always resolved over the HTTPS palette.
+		*/
+		getAddresses: require_sleep.method(zod.z.object({ scheme: zod.z.enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema),
+		/**
+		* Add a custom address. Validated: an http(s) origin with a host, no
+		* credentials, no path, never loopback — an invalid one is refused with
+		* the reason and nothing is stored. Adding an address that already exists
+		* only updates its label.
+		*/
+		addCustomAddress: require_sleep.method(zod.z.object({
+			baseUrl: zod.z.string(),
+			label: zod.z.string().max(80)
+		}), HubAddressBookSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Remove a custom address. Its role flags go with it (those roles turn automatic). */
+		removeCustomAddress: require_sleep.method(zod.z.object({ baseUrl: zod.z.string() }), HubAddressBookSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Flag (`enabled: true`) or unflag an address for a role. For a
+		* single-valued role, flagging moves the flag off every other address.
+		* `baseUrl: null` returns the role to automatic. The address must be a row
+		* of the table (detected, custom, or the app link for notifications);
+		* `signIn` on a plain-http address is refused unless `acceptInsecureHttp`.
+		*/
+		setAddressRole: require_sleep.method(zod.z.object({
+			role: HubAddressRoleSchema,
+			baseUrl: zod.z.string().nullable(),
+			enabled: zod.z.boolean(),
+			acceptInsecureHttp: zod.z.boolean().optional()
+		}), HubAddressBookSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* @deprecated Read `getAddresses().roles.agents` / `.signIn`. Kept one
+		* release so an addon built against the D729 amendment keeps resolving:
+		* `cluster` = the `agents` role, `browser` = the `signIn` role.
+		*/
+		getHubAddresses: require_sleep.method(zod.z.void(), HubAddressesSchema),
+		/**
 		* Read the operator's allowlist. Empty = "auto" (no filter). Used
 		* by the admin UI's address selector to seed its checkbox state.
 		*/
@@ -47869,7 +48474,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 +48522,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
@@ -53367,12 +53975,24 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.addCustomAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.downloadCa": {
 		capName: "local-network",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getAddresses": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -53385,6 +54005,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",
@@ -53421,6 +54047,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.removeCustomAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"localNetwork.resetAllowlistToBestMatch": {
 		capName: "local-network",
 		capScope: "system",
@@ -53433,6 +54065,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setAddressRole": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.setAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -57687,6 +58325,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"webrtcSession.applyDownlinkProbe": {
+		capName: "webrtc-session",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"webrtcSession.closeSession": {
 		capName: "webrtc-session",
 		capScope: "device",
@@ -64961,6 +65605,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"webrtcSession.applyDownlinkProbe": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"webrtcSession.closeSession": [{
 		name: "deviceId",
 		form: "single",
@@ -66001,6 +66650,11 @@ function createSystemProxy(api) {
 			setNotificationEndpoint: (input) => dispatch("localNetwork", "setNotificationEndpoint", "mutation", input),
 			getViewerEndpoints: (input) => dispatch("localNetwork", "getViewerEndpoints", "query", input),
 			setViewerEndpoints: (input) => dispatch("localNetwork", "setViewerEndpoints", "mutation", input),
+			getAddresses: (input) => dispatch("localNetwork", "getAddresses", "query", input),
+			addCustomAddress: (input) => dispatch("localNetwork", "addCustomAddress", "mutation", input),
+			removeCustomAddress: (input) => dispatch("localNetwork", "removeCustomAddress", "mutation", input),
+			setAddressRole: (input) => dispatch("localNetwork", "setAddressRole", "mutation", input),
+			getHubAddresses: (input) => dispatch("localNetwork", "getHubAddresses", "query", input),
 			getAllowedAddresses: (input) => dispatch("localNetwork", "getAllowedAddresses", "query", input),
 			setAllowedAddresses: (input) => dispatch("localNetwork", "setAllowedAddresses", "mutation", input),
 			resetAllowlistToBestMatch: (input) => dispatch("localNetwork", "resetAllowlistToBestMatch", "mutation", input),
@@ -68962,7 +69616,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"],
@@ -71044,6 +71698,33 @@ 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
@@ -73160,6 +73841,7 @@ exports.AUDIO_NOT_CLASSIFIED_REASONS = AUDIO_NOT_CLASSIFIED_REASONS;
 exports.AUDIO_PRESETS = require_composition.AUDIO_PRESETS;
 exports.AUDIO_SCALE_EPOCH_ISO = AUDIO_SCALE_EPOCH_ISO;
 exports.AUDIO_SCALE_EPOCH_MS = AUDIO_SCALE_EPOCH_MS;
+exports.AUTOMATIC_HUB_ADDRESS_FLAGS = AUTOMATIC_HUB_ADDRESS_FLAGS;
 exports.AccessoriesStatusSchema = AccessoriesStatusSchema;
 exports.AccessoryKind = AccessoryKind;
 exports.AddBrokerInputSchema = AddBrokerInputSchema;
@@ -73323,6 +74005,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;
@@ -73515,7 +74199,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;
@@ -73692,9 +74375,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;
@@ -73708,7 +74388,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;
@@ -73730,12 +74409,14 @@ exports.HAP_KEYFRAME_INTERVAL_SEC = HAP_KEYFRAME_INTERVAL_SEC;
 exports.HF_BASE_URL = HF_BASE_URL;
 exports.HF_REPO = HF_REPO;
 exports.HOURS_PER_DAY = HOURS_PER_DAY;
+exports.HUB_ADDRESS_ROLES = HUB_ADDRESS_ROLES;
 exports.HUB_VIEWER_MOUNT = HUB_VIEWER_MOUNT;
 exports.HWACCEL_OPTIONS = HWACCEL_OPTIONS;
 exports.HealthStatusSchema = HealthStatusSchema;
 exports.HfModelResolutionSchema = HfModelResolutionSchema;
 exports.HistoryPointSchema = HistoryPointSchema;
 exports.HistoryResolutionEnum = HistoryResolutionEnum;
+exports.HubAddressRoleSchema = HubAddressRoleSchema;
 exports.HumidifierStatusSchema = HumidifierStatusSchema;
 exports.HumiditySensorStatusSchema = HumiditySensorStatusSchema;
 exports.HvacModeSchema = HvacModeSchema;
@@ -73757,8 +74438,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;
@@ -74282,6 +74964,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;
@@ -74366,6 +75052,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;
@@ -74389,6 +75076,8 @@ exports.SCOPE_PRESETS = SCOPE_PRESETS;
 exports.SENSOR_FEATURES = SENSOR_FEATURES;
 exports.SENSOR_MAP = SENSOR_MAP;
 exports.SHARE_VIEW_KINDS = require_sleep.SHARE_VIEW_KINDS;
+exports.SIGN_IN_HTTP_REASON = SIGN_IN_HTTP_REASON;
+exports.SINGLE_HUB_ADDRESS_ROLES = SINGLE_HUB_ADDRESS_ROLES;
 exports.SOURCE_CAPS = require_composition.SOURCE_CAPS;
 exports.SOURCE_CAP_ACTIVE_FIELD = require_composition.SOURCE_CAP_ACTIVE_FIELD;
 exports.SOURCE_CAP_CHANGED_AT_FIELD = require_composition.SOURCE_CAP_CHANGED_AT_FIELD;
@@ -74517,6 +75206,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;
@@ -74574,6 +75264,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;
@@ -74668,6 +75360,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;
@@ -74732,6 +75425,7 @@ exports.canConvertUnit = canConvertUnit;
 exports.canonicalEgressPlan = canonicalEgressPlan;
 exports.carbonMonoxideCapability = carbonMonoxideCapability;
 exports.cellsToRects = cellsToRects;
+exports.checkRoleAddress = checkRoleAddress;
 exports.classifyBearerPrincipal = classifyBearerPrincipal;
 exports.classifyStream = classifyStream;
 exports.classifyStreams = classifyStreams;
@@ -74774,6 +75468,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;
@@ -74817,15 +75512,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;
@@ -74909,7 +75607,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;
@@ -74934,6 +75631,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;
@@ -74960,9 +75658,9 @@ exports.isAudioRule = isAudioRule;
 exports.isBaseConditionKey = isBaseConditionKey;
 exports.isBatteryPresenceFault = isBatteryPresenceFault;
 exports.isClusterScopedStep = isClusterScopedStep;
-exports.isCocoLabelmap = isCocoLabelmap;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDefaultAlarmProfileId = isDefaultAlarmProfileId;
+exports.isDefaultViewerEndpoint = isDefaultViewerEndpoint;
 exports.isDeployableToAgent = isDeployableToAgent;
 exports.isDetectionMacroClass = isDetectionMacroClass;
 exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
@@ -74974,11 +75672,11 @@ 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;
@@ -74988,9 +75686,11 @@ exports.isOwnerOnlyEventCategory = require_event_category.isOwnerOnlyEventCatego
 exports.isRemovedModelId = isRemovedModelId;
 exports.isRestoredCap = isRestoredCap;
 exports.isRetiredClearKey = isRetiredClearKey;
+exports.isRootSuppliableStepId = isRootSuppliableStepId;
 exports.isSameAddonId = isSameAddonId;
 exports.isScheduleActive = isScheduleActive;
 exports.isSecretConfigField = isSecretConfigField;
+exports.isSingleHubAddressRole = isSingleHubAddressRole;
 exports.isSoftwareDecode = require_composition.isSoftwareDecode;
 exports.isSourceCap = require_composition.isSourceCap;
 exports.isStateLabelKey = isStateLabelKey;
@@ -75143,11 +75843,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;
@@ -75167,6 +75867,7 @@ exports.resetPoolBaseline = resetPoolBaseline;
 exports.resolveAddonExecution = resolveAddonExecution;
 exports.resolveAddonGroup = resolveAddonGroup;
 exports.resolveAddonPlacement = resolveAddonPlacement;
+exports.resolveAgentsAddress = resolveAgentsAddress;
 exports.resolveBucketMs = resolveBucketMs;
 exports.resolveCapMount = require_sleep.resolveCapMount;
 exports.resolveClipSearchMinScore = resolveClipSearchMinScore;
@@ -75180,22 +75881,28 @@ exports.resolveDeviceProfile = resolveDeviceProfile;
 exports.resolveEgressDecodeHwAccel = resolveEgressDecodeHwAccel;
 exports.resolveExportProfiles = resolveExportProfiles;
 exports.resolveFormat = resolveFormat;
+exports.resolveHubAddressRoles = resolveHubAddressRoles;
 exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
-exports.resolveLabelLink = resolveLabelLink;
 exports.resolveLocationIcon = resolveLocationIcon;
 exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
 exports.resolveModeDelays = resolveModeDelays;
 exports.resolveModeNotifyPolicy = resolveModeNotifyPolicy;
 exports.resolveMutate = resolveMutate;
+exports.resolveNotificationsAddress = resolveNotificationsAddress;
 exports.resolvePoolMemoryPolicy = resolvePoolMemoryPolicy;
 exports.resolveRecordingProfiles = resolveRecordingProfiles;
+exports.resolveRootSupply = resolveRootSupply;
 exports.resolveRunnerId = resolveRunnerId;
+exports.resolveSignInAddress = resolveSignInAddress;
 exports.resolveStreamMaps = require_composition.resolveStreamMaps;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
+exports.resolveViewerAddresses = resolveViewerAddresses;
 exports.roleSpec = roleSpec;
 exports.roomCompositionExample = roomCompositionExample;
+exports.rootSuppliesOf = rootSuppliesOf;
+exports.rootSupplyServes = rootSupplyServes;
 exports.ruleAutoTriggersAlarm = ruleAutoTriggersAlarm;
 exports.ruleBelongsToAlarm = ruleBelongsToAlarm;
 exports.ruleDeviceCompatCapNames = ruleDeviceCompatCapNames;
@@ -75225,6 +75932,7 @@ exports.scriptRunnerCapability = scriptRunnerCapability;
 exports.searchDisplayIcons = searchDisplayIcons;
 exports.secureActuationFor = secureActuationFor;
 exports.selectAssignedProfileSlots = require_sleep.selectAssignedProfileSlots;
+exports.selectViewerEndpoints = selectViewerEndpoints;
 exports.sendTimesForEditor = sendTimesForEditor;
 exports.sendTimesOfSchedule = sendTimesOfSchedule;
 exports.sensorRaisedOf = sensorRaisedOf;
@@ -75265,6 +75973,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;
@@ -75315,6 +76024,7 @@ exports.userManagementCapability = userManagementCapability;
 exports.userPasskeysCapability = userPasskeysCapability;
 exports.vacuumControlCapability = vacuumControlCapability;
 exports.validateComposition = validateComposition;
+exports.validateCustomAddress = validateCustomAddress;
 exports.validateExpressionSource = require_composition.validateExpressionSource;
 exports.validateRecipeBounds = validateRecipeBounds;
 exports.valveCapability = valveCapability;