@camstack/system 1.2.61 → 1.2.63

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

@@ -3,9 +3,8 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 require("../../chunk-Cek0wNdY.js");
-const require_dist = require("../../dist-BN681PgO.js");
+const require_dist = require("../../dist-LDrOFrd-.js");
 let _camstack_types_node = require("@camstack/types/node");
-let zod = require("zod");
 let node_crypto = require("node:crypto");
 //#region src/builtins/device-manager/day-night-config-schema.ts
 var MODE_LABELS = {
@@ -537,13 +536,6 @@ function mergeAggregates(parts) {
 //#endregion
 //#region src/builtins/device-manager/device-projection.ts
 /**
-* Pure device-projection + small predicate helpers for the device-manager
-* addon. Extracted verbatim from `device-manager.addon.ts`. None of these
-* functions close over the addon instance — they take everything they need
-* as explicit parameters, so they are safe to share across the addon's
-* query / aggregation modules.
-*/
-/**
 * Return true when `err` is a transient Moleculer error that is worth
 * retrying — specifically any `MoleculerRetryableError` subclass
 * (ServiceNotAvailableError, ServiceNotFoundError, BrokerDisconnectedError,
@@ -572,10 +564,6 @@ function shallowEqual(a, b) {
 	for (const k of ak) if (a[k] !== b[k]) return false;
 	return true;
 }
-/** Returns true when `x` is a non-null, non-array plain object. */
-function isRecord$1(x) {
-	return x !== null && typeof x === "object" && !Array.isArray(x);
-}
 function isCameraDevice(device) {
 	return "getStreamSources" in device && typeof device.getStreamSources === "function";
 }
@@ -660,7 +648,6 @@ 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?.display !== void 0 ? { display: metaRow.display } : {}
 	};
 }
@@ -676,28 +663,6 @@ function resolveDeviceById(registry, deviceId) {
 }
 //#endregion
 //#region src/builtins/device-manager/device-queries.ts
-/**
-* Device query + live-runtime + provider/adoption operations for the
-* device-manager addon — the read/live half of the `IDeviceManagerProvider`
-* surface. Extracted verbatim from the `onInitialize` provider literal as free
-* functions taking a `ProviderContext` (DI). Input/return types are pinned to
-* the cap contract via `Parameters<IDeviceManagerProvider['x']>[0]` /
-* `ReturnType<…>` so the typed surface is identical to the inferred methods.
-*
-* Covers: persisted/live device queries (listPersistedByAddon, listAll,
-* getDevice, getChildren), live runtime methods (getStreamSources,
-* getConfigSchema, getSettingsSchema, updateConfig, enable, disable, remove,
-* removeByIntegration, getStreamProfileMap, setStreamProfileMap, probeStreams),
-* device-provider ops (discoverDevices, adoptDevice, getCreationSchema,
-* createDevice, testCreationField), and device-adoption ops
-* (adoptionListCandidates/Refresh/Adopt/Release/Resync, testField).
-*
-* The hub-live-then-persisted-fallback union, the cross-process device-ops
-* dispatch, the depth-first remove cascade, and the resetToSource resync purge
-* are byte-for-byte preserved. `remove`/`removeByIntegration`/`enable`/`disable`/
-* `probeStreams`/`getStreamProfileMap` self-call sibling cap methods via
-* `pctx.provider`. Pure refactor — no behavior change.
-*/
 async function listPersistedByAddon(pctx, input) {
 	const { addonId } = input;
 	const [index, meta] = await Promise.all([pctx.metaStore.readIndex(), pctx.metaStore.readMeta()]);
@@ -774,7 +739,6 @@ async function listAll(pctx, input) {
 			...m?.linkDeviceId !== void 0 ? { linkDeviceId: m.linkDeviceId } : {},
 			...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 } : {},
 			...(() => {
 				if (slim) return {};
@@ -824,7 +788,6 @@ async function getDevice(pctx, input) {
 		...m.linkDeviceId !== void 0 ? { linkDeviceId: m.linkDeviceId } : {},
 		...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 } : {}
 	};
@@ -887,7 +850,6 @@ async function getChildren(pctx, input) {
 			...m.linkDeviceId !== void 0 ? { linkDeviceId: m.linkDeviceId } : {},
 			...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 } : {}
 		});
@@ -1443,18 +1405,6 @@ function splitDeviceStoreKeys(patch) {
 //#endregion
 //#region src/builtins/device-manager/device-bindings-store.ts
 /**
-* Persisted wrapper-activation + per-device binding resolution for the
-* device-manager addon. Extracted from `device-manager.addon.ts` as free
-* functions that receive an explicit `BindingsDeps` context (dependency
-* injection) instead of closing over the addon instance — keeps the routing
-* logic cohesive and independently testable while preserving the EXACT call
-* semantics, ordering, and side effects of the original class methods.
-*
-* The addon keeps thin delegator methods (`getBindings`, `getAllBindings`, …)
-* that build `BindingsDeps` from its own state and forward here, so every
-* existing internal + cap-router call site is unchanged.
-*/
-/**
 * Wire the push-fed cross-process native-cap cache (`remoteNativeCaps`).
 * Workers emit `DeviceBindingsChanged` on `ctx.registerNativeCap` / device
 * removal; we mirror those into `remoteNativeCaps` so `getBindings` returns the
@@ -1556,9 +1506,47 @@ function resolveRemoteNativeCapFromRegistry(deps, capName, deviceId) {
 	};
 	return null;
 }
+/**
+* Resolve the device's declared TYPE (`'camera'`, `'event-emitter'`, …), or
+* `undefined` when it cannot be established.
+*
+* The PERSISTED meta is the authority: `ctx.kernel.deviceRegistry` is hub-only
+* and has been observed empty in the very process that answers `getBindings`
+* correctly (see the note on `getAllBindings`). The registry is consulted only
+* as a secondary source, for a device constructed but not yet persisted.
+*
+* `undefined` is a first-class answer and callers must treat it as "no
+* filtering" — an absent row must never be the reason a device loses bindings.
+*/
+function resolveDeviceType(deps, rawStore, deviceId) {
+	const persisted = rawStore.deviceMeta?.[String(deviceId)]?.type;
+	if (typeof persisted === "string" && persisted.length > 0) return persisted;
+	const live = deps.ctx.kernel?.deviceRegistry?.getById(deviceId)?.type;
+	return typeof live === "string" && live.length > 0 ? live : void 0;
+}
+/**
+* Does a capability apply to a device of type `deviceType`?
+*
+* The cap's `deviceTypes` is the ONLY declaration consulted (D4: behavioural
+* cap metadata lives in the `*.cap.ts`, never in a manifest). Two deliberate
+* fail-open cases:
+*
+*   - a cap that declares no `deviceTypes` (or an empty list) applies to every
+*     device — the pre-existing, back-compatible semantics;
+*   - an UNKNOWN `deviceType` never filters, so a missing/failed meta lookup
+*     changes nothing (D49: a read that fails must not destroy work).
+*/
+function capAppliesToDeviceType(def, deviceType) {
+	if (deviceType === void 0) return true;
+	const declared = def?.deviceTypes;
+	if (!declared || declared.length === 0) return true;
+	return declared.some((t) => t === deviceType);
+}
 async function getBindings(deps, input) {
 	const storeKey = String(input.deviceId);
-	const perDevice = (await readBindingsStore(deps)).deviceBindings[storeKey] ?? {};
+	const rawStore = await deps.ctx.settings.readAddonStore();
+	const perDevice = (rawStore.deviceBindings ?? {})[storeKey] ?? {};
+	const deviceType = resolveDeviceType(deps, rawStore, input.deviceId);
 	const entries = [];
 	const seenCaps = /* @__PURE__ */ new Set();
 	const resolveRemote = (capName) => deps.remoteNativeCaps.get(input.deviceId)?.get(capName) ?? resolveRemoteNativeCapFromRegistry(deps, capName, input.deviceId);
@@ -1580,21 +1568,35 @@ async function getBindings(deps, input) {
 		});
 		seenCaps.add(capName);
 	}
