@camstack/system 1.2.357 → 1.2.358

package/dist/{dist-CFVOy8VT.js → dist-DzAHit0a.js}

@@ -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,131 @@ var filesystemBrowseCapability = {
 		})
 	}
 };
+var IPV4_LITERAL = /^\d{1,3}(?:\.\d{1,3}){3}$/;
+function hostnameOf(baseUrl) {
+	try {
+		const host = new URL(baseUrl).hostname;
+		return host.length > 0 ? host : null;
+	} catch {
+		return null;
+	}
+}
+function isMesh(endpoint) {
+	return endpoint.kind === "public" && endpoint.interfaceKind === "vpn";
+}
+function isTunnel(endpoint) {
+	return endpoint.kind === "public" && endpoint.interfaceKind === "public";
+}
+function isPlausibleLan(endpoint) {
+	return (endpoint.kind === "lan-ipv4" || endpoint.kind === "lan-ipv6") && endpoint.plausible;
+}
+function isLanIpv4Literal(endpoint) {
+	if (endpoint.kind !== "lan-ipv4" || !endpoint.plausible) return false;
+	const host = hostnameOf(endpoint.baseUrl);
+	return host !== null && IPV4_LITERAL.test(host);
+}
+/** Lower = better; `null` = never this audience's answer. */
+function rankFor(audience, endpoint) {
+	if (endpoint.kind === "loopback" || endpoint.kind === "app-link") return null;
+	if (hostnameOf(endpoint.baseUrl) === null) return null;
+	if (audience === "cluster") {
+		if (isLanIpv4Literal(endpoint)) return 0;
+		if (isPlausibleLan(endpoint)) return 1;
+		if (isMesh(endpoint)) return 2;
+		return null;
+	}
+	if (isTunnel(endpoint)) return 0;
+	if (isMesh(endpoint)) return 1;
+	if (isLanIpv4Literal(endpoint)) return 2;
+	if (isPlausibleLan(endpoint)) return 3;
+	return null;
+}
+var LOOPBACK_HOSTS = new Set([
+	"localhost",
+	"0.0.0.0",
+	"::1",
+	"[::1]",
+	"::",
+	"[::]"
+]);
+function isLoopbackHost(hostname) {
+	const h = hostname.toLowerCase();
+	if (LOOPBACK_HOSTS.has(h) || h.endsWith(".localhost")) return true;
+	return /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
+/**
+* Validate an operator-typed override: an http(s) URL with a host, no
+* credentials, no path, and never loopback (it would name whoever dials it).
+* Answers the normalised origin (`scheme://host[:port]`).
+*/
+function validateHubAddressOverride(raw) {
+	const trimmed = raw.trim();
+	if (trimmed === "") return {
+		ok: false,
+		reason: "Enter an address, e.g. https://192.168.1.50:4443."
+	};
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return {
+			ok: false,
+			reason: "Not a URL — include http:// or https://."
+		};
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return {
+		ok: false,
+		reason: "Use an http:// or https:// address."
+	};
+	if (parsed.username !== "" || parsed.password !== "") return {
+		ok: false,
+		reason: "The address must not carry a user name or password."
+	};
+	if (parsed.hostname === "") return {
+		ok: false,
+		reason: "The address has no host."
+	};
+	if (isLoopbackHost(parsed.hostname)) return {
+		ok: false,
+		reason: "A loopback address names whoever dials it, never this hub — use an address other machines reach."
+	};
+	if (parsed.pathname !== "/" || parsed.search !== "" || parsed.hash !== "") return {
+		ok: false,
+		reason: "Enter only the address (scheme, host and port), without a path."
+	};
+	return {
+		ok: true,
+		baseUrl: parsed.origin
+	};
+}
+/** {@link pickHubBaseUrl}, saying where the answer came from. */
+function resolveHubAddress(endpoints, audience, override) {
+	if (override !== null && override !== "") {
+		const check = validateHubAddressOverride(override);
+		if (check.ok) return {
+			override,
+			resolved: check.baseUrl,
+			source: "override"
+		};
+	}
+	const auto = pickFromPalette(endpoints, audience);
+	return {
+		override: override === null || override === "" ? null : override,
+		resolved: auto,
+		source: auto === null ? "none" : "auto"
+	};
+}
+function pickFromPalette(endpoints, audience) {
+	const best = endpoints.flatMap((endpoint) => {
+		const rank = rankFor(audience, endpoint);
+		return rank === null ? [] : [{
+			rank,
+			priority: endpoint.priority,
+			endpoint
+		}];
+	}).toSorted((a, b) => a.rank - b.rank || a.priority - b.priority)[0];
+	return best === void 0 ? null : best.endpoint.baseUrl.replace(/\/+$/, "");
+}
 /**
 * Transport bounds for AI capability methods.
 *
@@ -19280,6 +19386,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 +25664,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 +25823,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 +26227,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 +27549,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
@@ -36416,6 +36619,27 @@ var ViewerEndpointsSchema = zod.z.object({
 	/** What the ranking currently resolves to (may be empty if nothing is up). */
 	resolved: zod.z.array(zod.z.string()).readonly()
 });
