@camstack/system 1.1.23 → 1.1.25

package/dist/addon-runner.js

@@ -1,5 +1,5 @@
 const require_chunk = require("./chunk-Cek0wNdY.js");
-const require_manifest_python_deps = require("./manifest-python-deps-D7iR07uA.js");
+const require_manifest_python_deps = require("./manifest-python-deps-BqXCckob.js");
 const require_custom_action_registry = require("./custom-action-registry-vLYEFTtv.js");
 let node_fs = require("node:fs");
 node_fs = require_chunk.__toESM(node_fs);

package/dist/addon-runner.mjs

@@ -1,4 +1,4 @@
-import { I as createUdsLoggerWithControl, L as LocalChildClient, at as setWorkerNativeCapsChangeListener, bt as resolveAddonClass, i as createUdsAddonContext, nt as getWorkerNativeCapProvider, rt as getWorkerNativeCapSnapshot, st as validateProviderRegistrations, t as installManifestPythonDeps, yt as installManifestNativeDeps } from "./manifest-python-deps-hDWMDe_b.mjs";
+import { F as createUdsLoggerWithControl, I as LocalChildClient, i as createUdsAddonContext, it as setWorkerNativeCapsChangeListener, nt as getWorkerNativeCapSnapshot, ot as validateProviderRegistrations, t as installManifestPythonDeps, tt as getWorkerNativeCapProvider, vt as installManifestNativeDeps, yt as resolveAddonClass } from "./manifest-python-deps-Dxl4twM3.mjs";
 import { t as CustomActionRegistry } from "./custom-action-registry-BEXwC-oo.mjs";
 import { register } from "node:module";
 import * as fs from "node:fs";

package/dist/builtins/device-manager/device-link-overlay.d.ts

