@camstack/addon-osd-manager 0.1.156 → 0.1.160

package/dist/index.js

@@ -15445,6 +15445,51 @@ var SourceInfoSchema = object({
 	raw: record(string(), unknown()).optional()
 });
 /**
+* Coerce common unit-of-measurement string variants to a canonical form
+* so the UI's display templates can rely on stable strings. Pure
+* passthrough for unknown units — kept conservative on purpose, the goal
+* is to normalise the long tail of HA `unit_of_measurement` values that
+* have multiple historical spellings (`'°C'` vs `'C'` vs `'celsius'`).
+*
+* Extend the map as we encounter real-world data. Returning the raw
+* input for unknown values is intentional: providers should never
+* lose information silently here.
+*/
+function normalizeUnit(raw) {
+	if (raw == null) return void 0;
+	const trimmed = raw.trim();
+	if (trimmed === "") return void 0;
+	const lower = trimmed.toLowerCase();
+	if (lower === "°c" || lower === "c" || lower === "celsius") return "°C";
+	if (lower === "°f" || lower === "f" || lower === "fahrenheit") return "°F";
+	if (lower === "k" || lower === "kelvin") return "K";
+	if (lower === "%" || lower === "percent" || lower === "percentage") return "%";
+	if (lower === "lx" || lower === "lux") return "lx";
+	if (lower === "hpa" || lower === "hectopascal") return "hPa";
+	if (lower === "kpa") return "kPa";
+	if (lower === "pa") return "Pa";
+	if (lower === "mbar" || lower === "millibar") return "mbar";
+	if (lower === "w" || lower === "watt") return "W";
+	if (lower === "kw" || lower === "kilowatt") return "kW";
+	if (lower === "wh" || lower === "watt-hour") return "Wh";
+	if (lower === "kwh" || lower === "kilowatt-hour") return "kWh";
+	if (lower === "v" || lower === "volt") return "V";
+	if (lower === "a" || lower === "amp" || lower === "ampere") return "A";
+	if (lower === "ma" || lower === "milliampere") return "mA";
+	if (lower === "va") return "VA";
+	if (lower === "ppm") return "ppm";
+	if (lower === "ppb") return "ppb";
+	if (lower === "µg/m³" || lower === "ug/m3" || lower === "µg/m3") return "µg/m³";
+	if (lower === "km/h" || lower === "kph") return "km/h";
+	if (lower === "mph") return "mph";
+	if (lower === "m/s") return "m/s";
+	if (lower === "m") return "m";
+	if (lower === "km") return "km";
+	if (lower === "kg") return "kg";
+	if (lower === "g") return "g";
+	return trimmed;
+}
+/**
 * device-discovery — device-scoped capability for parents that host /
 * enumerate child devices (Reolink Hub / NVR, ONVIF gateway, future
 * integrations). The parent advertises a list of discoverable children,
@@ -39296,28 +39341,50 @@ setOverlay: method(object({
 *
 * This cap owns the other half: a per-(camera, slot) BINDING that says
 * which value feeds the slot, how it is formatted, and under which
-* conditions it is shown at all. One addon renders every binding on every
-* camera, so a new source costs zero driver code.
-*
-* Three deliberate choices, each with a rejected alternative:
-*
-*  1. A source is `(capName, valuePath)` over the kernel's device
-*     runtime-state mirror — NOT a closed enum of source kinds. Every
-*     cap-keyed slice a device publishes is bindable the day the cap
-*     ships. The rejected alternative (one enum member per source, with
-*     a resolver branch each) is what makes "add the humidity too" a
-*     code change.
-*  2. The display gate reuses `NcConditionsSchema` verbatim — the
-*     notification centre's condition vocabulary — rather than a parallel
-*     model. An operator who has learned one condition editor has learned
-*     both.
-*  3. Because the renderer's facts are device STATE and not a detection
-*     record, only a SUBSET of that vocabulary can be answered here.
-*     `setSlotBinding` REJECTS the rest at write time (see
-*     `getConditionSupport`). It does not accept-then-fail-closed: a
-*     condition that can never be true renders a permanently blank
-*     overlay, and a blank overlay looks exactly like a broken camera.
+* conditions it is shown at all. Named TEMPLATES combine many device
+* fields into one overlay string (Scrypted OSD Manager parity).
+*/
+/** What `{alias}` expands to for one template binding. Exactly one choice. */
+var OsdTemplateFormatSchema = _enum([
+	"value+unit",
+	"value",
+	"unit"
+]);
+/**
+* How the operator reached the leaf device. `deviceId` is ALWAYS the
+* OSD-supported leaf that is read; `containerId` is set when the pick
+* went through a container (gateway) first.
+*/
+var OsdTemplatePickSchema = object({
+	containerId: number().int().optional(),
+	deviceId: number().int()
+});
+/**
+* One named binding inside a multi-device template. The parser only
+* sees `{alias}`; format / unit / decimals live here structurally.
+*/
+var OsdTemplateBindingSchema = object({
+	/** Token in the parser, e.g. `t` → `{t}`. Unique within the template. */
+	alias: string().min(1).max(32).regex(/^[A-Za-z][A-Za-z0-9_-]*$/, "alias must start with a letter"),
+	pick: OsdTemplatePickSchema,
+	capName: string().min(1).max(64),
+	valuePath: string().min(1).max(64),
+	format: OsdTemplateFormatSchema.default("value+unit"),
+	/** Convert TO this unit at render (`tryConvertUnit`). Absent = source unit. */
+	displayUnit: string().max(16).optional(),
+	maxDecimals: number().int().min(0).max(4).default(1)
+});
+/**
+* A named template: bindings (alias → leaf field) + a parser that only
+* references `{alias}` tokens.
 */