+/**
+* One audience's hub address (see `hub-address.ts`): the operator's stored
+* override, the address in use, and where it came from.
+*/
+var HubAddressSnapshotSchema = zod.z.object({
+	/** The operator's override, or null for automatic. */
+	override: zod.z.string().nullable(),
+	/** The address in use, or null when nothing qualifies (never loopback). */
+	resolved: zod.z.string().nullable(),
+	source: zod.z.enum([
+		"override",
+		"auto",
+		"none"
+	])
+});
+var HubAddressesSchema = zod.z.object({
+	/** "Hub address for agents" — agents' bundle/model pulls, LAN devices. */
+	cluster: HubAddressSnapshotSchema,
+	/** "Public address for sign-in links" — e-mail links, OIDC, WebAuthn, OAuth2. */
+	browser: HubAddressSnapshotSchema
+});
 var AllowedAddressesSchema = zod.z.object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -36548,6 +36772,26 @@ var localNetworkCapability = {
 		*/
 		setViewerEndpoints: method(zod.z.object({ baseUrls: zod.z.array(zod.z.string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }),
 		/**
+		* The hub's address for each audience — agents (`cluster`) and sign-in
+		* links (`browser`) — as every consumer must read it: the operator's
+		* override when set, else the automatic pick from this cap's palette,
+		* never loopback. The ONE answer to "at which address is this hub
+		* reached?"; there is no environment variable for it.
+		*/
+		getHubAddresses: method(zod.z.void(), HubAddressesSchema),
+		/**
+		* Set or clear (`baseUrl: null`) one audience's override. Validated: an
+		* http(s) origin with a host, no credentials, no path, never loopback —
+		* an invalid value is refused with the reason, nothing is stored.
+		*/
+		setHubAddress: method(zod.z.object({
+			audience: zod.z.enum(["cluster", "browser"]),
+			baseUrl: zod.z.string().nullable()
+		}), HubAddressesSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Read the operator's allowlist. Empty = "auto" (no filter). Used
 		* by the admin UI's address selector to seed its checkbox state.
 		*/
@@ -49660,6 +49904,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",
@@ -49714,6 +49964,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setHubAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.setNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -58972,7 +59228,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"],
@@ -60702,6 +60958,12 @@ Object.defineProperty(exports, "resolveCoreBlockFiles", {
 		return resolveCoreBlockFiles;
 	}
 });
+Object.defineProperty(exports, "resolveHubAddress", {
+	enumerable: true,
+	get: function() {
+		return resolveHubAddress;
+	}
+});
 Object.defineProperty(exports, "resolveLocationMode", {
 	enumerable: true,
 	get: function() {
@@ -60828,6 +61090,12 @@ Object.defineProperty(exports, "validateComposition", {
 		return validateComposition;
 	}
 });
+Object.defineProperty(exports, "validateHubAddressOverride", {
+	enumerable: true,
+	get: function() {
+		return validateHubAddressOverride;
+	}
+});
 Object.defineProperty(exports, "vectorDimFromBase64", {
 	enumerable: true,
 	get: function() {