@@ -2,7 +2,12 @@ import { DeviceLink } from '@camstack/types';
 /** A target link with its source already resolved to a live numeric id. */
 export interface ResolvedTargetLink {
     readonly link: DeviceLink;
+    /** Resolved source device id for scalar sources; `-1` sentinel for a literal
+     *  source AND for an expression source (whose per-binding ids live below). */
     readonly sourceDeviceId: number;
+    /** Expression links only: binding name → resolved source device id. Literal
+     *  bindings and unresolved bindings are ABSENT from the map. */
+    readonly bindingSourceIds?: Readonly<Record<string, number>>;
 }
 /** A target that depends on a given source slice (for reactive re-emit). */
 export interface DependentLink {
@@ -15,9 +20,14 @@ export interface LinkIndexes {
     /** `${sourceDeviceId}:${sourceCap}` → targets to recompute on a source change. */
     readonly dependents: Map<string, DependentLink[]>;
 }
+/** One resolved link entry fed to `buildLinkIndexes`. */
+export interface LinkIndexEntry {
+    readonly targetDeviceId: number;
+    readonly link: DeviceLink;
+    /** Resolved scalar source id; `-1` for literal/expression sources. */
+    readonly sourceDeviceId: number;
+    /** Expression links: binding name → resolved source device id. */
+    readonly bindingSourceIds?: Readonly<Record<string, number>>;
+}
 /** Build both lookup maps from resolved link entries. Pure — order-preserving. */
-export declare function buildLinkIndexes(entries: ReadonlyArray<{
-    targetDeviceId: number;
-    link: DeviceLink;
-    sourceDeviceId: number;
-}>): LinkIndexes;
+export declare function buildLinkIndexes(entries: ReadonlyArray<LinkIndexEntry>): LinkIndexes;

package/dist/builtins/device-manager/device-link-resolver.d.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { CapabilityStatusItemArray, DeviceLink } from '@camstack/types';
+import { ResolvedTargetLink } from './device-link-overlay.js';
 /** One resolved source reading paired with the link that produced it. The
  *  `sourceValue` is already transformed; `undefined` skips the overlay. */
 export interface ResolvedLinkValue {
@@ -16,6 +17,16 @@ export interface ResolvedLinkValue {
  * `source.kind` directly.
  */
 export declare function resolveLinkValue(link: DeviceLink, readField: (cap: string, fieldPath: string) => unknown): unknown;
+/**
+ * Sync-channel expression resolution: bindings read from the mirror via
+ * `readField(deviceId, cap, fieldPath)` using the pre-resolved per-binding ids
+ * on the `ResolvedTargetLink`. A literal binding uses its constant; an absent
+ * binding id (dangling source) or a non-primitive read resolves to `null`.
+ * Returns `undefined` on parse/eval failure (skip overlay) — silent by design:
+ * the mirror path is hot and churn-free; the async channel logs. Compile
+ * failures cost one parse ever thanks to the negative LRU compile cache. Pure.
+ */
+export declare function resolveExpressionLinkValue(rl: ResolvedTargetLink, readField: (deviceId: number, cap: string, fieldPath: string) => unknown, now: number): unknown;
 /**
  * Overlay transformed source values onto `base` by dot-path, then validate the
  * result against the target cap's `statusSchema`. On validation failure the

package/dist/builtins/device-manager/device-manager.addon.js

@@ -300,7 +300,8 @@ function toDeviceInfo(addonId, device, metadata = null, metaRow = null) {
 		...metaRow?.linkDeviceId !== void 0 ? { linkDeviceId: metaRow.linkDeviceId } : {},
 		...metaRow?.primaryChildEntityId !== void 0 ? { primaryChildEntityId: metaRow.primaryChildEntityId } : {},
 		...metaRow?.childLayout !== void 0 ? { childLayout: metaRow.childLayout } : {},
-		...metaRow?.deviceLinks !== void 0 ? { deviceLinks: metaRow.deviceLinks } : {}
+		...metaRow?.deviceLinks !== void 0 ? { deviceLinks: metaRow.deviceLinks } : {},
+		...metaRow?.display !== void 0 ? { display: metaRow.display } : {}
 	};
 }
 function resolveDeviceById(registry, deviceId) {
@@ -1371,20 +1372,41 @@ var DeviceEventPropagator = class {
 function nodeKey(deviceId, cap) {
 	return `${deviceId}:${cap}`;
 }
+/** The target's container stableId — its parent's (falling back to its own for
+*  a top-level target). Sibling FIELD sources resolve relative to this, the same
+*  rule `rebuildLinkDependents` / `resolveLinkedStatus` apply. */
+function containerStableId(targetRow, rowById) {
+	return targetRow.parentDeviceId !== null ? rowById.get(targetRow.parentDeviceId)?.stableId ?? targetRow.stableId : targetRow.stableId;
+}
+/** Resolve ONE field/global/literal binding to its `(deviceId, cap)` node, or
+*  null when it is a literal or resolves to no known device. */
+function resolveBindingNode(binding, targetRow, rowById, idByStableId) {
+	if (binding.kind === "literal") return null;
+	const wantedStableId = binding.kind === "global" ? binding.sourceStableId : `${containerStableId(targetRow, rowById)}-${binding.sourceKey}`;
+	const srcId = idByStableId.get(wantedStableId);
+	if (srcId === void 0) return null;
+	return nodeKey(srcId, binding.cap);
+}
 /**
-* Resolve a link source to its `(deviceId, cap)` node, or null when the
-* source is a literal (no device) or does not resolve to a known device.
-* Sibling FIELD sources resolve against the TARGET's container stableId
-* (its parent's, falling back to its own for a top-level target) — the same
-* rule `rebuildLinkDependents` / `resolveLinkedStatus` apply.
+* Resolve a link source to the set of `(deviceId, cap)` nodes it depends on.
+* A literal source depends on nothing; a field/global source depends on exactly
+* one node; an EXPRESSION source depends on one node per resolvable non-literal
+* binding. Unresolvable (dangling) bindings contribute no edge — they cannot
+* loop while dangling; a cycle that only becomes resolvable later is bounded by
+* the resolve-time re-entrancy guard.
 */
-function resolveSourceNode(link, targetRow, rowById, idByStableId) {
+function resolveSourceNodes(link, targetRow, rowById, idByStableId) {
 	const src = link.source;
-	if (src.kind === "literal") return null;
-	const wantedStableId = src.kind === "global" ? src.sourceStableId : `${targetRow.parentDeviceId !== null ? rowById.get(targetRow.parentDeviceId)?.stableId ?? targetRow.stableId : targetRow.stableId}-${src.sourceKey}`;
-	const srcId = idByStableId.get(wantedStableId);
-	if (srcId === void 0) return null;
-	return nodeKey(srcId, src.cap);
+	if (src.kind === "expression") {
+		const nodes = [];
+		for (const binding of Object.values(src.bindings)) {
+			const node = resolveBindingNode(binding, targetRow, rowById, idByStableId);
+			if (node !== null) nodes.push(node);
+		}
+		return nodes;
+	}
+	const node = resolveBindingNode(src, targetRow, rowById, idByStableId);
+	return node !== null ? [node] : [];
 }
 /**
 * Detect whether replacing `editedDeviceId`'s links with `editedLinks` closes
@@ -1402,11 +1424,11 @@ function findDeviceLinkCycle(allMeta, editedDeviceId, editedLinks) {
 	const dependsOn = /* @__PURE__ */ new Map();
 	const addEdges = (row, links) => {
 		for (const link of links) {
-			const srcNode = resolveSourceNode(link, row, rowById, idByStableId);
-			if (srcNode === null) continue;
+			const srcNodes = resolveSourceNodes(link, row, rowById, idByStableId);
+			if (srcNodes.length === 0) continue;
 			const tNode = nodeKey(row.id, link.target.cap);
 			const list = dependsOn.get(tNode) ?? [];
-			list.push(srcNode);
+			for (const srcNode of srcNodes) list.push(srcNode);
 			dependsOn.set(tNode, list);
 		}
 	};
@@ -1473,7 +1495,7 @@ function dfsFindCycle(root, dependsOn) {
 * removeDevice), config persistence (persistConfig, loadConfig), the meta
 * surface load (loadMeta, loadRuntimeState), every meta setter (setName,
 * setLocation, setType, setIntegrationId, setLinkDeviceId,
-* setPrimaryChildEntityId, setChildLayout, setDeviceLinks, setRole,
+* setPrimaryChildEntityId, setChildLayout, setDeviceLinks, setRole, setDisplay,
 * applyInitialMeta, setMetadata, setDisabled), and the location registry
 * (listLocations, addLocation, removeLocation).
 *
@@ -1582,6 +1604,7 @@ async function registerDevice(pctx, input) {
 				...existingMeta?.childLayout !== void 0 ? { childLayout: existingMeta.childLayout } : {},
 				...existingMeta?.deviceLinks !== void 0 ? { deviceLinks: existingMeta.deviceLinks } : {},
 				...existingMeta?.role !== void 0 ? { role: existingMeta.role } : {},
+				...existingMeta?.display !== void 0 ? { display: existingMeta.display } : {},
 				parentDeviceId,
 				id,
 				features: featuresArr,
@@ -2023,6 +2046,11 @@ async function setDeviceLinks(pctx, input) {
 	const { deviceId, deviceLinks } = input;
 	const cycle = findDeviceLinkCycle(await pctx.metaStore.readMeta(), deviceId, deviceLinks);
 	if (cycle) throw new Error(`[device-manager] setDeviceLinks: cross-device link cycle: ${cycle.join(" → ")}`);
+	for (const link of deviceLinks) {
+		if (link.source.kind !== "expression") continue;
+		const err = (0, _camstack_types.validateExpressionSource)(link.source);
+		if (err) throw new Error(`[device-manager] setDeviceLinks: invalid expression on link '${link.id}': ${err}`);
+	}
 	await pctx.metaStore.withMetaWriteLock(async () => {
 		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
 		if (!persisted) throw new Error(`[device-manager] setDeviceLinks: unknown device id=${deviceId}`);
@@ -2093,6 +2121,84 @@ async function setRole(pctx, input) {
 	});
 }
 /**
+* Normalize an operator-authored display override at write time so the render
+* path's `UNIT_TABLE` lookups always hit canonical spellings — maps `unit` and
+* every `perCap[*].unit` through `normalizeUnit`. Pure: rebuilds new objects,
+* never mutates the input. A unit `normalizeUnit` cannot canonicalize is left
+* as-is (the render path refuses conversion for unknown spellings).
+*/
+function normalizeDisplayOverride(display) {
+	return {
+		...display,
+		...display.unit !== void 0 ? { unit: (0, _camstack_types.normalizeUnit)(display.unit) ?? display.unit } : {},
+		...display.perCap !== void 0 ? { perCap: Object.fromEntries(Object.entries(display.perCap).map(([cap, refine]) => [cap, refine.unit !== void 0 ? {
+			...refine,
+			unit: (0, _camstack_types.normalizeUnit)(refine.unit) ?? refine.unit
+		} : refine])) } : {}
+	};
+}
+/**
+* Set (or clear) the per-device display override on a device's meta row.
+* Mirrors `setChildLayout` persistence; `null` REMOVES the `display` key
+* entirely (immutable rest-destructure — matches the "absent ⇒ no override"
+* projection contract, never persists `display: undefined`). Override units are
+* normalized at write so the render path always looks up canonical spellings.
+*/
+async function setDisplay(pctx, input) {
+	const { deviceId, display } = input;
+	const normalized = display === null ? null : normalizeDisplayOverride(display);
+	await pctx.metaStore.withMetaWriteLock(async () => {
+		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+		if (!persisted) throw new Error(`[device-manager] setDisplay: unknown device id=${deviceId}`);
+		const { meta: m } = persisted;
+		const key = String(deviceId);
+		const allMeta = await pctx.metaStore.readMeta();
+		const nextRow = normalized === null ? (({ display: _drop, ...rest }) => rest)(m) : {
+			...m,
+			display: normalized
+		};
+		await pctx.settings.writeAddonStore({ deviceMeta: {
+			...allMeta,
+			[key]: nextRow
+		} });
+	});
+	pctx.host.ctx.eventBus.emit({
+		id: (0, node_crypto.randomUUID)(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: deviceId
+		},
+		category: _camstack_types.EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId,
+			field: "display",
+			value: normalized
+		}
+	});
+}
+/**
+* Read the operator-authored per-role display defaults. Empty record when none
+* set. Not per-device — a plain top-level-key read.
+*/
+async function getRoleDisplayDefaults(pctx, _input) {
+	return { defaults: (await pctx.metaStore.readStore()).roleDisplayDefaults ?? {} };
+}
+/**
+* Replace the per-role display defaults whole-record (full replace). Override
+* units are normalized (`normalizeUnit`) at write so the render path always
+* looks up canonical spellings. Single-writer top-level key — no lock, no RMW,
+* no interaction with the `deviceMeta` write lock. Not per-device, so no event
+* is emitted; the UI invalidates its own query on mutate.
+*/
+async function setRoleDisplayDefaults(pctx, input) {
+	const normalized = Object.fromEntries(Object.entries(input.defaults).map(([role, def]) => [role, def.unit !== void 0 ? {
+		...def,
+		unit: (0, _camstack_types.normalizeUnit)(def.unit) ?? def.unit
+	} : def]));
+	await pctx.settings.writeAddonStore({ roleDisplayDefaults: normalized });
+}
+/**
 * Batched meta pre-seed. Applies every provided field to the
 * device's meta row in ONE read-modify-write under a single
 * `withMetaWriteLock` acquisition (one `deviceMeta` blob write),
@@ -2337,23 +2443,33 @@ async function removeLocation(pctx, input) {
 function buildLinkIndexes(entries) {
 	const targets = /* @__PURE__ */ new Map();
 	const dependents = /* @__PURE__ */ new Map();
-	for (const { targetDeviceId, link, sourceDeviceId } of entries) {
+	for (const { targetDeviceId, link, sourceDeviceId, bindingSourceIds } of entries) {
 		const tKey = `${targetDeviceId}:${link.target.cap}`;
 		const tList = targets.get(tKey) ?? [];
 		tList.push({
 			link,
-			sourceDeviceId
+			sourceDeviceId,
+			...bindingSourceIds !== void 0 ? { bindingSourceIds } : {}
 		});
 		targets.set(tKey, tList);
-		if (link.source.kind !== "literal") {
-			const sKey = `${sourceDeviceId}:${link.source.cap}`;
+		const addDependent = (sourceId, sourceCap) => {
+			const sKey = `${sourceId}:${sourceCap}`;
 			const sList = dependents.get(sKey) ?? [];
 			sList.push({
 				targetDeviceId,
 				targetCap: link.target.cap
 			});
 			dependents.set(sKey, sList);
+		};
+		if (link.source.kind === "expression") {
+			if (bindingSourceIds !== void 0) for (const [name, bindingDeviceId] of Object.entries(bindingSourceIds)) {
+				const binding = link.source.bindings[name];
+				if (binding === void 0 || binding.kind === "literal") continue;
+				addDependent(bindingDeviceId, binding.cap);
+			}
+			continue;
 		}
+		if (link.source.kind !== "literal") addDependent(sourceDeviceId, link.source.cap);
 	}
 	return {
 		targets,
@@ -2508,6 +2624,23 @@ var DeviceMetaStore = class {
 			if (container === void 0) continue;
 			for (const link of targetMeta.deviceLinks ?? []) {
 				const src = link.source;
+				if (src.kind === "expression") {
+					const bindingSourceIds = {};
+					for (const [name, b] of Object.entries(src.bindings)) {
+						if (b.kind === "literal") continue;
+						const wanted = b.kind === "global" ? b.sourceStableId : `${container}-${b.sourceKey}`;
+						expectedSources.add(wanted);
+						const bid = idByStableId.get(wanted);
+						if (bid !== void 0) bindingSourceIds[name] = bid;
+					}
+					entries.push({
+						targetDeviceId: targetId,
+						link,
+						sourceDeviceId: -1,
+						bindingSourceIds
+					});
+					continue;
+				}
 				if (src.kind === "literal") {
 					entries.push({
 						targetDeviceId: targetId,
@@ -2625,6 +2758,7 @@ async function listAll(pctx, input) {
 			...m?.primaryChildEntityId !== void 0 ? { primaryChildEntityId: m.primaryChildEntityId } : {},
 			...m?.childLayout !== void 0 ? { childLayout: m.childLayout } : {},
 			...m?.deviceLinks !== void 0 ? { deviceLinks: m.deviceLinks } : {},
+			...m?.display !== void 0 ? { display: m.display } : {},
 			...(() => {
 				const si = buildSourceInfoFromConfig(persistedConfig ?? {}, stableId, aid);
 				return si !== void 0 ? { sourceInfo: si } : {};
@@ -2673,6 +2807,7 @@ async function getDevice(pctx, input) {
 		...m.primaryChildEntityId !== void 0 ? { primaryChildEntityId: m.primaryChildEntityId } : {},
 		...m.childLayout !== void 0 ? { childLayout: m.childLayout } : {},
 		...m.deviceLinks !== void 0 ? { deviceLinks: m.deviceLinks } : {},
+		...m.display !== void 0 ? { display: m.display } : {},
 		...sourceInfoGetDevice !== void 0 ? { sourceInfo: sourceInfoGetDevice } : {}
 	};
 }
@@ -2735,6 +2870,7 @@ async function getChildren(pctx, input) {
 			...m.primaryChildEntityId !== void 0 ? { primaryChildEntityId: m.primaryChildEntityId } : {},
 			...m.childLayout !== void 0 ? { childLayout: m.childLayout } : {},
 			...m.deviceLinks !== void 0 ? { deviceLinks: m.deviceLinks } : {},
+			...m.display !== void 0 ? { display: m.display } : {},
 			...sourceInfoChild !== void 0 ? { sourceInfo: sourceInfoChild } : {}
 		});
 	}
@@ -3074,7 +3210,37 @@ function isRecord(x) {
 * `source.kind` directly.
 */
 function resolveLinkValue(link, readField) {
-	return (0, _camstack_types.applyTransform)(link.source.kind === "literal" ? link.source.value : readField(link.source.cap, link.source.fieldPath), link.transform);
+	const src = link.source;
+	if (src.kind === "expression") return void 0;
+	return (0, _camstack_types.applyTransform)(src.kind === "literal" ? src.value : readField(src.cap, src.fieldPath), link.transform);
+}
+/**
+* Sync-channel expression resolution: bindings read from the mirror via
+* `readField(deviceId, cap, fieldPath)` using the pre-resolved per-binding ids
+* on the `ResolvedTargetLink`. A literal binding uses its constant; an absent
+* binding id (dangling source) or a non-primitive read resolves to `null`.
+* Returns `undefined` on parse/eval failure (skip overlay) — silent by design:
+* the mirror path is hot and churn-free; the async channel logs. Compile
+* failures cost one parse ever thanks to the negative LRU compile cache. Pure.
+*/
+function resolveExpressionLinkValue(rl, readField, now) {
+	const src = rl.link.source;
+	if (src.kind !== "expression") return void 0;
+	const bindingValues = {};
+	for (const [name, b] of Object.entries(src.bindings)) {
+		if (b.kind === "literal") {
+			bindingValues[name] = b.value;
+			continue;
+		}
+		const bId = rl.bindingSourceIds?.[name];
+		if (bId === void 0) {
+			bindingValues[name] = null;
+			continue;
+		}
+		bindingValues[name] = (0, _camstack_types.toExpressionValue)(readField(bId, b.cap, b.fieldPath)) ?? null;
+	}
+	const result = (0, _camstack_types.evaluateLinkExpression)(src.expr, bindingValues, now);
+	return result.ok ? (0, _camstack_types.applyTransform)(result.value, rl.link.transform) : void 0;
 }
 /** Narrow Zod v4's structural `$ZodType` (returned by `.unwrap()`) back to the
 *  concrete classic `z.ZodType`. Every runtime schema is a `z.ZodType`, so this
@@ -3395,9 +3561,10 @@ var DeviceStateMirror = class DeviceStateMirror {
 		const raw = this.stateMirror.get(deviceId)?.get(cap) ?? null;
 		const links = this.linkHost.linkTargets.get(`${deviceId}:${cap}`);
 		if (!links || links.length === 0) return raw ? { ...raw } : null;
+		const now = Date.now();
 		const resolved = links.map((rl) => ({
 			link: rl.link,
-			sourceValue: resolveLinkValue(rl.link, (srcCap, fieldPath) => (0, _camstack_types.getByPath)(this.stateMirror.get(rl.sourceDeviceId)?.get(srcCap), fieldPath))
+			sourceValue: rl.link.source.kind === "expression" ? resolveExpressionLinkValue(rl, (srcDeviceId, srcCap, fieldPath) => (0, _camstack_types.getByPath)(this.stateMirror.get(srcDeviceId)?.get(srcCap), fieldPath), now) : resolveLinkValue(rl.link, (srcCap, fieldPath) => (0, _camstack_types.getByPath)(this.stateMirror.get(rl.sourceDeviceId)?.get(srcCap), fieldPath))
 		}));
 		const capStatus = this.linkHost.capabilityRegistry?.getDefinition(cap)?.status;
 		const schema = capStatus?.schema;
@@ -3588,6 +3755,39 @@ async function resolveLinkedStatusInner(pctx, input) {
 		const parentMeta = allMeta[String(parentId)];
 		if (parentMeta) containerStableId = parentMeta.stableId;
 	}
+	const now = Date.now();
+	const statusMemo = /* @__PURE__ */ new Map();
+	const readSourceStatus = async (srcId, srcCap) => {
+		const key = `${srcId}:${srcCap}`;
+		const cached = statusMemo.get(key);
+		if (cached !== void 0) return cached;
+		let result;
+		try {
+			const srcProvider = capRegistry?.getProviderForDevice(srcCap, srcId);
+			result = {
+				status: typeof srcProvider?.getStatus === "function" ? await srcProvider.getStatus({ deviceId: srcId }) : void 0,
+				ok: true
+			};
+		} catch (err) {
+			pctx.host.ctx.logger.warn("resolveLinkedStatus: source read failed", {
+				tags: {
+					deviceId,
+					capName: cap
+				},
+				meta: {
+					sourceCap: srcCap,
+					sourceId: srcId,
+					error: err instanceof Error ? err.message : String(err)
+				}
+			});
+			result = {
+				status: void 0,
+				ok: false
+			};
+		}
+		statusMemo.set(key, result);
+		return result;
+	};
 	const resolved = [];
 	for (const link of links) {
 		const src = link.source;
@@ -3598,27 +3798,46 @@ async function resolveLinkedStatusInner(pctx, input) {
 			});
 			continue;
 		}
-		const srcId = src.kind === "global" ? pctx.metaStore.resolveGlobalSourceDeviceId(src.sourceStableId, allMeta) : pctx.metaStore.resolveSourceDeviceId(containerStableId, src.sourceKey, allMeta);
-		if (srcId === null) continue;
-		try {
-			const srcProvider = capRegistry?.getProviderForDevice(src.cap, srcId);
-			const raw = (0, _camstack_types.getByPath)(typeof srcProvider?.getStatus === "function" ? await srcProvider.getStatus({ deviceId: srcId }) : void 0, src.fieldPath);
-			resolved.push({
+		if (src.kind === "expression") {
+			const bindingValues = {};
+			for (const [name, b] of Object.entries(src.bindings)) {
+				if (b.kind === "literal") {
+					bindingValues[name] = b.value;
+					continue;
+				}
+				const bId = b.kind === "global" ? pctx.metaStore.resolveGlobalSourceDeviceId(b.sourceStableId, allMeta) : pctx.metaStore.resolveSourceDeviceId(containerStableId, b.sourceKey, allMeta);
+				if (bId === null) {
+					bindingValues[name] = null;
+					continue;
+				}
+				bindingValues[name] = (0, _camstack_types.toExpressionValue)((0, _camstack_types.getByPath)((await readSourceStatus(bId, b.cap)).status, b.fieldPath)) ?? null;
+			}
+			const result = (0, _camstack_types.evaluateLinkExpression)(src.expr, bindingValues, now);
+			if (result.ok) resolved.push({
 				link,
-				sourceValue: (0, _camstack_types.applyTransform)(raw, link.transform)
+				sourceValue: (0, _camstack_types.applyTransform)(result.value, link.transform)
 			});
-		} catch (err) {
-			pctx.host.ctx.logger.warn("resolveLinkedStatus: source read failed", {
+			else pctx.host.ctx.logger.warn("resolveLinkedStatus: expression skipped", {
 				tags: {
 					deviceId,
 					capName: cap
 				},
 				meta: {
-					sourceKey: src.kind === "global" ? src.sourceStableId : src.sourceKey,
-					error: err instanceof Error ? err.message : String(err)
+					linkId: link.id,
+					error: result.error
 				}
 			});
+			continue;
 		}
+		const srcId = src.kind === "global" ? pctx.metaStore.resolveGlobalSourceDeviceId(src.sourceStableId, allMeta) : pctx.metaStore.resolveSourceDeviceId(containerStableId, src.sourceKey, allMeta);
+		if (srcId === null) continue;
+		const read = await readSourceStatus(srcId, src.cap);
+		if (!read.ok) continue;
+		const raw = (0, _camstack_types.getByPath)(read.status, src.fieldPath);
+		resolved.push({
+			link,
+			sourceValue: (0, _camstack_types.applyTransform)(raw, link.transform)
+		});
 	}
 	if (resolved.length === 0) return null;
 	const synthesizing = !isRecord$1(baseStatus);
@@ -3931,6 +4150,9 @@ var DeviceManagerAddon = class extends _camstack_types.BaseAddon {
 			setChildLayout: (input) => setChildLayout(pctx, input),
 			setDeviceLinks: (input) => setDeviceLinks(pctx, input),
 			setRole: (input) => setRole(pctx, input),
+			setDisplay: (input) => setDisplay(pctx, input),
+			getRoleDisplayDefaults: (input) => getRoleDisplayDefaults(pctx, input),
+			setRoleDisplayDefaults: (input) => setRoleDisplayDefaults(pctx, input),
 			applyInitialMeta: (input) => applyInitialMeta(pctx, input),
 			setMetadata: (input) => setMetadata(pctx, input),
 			setDisabled: (input) => setDisabled(pctx, input),