@camstack/system 1.2.357 → 1.2.359

package/dist/{dist-CFVOy8VT.js → dist-W_X44h-s.js}

@@ -710,7 +710,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-DXKLNFvA.mjs
+//#region ../types/dist/sleep-C16NCZR2.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -7867,57 +7867,15 @@ var ClipSearchStrictnessSchema = zod.z.enum([
 	"balanced",
 	"strict"
 ]);
-new Set([
-	{
-		id: "person",
-		name: "Person"
-	},
-	{
-		id: "vehicle",
-		name: "Vehicle"
-	},
-	{
-		id: "animal",
-		name: "Animal"
-	},
-	{
-		id: "package",
-		name: "Package"
-	}
-].map((l) => l.id));
-var COCO_TO_MACRO = {
-	mapping: {
-		person: "person",
-		bicycle: "vehicle",
-		car: "vehicle",
-		motorcycle: "vehicle",
-		airplane: "vehicle",
-		bus: "vehicle",
-		train: "vehicle",
-		truck: "vehicle",
-		boat: "vehicle",
-		bird: "animal",
-		cat: "animal",
-		dog: "animal",
-		horse: "animal",
-		sheep: "animal",
-		cow: "animal",
-		elephant: "animal",
-		bear: "animal",
-		zebra: "animal",
-		giraffe: "animal",
-		suitcase: "package",
-		backpack: "package",
-		handbag: "package"
-	},
-	preserveOriginal: false
-};
-/** Steps a root detector may declare it fills. */
-var FILLABLE_STEP_IDS = [
+/** Steps whose effect a root label can BE. */
+var LABEL_SUPPLY_STEP_IDS = [
 	"animal-classifier",
 	"vehicle-classifier",
 	"package-detection"
 ];
+/** Steps whose box a root detection can BE. */
+var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
+[...LABEL_SUPPLY_STEP_IDS, ...CROP_SUPPLY_STEP_IDS];
 var MODEL_FORMATS = [
 	"onnx",
 	"coreml",
@@ -8051,12 +8009,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(),
@@ -8183,15 +8164,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
@@ -12298,7 +12279,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`)
 	};
 }
 /** Item fields the composer writes itself, with the value it writes. */
@@ -17197,6 +17178,279 @@ var filesystemBrowseCapability = {
 		})
 	}
 };
+/** The central link domain the viewer app claims (Universal Links / App Links). */
+var CAMSTACK_APP_LINK_ORIGIN = "https://camstack.zentik.app";
+/** 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;
+	}
+}
+/**
+* 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;
+}
+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)
+	};
+}
 /**
 * Transport bounds for AI capability methods.
 *
@@ -19280,6 +19534,51 @@ var notificationOutputCapability = {
 		})
 	}
 };
+new Set([
+	{
+		id: "person",
+		name: "Person"
+	},
+	{
+		id: "vehicle",
+		name: "Vehicle"
+	},
+	{
+		id: "animal",
+		name: "Animal"
+	},
+	{
+		id: "package",
+		name: "Package"
+	}
+].map((l) => l.id));
+var COCO_TO_MACRO = {
+	mapping: {
+		person: "person",
+		bicycle: "vehicle",
+		car: "vehicle",
+		motorcycle: "vehicle",
+		airplane: "vehicle",
+		bus: "vehicle",
+		train: "vehicle",
+		truck: "vehicle",
+		boat: "vehicle",
+		bird: "animal",
+		cat: "animal",
+		dog: "animal",
+		horse: "animal",
+		sheep: "animal",
+		cow: "animal",
+		elephant: "animal",
+		bear: "animal",
+		zebra: "animal",
+		giraffe: "animal",
+		suitcase: "package",
+		backpack: "package",
+		handbag: "package"
+	},
+	preserveOriginal: false
+};
 var AUDIO_MACRO_LABELS = [
 	{
 		id: "speech",
@@ -25513,6 +25812,34 @@ var pipelineAnalyticsCapability = {
 	}
 };
 /**
+* 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.
@@ -25644,7 +25971,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({
@@ -26048,7 +26375,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
@@ -27361,7 +27697,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
@@ -31512,50 +31863,6 @@ var videoclipsCapability = {
 		})
 	}
 };
-/** The central link domain the viewer app claims (Universal Links / App Links). */
-var CAMSTACK_APP_LINK_ORIGIN = "https://camstack.zentik.app";
-/**
-* 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;
-}
 /**
 * Optional client-side hints sent at session creation to help the provider
 * pick the best native source. All fields optional — a viewer that knows
@@ -32031,6 +32338,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: 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: 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
@@ -36314,7 +36650,8 @@ var ConnectionEndpointSchema = zod.z.object({
 		"lan-ipv6",
 		"public",
 		"loopback",
-		"app-link"
+		"app-link",
+		"custom"
 	]),
 	/**
 	* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
@@ -36416,6 +36753,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
@@ -36528,26 +36941,78 @@ var localNetworkCapability = {
 		*/
 		getNotificationEndpoint: 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: 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: 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: 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: 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: 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: 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: 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: 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.
 		*/
@@ -49642,12 +50107,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",
@@ -49660,6 +50137,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",
@@ -49696,6 +50179,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",
@@ -49708,6 +50197,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",
@@ -53962,6 +54457,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",
@@ -58139,6 +58640,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"webrtcSession.applyDownlinkProbe": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"webrtcSession.closeSession": [{
 		name: "deviceId",
 		form: "single",
@@ -58972,7 +59478,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"],
@@ -60162,6 +60668,12 @@ Object.defineProperty(exports, "cameraGridLayoutCapability", {
 		return cameraGridLayoutCapability;
 	}
 });
+Object.defineProperty(exports, "checkRoleAddress", {
+	enumerable: true,
+	get: function() {
+		return checkRoleAddress;
+	}
+});
 Object.defineProperty(exports, "cloneStatefulExpressionMemory", {
 	enumerable: true,
 	get: function() {
@@ -60450,6 +60962,12 @@ Object.defineProperty(exports, "hydrateSchema", {
 		return hydrateSchema;
 	}
 });
+Object.defineProperty(exports, "isAppLinkBase", {
+	enumerable: true,
+	get: function() {
+		return isAppLinkBase;
+	}
+});
 Object.defineProperty(exports, "isArrayOutputSchema", {
 	enumerable: true,
 	get: function() {
@@ -60462,6 +60980,12 @@ Object.defineProperty(exports, "isCollectionArrayMethod", {
 		return isCollectionArrayMethod;
 	}
 });
+Object.defineProperty(exports, "isDefaultViewerEndpoint", {
+	enumerable: true,
+	get: function() {
+		return isDefaultViewerEndpoint;
+	}
+});
 Object.defineProperty(exports, "isDeviceConfigCap", {
 	enumerable: true,
 	get: function() {
@@ -60702,6 +61226,12 @@ Object.defineProperty(exports, "resolveCoreBlockFiles", {
 		return resolveCoreBlockFiles;
 	}
 });
+Object.defineProperty(exports, "resolveHubAddressRoles", {
+	enumerable: true,
+	get: function() {
+		return resolveHubAddressRoles;
+	}
+});
 Object.defineProperty(exports, "resolveLocationMode", {
 	enumerable: true,
 	get: function() {
@@ -60714,6 +61244,18 @@ Object.defineProperty(exports, "resolveMethodAuth", {
 		return resolveMethodAuth;
 	}
 });
+Object.defineProperty(exports, "resolveNotificationsAddress", {
+	enumerable: true,
+	get: function() {
+		return resolveNotificationsAddress;
+	}
+});
+Object.defineProperty(exports, "resolveViewerAddresses", {
+	enumerable: true,
+	get: function() {
+		return resolveViewerAddresses;
+	}
+});
 Object.defineProperty(exports, "runtimeStatePolicyFor", {
 	enumerable: true,
 	get: function() {
@@ -60828,6 +61370,12 @@ Object.defineProperty(exports, "validateComposition", {
 		return validateComposition;
 	}
 });
+Object.defineProperty(exports, "validateCustomAddress", {
+	enumerable: true,
+	get: function() {
+		return validateCustomAddress;
+	}
+});
 Object.defineProperty(exports, "vectorDimFromBase64", {
 	enumerable: true,
 	get: function() {