+var OsdNamedTemplateSchema = object({
+	id: string().min(1).max(64),
+	name: string().min(1).max(64),
+	bindings: array(OsdTemplateBindingSchema).max(32).default([]),
+	/** Parser with alias placeholders, e.g. `{t} / {h}`. */
+	parser: string().max(256).default("")
+});
 /** Where a slot's value comes from. */
 var OsdSourceSchema = discriminatedUnion("kind", [
 	object({
@@ -39336,11 +39403,17 @@ var OsdSourceSchema = discriminatedUnion("kind", [
 		deviceId: number().int().optional(),
 		capName: string().min(1).max(64),
 		/** Dot path inside the slice, e.g. `detected`, `value`, `mode`. */
-		valuePath: string().min(1).max(64)
+		valuePath: string().min(1).max(64),
+		/** Convert TO this unit at render. Absent = no conversion. */
+		displayUnit: string().max(16).optional()
 	}),
 	object({
 		kind: literal("latest-recognition"),
 		recognition: _enum(["person", "plate"])
+	}),
+	object({
+		kind: literal("template"),
+		templateId: string().min(1).max(64)
 	})
 ]);
 var OsdSlotBindingSchema = object({
@@ -39356,7 +39429,10 @@ var OsdSlotBindingSchema = object({
 	* documented workaround for firmwares that reject `.` in overlay text.
 	*/
 	maxDecimals: number().int().min(0).max(4).default(1),
-	/** Appended via `${unit}`. The state mirror does not carry units. */
+	/**
+	* Appended via `${unit}` when no unit conversion produces a label.
+	* Prefer `source.displayUnit` for converted device-state values.
+	*/
 	unitLabel: string().max(8).optional(),
 	/** Raw value → display text, e.g. `{"true":"MOTION","false":""}`. */
 	valueMap: record(string(), string()).optional(),
@@ -39510,6 +39586,21 @@ var osdManagerCapability = {
 		renderDevice: method(object({ deviceId: number().int() }), object({ results: array(OsdRenderResultSchema) }), {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/** Every named multi-device template. */
+		listTemplates: method(object({}), object({ templates: array(OsdNamedTemplateSchema) }), { auth: "admin" }),
+		/**
+		* Create or replace a named template by `id`. Returns the stored record
+		* after Zod normalisation.
+		*/
+		upsertTemplate: method(object({ template: OsdNamedTemplateSchema }), object({ template: OsdNamedTemplateSchema }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Drop a named template. Bindings that still reference it render unreadable. */
+		deleteTemplate: method(object({ templateId: string().min(1).max(64) }), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -45260,6 +45351,265 @@ var zoneRulesCapability = {
 	*/
 	durability: "restored"
 };
+/**
+* Frozen unit → spec table. `•` in the doc marks each dimension's canonical
+* unit (`factor: 1, offset: 0`). °F derives from `°C = (°F − 32) × 5/9` ⇒
+* `factor = 5/9`, `offset = -160/9` (kept as exact expressions, not rounded
+* decimals). K derives from `°C = K − 273.15`.
+*/
+var UNIT_TABLE = {
+	"°C": {
+		dimension: "temperature",
+		factor: 1,
+		offset: 0
+	},
+	"°F": {
+		dimension: "temperature",
+		factor: 5 / 9,
+		offset: -160 / 9
+	},
+	K: {
+		dimension: "temperature",
+		factor: 1,
+		offset: -273.15
+	},
+	hPa: {
+		dimension: "pressure",
+		factor: 1,
+		offset: 0
+	},
+	kPa: {
+		dimension: "pressure",
+		factor: 10,
+		offset: 0
+	},
+	Pa: {
+		dimension: "pressure",
+		factor: .01,
+		offset: 0
+	},
+	mbar: {
+		dimension: "pressure",
+		factor: 1,
+		offset: 0
+	},
+	bar: {
+		dimension: "pressure",
+		factor: 1e3,
+		offset: 0
+	},
+	inHg: {
+		dimension: "pressure",
+		factor: 33.8639,
+		offset: 0
+	},
+	mmHg: {
+		dimension: "pressure",
+		factor: 1.33322,
+		offset: 0
+	},
+	psi: {
+		dimension: "pressure",
+		factor: 68.9476,
+		offset: 0
+	},
+	"m/s": {
+		dimension: "speed",
+		factor: 1,
+		offset: 0
+	},
+	"km/h": {
+		dimension: "speed",
+		factor: 1 / 3.6,
+		offset: 0
+	},
+	mph: {
+		dimension: "speed",
+		factor: .44704,
+		offset: 0
+	},
+	kn: {
+		dimension: "speed",
+		factor: .514444,
+		offset: 0
+	},
+	"mm/h": {
+		dimension: "precipitation-rate",
+		factor: 1,
+		offset: 0
+	},
+	"in/h": {
+		dimension: "precipitation-rate",
+		factor: 25.4,
+		offset: 0
+	},
+	m: {
+		dimension: "length",
+		factor: 1,
+		offset: 0
+	},
+	mm: {
+		dimension: "length",
+		factor: .001,
+		offset: 0
+	},
+	cm: {
+		dimension: "length",
+		factor: .01,
+		offset: 0
+	},
+	km: {
+		dimension: "length",
+		factor: 1e3,
+		offset: 0
+	},
+	in: {
+		dimension: "length",
+		factor: .0254,
+		offset: 0
+	},
+	ft: {
+		dimension: "length",
+		factor: .3048,
+		offset: 0
+	},
+	mi: {
+		dimension: "length",
+		factor: 1609.344,
+		offset: 0
+	},
+	lx: {
+		dimension: "illuminance",
+		factor: 1,
+		offset: 0
+	},
+	"W/m²": {
+		dimension: "irradiance",
+		factor: 1,
+		offset: 0
+	},
+	W: {
+		dimension: "power",
+		factor: 1,
+		offset: 0
+	},
+	kW: {
+		dimension: "power",
+		factor: 1e3,
+		offset: 0
+	},
+	VA: {
+		dimension: "apparent-power",
+		factor: 1,
+		offset: 0
+	},
+	Wh: {
+		dimension: "energy",
+		factor: 1,
+		offset: 0
+	},
+	kWh: {
+		dimension: "energy",
+		factor: 1e3,
+		offset: 0
+	},
+	MWh: {
+		dimension: "energy",
+		factor: 1e6,
+		offset: 0
+	},
+	V: {
+		dimension: "voltage",
+		factor: 1,
+		offset: 0
+	},
+	mV: {
+		dimension: "voltage",
+		factor: .001,
+		offset: 0
+	},
+	A: {
+		dimension: "current",
+		factor: 1,
+		offset: 0
+	},
+	mA: {
+		dimension: "current",
+		factor: .001,
+		offset: 0
+	},
+	ppm: {
+		dimension: "concentration-volume",
+		factor: 1,
+		offset: 0
+	},
+	ppb: {
+		dimension: "concentration-volume",
+		factor: .001,
+		offset: 0
+	},
+	"µg/m³": {
+		dimension: "concentration-mass",
+		factor: 1,
+		offset: 0
+	},
+	"mg/m³": {
+		dimension: "concentration-mass",
+		factor: 1e3,
+		offset: 0
+	},
+	kg: {
+		dimension: "mass",
+		factor: 1,
+		offset: 0
+	},
+	g: {
+		dimension: "mass",
+		factor: .001,
+		offset: 0
+	},
+	lb: {
+		dimension: "mass",
+		factor: .453592,
+		offset: 0
+	},
+	oz: {
+		dimension: "mass",
+		factor: .0283495,
+		offset: 0
+	},
+	"%": {
+		dimension: "percentage",
+		factor: 1,
+		offset: 0
+	}
+};
+/** Resolve a unit's `UnitSpec`, or `undefined` when the spelling is unknown. */
+function specFor(unit) {
+	return Object.hasOwn(UNIT_TABLE, unit) ? UNIT_TABLE[unit] : void 0;
+}
+/** Value in `spec`'s unit → its dimension's canonical unit. */
+function toCanonical(value, spec) {
+	return value * spec.factor + spec.offset;
+}
+/** Canonical-unit value → the unit described by `spec`. */
+function fromCanonical(canonical, spec) {
+	return (canonical - spec.offset) / spec.factor;
+}
+/**
+* Graceful variant for the render path: returns the converted value, or
+* `undefined` when the conversion is refused (unknown unit / cross-dimension).
+* Never throws — a render caller falls back to the raw value + source unit.
+*/
+function tryConvertUnit(value, from, to) {
+	if (from === to) return value;
+	const fromSpec = specFor(from);
+	if (!fromSpec) return void 0;
+	const toSpec = specFor(to);
+	if (!toSpec) return void 0;
+	if (fromSpec.dimension !== toSpec.dimension) return void 0;
+	return fromCanonical(toCanonical(value, fromSpec), toSpec);
+}
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
 /**
 * Most specific first. Extending this list is how a new device kind becomes
@@ -50628,6 +50978,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.deleteTemplate": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"osdManager.getConditionSupport": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -50646,6 +51002,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"osdManager.listTemplates": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"osdManager.previewSlot": {
 		capName: "osd-manager",
 		capScope: "system",
@@ -50664,6 +51026,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"osdManager.upsertTemplate": {
+		capName: "osd-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"petFeeder.callPet": {
 		capName: "pet-feeder",
 		capScope: "device",
@@ -57912,10 +58280,10 @@ function limitText(text, max) {
 	return `${text.slice(0, max - 3)}...`;
 }
 /** Turn a raw state value into the string that goes into `${value}`. */
-function displayValue(raw, binding) {
+function displayValue(raw, binding, maxDecimals = binding.maxDecimals) {
 	const mapped = binding.valueMap?.[String(raw)];
 	if (mapped !== void 0) return mapped;
-	if (typeof raw === "number") return truncateDecimals(raw, binding.maxDecimals);
+	if (typeof raw === "number") return truncateDecimals(raw, maxDecimals);
 	if (typeof raw === "boolean") return raw ? "ON" : "OFF";
 	if (raw === null || raw === void 0) return "";
 	if (typeof raw === "string") return raw;
@@ -57929,9 +58297,10 @@ function applyTemplate(template, value, unit) {
 	return template.replaceAll("${value}", value).replaceAll("${unit}", unit);
 }
 /** The whole formatting chain: raw value → the text to burn into the slot. */
-function formatSlotText(raw, binding) {
-	const value = displayValue(raw, binding);
-	return limitText(applyTemplate(binding.template, value, binding.unitLabel ?? "").trim(), binding.maxCharacters);
+function formatSlotText(raw, binding, options = {}) {
+	const value = displayValue(options.displayRaw ?? raw, binding);
+	const unit = options.unit ?? binding.unitLabel ?? "";
+	return limitText(applyTemplate(binding.template, value, unit).trim(), binding.maxCharacters);
 }
 //#endregion
 //#region src/state-leaves.ts
@@ -58019,6 +58388,144 @@ function readStatePath(slice, path) {
 	return current;
 }
 //#endregion
+//#region src/template-tokens.ts
+/** Build the placeholder token for one binding alias. */
+function aliasToken(alias) {
+	return `{${alias}}`;
+}
+/** Chip / parser token for a binding. */
+function bindingToken(binding) {
+	return aliasToken(binding.alias);
+}
+/** Parse `{alias}` tokens from a parser string (letters, digits, `_`, `-`). */
+function parseAliasTokens(parser) {
+	const out = [];
+	for (const match of parser.matchAll(/\{([A-Za-z][A-Za-z0-9_-]*)\}/g)) {
+		const alias = match[1];
+		if (alias === void 0 || alias === "") continue;
+		if (!out.includes(alias)) out.push(alias);
+	}
+	return out;
+}
+/** Replace every occurrence of `token` in `parser` with `value`. */
+function replaceToken(parser, token, value) {
+	return parser.replaceAll(token, value);
+}
+/**
+* Suggest a short unique alias from a device/field name.
+* Falls back to `b1`, `b2`, … when the slug collides.
+*/
+function suggestAlias(seed, taken, fallbackPrefix = "b") {
+	const slug = seed.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").replace(/^(\d)/, "a$1").slice(0, 24);
+	const base = slug.length > 0 ? slug : fallbackPrefix;
+	if (!taken.has(base)) return base;
+	for (let i = 2; i < 1e3; i += 1) {
+		const candidate = `${base}${i}`.slice(0, 32);
+		if (!taken.has(candidate)) return candidate;
+	}
+	return `${fallbackPrefix}${Date.now().toString(36)}`;
+}
+//#endregion
+//#region src/unit-display.ts
+/**
+* Convert a numeric state value for OSD display using `@camstack/types`
+* UNIT_TABLE / tryConvertUnit (same set as D699).
+*/
+/**
+* Convert `raw` from `sourceUnit` to `displayUnit` when both are known and
+* same-dimension. On refusal, keep the raw value and the source unit so the
+* label never lies about the number.
+*/
+function convertForDisplay(raw, sourceUnit, displayUnit) {
+	const from = sourceUnit !== void 0 ? normalizeUnit(sourceUnit) : void 0;
+	const to = displayUnit !== void 0 ? normalizeUnit(displayUnit) : void 0;
+	if (from === void 0 || to === void 0 || from === to) return {
+		value: raw,
+		unit: to ?? from ?? ""
+	};
+	const converted = tryConvertUnit(raw, from, to);
+	if (converted === void 0) return {
+		value: raw,
+		unit: from
+	};
+	return {
+		value: converted,
+		unit: to
+	};
+}
+/**
+* Best-effort unit from a state slice: sibling `unit` at the same depth as
+* `valuePath`, else top-level `unit`.
+*/
+function inferSourceUnit(slice, valuePath) {
+	if (typeof slice !== "object" || slice === null || Array.isArray(slice)) return void 0;
+	const root = { ...slice };
+	const segments = valuePath.split(".");
+	if (segments.length >= 1) {
+		let parent = root;
+		for (const segment of segments.slice(0, -1)) {
+			if (typeof parent !== "object" || parent === null || Array.isArray(parent)) {
+				parent = void 0;
+				break;
+			}
+			parent = { ...parent }[segment];
+		}
+		if (typeof parent === "object" && parent !== null && !Array.isArray(parent)) {
+			const unit = { ...parent }.unit;
+			if (typeof unit === "string" && unit.length > 0) return unit;
+		}
+	}
+	const top = root.unit;
+	return typeof top === "string" && top.length > 0 ? top : void 0;
+}
+//#endregion
+//#region src/named-template-render.ts
+/** Combine value/unit according to the binding's single format choice. */
+function applyTemplateFormat(value, unit, format) {
+	if (format === "value") return value;
+	if (format === "unit") return unit;
+	const v = value.trim();
+	const u = unit.trim();
+	if (v === "") return u;
+	if (u === "") return v;
+	return `${v} ${u}`;
+}
+/** Resolve one binding to live value/unit/formatted parts (or a reason). */
+function resolveBindingLive(binding, facts) {
+	const deviceId = binding.pick.deviceId;
+	const deviceState = facts.stateByDevice.get(deviceId);
+	if (deviceState === void 0) return { reason: `no state mirrored for device ${deviceId}` };
+	const slice = deviceState[binding.capName];
+	if (slice === void 0) return { reason: `device ${deviceId} publishes no "${binding.capName}" state` };
+	const raw = readStatePath(slice, binding.valuePath);
+	if (raw === void 0) return { reason: `"${binding.capName}.${binding.valuePath}" is absent on device ${deviceId}` };
+	let value;
+	let unit = "";
+	if (typeof raw === "number") {
+		const converted = convertForDisplay(raw, inferSourceUnit(slice, binding.valuePath), binding.displayUnit);
+		value = truncateDecimals(converted.value, binding.maxDecimals);
+		unit = converted.unit;
+	} else if (typeof raw === "boolean") value = raw ? "ON" : "OFF";
+	else if (raw === null) value = "";
+	else value = String(raw);
+	return {
+		value,
+		unit,
+		formatted: applyTemplateFormat(value, unit, binding.format)
+	};
+}
+/** Render one named template's parser from live states. */
+function renderNamedTemplate(template, facts) {
+	let text = template.parser;
+	if (template.bindings.length === 0) return text.trim() === "" ? { reason: `template "${template.id}" has no bindings` } : { text };
+	for (const binding of template.bindings) {
+		const live = resolveBindingLive(binding, facts);
+		if ("reason" in live) return live;
+		text = replaceToken(text, aliasToken(binding.alias), live.formatted);
+	}
+	return { text };
+}
+//#endregion
 //#region src/render.ts
 /**
 * Read the source's value. `null` means "unreadable" — a missing device, a
@@ -58033,6 +58540,16 @@ function resolveSource(binding, cameraDeviceId, facts) {
 		const value = facts.recognitionByDevice.get(cameraDeviceId)?.[source.recognition];
 		return value === void 0 ? { reason: `no recognized ${source.recognition} has been persisted for device ${cameraDeviceId}` } : { value: { raw: value } };
 	}
+	if (source.kind === "template") {
+		const named = facts.templatesById.get(source.templateId);
+		if (named === void 0) return { reason: `named template "${source.templateId}" is missing` };
+		const rendered = renderNamedTemplate(named, { stateByDevice: facts.stateByDevice });
+		if ("reason" in rendered) return rendered;
+		return { value: {
+			raw: rendered.text,
+			preformatted: rendered.text
+		} };
+	}
 	const deviceId = source.deviceId ?? cameraDeviceId;
 	const deviceState = facts.stateByDevice.get(deviceId);
 	if (deviceState === void 0) return { reason: `no state mirrored for device ${deviceId}` };
@@ -58040,6 +58557,14 @@ function resolveSource(binding, cameraDeviceId, facts) {
 	if (slice === void 0) return { reason: `device ${deviceId} publishes no "${source.capName}" state` };
 	const raw = readStatePath(slice, source.valuePath);
 	if (raw === void 0) return { reason: `"${source.capName}.${source.valuePath}" is absent on device ${deviceId}` };
+	if (typeof raw === "number") {
+		const converted = convertForDisplay(raw, inferSourceUnit(slice, source.valuePath), source.displayUnit);
+		return { value: {
+			raw,
+			displayRaw: converted.value,
+			unit: converted.unit || binding.unitLabel
+		} };
+	}
 	return { value: { raw } };
 }
 /**
@@ -58072,7 +58597,12 @@ function renderSlot(slotId, binding, cameraDeviceId, facts, previousText) {
 	if (!gate.open) return settle(slotId, fallback, previousText, "gated", `condition "${gate.failedCondition}"`);
 	const resolved = resolveSource(binding, cameraDeviceId, facts);
 	if ("reason" in resolved) return settle(slotId, fallback, previousText, "unreadable", resolved.reason);
-	return settle(slotId, formatSlotText(resolved.value.raw, binding), previousText, "written");
+	if (resolved.value.preformatted !== void 0 && binding.source.kind === "template") return settle(slotId, limitText(resolved.value.preformatted.trim(), binding.maxCharacters), previousText, "written");
+	const unit = resolved.value.unit ?? binding.unitLabel;
+	return settle(slotId, formatSlotText(resolved.value.raw, binding, {
+		...resolved.value.displayRaw !== void 0 ? { displayRaw: resolved.value.displayRaw } : {},
+		...unit !== void 0 ? { unit } : {}
+	}), previousText, "written");
 }
 function settle(slotId, text, previousText, outcome, reason) {
 	if (previousText !== void 0 && previousText === text) return {
@@ -58093,20 +58623,98 @@ function settle(slotId, text, previousText, outcome, reason) {
 	};
 }
 //#endregion
+//#region src/osd-source-fields.ts
+/** Caps the OSD source picker may bind. */
+var OSD_SOURCE_CAP_NAMES = new Set([
+	"temperature-sensor",
+	"humidity-sensor",
+	"climate-control",
+	"numeric-sensor",
+	"weather",
+	"air-quality-sensor",
+	"lock-control",
+	"contact",
+	"binary",
+	"battery"
+]);
+/**
+* Per-cap leaf allowlist. Absent entry ⇒ every leaf from `stateLeavesOf`
+* that survives bookkeeping (single-metric sensors). Present ⇒ only these
+* paths (climate / weather / battery).
+*/
+var OSD_SOURCE_PATHS = new Map([
+	["climate-control", new Set([
+		"currentTemp",
+		"currentHumidity",
+		"target",
+		"targetHumidity",
+		"mode"
+	])],
+	["weather", new Set([
+		"condition",
+		"temperature",
+		"humidity",
+		"pressure",
+		"windSpeed",
+		"windBearing"
+	])],
+	["battery", new Set(["percentage"])],
+	["temperature-sensor", new Set(["celsius"])],
+	["humidity-sensor", new Set(["percent"])],
+	["numeric-sensor", new Set(["value"])],
+	["air-quality-sensor", new Set([
+		"co2Ppm",
+		"vocPpb",
+		"pm25",
+		"pm10",
+		"aqi"
+	])],
+	["binary", new Set(["on"])],
+	["contact", new Set(["entryOpen"])],
+	["lock-control", new Set(["state"])]
+]);
+function isOsdSourceCap(capName) {
+	return OSD_SOURCE_CAP_NAMES.has(capName);
+}
+/** Bindable OSD leaves for one cap — empty when the cap is not OSD-relevant. */
+function osdStateLeavesOf(cap) {
+	if (!isOsdSourceCap(cap.name)) return [];
+	const leaves = stateLeavesOf(cap);
+	const allowed = OSD_SOURCE_PATHS.get(cap.name);
+	if (allowed === void 0) return leaves;
+	return leaves.filter((leaf) => allowed.has(leaf.path));
+}
+/** Device types that never contribute their OWN catalog leaves. */
+var OSD_NON_LEAF_TYPES = new Set(["container"]);
+/** True when this device type may expose OSD leaves (not a container gateway). */
+function isOsdLeafDeviceType(type) {
+	if (type === null || type === void 0) return true;
+	return !OSD_NON_LEAF_TYPES.has(type);
+}
+/** @deprecated Prefer {@link isOsdLeafDeviceType}. */
+var OSD_PICKER_EXCLUDED_TYPES = OSD_NON_LEAF_TYPES;
+/** @deprecated Prefer {@link isOsdLeafDeviceType}. */
+function isOsdPickerDeviceType(type) {
+	return isOsdLeafDeviceType(type);
+}
+function isContainerDeviceType(type) {
+	return type === "container";
+}
+//#endregion
 //#region src/source-catalog.ts
 /**
-* Build the editor's source picker from the CAP DEFINITIONS — never a
-* hand-written list. A cap that ships a new runtime-state field becomes
-* bindable the moment it deploys, with no change here.
+* Build the editor's source picker from OSD-relevant cap definitions.
+* Gateway / infrastructure caps (broker, mqtt, deviceExport, …) never
+* appear — see `osd-source-fields.ts`.
 */
 /** Turn `air-quality-sensor` + `pm25` into `Air Quality Sensor · pm25`. */
 function humanizeCapName(capName) {
 	return capName.split("-").map((part) => part.length === 0 ? part : part[0].toUpperCase() + part.slice(1)).join(" ");
 }
 /**
-* Every bindable value across the cluster, with the camera's own state
-* first — that is what an operator reaches for, and a picker that buries
-* it under 200 other devices is a picker nobody uses.
+* Every OSD-bindable value across the cluster, with the camera's own
+* state first — that is what an operator reaches for, and a picker that
+* buries it under 200 other devices is a picker nobody uses.
 */
 function sourceOptionsFor(cameraDeviceId, devices, capsByDevice) {
 	const capsByName = new Map(ALL_CAPABILITY_DEFINITIONS.map((cap) => [cap.name, cap]));
@@ -58116,22 +58724,44 @@ function sourceOptionsFor(cameraDeviceId, devices, capsByDevice) {
 		return a.id - b.id;
 	});
 	const options = [];
-	for (const device of ordered) for (const capName of capsByDevice.get(device.id) ?? []) {
-		const cap = capsByName.get(capName);
-		if (cap === void 0) continue;
-		for (const leaf of stateLeavesOf(cap)) options.push({
-			deviceId: device.id,
-			deviceName: device.name,
-			capName,
-			valuePath: leaf.path,
-			label: `${humanizeCapName(capName)} · ${leaf.path}`,
-			valueType: leaf.valueType,
-			...leaf.enumValues !== void 0 ? { enumValues: leaf.enumValues } : {}
-		});
+	for (const device of ordered) {
+		if (!isOsdLeafDeviceType(device.type ?? null)) continue;
+		for (const capName of capsByDevice.get(device.id) ?? []) {
+			if (!isOsdSourceCap(capName)) continue;
+			const cap = capsByName.get(capName);
+			if (cap === void 0) continue;
+			for (const leaf of osdStateLeavesOf(cap)) options.push({
+				deviceId: device.id,
+				deviceName: device.name,
+				capName,
+				valuePath: leaf.path,
+				label: `${humanizeCapName(capName)} · ${leaf.path}`,
+				valueType: leaf.valueType,
+				...leaf.enumValues !== void 0 ? { enumValues: leaf.enumValues } : {}
+			});
+		}
 	}
 	return options;
 }
 //#endregion
+//#region src/templates-store.ts
+/**
+* Named OSD templates — durable in the addon's own (global) store.
+*/
+var OSD_TEMPLATES_KEY = "namedTemplates";
+var OsdNamedTemplatesSchema = array(OsdNamedTemplateSchema);
+var EMPTY_TEMPLATES = [];
+function upsertNamedTemplate(prev, template) {
+	const parsed = OsdNamedTemplateSchema.parse(template);
+	return [...prev.filter((t) => t.id !== parsed.id), parsed].toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function deleteNamedTemplate(prev, templateId) {
+	return prev.filter((t) => t.id !== templateId);
+}
+function findNamedTemplate(templates, templateId) {
+	return templates.find((t) => t.id === templateId);
+}
+//#endregion
 //#region src/osd-manager.ts
 /**
 * The `osd-manager` provider — the render loop and the operator surface.
@@ -58495,6 +59125,26 @@ var OsdManager = class {
 	renderDevice = async ({ deviceId }) => {
 		return { results: [...await this.renderDeviceInternal(deviceId, null)] };
 	};
+	listTemplates = async () => {
+		return { templates: [...await this.deps.templates.get()] };
+	};
+	upsertTemplate = async ({ template }) => {
+		const next = upsertNamedTemplate(await this.deps.templates.get(), template);
+		await this.deps.templates.set(next);
+		const stored = findNamedTemplate(next, template.id);
+		if (stored === void 0) throw new Error(`osd-manager: template "${template.id}" missing after upsert`);
+		this.logger.info("osd-manager: named template upserted", { meta: {
+			templateId: stored.id,
+			bindingCount: stored.bindings.length
+		} });
+		return { template: stored };
+	};
+	deleteTemplate = async ({ templateId }) => {
+		const prev = await this.deps.templates.get();
+		await this.deps.templates.set(deleteNamedTemplate(prev, templateId));
+		this.logger.info("osd-manager: named template deleted", { meta: { templateId } });
+		return { success: true };
+	};
 	async renderAllBound() {
 		for (const deviceId of [...this.boundDevices]) try {
 			await this.renderDeviceInternal(deviceId, null);
@@ -58562,11 +59212,19 @@ var OsdManager = class {
 	async collectFacts(cameraDeviceId, bindings) {
 		const wanted = new Set([cameraDeviceId]);
 		const needsRecognition = Object.values(bindings).some((binding) => binding.source.kind === "latest-recognition");
+		const templateIds = /* @__PURE__ */ new Set();
 		for (const binding of Object.values(bindings)) {
 			if (binding.source.kind === "device-state" && binding.source.deviceId !== void 0) wanted.add(binding.source.deviceId);
+			if (binding.source.kind === "template") templateIds.add(binding.source.templateId);
 			const gated = binding.conditions?.deviceState?.deviceId;
 			if (gated !== void 0) wanted.add(gated);
 		}
+		const allTemplates = await this.deps.templates.get();
+		const templatesById = /* @__PURE__ */ new Map();
+		for (const named of allTemplates) {
+			templatesById.set(named.id, named);
+			if (templateIds.has(named.id)) for (const binding of named.bindings) wanted.add(binding.pick.deviceId);
+		}
 		const stateByDevice = /* @__PURE__ */ new Map();
 		const gateState = /* @__PURE__ */ new Map();
 		for (const id of wanted) try {
@@ -58591,7 +59249,8 @@ var OsdManager = class {
 			atMs: this.now(),
 			stateByDevice,
 			recognitionByDevice,
-			deviceState: (id) => gateState.get(id)
+			deviceState: (id) => gateState.get(id),
+			templatesById
 		};
 	}
 	async hydrateRecognitions(deviceId) {
@@ -58732,6 +59391,7 @@ var OsdManagerAddon = class extends BaseAddon {
 		const ctx = this.ctx;
 		const store = new OsdBindingsStore((deviceId, key, schema, fallback) => this.deviceState(deviceId, key, schema, fallback));
 		const boundIndex = this.state(OSD_BOUND_INDEX_KEY, OsdBoundIndexSchema, null);
+		const templates = this.state(OSD_TEMPLATES_KEY, OsdNamedTemplatesSchema, EMPTY_TEMPLATES);
 		const manager = new OsdManager({
 			logger: ctx.logger,
 			readOsdStatus: async (deviceId) => {
@@ -58765,7 +59425,8 @@ var OsdManagerAddon = class extends BaseAddon {
 			listDevices: async () => {
 				return (await ctx.api.deviceManager.listAll.query({ projection: "slim" })).map((d) => ({
 					id: d.id,
-					name: d.name
+					name: d.name,
+					type: d.type ?? null
 				}));
 			},
 			listCameras: async () => {
@@ -58805,7 +59466,8 @@ var OsdManagerAddon = class extends BaseAddon {
 				};
 			},
 			bindings: (deviceId) => store.forDevice(deviceId),
-			boundIndex
+			boundIndex,
+			templates
 		});
 		this.manager = manager;
 		this.subscribe({ category: EventCategory.PipelineAnalyticsTrackLifecycle }, (event) => {
@@ -58862,28 +59524,86 @@ var OsdManagerAddon = class extends BaseAddon {
 	}
 };
 //#endregion
+//#region src/osd-picker-devices.ts
+/**
+* Devices offered to the OSD DevicePicker — containers INCLUDED so the
+* operator can pick a gateway, then an OSD-supported child.
+*/
+function toOsdPickerDevices(devices) {
+	return devices.map((d) => ({
+		id: d.id,
+		name: d.name,
+		type: d.type ?? null,
+		location: d.location ?? null,
+		parentDeviceId: d.parentDeviceId ?? null
+	}));
+}
+/** Children of a container that have at least one OSD catalog field. */
+function osdSupportedChildrenOf(containerId, devices, deviceIdsWithOsdFields) {
+	return devices.filter((d) => d.parentDeviceId === containerId && isOsdLeafDeviceType(d.type) && deviceIdsWithOsdFields.has(d.id)).toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function deviceById(devices, id) {
+	return devices.find((d) => d.id === id);
+}
+//#endregion
+//#region src/template-id.ts
+/**
+* Named-template ids are system-generated — never an operator text field.
+* Create uses a uuid; the editable surface is the template name.
+*/
+function generateTemplateId() {
+	if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+	return `tpl-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/** Optional slug helper when a stable short id from the name is preferred. */
+function templateIdFromName(name) {
+	const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48);
+	return `${slug.length > 0 ? slug : "template"}-${Date.now().toString(36)}`;
+}
+//#endregion
 exports.DEFAULT_TICK_MS = DEFAULT_TICK_MS;
 exports.EMPTY_BINDINGS = EMPTY_BINDINGS;
 exports.OSD_BINDINGS_KEY = OSD_BINDINGS_KEY;
+exports.OSD_NON_LEAF_TYPES = OSD_NON_LEAF_TYPES;
+exports.OSD_PICKER_EXCLUDED_TYPES = OSD_PICKER_EXCLUDED_TYPES;
+exports.OSD_SOURCE_CAP_NAMES = OSD_SOURCE_CAP_NAMES;
 exports.OSD_SUPPORTED_CONDITIONS = OSD_SUPPORTED_CONDITIONS;
 exports.OsdBindingsStore = OsdBindingsStore;
 exports.OsdDeviceBindingsSchema = OsdDeviceBindingsSchema;
 exports.OsdManager = OsdManager;
 exports.OsdManagerAddon = OsdManagerAddon;
+exports.aliasToken = aliasToken;
 exports.applyTemplate = applyTemplate;
+exports.applyTemplateFormat = applyTemplateFormat;
 exports.assertSupportedConditions = assertSupportedConditions;
+exports.bindingToken = bindingToken;
 exports.default = OsdManagerAddon;
+exports.deviceById = deviceById;
 exports.displayValue = displayValue;
 exports.evaluateGate = evaluateGate;
 exports.formatClock = formatClock;
 exports.formatSlotText = formatSlotText;
+exports.generateTemplateId = generateTemplateId;
 exports.humanizeCapName = humanizeCapName;
+exports.isContainerDeviceType = isContainerDeviceType;
+exports.isOsdLeafDeviceType = isOsdLeafDeviceType;
+exports.isOsdPickerDeviceType = isOsdPickerDeviceType;
+exports.isOsdSourceCap = isOsdSourceCap;
 exports.limitText = limitText;
+exports.osdStateLeavesOf = osdStateLeavesOf;
+exports.osdSupportedChildrenOf = osdSupportedChildrenOf;
+exports.parseAliasTokens = parseAliasTokens;
 exports.readStatePath = readStatePath;
+exports.renderNamedTemplate = renderNamedTemplate;
 exports.renderSlot = renderSlot;
+exports.replaceToken = replaceToken;
+exports.resolveBindingLive = resolveBindingLive;
 exports.resolveSource = resolveSource;
 exports.sourceOptionsFor = sourceOptionsFor;
 exports.stateLeavesOf = stateLeavesOf;
+exports.suggestAlias = suggestAlias;
+exports.templateIdFromName = templateIdFromName;
+exports.toOsdPickerDevices = toOsdPickerDevices;
 exports.truncateDecimals = truncateDecimals;
 exports.unsupportedConditionKeys = unsupportedConditionKeys;
 exports.withBinding = withBinding;