-	if (deps.capabilityRegistry) for (const capName of deps.capabilityRegistry.getCapsWithDefaultWrapper()) {
-		if (seenCaps.has(capName)) continue;
-		const defaultWrapperAddonId = deps.capabilityRegistry.getDefaultWrapperForCap(capName);
-		if (!defaultWrapperAddonId) continue;
-		const hubLocalNative = deps.capabilityRegistry.getNativeAddonId(capName, input.deviceId) ?? null;
-		const remoteNative = resolveRemote(capName);
-		const nativeAddonId = hubLocalNative ?? remoteNative?.addonId ?? "";
-		entries.push({
-			capName,
-			kind: "wrapped",
-			providerAddonId: defaultWrapperAddonId,
-			providerNodeId: resolveWrapperNodeId(defaultWrapperAddonId),
-			nativeAddonId
+	if (deps.capabilityRegistry) {
+		const skippedForType = [];
+		for (const capName of deps.capabilityRegistry.getCapsWithDefaultWrapper()) {
+			if (seenCaps.has(capName)) continue;
+			if (!capAppliesToDeviceType(deps.capabilityRegistry.getDefinition(capName), deviceType)) {
+				skippedForType.push(capName);
+				continue;
+			}
+			const defaultWrapperAddonId = deps.capabilityRegistry.getDefaultWrapperForCap(capName);
+			if (!defaultWrapperAddonId) continue;
+			const hubLocalNative = deps.capabilityRegistry.getNativeAddonId(capName, input.deviceId) ?? null;
+			const remoteNative = resolveRemote(capName);
+			const nativeAddonId = hubLocalNative ?? remoteNative?.addonId ?? "";
+			entries.push({
+				capName,
+				kind: "wrapped",
+				providerAddonId: defaultWrapperAddonId,
+				providerNodeId: resolveWrapperNodeId(defaultWrapperAddonId),
+				nativeAddonId
+			});
+			seenCaps.add(capName);
+		}
+		if (skippedForType.length > 0) deps.ctx.logger.debug("getBindings: default wrappers skipped — deviceTypes mismatch", {
+			tags: { deviceId: input.deviceId },
+			meta: {
+				deviceType,
+				skipped: skippedForType
+			}
 		});
-		seenCaps.add(capName);
 	}
 	if (deps.capabilityRegistry) for (const capName of deps.capabilityRegistry.getNativeCapsForDevice(input.deviceId)) {
 		if (seenCaps.has(capName)) continue;
@@ -1636,21 +1638,6 @@ async function getBindings(deps, input) {
 		});
 		seenCaps.add(entry.capName);
 	}
-	if (deps.devicesWithLinks?.has(input.deviceId)) {
-		const row = ((await deps.ctx.settings.readAddonStore()).deviceMeta ?? {})[String(input.deviceId)];
-		for (const link of row?.deviceLinks ?? []) {
-			const capName = link.target.cap;
-			if (seenCaps.has(capName)) continue;
-			entries.push({
-				capName,
-				kind: "linked",
-				providerAddonId: require_dist.bareAddonId(deps.ctx.id),
-				providerNodeId: deps.ctx.kernel.localNodeId ?? "hub",
-				nativeAddonId: ""
-			});
-			seenCaps.add(capName);
-		}
-	}
 	return {
 		deviceId: input.deviceId,
 		entries
@@ -1668,10 +1655,20 @@ async function getBindings(deps, input) {
 * payload periodically.
 */
 async function getAllBindings(deps) {
-	const hubRegistry = deps.ctx.kernel?.deviceRegistry;
-	if (!hubRegistry) return [];
+	const store = await deps.ctx.settings.readAddonStore();
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(store.deviceMeta ?? {})) {
+		const id = Number(key);
+		if (Number.isInteger(id)) ids.add(id);
+	}
+	const registered = deps.ctx.kernel?.deviceRegistry?.getAll() ?? [];
+	for (const device of registered) ids.add(device.id);
+	if (ids.size === 0) {
+		deps.ctx.logger.warn("getAllBindings found no devices — warm boot will see nothing", { meta: { hasRegistry: deps.ctx.kernel?.deviceRegistry !== void 0 } });
+		return [];
+	}
 	const out = [];
-	for (const device of hubRegistry.getAll()) out.push(await getBindings(deps, { deviceId: device.id }));
+	for (const deviceId of [...ids].sort((a, b) => a - b)) out.push(await getBindings(deps, { deviceId }));
 	return out;
 }
 /**
@@ -1992,6 +1989,30 @@ function resolveNativeDeviceOwner(deps, deviceId) {
 	} : null;
 }
 /**
+* Race `work` against a deadline WITHOUT swallowing its rejection.
+*
+* `Promise.race` attaches a handler to every entrant, so a `work` that rejects
+* after the deadline already fired is still handled — no unhandled rejection,
+* and no `.catch(() => {})` that would also hide a genuine throw from the
+* caller's `try`. A rejection propagates out of here exactly as it would
+* without the race; only the TIMEOUT is turned into a value.
+*/
+async function withDeadline(work, deadlineMs) {
+	let timer;
+	const deadline = new Promise((resolve) => {
+		timer = setTimeout(() => resolve({ kind: "timed-out" }), deadlineMs);
+		timer.unref?.();
+	});
+	try {
+		return await Promise.race([work.then((value) => ({
+			kind: "value",
+			value
+		})), deadline]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/**
 * Aggregate `status` across every registered cap for a device.
 *
 * Walks the supplied cap list (or `CAP_NAMES_WITH_STATUS` when
@@ -2002,11 +2023,16 @@ function resolveNativeDeviceOwner(deps, deviceId) {
 * overall aggregate stays usable — a single misbehaving provider
 * must not blank out a device's entire status view.
 *
+* A provider that never answers is treated exactly like one that throws: it
+* costs its own cap and nothing else. See {@link STATUS_CALL_DEADLINE_MS} for
+* why a bound is needed at all when the transport already has one.
+*
 * Returned shape is `Record<capName, unknown | null>`; the client-
 * side hook tightens this to `CapStatusTypeMap` via the generated
 * `cap-status-types.ts`.
 */
-async function getDeviceStatusAggregate(deps, input) {
+async function getDeviceStatusAggregate(deps, input, options) {
+	const deadlineMs = options?.deadlineMs ?? 3e3;
 	const capNames = input.caps ?? require_dist.CAP_NAMES_WITH_STATUS;
 	const registry = deps.capabilityRegistry;
 	const out = {};
@@ -2026,7 +2052,20 @@ async function getDeviceStatusAggregate(deps, input) {
 				out[capName] = null;
 				return;
 			}
-			const raw = await provider.getStatus({ deviceId: input.deviceId });
+			const settled = await withDeadline(provider.getStatus({ deviceId: input.deviceId }), deadlineMs);
+			if (settled.kind === "timed-out") {
+				deps.ctx.logger.warn("getDeviceStatusAggregate: cap missed its deadline, dropping", {
+					tags: { deviceId: input.deviceId },
+					meta: {
+						deviceId: input.deviceId,
+						capName,
+						deadlineMs
+					}
+				});
+				out[capName] = null;
+				return;
+			}
+			const raw = settled.value;
 			if (raw == null) {
 				out[capName] = null;
 				return;
@@ -2080,8 +2119,21 @@ var STATUS_BATCH_WINDOW = 10;
 * A device whose whole aggregation fails still gets an ENTRY (all caps null)
 * rather than being omitted: a caller that reads a missing key as "not
 * answered yet" would keep the previous badge on screen forever.
+*
+* ## The response is BOUNDED, and that is load-bearing
+*
+* The windows are walked SEQUENTIALLY, so before the per-cap deadline existed a
+* single unanswerable device did not merely cost its own window — it held every
+* later window behind it, and the call never returned at all. That is the whole
+* mechanism behind "one node offline and the app loads nothing": this is the
+* one call a camera list makes for every card, the client has no timeout of its
+* own, and a tRPC query that never settles is `isLoading` forever.
+*
+* The ceiling is now `ceil(devices / STATUS_BATCH_WINDOW) × STATUS_CALL_DEADLINE_MS`
+* in the worst case (a dead device in every window), and unchanged when every
+* node is healthy. It is never unbounded.
 */
-async function getDeviceStatusAggregateBatch(deps, input) {
+async function getDeviceStatusAggregateBatch(deps, input, options) {
 	const out = {};
 	const ids = [...new Set(input.deviceIds)];
 	for (let i = 0; i < ids.length; i += STATUS_BATCH_WINDOW) {
@@ -2090,7 +2142,7 @@ async function getDeviceStatusAggregateBatch(deps, input) {
 			try {
 				const single = { deviceId };
 				if (input.caps !== void 0) single.caps = input.caps;
-				out[String(deviceId)] = await getDeviceStatusAggregate(deps, single);
+				out[String(deviceId)] = await getDeviceStatusAggregate(deps, single, options);
 			} catch (err) {
 				deps.ctx.logger.warn("getDeviceStatusAggregateBatch: device aggregation threw", {
 					tags: { deviceId },
@@ -2540,120 +2592,6 @@ var DeviceEventPropagator = class {
 	}
 };
 //#endregion
-//#region src/builtins/device-manager/device-link-cycle.ts
-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 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 resolveSourceNodes(link, targetRow, rowById, idByStableId) {
-	const src = link.source;
-	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
-* a dependency cycle. Returns the cycle as an ordered list of node keys
-* (first node repeated at the end) or null when the set is safe.
-*/
-function findDeviceLinkCycle(allMeta, editedDeviceId, editedLinks) {
-	const rows = Object.values(allMeta);
-	const rowById = /* @__PURE__ */ new Map();
-	const idByStableId = /* @__PURE__ */ new Map();
-	for (const r of rows) {
-		rowById.set(r.id, r);
-		if (!idByStableId.has(r.stableId)) idByStableId.set(r.stableId, r.id);
-	}
-	const dependsOn = /* @__PURE__ */ new Map();
-	const addEdges = (row, links) => {
-		for (const link of links) {
-			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) ?? [];
-			for (const srcNode of srcNodes) list.push(srcNode);
-			dependsOn.set(tNode, list);
-		}
-	};
-	for (const r of rows) {
-		const links = r.id === editedDeviceId ? editedLinks : r.deviceLinks ?? [];
-		if (links.length > 0) addEdges(r, links);
-	}
-	const roots = [...new Set(editedLinks.map((l) => nodeKey(editedDeviceId, l.target.cap)))];
-	for (const root of roots) {
-		const cycle = dfsFindCycle(root, dependsOn);
-		if (cycle) return cycle;
-	}
-	return null;
-}
-/** Iterative DFS from `root` over `dependsOn`; returns the first back-edge
-*  cycle path (closed — first node repeated last) or null. */
-function dfsFindCycle(root, dependsOn) {
-	const onPath = /* @__PURE__ */ new Set();
-	const done = /* @__PURE__ */ new Set();
-	const path = [];
-	const stack = [{
-		node: root,
-		nextChild: 0
-	}];
-	onPath.add(root);
-	path.push(root);
-	while (stack.length > 0) {
-		const frame = stack[stack.length - 1];
-		const children = dependsOn.get(frame.node) ?? [];
-		if (frame.nextChild < children.length) {
-			const child = children[frame.nextChild];
-			frame.nextChild += 1;
-			if (onPath.has(child)) {
-				const start = path.indexOf(child);
-				return [...path.slice(start), child];
-			}
-			if (done.has(child)) continue;
-			stack.push({
-				node: child,
-				nextChild: 0
-			});
-			onPath.add(child);
-			path.push(child);
-			continue;
-		}
-		stack.pop();
-		onPath.delete(frame.node);
-		path.pop();
-		done.add(frame.node);
-	}
-	return null;
-}
-//#endregion
 //#region src/builtins/device-manager/device-meta-actions.ts
 /**
 * Device meta-mutation + persistence actions for the device-manager addon —
@@ -2667,7 +2605,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, setDisplay,
+* setPrimaryChildEntityId, setChildLayout, setRole, setDisplay,
 * applyInitialMeta, setMetadata, setDisabled), and the location registry
 * (listLocations, addLocation, removeLocation).
 *
@@ -2774,7 +2712,6 @@ async function registerDevice(pctx, input) {
 				...existingMeta?.linkDeviceId !== void 0 ? { linkDeviceId: existingMeta.linkDeviceId } : {},
 				...existingMeta?.primaryChildEntityId !== void 0 ? { primaryChildEntityId: existingMeta.primaryChildEntityId } : {},
 				...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,
@@ -2836,7 +2773,6 @@ async function registerDevice(pctx, input) {
 			generation: Date.now()
 		}
 	});
-	if (pctx.host.devicesWithLinks.size > 0 && pctx.host.expectedSourceStableIds.has(stableId)) await pctx.metaStore.rebuildLinkDependents();
 }
 async function removeDevice(pctx, input) {
 	const { deviceId } = input;
@@ -2875,9 +2811,6 @@ async function removeDevice(pctx, input) {
 	pctx.host.remoteNativeCaps.delete(deviceId);
 	pctx.host.capabilityRegistry?.unregisterAllNativeForDevice(deviceId);
 	pctx.metaStore.idToAddonId.delete(deviceId);
-	pctx.host.devicesWithLinks.delete(deviceId);
-	pctx.host.dropDeviceOverlays(deviceId);
-	await pctx.metaStore.rebuildLinkDependents();
 	pctx.host.ctx.logger.info("removed device", { tags: {
 		deviceId,
 		deviceName: deviceName.length > 0 ? deviceName : stableId
@@ -3208,54 +3141,6 @@ async function setChildLayout(pctx, input) {
 	});
 }
 /**
-* Set (or replace) the operator-authored cross-device field wirings on
-* a device's meta row. Mirrors `setChildLayout` but persists the
-* `deviceLinks` array. Persisted, projected, and preserved across
-* re-register/restore. Also maintains the in-memory `devicesWithLinks`
-* Set used as an O(1) gate by `resolveLinkedStatus`.
-*/
-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 = require_dist.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}`);
-		const { meta: m } = persisted;
-		const key = String(deviceId);
-		const allMeta = await pctx.metaStore.readMeta();
-		await pctx.settings.writeAddonStore({ deviceMeta: {
-			...allMeta,
-			[key]: {
-				...m,
-				deviceLinks
-			}
-		} });
-	});
-	if (deviceLinks.length > 0) pctx.host.devicesWithLinks.add(deviceId);
-	else pctx.host.devicesWithLinks.delete(deviceId);
-	await pctx.metaStore.rebuildLinkDependents();
-	pctx.host.ctx.eventBus.emit({
-		id: (0, node_crypto.randomUUID)(),
-		timestamp: /* @__PURE__ */ new Date(),
-		source: {
-			type: "device",
-			id: deviceId
-		},
-		category: require_dist.EventCategory.DeviceMetaChanged,
-		data: {
-			deviceId,
-			field: "deviceLinks",
-			value: deviceLinks
-		}
-	});
-}
-/**
 * Stamp (or update) the semantic role on the device's meta row.
 * Called by the kernel's `create()` / `spawnAccessoryChild`
 * pre-seed when `initialMeta.role` is set (analogous to
@@ -3610,69 +3495,10 @@ async function removeLocation(pctx, input) {
 	});
 }
 //#endregion
-//#region src/builtins/device-manager/device-link-overlay.ts
-/** Build both lookup maps from resolved link entries. Pure — order-preserving. */
-function buildLinkIndexes(entries) {
-	const targets = /* @__PURE__ */ new Map();
-	const dependents = /* @__PURE__ */ new Map();
-	for (const { targetDeviceId, link, sourceDeviceId, bindingSourceIds } of entries) {
-		const tKey = `${targetDeviceId}:${link.target.cap}`;
-		const tList = targets.get(tKey) ?? [];
-		tList.push({
-			link,
-			sourceDeviceId,
-			...bindingSourceIds !== void 0 ? { bindingSourceIds } : {}
-		});
-		targets.set(tKey, tList);
-		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,
-		dependents
-	};
-}
-//#endregion
 //#region src/builtins/device-manager/device-meta-store.ts
-/**
-* Meta persistence layer for the device-manager addon.
-*
-* `DeviceMetaStore` encapsulates the read/modify/write helpers that previously
-* lived as closures inside `onInitialize`: the `ctx.settings`-backed reads
-* (`readStore` / `readIndex` / `readMeta` / `readMetadataMap`), the
-* single-writer mutex (`withMetaWriteLock`), id allocation
-* (`allocateNextDeviceId`), ownership/child resolution, link-source resolution,
-* and the cross-device link reverse-index rebuild. Extracting it as a class
-* (constructed once per `onInitialize`) keeps the EXACT semantics — the
-* `withMetaWriteLock` promise-chain is per-instance state, identical to the
-* former closure — while letting the meta-action + query modules depend on a
-* named, injectable surface instead of captured closures.
-*
-* Cross-device link state (the `linkTargets` / `linkDependents` /
-* `expectedSourceStableIds` maps + the `devicesWithLinks` gate) lives on the
-* addon; the store reaches it through the injected `LinkIndexHost` so the
-* single owner of that state stays the addon instance.
-*/
 var DeviceMetaStore = class {
 	settings;
 	registry;
-	linkHost;
 	/** Synchronous ownership cache, keyed by NUMERIC deviceId → owning addonId.
 	*  The persisted meta store is authoritative but reads are async; hub-side
 	*  callers (e.g. `CapabilityRegistry.getNativeProvider` fallback) need
@@ -3683,10 +3509,9 @@ var DeviceMetaStore = class {
 	*  through one promise chain (see `withMetaWriteLock`). Per-instance state —
 	*  identical to the former `onInitialize` closure variable. */
 	metaWriteChain = Promise.resolve();
-	constructor(settings, registry, linkHost) {
+	constructor(settings, registry) {
 		this.settings = settings;
 		this.registry = registry;
-		this.linkHost = linkHost;
 	}
 	readStore = async () => {
 		return await this.settings.readAddonStore();
@@ -3748,279 +3573,31 @@ var DeviceMetaStore = class {
 		ids.delete(parentId);
 		return [...ids];
 	};
-	/** Resolve a link's `sourceKey` to a live device id: the sibling accessory
-	*  whose stableId is `${parentStableId}-${sourceKey}`. Null when absent.
-	*  Pure over a pre-read meta map so a multi-link resolve reads the store once. */
-	resolveSourceDeviceId = (parentStableId, sourceKey, meta) => {
-		const wanted = `${parentStableId}-${sourceKey}`;
-		for (const m of Object.values(meta)) if (m.stableId === wanted) return m.id;
-		return null;
-	};
-	/** Resolve a GLOBAL link source (P2e) to a live device id: the device whose
-	*  FULL stableId equals `sourceStableId`, regardless of parent container.
-	*  First match wins (stableIds are effectively unique cluster-wide — see the
-	*  `DeviceLinkGlobalSource` docblock). Null when absent. Pure over a
-	*  pre-read meta map so a multi-link resolve reads the store once. */
-	resolveGlobalSourceDeviceId = (sourceStableId, meta) => {
-		for (const m of Object.values(meta)) if (m.stableId === sourceStableId) return m.id;
-		return null;
-	};
 	allocateNextDeviceId = async () => {
 		const current = (await this.readStore()).nextDeviceId ?? 1;
 		await this.settings.writeAddonStore({ nextDeviceId: current + 1 });
 		return current;
 	};
-	/** Rebuild the `linkTargets` / `linkDependents` reverse-index maps from the
-	*  current persisted meta. Called at boot (once the `devicesWithLinks` seed
-	*  has run) and whenever the link topology can change: `setDeviceLinks`,
-	*  `registerDevice` (a new sibling source may resolve previously-dangling
-	*  links), and `removeDevice` (its entries must be evicted). */
-	rebuildLinkDependents = async () => {
-		if (this.linkHost.devicesWithLinks.size === 0) {
-			this.linkHost.setLinkIndexes(/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map(), /* @__PURE__ */ new Set());
-			return;
-		}
-		const allMeta = await this.readMeta();
-		const stableIdById = /* @__PURE__ */ new Map();
-		const idByStableId = /* @__PURE__ */ new Map();
-		for (const m of Object.values(allMeta)) {
-			stableIdById.set(m.id, m.stableId);
-			idByStableId.set(m.stableId, m.id);
-		}
-		const entries = [];
-		const expectedSources = /* @__PURE__ */ new Set();
-		for (const targetId of this.linkHost.devicesWithLinks) {
-			const targetMeta = Object.values(allMeta).find((m) => m.id === targetId);
-			if (!targetMeta) continue;
-			const container = targetMeta.parentDeviceId !== null ? stableIdById.get(targetMeta.parentDeviceId) ?? stableIdById.get(targetId) : stableIdById.get(targetId);
-			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,
-						link,
-						sourceDeviceId: -1
-					});
-					continue;
-				}
-				const wantedStableId = src.kind === "global" ? src.sourceStableId : `${container}-${src.sourceKey}`;
-				expectedSources.add(wantedStableId);
-				const srcId = idByStableId.get(wantedStableId);
-				if (srcId === void 0) continue;
-				entries.push({
-					targetDeviceId: targetId,
-					link,
-					sourceDeviceId: srcId
-				});
-			}
-		}
-		const { targets, dependents } = buildLinkIndexes(entries);
-		this.linkHost.setLinkIndexes(targets, dependents, expectedSources);
-	};
 };
 //#endregion
-//#region src/builtins/device-manager/device-link-resolver.ts
-/** Returns true when `x` is a non-null, non-array plain object. */
-function isRecord(x) {
-	return x !== null && typeof x === "object" && !Array.isArray(x);
-}
-/**
-* Resolve one link's transformed value. Field sources read via `readField`
-* (the caller supplies the sibling lookup — sync, e.g. the in-hub state
-* mirror); literal sources use their per-device constant and never consult
-* the reader. Returns `undefined` to skip the overlay (unreadable field).
-* Pure. Async source reads (`resolveLinkedStatus`'s provider `getStatus`
-* path) cannot use this helper for field sources — they branch on
-* `source.kind` directly.
-*/
-function resolveLinkValue(link, readField) {
-	const src = link.source;
-	if (src.kind === "expression") return void 0;
-	return require_dist.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] = require_dist.toExpressionValue(readField(bId, b.cap, b.fieldPath)) ?? null;
-	}
-	const result = require_dist.evaluateLinkExpression(src.expr, bindingValues, now);
-	return result.ok ? require_dist.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
-*  is a true `instanceof` guard rather than a cast. */
-function asZodType(schema) {
-	return schema instanceof zod.z.ZodType ? schema : null;
-}
-/** Unwrap ZodNullable / ZodOptional / ZodDefault wrappers to reach the inner
-*  type. This lets the repair logic recognise a `TankStatus.nullable()` field
-*  as a ZodObject so it can fill in missing nullable keys. */
-function unwrapSchema(schema) {
-	if (schema instanceof zod.z.ZodNullable || schema instanceof zod.z.ZodOptional || schema instanceof zod.z.ZodDefault) {
-		const inner = asZodType(schema.unwrap());
-		return inner ? unwrapSchema(inner) : schema;
-	}
-	return schema;
-}
-/** For a ZodObject schema, ensure every nullable key present under `value` is
-*  filled — a missing key whose field accepts `null` is set to `null`. Generic
-*  repair for the common "set one leaf of a previously-null structured field"
-*  case (e.g. TankStatus.level). Recurses into nested object fields. */
-function fillNullableDefaults(schema, value) {
-	const inner = unwrapSchema(schema);
-	if (!(inner instanceof zod.z.ZodObject) || !isRecord(value)) return value;
-	const shape = inner.shape;
-	const out = { ...value };
-	for (const [key, field] of Object.entries(shape)) if (out[key] === void 0) {
-		if (field.safeParse(null).success) out[key] = null;
-	} else out[key] = fillNullableDefaults(field, out[key]);
-	return out;
-}
-/**
-* Group item-targeted links (`target.itemKey` set) by itemKey and upsert each
-* group as ONE item into the status' item array (see
-* `CapabilityStatusItemArray`). A NEW item is seeded from `emptyItem` with
-* `keyField` (and `labelField`, when declared) set to the itemKey; an
-* EXISTING item (matched by `keyField`) is cloned and overlaid in place, so
-* native fields a link doesn't touch are preserved. Each upserted item is
-* validated against `itemSchema` — an invalid item is skipped WITHOUT
-* discarding its valid siblings. Returns the new draft and whether anything
-* was applied. Pure + immutable (base array/items are never mutated).
-*/
-function upsertItemArrayLinks(draft, grouped, itemArray) {
-	const arrRaw = require_dist.getByPath(draft, itemArray.path);
-	const arr = Array.isArray(arrRaw) ? [...arrRaw] : [];
-	let touched = false;
-	for (const [itemKey, group] of grouped) {
-		const idx = arr.findIndex((el) => isRecord(el) && el[itemArray.keyField] === itemKey);
-		const existing = idx >= 0 ? arr[idx] : null;
-		let item = isRecord(existing) ? { ...existing } : {
-			...itemArray.emptyItem,
-			[itemArray.keyField]: itemKey,
-			...itemArray.labelField !== void 0 ? { [itemArray.labelField]: itemKey } : {}
-		};
-		let itemTouched = false;
-		for (const { link, sourceValue } of group) {
-			if (sourceValue === void 0) continue;
-			item = require_dist.setByPath(item, link.target.fieldPath, sourceValue);
-			itemTouched = true;
-		}
-		if (!itemTouched) continue;
-		const repaired = fillNullableDefaults(itemArray.itemSchema, item);
-		const parsed = itemArray.itemSchema.safeParse(repaired);
-		if (!parsed.success) continue;
-		if (isRecord(parsed.data)) item = parsed.data;
-		if (idx >= 0) arr[idx] = item;
-		else arr.push(item);
-		touched = true;
-	}
-	if (!touched) return {
-		draft,
-		touched: false
-	};
-	return {
-		draft: require_dist.setByPath(draft, itemArray.path, arr),
-		touched: true
-	};
-}
-/**
-* Overlay transformed source values onto `base` by dot-path, then validate the
-* result against the target cap's `statusSchema`. On validation failure the
-* overlay is discarded and `base` is returned unchanged (a misconfigured link
-* must never corrupt a cap response). Pure — all I/O happens in the caller.
-*
-* Item-array grouping (P2b): when the cap declares `status.itemArray`, links
-* carrying a `target.itemKey` are grouped per key and upserted as items into
-* the array (see `upsertItemArrayLinks`); their `fieldPath` is relative to
-* ONE item ('level', 'status', 'label'). Links WITHOUT an itemKey keep the
-* scalar dot-path behavior unchanged. A link with an itemKey on a cap that
-* declares NO `itemArray` is dropped (its item-relative path must never be
-* scalar-applied to the status root).
-*/
-function mergeLinkedStatus(base, resolved, statusSchema, itemArray) {
-	let draft = base;
-	let touched = false;
-	const grouped = /* @__PURE__ */ new Map();
-	for (const entry of resolved) {
-		const itemKey = entry.link.target.itemKey;
-		if (itemKey !== void 0) {
-			if (!itemArray) continue;
-			const group = grouped.get(itemKey);
-			if (group) group.push(entry);
-			else grouped.set(itemKey, [entry]);
-			continue;
-		}
-		if (entry.sourceValue === void 0) continue;
-		draft = require_dist.setByPath(draft, entry.link.target.fieldPath, entry.sourceValue);
-		touched = true;
-	}
-	if (itemArray && grouped.size > 0) {
-		const upserted = upsertItemArrayLinks(draft, grouped, itemArray);
-		draft = upserted.draft;
-		touched = touched || upserted.touched;
-	}
-	if (!touched) return base;
-	if (!statusSchema) return draft;
-	const repaired = fillNullableDefaults(statusSchema, draft);
-	const parsed = statusSchema.safeParse(repaired);
-	if (!parsed.success) return base;
-	return isRecord(parsed.data) ? parsed.data : base;
-}
-//#endregion
 //#region src/builtins/device-manager/device-state-mirror.ts
 /**
 * Hub-side runtime-state mirror for the device-manager addon.
 *
 * `DeviceStateMirror` owns the per-device cap-keyed slice mirror and the
-* debounced disk-write coalescer that previously lived directly on the addon
-* class. It mirrors every `deviceState.setCapSlice` write, emits
-* `DeviceStateChanged` (overlaid with cross-device linked values), and coalesces
-* frequent writes into one `writeDeviceRuntimeState` per debounce window. The
-* cross-device link reverse-index lives on the addon; the mirror reads it
-* through the injected `LinkOverlayHost` so the single owner of that state stays
-* the addon. Extracted verbatim — behavior unchanged.
+* debounced disk-write coalescer. It mirrors every `deviceState.setCapSlice`
+* write, emits `DeviceStateChanged`, and coalesces frequent writes into one
+* `writeDeviceRuntimeState` per debounce window.
+*
+* It used to do one more thing: overlay each emitted slice with cross-device
+* LINKED values, walk a `linkDependents` reverse-index and re-emit for every
+* dependent target, guarded by a `lastEmittedOverlay` churn map. Wiring was
+* deleted on 2026-08-08 (0 links across 302 devices), so the mirror emits what
+* the provider wrote — one writer per field, which is what D62 asks for
+* everywhere else.
 */
 var DeviceStateMirror = class DeviceStateMirror {
 	ctx;
-	linkHost;
 	/**
 	* Hub-side mirror of every device's cap-keyed runtime state.
 	* Key: deviceId. Value: per-cap slice map. Empty by default —
@@ -4034,11 +3611,8 @@ var DeviceStateMirror = class DeviceStateMirror {
 	*/
 	runtimeStateDebounce = /* @__PURE__ */ new Map();
 	static RUNTIME_STATE_DEBOUNCE_MS = 1e3;
-	/** Loop/churn guard: last overlaid slice emitted per `${deviceId}:${cap}`. */
-	lastEmittedOverlay = /* @__PURE__ */ new Map();
-	constructor(ctx, linkHost) {
+	constructor(ctx) {
 		this.ctx = ctx;
-		this.linkHost = linkHost;
 	}
 	/**
 	* Single-cap mirror update — diff against the current mirror,
@@ -4055,9 +3629,7 @@ var DeviceStateMirror = class DeviceStateMirror {
 		const prior = perCap.get(capName);
 		if (prior && shallowEqual(prior, slice)) return;
 		perCap.set(capName, { ...slice });
-		this.emitOverlayed(deviceId, capName);
-		const deps = this.linkHost.linkDependents.get(`${deviceId}:${capName}`);
-		if (deps) for (const d of deps) this.emitOverlayed(d.targetDeviceId, d.targetCap);
+		this.emitStateChanged(deviceId, capName, { ...slice });
 	}
 	/**
 	* Debounced disk writer. Coalesces frequent writes (motion phase
@@ -4189,68 +3761,17 @@ var DeviceStateMirror = class DeviceStateMirror {
 		for (const [k, v] of perCap) out[k] = { ...v };
 		return out;
 	}
-	/**
-	* Read-time overlay of a cap slice with its cross-device linked values.
-	* Returns a cloned raw mirror slice when the (device, cap) pair has no
-	* links. Sources are read from the same in-hub stateMirror — sync, no
-	* cross-process call. When the raw slice is ABSENT but the cap is a link
-	* target, the slice is SYNTHESIZED: the merge base is seeded from the
-	* cap's declared `status.empty` default; a failed/empty synthesize
-	* returns null (no phantom slices). The disk writer must NOT use this
-	* method; it must persist raw provider truth via snapshotForDevice.
-	*/
-	overlayedSlice(deviceId, cap) {
-		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: rl.link.source.kind === "expression" ? resolveExpressionLinkValue(rl, (srcDeviceId, srcCap, fieldPath) => require_dist.getByPath(this.stateMirror.get(srcDeviceId)?.get(srcCap), fieldPath), now) : resolveLinkValue(rl.link, (srcCap, fieldPath) => require_dist.getByPath(this.stateMirror.get(rl.sourceDeviceId)?.get(srcCap), fieldPath))
-		}));
-		const capStatus = this.linkHost.capabilityRegistry?.getDefinition(cap)?.status;
-		const schema = capStatus?.schema;
-		const empty = capStatus?.empty;
-		const base = raw ? { ...raw } : empty !== null && typeof empty === "object" && !Array.isArray(empty) ? { ...empty } : {};
-		const merged = mergeLinkedStatus(base, resolved, schema, capStatus?.itemArray);
-		if (!raw && merged === base) return null;
-		return merged;
+	/** One cap's mirrored slice, cloned. Null when the device has never written
+	*  it — callers read that as "the cap has no state", never as an empty slice. */
+	capSlice(deviceId, cap) {
+		const raw = this.stateMirror.get(deviceId)?.get(cap);
+		return raw ? { ...raw } : null;
 	}
-	/**
-	* Like snapshotForDevice but applies the device-link overlay per cap.
-	* Used exclusively by the device-state READ methods (getSnapshot,
-	* getAllSnapshots) so callers see overlayed values. SYNTHESIZE-only
-	* link-target caps (no base mirror slice) are unioned into the iterated
-	* key set so they appear at warm-load — `overlayedSlice` builds them from
-	* the cap's `status.empty` (and drops them when nothing resolves). The
-	* debounced disk writer must continue to call snapshotForDevice (raw truth).
-	*/
-	snapshotForDeviceOverlayed(deviceId) {
-		const perCap = this.stateMirror.get(deviceId);
-		const capNames = new Set(perCap ? perCap.keys() : []);
-		const prefix = `${deviceId}:`;
-		for (const key of this.linkHost.linkTargets.keys()) if (key.startsWith(prefix)) capNames.add(key.slice(prefix.length));
+	/** Whole-system mirror dump. Backs `deviceState.getAllSnapshots` — one
+	*  round-trip for a warm boot instead of N per-device calls. */
+	allSnapshots() {
 		const out = {};
-		for (const capName of capNames) {
-			const s = this.overlayedSlice(deviceId, capName);
-			if (s) out[capName] = s;
-		}
-		return out;
-	}
-	/** Whole-system mirror dump (overlaid). Backs `deviceState.getAllSnapshots`.
-	*  Devices that only exist as link TARGETS (no mirror slice yet) are
-	*  included via the link reverse-index so their synthesized caps appear. */
-	allSnapshotsOverlayed() {
-		const deviceIds = new Set(this.stateMirror.keys());
-		for (const key of this.linkHost.linkTargets.keys()) {
-			const id = Number(key.slice(0, key.indexOf(":")));
-			if (Number.isFinite(id)) deviceIds.add(id);
-		}
-		const out = {};
-		for (const deviceId of deviceIds) {
-			const dev = this.snapshotForDeviceOverlayed(deviceId);
-			if (this.stateMirror.has(deviceId) || Object.keys(dev).length > 0) out[String(deviceId)] = dev;
-		}
+		for (const deviceId of this.stateMirror.keys()) out[String(deviceId)] = this.snapshotForDevice(deviceId);
 		return out;
 	}
 	emitStateChanged(deviceId, capName, slice) {
@@ -4269,24 +3790,6 @@ var DeviceStateMirror = class DeviceStateMirror {
 			}
 		});
 	}
-	/** Emit DeviceStateChanged for (deviceId, cap) using the OVERLAID slice,
-	*  skipping when the overlay is unchanged since the last emit (loop/churn
-	*  guard). Used for the written pair AND its dependent targets. */
-	emitOverlayed(deviceId, cap) {
-		const slice = this.overlayedSlice(deviceId, cap);
-		if (!slice) return;
-		const key = `${deviceId}:${cap}`;
-		const prev = this.lastEmittedOverlay.get(key);
-		if (prev && shallowEqual(prev, slice)) return;
-		this.lastEmittedOverlay.set(key, slice);
-		this.emitStateChanged(deviceId, cap, slice);
-	}
-	/** Drop a removed device's overlay-emit guard entries (keyed
-	*  `${deviceId}:${cap}`) so the map doesn't retain rows for a removed device.
-	*  Called from `removeDevice`. */
-	dropDeviceOverlays(deviceId) {
-		for (const overlayKey of this.lastEmittedOverlay.keys()) if (overlayKey.startsWith(`${deviceId}:`)) this.lastEmittedOverlay.delete(overlayKey);
-	}
 	/** Flush every pending debounced disk write (graceful shutdown). Clears the
 	*  debounce slots after awaiting in-flight + scheduled writes so shutdown is
 	*  lossless. */
@@ -4315,11 +3818,15 @@ var DeviceStateMirror = class DeviceStateMirror {
 //#endregion
 //#region src/builtins/device-manager/device-sync-resolvers.ts
 /**
-* Synchronous ownership / native-cap resolvers + the read-time cross-device
-* link-status overlay for the device-manager provider. Extracted verbatim from
-* the `onInitialize` provider literal as free functions taking a
-* `ProviderContext` (DI). These back `CapabilityRegistry`'s native fallback and
-* the cap-mount linked-status overlay. Behavior unchanged.
+* Synchronous ownership / native-cap resolvers for the device-manager provider.
+* Free functions over a `ProviderContext` (DI); these back
+* `CapabilityRegistry`'s native fallback.
+*
+* This file also held `resolveLinkedStatus`, the read-time cross-device link
+* overlay. Wiring was deleted on 2026-08-08 — 0 links across 302 devices, a
+* month after the tab shipped — so the overlay, its re-entrancy guard and its
+* per-call source-read memo went with it. A cross-device derivation now
+* produces a DEVICE, not a field on somebody else's cap.
 */
 /**
 * Sync ownership lookup backing persistence fallbacks (e.g. remove()
@@ -4361,133 +3868,6 @@ function resolveNativeCapOwnerSync(pctx, capName, deviceId) {
 	};
 	return resolveRemoteNativeCapFromRegistry(pctx.bindingsDeps, capName, deviceId);
 }
-/**
-* Read-time overlay: merge cross-device linked values onto a target cap's
-* status. Returns null when the device has no links for `cap` (caller uses
-* the base status untouched). Reads each source cap via the hub registry's
-* `getProviderForDevice` (routes cross-process); merge is pure.
-*/
-async function resolveLinkedStatus(pctx, input) {
-	const { deviceId, cap } = input;
-	if (!pctx.host.devicesWithLinks.has(deviceId)) return null;
-	const inFlightKey = `${deviceId}:${cap}`;
-	if (pctx.host.linkResolveInFlight.has(inFlightKey)) return null;
-	pctx.host.linkResolveInFlight.add(inFlightKey);
-	try {
-		return await resolveLinkedStatusInner(pctx, input);
-	} finally {
-		pctx.host.linkResolveInFlight.delete(inFlightKey);
-	}
-}
-/** Body of `resolveLinkedStatus` — see the wrapper for the re-entrancy guard. */
-async function resolveLinkedStatusInner(pctx, input) {
-	const { deviceId, cap, baseStatus } = input;
-	const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
-	if (!persisted) return null;
-	const links = (persisted.meta.deviceLinks ?? []).filter((l) => l.target.cap === cap);
-	if (links.length === 0) return null;
-	const capRegistry = pctx.host.capabilityRegistry;
-	const capStatus = capRegistry?.getDefinition(cap)?.status;
-	const schema = capStatus?.schema;
-	if (!schema) return null;
-	const allMeta = await pctx.metaStore.readMeta();
-	let containerStableId = persisted.stableId;
-	const parentId = persisted.meta.parentDeviceId;
-	if (parentId !== null) {
-		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;
-		if (src.kind === "literal") {
-			resolved.push({
-				link,
-				sourceValue: require_dist.applyTransform(src.value, link.transform)
-			});
-			continue;
-		}
-		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] = require_dist.toExpressionValue(require_dist.getByPath((await readSourceStatus(bId, b.cap)).status, b.fieldPath)) ?? null;
-			}
-			const result = require_dist.evaluateLinkExpression(src.expr, bindingValues, now);
-			if (result.ok) resolved.push({
-				link,
-				sourceValue: require_dist.applyTransform(result.value, link.transform)
-			});
-			else pctx.host.ctx.logger.warn("resolveLinkedStatus: expression skipped", {
-				tags: {
-					deviceId,
-					capName: cap
-				},
-				meta: {
-					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 = require_dist.getByPath(read.status, src.fieldPath);
-		resolved.push({
-			link,
-			sourceValue: require_dist.applyTransform(raw, link.transform)
-		});
-	}
-	if (resolved.length === 0) return null;
-	const synthesizing = !isRecord$1(baseStatus);
-	const base = isRecord$1(baseStatus) ? baseStatus : isRecord$1(capStatus.empty) ? { ...capStatus.empty } : {};
-	const merged = mergeLinkedStatus(base, resolved, schema, capStatus.itemArray);
-	if (synthesizing && merged === base) return null;
-	return merged;
-}
 //#endregion
 //#region src/builtins/device-manager/device-manager.addon.ts
 var DeviceManagerAddon = class extends require_dist.BaseAddon {
@@ -4540,100 +3920,24 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 	* the D3 re-handshake after device restore is the reliable replacement.
 	*/
 	remoteNativeCaps = /* @__PURE__ */ new Map();
-	/** Device ids that currently have at least one `deviceLinks` entry. O(1) gate
-	*  consulted by `resolveLinkedStatus` so the cap-mount overlay is a no-op for
-	*  the vast majority of devices that have no links. Rebuilt on restore. */
-	devicesWithLinks = /* @__PURE__ */ new Set();
-	/** Whether a device currently has cross-device links. */
-	devicesWithLinksHas(deviceId) {
-		return this.devicesWithLinks.has(deviceId);
-	}
-	/** `${targetDeviceId}:${targetCap}` → resolved links feeding that cap's slice. */
-	linkTargets = /* @__PURE__ */ new Map();
-	/** `${sourceDeviceId}:${sourceCap}` → targets to recompute when that source changes. */
-	linkDependents = /* @__PURE__ */ new Map();
-	/** Expected source `stableId`s (`${container}-${sourceKey}` for sibling
-	*  sources, the full `sourceStableId` for global sources) across all links,
-	*  resolved or not — gates the `registerDevice` rebuild so only a registering
-	*  device that IS a link source triggers a reindex (not every boot restore). */
-	expectedSourceStableIds = /* @__PURE__ */ new Set();
-	/** In-flight `${deviceId}:${cap}` pairs of `resolveLinkedStatus` — the P2e
-	*  defensive re-entrancy guard bounding link cycles at resolve time. Mutated
-	*  in place (never reassigned), so the host exposes a direct reference. */
-	linkResolveInFlight = /* @__PURE__ */ new Set();
-	/** Test/diagnostic accessors. */
-	linkTargetKeys() {
-		return [...this.linkTargets.keys()];
-	}
-	linkDependentsKeys() {
-		return [...this.linkDependents.keys()];
-	}
-	/** Replace the cross-device link reverse-index maps in one atomic swap.
-	*  Sole writer of `linkTargets` / `linkDependents` / `expectedSourceStableIds`;
-	*  called by `DeviceMetaStore.rebuildLinkDependents` via the `LinkIndexHost`. */
-	setLinkIndexes(targets, dependents, expectedSourceStableIds) {
-		this.linkTargets = targets;
-		this.linkDependents = dependents;
-		this.expectedSourceStableIds = expectedSourceStableIds;
-	}
-	/** Build the `LinkIndexHost` the meta store mutates — exposes this addon's
-	*  `devicesWithLinks` gate (read) + `setLinkIndexes` (write) without leaking
-	*  the private maps. */
-	get linkIndexHost() {
-		return {
-			devicesWithLinks: this.devicesWithLinks,
-			setLinkIndexes: (targets, dependents, expected) => this.setLinkIndexes(targets, dependents, expected)
-		};
-	}
 	/** The runtime-state mirror, asserted present (constructed in onInitialize). */
 	get stateMirror() {
 		if (!this.stateMirrorImpl) throw new Error("DeviceManagerAddon: state mirror accessed before onInitialize");
 		return this.stateMirrorImpl;
 	}
-	/** Build the `LinkOverlayHost` the state mirror reads when overlaying linked
-	*  values — exposes the link reverse-index maps + registry via LIVE thunks
-	*  (the maps are reassigned on every `rebuildLinkDependents`). Arrow thunks
-	*  capture `this` lexically so the getters never go stale. */
-	get linkOverlayHost() {
-		const linkTargets = () => this.linkTargets;
-		const linkDependents = () => this.linkDependents;
-		const capabilityRegistry = () => this.capabilityRegistry;
-		return {
-			get linkTargets() {
-				return linkTargets();
-			},
-			get linkDependents() {
-				return linkDependents();
-			},
-			get capabilityRegistry() {
-				return capabilityRegistry();
-			}
-		};
-	}
 	/** Build the `ProviderHost` the extracted provider-method modules
 	*  (`device-meta-actions`, `device-queries`) reach — exposes the addon's
 	*  private state/methods they need without leaking the class internals.
 	*
-	*  `expectedSourceStableIds` is exposed via a LIVE thunk: the field is
-	*  reassigned to a fresh Set on every `rebuildLinkDependents`, so a captured
-	*  reference would go stale. `devicesWithLinks` / `remoteNativeCaps` are
-	*  mutated in place (never reassigned) so a direct reference preserves the
-	*  original live semantics. The overlay-emit guard now lives in the state
-	*  mirror — pruning is routed through `dropDeviceOverlays`. */
+	*  `remoteNativeCaps` is mutated in place (never reassigned) so a direct
+	*  reference preserves the live semantics. */
 	get providerHost() {
 		const capabilityRegistry = () => this.capabilityRegistry;
-		const expectedSourceStableIds = () => this.expectedSourceStableIds;
 		return {
 			ctx: this.ctx,
 			get capabilityRegistry() {
 				return capabilityRegistry();
 			},
-			devicesWithLinks: this.devicesWithLinks,
-			get expectedSourceStableIds() {
-				return expectedSourceStableIds();
-			},
-			linkResolveInFlight: this.linkResolveInFlight,
-			dropDeviceOverlays: (deviceId) => this.stateMirror.dropDeviceOverlays(deviceId),
 			remoteNativeCaps: this.remoteNativeCaps,
 			seedMirror: (deviceId, blob) => this.stateMirror.seedMirror(deviceId, blob),
 			withResetSessionProbe: (blob) => this.stateMirror.withResetSessionProbe(blob),
@@ -4681,15 +3985,12 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			}
 		}))).filter((id) => id !== null);
 	}
-	/** Build the dependency context the extracted binding resolvers consume.
-	*  `devicesWithLinks` is mutated in place (never reassigned) so the direct
-	*  reference stays live — it gates the virtual `linked` binding step. */
+	/** Build the dependency context the extracted binding resolvers consume. */
 	get bindingsDeps() {
 		return {
 			ctx: this.ctx,
 			capabilityRegistry: this.capabilityRegistry,
-			remoteNativeCaps: this.remoteNativeCaps,
-			devicesWithLinks: this.devicesWithLinks
+			remoteNativeCaps: this.remoteNativeCaps
 		};
 	}
 	async getBindings(input) {
@@ -4745,21 +4046,16 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			if (!ops) throw new Error(`[device-manager] device-ops native provider not found for '${deviceId}'`);
 			return ops;
 		};
-		const metaStore = new DeviceMetaStore(settings, registry, this.linkIndexHost);
-		this.stateMirrorImpl = new DeviceStateMirror(this.ctx, this.linkOverlayHost);
+		const metaStore = new DeviceMetaStore(settings, registry);
+		this.stateMirrorImpl = new DeviceStateMirror(this.ctx);
 		const stateMirror = this.stateMirrorImpl;
 		const readMeta = metaStore.readMeta;
 		const resolvePersistedById = metaStore.resolvePersistedById;
-		const rebuildLinkDependents = metaStore.rebuildLinkDependents;
 		const idToAddonId = metaStore.idToAddonId;
 		{
 			const meta = await readMeta();
-			for (const m of Object.values(meta)) {
-				idToAddonId.set(m.id, m.addonId);
-				if (Array.isArray(m.deviceLinks) && m.deviceLinks.length > 0) this.devicesWithLinks.add(m.id);
-			}
+			for (const m of Object.values(meta)) idToAddonId.set(m.id, m.addonId);
 		}
-		await rebuildLinkDependents();
 		const stampIntegrationId$1 = (deviceId, integrationId) => stampIntegrationId(metaStore, settings, this.ctx, deviceId, integrationId);
 		const pctx = {
 			host: this.providerHost,
@@ -4776,7 +4072,6 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 		const provider = {
 			resolveDeviceOwnerSync: (deviceId) => resolveDeviceOwnerSync(pctx, deviceId),
 			resolveNativeCapOwnerSync: (capName, deviceId) => resolveNativeCapOwnerSync(pctx, capName, deviceId),
-			resolveLinkedStatus: (input) => resolveLinkedStatus(pctx, input),
 			allocateDeviceId: (input) => allocateDeviceId(pctx, input),
 			registerDevice: (input) => registerDevice(pctx, input),
 			removeDevice: (input) => removeDevice(pctx, input),
@@ -4790,7 +4085,6 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			setLinkDeviceId: (input) => setLinkDeviceId(pctx, input),
 			setPrimaryChildEntityId: (input) => setPrimaryChildEntityId(pctx, input),
 			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),
@@ -4950,13 +4244,13 @@ var DeviceManagerAddon = class extends require_dist.BaseAddon {
 			capability: require_dist.deviceStateCapability,
 			provider: {
 				getSnapshot: async (input) => {
-					return stateMirror.snapshotForDeviceOverlayed(input.deviceId);
+					return stateMirror.snapshotForDevice(input.deviceId);
 				},
 				getCapSlice: async (input) => {
-					return stateMirror.overlayedSlice(input.deviceId, input.capName);
+					return stateMirror.capSlice(input.deviceId, input.capName);
 				},
 				getAllSnapshots: async () => {
-					return stateMirror.allSnapshotsOverlayed();
+					return stateMirror.allSnapshots();
 				},
 				setCapSlice: async (input) => {
 					const { deviceId, capName, slice } = input;