@camstack/addon-osd-manager 0.1.156 → 0.1.157

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,29 @@ 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).
+*/
+/** One field reference inside a named multi-device template. */
+var OsdTemplateFieldSchema = object({
+	deviceId: number().int(),
+	capName: string().min(1).max(64),
+	valuePath: string().min(1).max(64),
+	/** 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: several device fields → one parser string with
+* `{deviceId.capName.valuePath}` tokens (Scrypted `{deviceId.sensorId}`).
 */
+var OsdNamedTemplateSchema = object({
+	id: string().min(1).max(64),
+	name: string().min(1).max(64),
+	fields: array(OsdTemplateFieldSchema).max(32).default([]),
+	/** Parser with multi-token placeholders, e.g. `T {12.thermometer.value}°`. */
+	parser: string().max(256).default("")
+});
 /** Where a slot's value comes from. */
 var OsdSourceSchema = discriminatedUnion("kind", [
 	object({
@@ -39336,11 +39382,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 +39408,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 +39565,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 +45330,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 +50957,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 +50981,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 +51005,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 +58259,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 +58276,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 +58367,92 @@ function readStatePath(slice, path) {
 	return current;
 }
 //#endregion
+//#region src/template-tokens.ts
+/** Build the placeholder token for one template field. */
+function fieldToken(field) {
+	return `{${field.deviceId}.${field.capName}.${field.valuePath}}`;
+}
+/** Replace every occurrence of `token` in `parser` with `value`. */
+function replaceToken(parser, token, value) {
+	return parser.replaceAll(token, value);
+}
+//#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
+/** Render one named template's parser from live states. */
+function renderNamedTemplate(template, facts) {
+	let text = template.parser;
+	if (template.fields.length === 0) return text.trim() === "" ? { reason: `template "${template.id}" has no fields` } : { text };
+	for (const field of template.fields) {
+		const token = fieldToken(field);
+		const deviceState = facts.stateByDevice.get(field.deviceId);
+		if (deviceState === void 0) return { reason: `no state mirrored for device ${field.deviceId}` };
+		const slice = deviceState[field.capName];
+		if (slice === void 0) return { reason: `device ${field.deviceId} publishes no "${field.capName}" state` };
+		const raw = readStatePath(slice, field.valuePath);
+		if (raw === void 0) return { reason: `"${field.capName}.${field.valuePath}" is absent on device ${field.deviceId}` };
+		let rendered;
+		if (typeof raw === "number") rendered = truncateDecimals(convertForDisplay(raw, inferSourceUnit(slice, field.valuePath), field.displayUnit).value, field.maxDecimals);
+		else if (typeof raw === "boolean") rendered = raw ? "ON" : "OFF";
+		else if (raw === null) rendered = "";
+		else rendered = String(raw);
+		text = replaceToken(text, token, rendered);
+	}
+	return { text };
+}
+//#endregion
 //#region src/render.ts
 /**
 * Read the source's value. `null` means "unreadable" — a missing device, a
@@ -58033,6 +58467,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 +58484,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 +58524,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 {
@@ -58132,6 +58589,24 @@ function sourceOptionsFor(cameraDeviceId, devices, capsByDevice) {
 	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 +58970,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,
+			fieldCount: stored.fields.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 +59057,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 field of named.fields) wanted.add(field.deviceId);
+		}
 		const stateByDevice = /* @__PURE__ */ new Map();
 		const gateState = /* @__PURE__ */ new Map();
 		for (const id of wanted) try {
@@ -58591,7 +59094,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 +59236,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) => {
@@ -58805,7 +59310,8 @@ var OsdManagerAddon = class extends BaseAddon {
 				};
 			},
 			bindings: (deviceId) => store.forDevice(deviceId),
-			boundIndex
+			boundIndex,
+			templates
 		});
 		this.manager = manager;
 		this.subscribe({ category: EventCategory.PipelineAnalyticsTrackLifecycle }, (event) => {