@camstack/system 1.1.13 → 1.1.14

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

@@ -2,114 +2,34 @@ import { canonicalDeviceFingerprint } from "@camstack/types/node";
 import { BaseAddon, CAP_NAMES_WITH_STATUS, DeviceFeature, DeviceRole, DeviceStatusSchema, DeviceType, EventCategory, STREAM_PROFILE_META, WELL_KNOWN_TAB_MAP, applyTransform, buildStreamParamsConfigSchema, deviceManagerCapability, deviceStateCapability, deviceStatusCapability, enumerateSchemaFields, errMsg, getByPath, isDeviceConfigCap, parseStreamParamsFormPatch, setByPath, sleep } from "@camstack/types";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
-//#region src/builtins/device-manager/device-event-propagator.ts
 /**
-* Walks the parent chain for every device-sourced event and re-emits a
-* copy on each ancestor scope with `via[]` populated.
-*
-* Design goals:
-*   - Transparent: drivers emit once on their own device scope; the
-*     framework handles fan-out. Zero provider boilerplate.
-*   - Anti-loop: events that already carry `via[]` are skipped (we only
-*     propagate ORIGINAL emissions).
-*   - Anti-cycle: the parent chain is bounded — if the device registry
-*     is corrupt and has a cycle, the walker caps at `MAX_CHAIN_DEPTH`
-*     and logs a warning.
-*   - Lazy: parent chain is resolved on-demand per event (no cached
-*     topology). The lookup is O(depth) which is ≤2 in practice.
-*
-* `via` contract (from SystemEvent.via JSDoc):
-*   - `via[0]` is the originating source (the device that produced the
-*     event). Subsequent entries walk up the parent chain.
-*   - On the re-emission, `source` is the ancestor at that level and
-*     `via[0..i]` is the prefix of the chain up to and including the
-*     first N ancestors below the current one.
-*
-* Example (grandchild → parent → grandparent):
-*   Original:  { source: {id: 7}, data: {...}, via: undefined }
-*   Re-emit 1: { source: {id: 4}, data: {...}, via: [{id: 7}] }
-*   Re-emit 2: { source: {id: 1}, data: {...}, via: [{id: 7}, {id: 4}] }
-*
-* A consumer listening at `source.id === 1` receives re-emit 2 (with
-* `via` showing the chain). A consumer listening at `source.id === 7`
-* with `via === undefined` receives the original only.
+* Build the device-detail form section for a `derived-form` device-config
+* cap. Returns null when the camera exposes no configurable property.
 */
-/** Bounded walk — paranoia against corrupt device registries with cycles. */
-var MAX_CHAIN_DEPTH = 16;
-var DeviceEventPropagator = class {
-	opts;
-	unsubscribe = null;
-	constructor(opts) {
-		this.opts = opts;
-	}
-	start() {
-		if (this.unsubscribe) return;
-		const unsub = this.opts.eventBus.subscribe({}, (ev) => this.handle(ev));
-		this.unsubscribe = unsub;
-	}
-	stop() {
-		if (!this.unsubscribe) return;
-		this.unsubscribe();
-		this.unsubscribe = null;
-	}
-	/** Exposed for tests — lets them inject events without the full bus. */
-	handle(ev) {
-		if (ev.via !== void 0) return;
-		if (ev.source.type !== "device") return;
-		const rawId = ev.source.id;
-		const deviceId = typeof rawId === "number" ? rawId : Number(rawId);
-		if (!Number.isFinite(deviceId)) return;
-		const chain = this.resolveParentChain(deviceId);
-		if (chain.length === 0) return;
-		const via = [ev.source];
-		for (const ancestorId of chain) {
-			const reEmission = {
-				...ev,
-				source: {
-					type: "device",
-					id: ancestorId
-				},
-				via: [...via]
-			};
-			this.opts.eventBus.emit(reEmission);
-			via.push({
-				type: "device",
-				id: ancestorId
-			});
-		}
-	}
-	resolveParentChain(deviceId) {
-		const chain = [];
-		const seen = new Set([deviceId]);
-		let current = this.opts.getParentOf(deviceId);
-		while (current != null) {
-			if (seen.has(current)) {
-				this.opts.logger.warn("device-event-propagator: cycle detected in parent chain — aborting propagation", {
-					tags: { deviceId },
-					meta: {
-						cycleAt: current,
-						chainSoFar: [...chain]
-					}
-				});
-				return chain;
-			}
-			seen.add(current);
-			chain.push(current);
-			if (chain.length >= MAX_CHAIN_DEPTH) {
-				this.opts.logger.warn("device-event-propagator: chain depth limit hit — truncating", {
-					tags: { deviceId },
-					meta: {
-						depth: chain.length,
-						max: MAX_CHAIN_DEPTH
-					}
-				});
-				break;
-			}
-			current = this.opts.getParentOf(current);
-		}
-		return chain;
+function deriveFormContribution(builderId, options, status) {
+	if (builderId !== "stream-params") throw new Error(`device-config: unknown derived-form builderId "${builderId}"`);
+	const schema = buildStreamParamsConfigSchema(options, status ?? null);
+	if (!schema) return null;
+	return { sections: schema.sections.map((s) => ({
+		id: s.id,
+		title: s.title,
+		...s.tab !== void 0 ? { tab: s.tab } : {},
+		...s.order !== void 0 ? { order: s.order } : {},
+		...s.description !== void 0 ? { description: s.description } : {},
+		...s.columns !== void 0 ? { columns: s.columns } : {},
+		fields: [...s.fields]
+	})) };
+}
+/**
+* Route a flat form patch back through the cap's per-profile setter.
+*/
+async function applyDerivedFormPatch(builderId, patch, setProfile) {
+	if (builderId !== "stream-params") throw new Error(`device-config: unknown derived-form builderId "${builderId}"`);
+	for (const meta of STREAM_PROFILE_META) {
+		const profilePatch = parseStreamParamsFormPatch(patch, meta.prefix);
+		if (profilePatch) await setProfile(meta.profile, profilePatch);
 	}
-};
+}
 //#endregion
 //#region src/builtins/device-manager/device-aggregation-merge.ts
 /**
@@ -250,102 +170,241 @@ function mergeAggregates(parts) {
 	return out;
 }
 //#endregion
-//#region src/builtins/device-manager/device-bindings-store.ts
+//#region src/builtins/device-manager/device-projection.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.
+* 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.
 */
 /**
-* 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
-* full cluster view. Events from the local node are ignored: hub-local natives
-* live in `capabilityRegistry` and are folded in directly by getBindings.
+* Return true when `err` is a transient Moleculer error that is worth
+* retrying — specifically any `MoleculerRetryableError` subclass
+* (ServiceNotAvailableError, ServiceNotFoundError, BrokerDisconnectedError,
+* RequestTimeoutError, …). Moleculer sets `retryable: true` on all of them.
 *
-* Push events are accurate in the steady state but can be lost during the
-* Moleculer transport handshake window (hub restart, crash-respawn,
-* restartAddon). The reliable replacement for lost events is the D3 re-handshake
-* (`listClusterNativeCaps()`), which `resolveNativeCapOwnerSync` /
-* `getBindings` step 4 fall through to on a push miss. The `$node.disconnected`
-* handler purges a gone node's entries; the worker re-handshakes (and re-emits
-* `native-registered`) on its next boot.
+* Falls back to a message-substring check for serialised errors that arrive
+* across the Moleculer transport as plain objects rather than real instances.
 */
-function wireRemoteNativeCapSync(ctx, remoteNativeCaps) {
-	const localNodeId = ctx.kernel.localNodeId ?? "hub";
-	ctx.eventBus.subscribe({ category: EventCategory.DeviceBindingsChanged }, (event) => {
-		const { deviceId, capName, reason, addonId, nodeId } = event.data;
-		if (nodeId === localNodeId) return;
-		if (reason === "native-registered") {
-			let perDevice = remoteNativeCaps.get(deviceId);
-			if (!perDevice) {
-				perDevice = /* @__PURE__ */ new Map();
-				remoteNativeCaps.set(deviceId, perDevice);
-			}
-			perDevice.set(capName, {
-				addonId,
-				nodeId
-			});
-		} else if (reason === "native-unregistered") {
-			const perDevice = remoteNativeCaps.get(deviceId);
-			if (!perDevice) return;
-			perDevice.delete(capName);
-			if (perDevice.size === 0) remoteNativeCaps.delete(deviceId);
-		}
-	});
-	const cluster = ctx.kernel.cluster;
-	if (cluster) cluster.broker.localBus.on("$node.disconnected", (payload) => {
-		const gone = payload.node.id;
-		const emptyDevices = [];
-		for (const [deviceId, perDevice] of remoteNativeCaps) {
-			const toDelete = [];
-			for (const [capName, entry] of perDevice) if (entry.nodeId === gone) toDelete.push(capName);
-			for (const capName of toDelete) perDevice.delete(capName);
-			if (perDevice.size === 0) emptyDevices.push(deviceId);
-		}
-		for (const deviceId of emptyDevices) remoteNativeCaps.delete(deviceId);
-	});
+function isTransientMoleculerError(err) {
+	if (err !== null && typeof err === "object") {
+		const e = err;
+		if (e["retryable"] === true) return true;
+		const code = typeof e["code"] === "string" ? e["code"] : "";
+		if (code === "SERVICE_NOT_FOUND" || code === "SERVICE_NOT_AVAILABLE" || code === "REQUEST_TIMEOUT" || code === "BAD_GATEWAY") return true;
+	}
+	if (err instanceof Error) {
+		const msg = err.message;
+		if (msg.includes("is not available") || msg.includes("is not found") || msg.includes("transporter has disconnected") || msg.includes("Request timed out")) return true;
+	}
+	return false;
 }
-async function readBindingsStore(deps) {
-	return { deviceBindings: (await deps.ctx.settings.readAddonStore()).deviceBindings ?? {} };
+function shallowEqual(a, b) {
+	const ak = Object.keys(a);
+	const bk = Object.keys(b);
+	if (ak.length !== bk.length) return false;
+	for (const k of ak) if (a[k] !== b[k]) return false;
+	return true;
 }
-async function writeBindingsStore(deps, next) {
-	await deps.ctx.settings.writeAddonStore({ deviceBindings: next.deviceBindings });
+/** 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 resolveWrapperNodeId(_wrapperAddonId) {
-	return "hub";
+function isCameraDevice(device) {
+	return "getStreamSources" in device && typeof device.getStreamSources === "function";
 }
+var DEVICE_FEATURE_VALUES = new Set(Object.values(DeviceFeature));
 /**
-* Reduce a provider node id to the routable form `DeviceProxy` can pin.
-*
-* Every addon runs in its own `addon-runner` with the composite node id
-* `${parentNodeId}/${runnerId}` (see `addon-runner.ts`) — e.g.
-* `hub/provider-reolink` or `dev-agent-0/provider-reolink`. That composite is
-* an IDENTITY, not a routable target: the `CapRouteResolver` reaches a child
-* only THROUGH its parent (the hub resolves a hub-local-uds child by
-* cap+device; an agent forwards to its own child). `DeviceProxy` pins
-* `entry.providerNodeId` on every cap call, so a binding entry must expose the
-* parent node id — otherwise the explicit pin classifies as `remote-moleculer`
-* to an unknown node → `no-provider`, which surfaces as
-* "this camera doesn't expose …" for client-proxy-driven widget caps
-* (motion-zones, privacy-mask). Wrappers already report the parent via
-* `resolveWrapperNodeId`; this aligns natives with the same contract.
-*
-* A flat node id (a genuine standalone node with no `/`) is returned
-* unchanged.
+* Validate persisted feature strings against the `DeviceFeature` enum
+* — workers serialise the live `device.features` array (so every entry
+* is a valid enum value at write time) but the persisted blob is loose
+* `string[]` on the wire. The narrow keeps unknown values out of the
+* `getDevice` response without losing the enum-typed contract.
 */
-function toRoutableProviderNodeId(nodeId) {
-	const slash = nodeId.indexOf("/");
-	return slash === -1 ? nodeId : nodeId.slice(0, slash);
-}
-/**
+function persistedFeatures(features) {
+	if (!features) return [];
+	const out = [];
+	for (const f of features) if (DEVICE_FEATURE_VALUES.has(f)) out.push(f);
+	return out;
+}
+/**
+* Build an identity-only `SourceInfo` from the persisted device config blob.
+*
+* Forked-worker accessory children (e.g. HA sensor entities) persist
+* `entityId` and `system` in their config blob at spawn time. The hub has no
+* live `IDevice` instance for these devices, so the persisted-fallback paths
+* in `listAll` / `getDevice` / `getChildren` must reconstruct the identity
+* `SourceInfo` from the config so dispatch routing keeps working.
+*
+* Rendering metadata (unit, precision) flows live through the cap STATUS SLICE
+* and must NOT be derived here. Only `id` + `system` (+ `uniqueId` when
+* present) are projected — purely identity, never rendering hints.
+*
+* Returns `undefined` when no identity anchor is resolvable (pure identity
+* devices like cameras/hubs that don't carry `entityId`/`system` in their
+* config blob) — the hub synthetic fallback applies in that case.
+*/
+function buildSourceInfoFromConfig(persistedConfig, stableId, addonId) {
+	const id = typeof persistedConfig["entityId"] === "string" ? persistedConfig["entityId"] : void 0;
+	const system = typeof persistedConfig["system"] === "string" ? persistedConfig["system"] : void 0;
+	if (id === void 0 && system === void 0) return void 0;
+	const uniqueId = typeof persistedConfig["uniqueId"] === "string" ? persistedConfig["uniqueId"] : void 0;
+	return {
+		id: id ?? stableId,
+		system: system ?? addonId,
+		...uniqueId !== void 0 ? { uniqueId } : {}
+	};
+}
+var DEVICE_ROLE_VALUES = new Set(Object.values(DeviceRole));
+/** Type guard: a string is a known `DeviceRole` enum member. */
+function isDeviceRole(value) {
+	return DEVICE_ROLE_VALUES.has(value);
+}
+/** Narrow a persisted role string (sqlite TEXT column) to a `DeviceRole`.
+*  Unknown / null values resolve to `null` so a stale or unrecognised role
+*  never leaks an off-enum string onto the wire shape. */
+function toDeviceRole(value) {
+	return value != null && isDeviceRole(value) ? value : null;
+}
+function toDeviceInfo(addonId, device, metadata = null, metaRow = null) {
+	const configValues = {};
+	for (const entry of device.config.entries()) configValues[entry.key] = entry.value;
+	const name = metaRow?.name ?? device.name;
+	const location = metaRow?.location !== void 0 ? metaRow.location : device.location;
+	const disabled = metaRow?.disabled ?? device.disabled;
+	const probeSlice = device.runtimeState?.getCapState("feature-probe");
+	const probed = probeSlice === void 0 ? true : (probeSlice.lastProbedAt ?? 0) > 0;
+	return {
+		id: device.id,
+		stableId: device.stableId,
+		addonId,
+		type: device.type,
+		name,
+		location,
+		disabled,
+		parentDeviceId: device.parentDeviceId,
+		role: device.role ?? null,
+		online: device.online,
+		probed,
+		features: device.features.length > 0 ? [...device.features] : persistedFeatures(metaRow?.features),
+		isCamera: isCameraDevice(device),
+		config: configValues,
+		metadata,
+		...metaRow?.integrationId !== void 0 ? { integrationId: metaRow.integrationId } : {},
+		...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 } : {}
+	};
+}
+function resolveDeviceById(registry, deviceId) {
+	const device = registry.getById(deviceId);
+	if (!device) return null;
+	const addonId = registry.getAddonId(deviceId);
+	if (!addonId) return null;
+	return {
+		addonId,
+		device
+	};
+}
+//#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
+* full cluster view. Events from the local node are ignored: hub-local natives
+* live in `capabilityRegistry` and are folded in directly by getBindings.
+*
+* Push events are accurate in the steady state but can be lost during the
+* Moleculer transport handshake window (hub restart, crash-respawn,
+* restartAddon). The reliable replacement for lost events is the D3 re-handshake
+* (`listClusterNativeCaps()`), which `resolveNativeCapOwnerSync` /
+* `getBindings` step 4 fall through to on a push miss. The `$node.disconnected`
+* handler purges a gone node's entries; the worker re-handshakes (and re-emits
+* `native-registered`) on its next boot.
+*/
+function wireRemoteNativeCapSync(ctx, remoteNativeCaps) {
+	const localNodeId = ctx.kernel.localNodeId ?? "hub";
+	ctx.eventBus.subscribe({ category: EventCategory.DeviceBindingsChanged }, (event) => {
+		const { deviceId, capName, reason, addonId, nodeId } = event.data;
+		if (nodeId === localNodeId) return;
+		if (reason === "native-registered") {
+			let perDevice = remoteNativeCaps.get(deviceId);
+			if (!perDevice) {
+				perDevice = /* @__PURE__ */ new Map();
+				remoteNativeCaps.set(deviceId, perDevice);
+			}
+			perDevice.set(capName, {
+				addonId,
+				nodeId
+			});
+		} else if (reason === "native-unregistered") {
+			const perDevice = remoteNativeCaps.get(deviceId);
+			if (!perDevice) return;
+			perDevice.delete(capName);
+			if (perDevice.size === 0) remoteNativeCaps.delete(deviceId);
+		}
+	});
+	const cluster = ctx.kernel.cluster;
+	if (cluster) cluster.broker.localBus.on("$node.disconnected", (payload) => {
+		const gone = payload.node.id;
+		const emptyDevices = [];
+		for (const [deviceId, perDevice] of remoteNativeCaps) {
+			const toDelete = [];
+			for (const [capName, entry] of perDevice) if (entry.nodeId === gone) toDelete.push(capName);
+			for (const capName of toDelete) perDevice.delete(capName);
+			if (perDevice.size === 0) emptyDevices.push(deviceId);
+		}
+		for (const deviceId of emptyDevices) remoteNativeCaps.delete(deviceId);
+	});
+}
+async function readBindingsStore(deps) {
+	return { deviceBindings: (await deps.ctx.settings.readAddonStore()).deviceBindings ?? {} };
+}
+async function writeBindingsStore(deps, next) {
+	await deps.ctx.settings.writeAddonStore({ deviceBindings: next.deviceBindings });
+}
+function resolveWrapperNodeId(_wrapperAddonId) {
+	return "hub";
+}
+/**
+* Reduce a provider node id to the routable form `DeviceProxy` can pin.
+*
+* Every addon runs in its own `addon-runner` with the composite node id
+* `${parentNodeId}/${runnerId}` (see `addon-runner.ts`) — e.g.
+* `hub/provider-reolink` or `dev-agent-0/provider-reolink`. That composite is
+* an IDENTITY, not a routable target: the `CapRouteResolver` reaches a child
+* only THROUGH its parent (the hub resolves a hub-local-uds child by
+* cap+device; an agent forwards to its own child). `DeviceProxy` pins
+* `entry.providerNodeId` on every cap call, so a binding entry must expose the
+* parent node id — otherwise the explicit pin classifies as `remote-moleculer`
+* to an unknown node → `no-provider`, which surfaces as
+* "this camera doesn't expose …" for client-proxy-driven widget caps
+* (motion-zones, privacy-mask). Wrappers already report the parent via
+* `resolveWrapperNodeId`; this aligns natives with the same contract.
+*
+* A flat node id (a genuine standalone node with no `/`) is returned
+* unchanged.
+*/
+function toRoutableProviderNodeId(nodeId) {
+	const slash = nodeId.indexOf("/");
+	return slash === -1 ? nodeId : nodeId.slice(0, slash);
+}
+/**
 * Resolve a remote native cap entry for a given `(capName, deviceId)` by
 * consulting the handshake-fed `HubNodeRegistry` via
 * `ctx.kernel.listClusterNativeCaps()`. Called when the push-based
@@ -478,202 +537,35 @@ async function getAllBindings(deps) {
 async function lookupPersistedStableId(deps, deviceId) {
 	return ((await deps.ctx.settings.readAddonStore()).deviceMeta ?? {})[String(deviceId)]?.stableId;
 }
-/**
-* Build the device-detail form section for a `derived-form` device-config
-* cap. Returns null when the camera exposes no configurable property.
-*/
-function deriveFormContribution(builderId, options, status) {
-	if (builderId !== "stream-params") throw new Error(`device-config: unknown derived-form builderId "${builderId}"`);
-	const schema = buildStreamParamsConfigSchema(options, status ?? null);
-	if (!schema) return null;
-	return { sections: schema.sections.map((s) => ({
-		id: s.id,
-		title: s.title,
-		...s.tab !== void 0 ? { tab: s.tab } : {},
-		...s.order !== void 0 ? { order: s.order } : {},
-		...s.description !== void 0 ? { description: s.description } : {},
-		...s.columns !== void 0 ? { columns: s.columns } : {},
-		fields: [...s.fields]
-	})) };
-}
-/**
-* Route a flat form patch back through the cap's per-profile setter.
-*/
-async function applyDerivedFormPatch(builderId, patch, setProfile) {
-	if (builderId !== "stream-params") throw new Error(`device-config: unknown derived-form builderId "${builderId}"`);
-	for (const meta of STREAM_PROFILE_META) {
-		const profilePatch = parseStreamParamsFormPatch(patch, meta.prefix);
-		if (profilePatch) await setProfile(meta.profile, profilePatch);
-	}
-}
 //#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.
-*/
+//#region src/builtins/device-manager/device-aggregation.ts
 /**
-* Return true when `err` is a transient Moleculer error that is worth
-* retrying — specifically any `MoleculerRetryableError` subclass
-* (ServiceNotAvailableError, ServiceNotFoundError, BrokerDisconnectedError,
-* RequestTimeoutError, …). Moleculer sets `retryable: true` on all of them.
+* Device-details aggregation + field-update routing for the device-manager
+* addon. Extracted from `device-manager.addon.ts` as free functions that
+* receive an explicit `AggregationDeps` context (DI) rather than closing over
+* the addon instance.
 *
-* Falls back to a message-substring check for serialised errors that arrive
-* across the Moleculer transport as plain objects rather than real instances.
+* This module owns the binding-driven settings/live/status aggregators
+* (`getDeviceAggregate`, `collectSystemDeviceContributions`,
+* `deriveDeviceConfigContribution`, `buildBaseDeviceSection`,
+* `getDeviceStatusAggregate`, `resolveDriverConfigSchema`) and the
+* field-update routing (`updateDeviceField`, `updateDeviceFieldsBatch`,
+* `applyGroupPatch`, `resolveContributionProvider`, `dispatchDeviceAction`)
+* plus the wrapper-activation mutators (`setWrapperActive`,
+* `listWrappersForCap`, `listBindableCapsForDeviceType`).
+*
+* Sibling aggregator functions call each other directly (passing `deps`);
+* cross-domain leaf calls (`getBindings`, `lookupPersistedStableId`,
+* `resolveRemoteNativeCapFromRegistry`, read/writeBindingsStore) route through
+* the bindings-store module via `deps.bindingsDeps`. EXACT semantics, ordering,
+* and side effects of the original class methods are preserved; the addon keeps
+* thin delegator methods over these functions.
 */
-function isTransientMoleculerError(err) {
-	if (err !== null && typeof err === "object") {
-		const e = err;
-		if (e["retryable"] === true) return true;
-		const code = typeof e["code"] === "string" ? e["code"] : "";
-		if (code === "SERVICE_NOT_FOUND" || code === "SERVICE_NOT_AVAILABLE" || code === "REQUEST_TIMEOUT" || code === "BAD_GATEWAY") return true;
-	}
-	if (err instanceof Error) {
-		const msg = err.message;
-		if (msg.includes("is not available") || msg.includes("is not found") || msg.includes("transporter has disconnected") || msg.includes("Request timed out")) return true;
-	}
-	return false;
-}
-function shallowEqual(a, b) {
-	const ak = Object.keys(a);
-	const bk = Object.keys(b);
-	if (ak.length !== bk.length) return false;
-	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";
-}
-var DEVICE_FEATURE_VALUES = new Set(Object.values(DeviceFeature));
-/**
-* Validate persisted feature strings against the `DeviceFeature` enum
-* — workers serialise the live `device.features` array (so every entry
-* is a valid enum value at write time) but the persisted blob is loose
-* `string[]` on the wire. The narrow keeps unknown values out of the
-* `getDevice` response without losing the enum-typed contract.
-*/
-function persistedFeatures(features) {
-	if (!features) return [];
-	const out = [];
-	for (const f of features) if (DEVICE_FEATURE_VALUES.has(f)) out.push(f);
-	return out;
-}
-/**
-* Build an identity-only `SourceInfo` from the persisted device config blob.
-*
-* Forked-worker accessory children (e.g. HA sensor entities) persist
-* `entityId` and `system` in their config blob at spawn time. The hub has no
-* live `IDevice` instance for these devices, so the persisted-fallback paths
-* in `listAll` / `getDevice` / `getChildren` must reconstruct the identity
-* `SourceInfo` from the config so dispatch routing keeps working.
-*
-* Rendering metadata (unit, precision) flows live through the cap STATUS SLICE
-* and must NOT be derived here. Only `id` + `system` (+ `uniqueId` when
-* present) are projected — purely identity, never rendering hints.
-*
-* Returns `undefined` when no identity anchor is resolvable (pure identity
-* devices like cameras/hubs that don't carry `entityId`/`system` in their
-* config blob) — the hub synthetic fallback applies in that case.
-*/
-function buildSourceInfoFromConfig(persistedConfig, stableId, addonId) {
-	const id = typeof persistedConfig["entityId"] === "string" ? persistedConfig["entityId"] : void 0;
-	const system = typeof persistedConfig["system"] === "string" ? persistedConfig["system"] : void 0;
-	if (id === void 0 && system === void 0) return void 0;
-	const uniqueId = typeof persistedConfig["uniqueId"] === "string" ? persistedConfig["uniqueId"] : void 0;
-	return {
-		id: id ?? stableId,
-		system: system ?? addonId,
-		...uniqueId !== void 0 ? { uniqueId } : {}
-	};
-}
-var DEVICE_ROLE_VALUES = new Set(Object.values(DeviceRole));
-/** Type guard: a string is a known `DeviceRole` enum member. */
-function isDeviceRole(value) {
-	return DEVICE_ROLE_VALUES.has(value);
-}
-/** Narrow a persisted role string (sqlite TEXT column) to a `DeviceRole`.
-*  Unknown / null values resolve to `null` so a stale or unrecognised role
-*  never leaks an off-enum string onto the wire shape. */
-function toDeviceRole(value) {
-	return value != null && isDeviceRole(value) ? value : null;
-}
-function toDeviceInfo(addonId, device, metadata = null, metaRow = null) {
-	const configValues = {};
-	for (const entry of device.config.entries()) configValues[entry.key] = entry.value;
-	const name = metaRow?.name ?? device.name;
-	const location = metaRow?.location !== void 0 ? metaRow.location : device.location;
-	const disabled = metaRow?.disabled ?? device.disabled;
-	const probeSlice = device.runtimeState?.getCapState("feature-probe");
-	const probed = probeSlice === void 0 ? true : (probeSlice.lastProbedAt ?? 0) > 0;
-	return {
-		id: device.id,
-		stableId: device.stableId,
-		addonId,
-		type: device.type,
-		name,
-		location,
-		disabled,
-		parentDeviceId: device.parentDeviceId,
-		role: device.role ?? null,
-		online: device.online,
-		probed,
-		features: device.features.length > 0 ? [...device.features] : persistedFeatures(metaRow?.features),
-		isCamera: isCameraDevice(device),
-		config: configValues,
-		metadata,
-		...metaRow?.integrationId !== void 0 ? { integrationId: metaRow.integrationId } : {},
-		...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 } : {}
-	};
-}
-function resolveDeviceById(registry, deviceId) {
-	const device = registry.getById(deviceId);
-	if (!device) return null;
-	const addonId = registry.getAddonId(deviceId);
-	if (!addonId) return null;
-	return {
-		addonId,
-		device
-	};
-}
-//#endregion
-//#region src/builtins/device-manager/device-aggregation.ts
-/**
-* Device-details aggregation + field-update routing for the device-manager
-* addon. Extracted from `device-manager.addon.ts` as free functions that
-* receive an explicit `AggregationDeps` context (DI) rather than closing over
-* the addon instance.
-*
-* This module owns the binding-driven settings/live/status aggregators
-* (`getDeviceAggregate`, `collectSystemDeviceContributions`,
-* `deriveDeviceConfigContribution`, `buildBaseDeviceSection`,
-* `getDeviceStatusAggregate`, `resolveDriverConfigSchema`) and the
-* field-update routing (`updateDeviceField`, `updateDeviceFieldsBatch`,
-* `applyGroupPatch`, `resolveContributionProvider`, `dispatchDeviceAction`)
-* plus the wrapper-activation mutators (`setWrapperActive`,
-* `listWrappersForCap`, `listBindableCapsForDeviceType`).
-*
-* Sibling aggregator functions call each other directly (passing `deps`);
-* cross-domain leaf calls (`getBindings`, `lookupPersistedStableId`,
-* `resolveRemoteNativeCapFromRegistry`, read/writeBindingsStore) route through
-* the bindings-store module via `deps.bindingsDeps`. EXACT semantics, ordering,
-* and side effects of the original class methods are preserved; the addon keeps
-* thin delegator methods over these functions.
-*/
-async function getDeviceAggregate(deps, deviceId, kind) {
-	const registry = deps.capabilityRegistry;
-	if (!registry) {
-		deps.ctx.logger.debug("capability registry unavailable — aggregate empty", { meta: { kind } });
-		return null;
+async function getDeviceAggregate(deps, deviceId, kind) {
+	const registry = deps.capabilityRegistry;
+	if (!registry) {
+		deps.ctx.logger.debug("capability registry unavailable — aggregate empty", { meta: { kind } });
+		return null;
 	}
 	const method = kind === "settings" ? "getDeviceSettingsContribution" : "getDeviceLiveContribution";
 	const { entries: bindingEntries } = await getBindings(deps.bindingsDeps, { deviceId });
@@ -1310,560 +1202,145 @@ async function getWireableFields(deps, input) {
 	return { caps };
 }
 //#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 } of entries) {
-		const tKey = `${targetDeviceId}:${link.target.cap}`;
-		const tList = targets.get(tKey) ?? [];
-		tList.push({
-			link,
-			sourceDeviceId
-		});
-		targets.set(tKey, tList);
-		const sKey = `${sourceDeviceId}:${link.source.cap}`;
-		const sList = dependents.get(sKey) ?? [];
-		sList.push({
-			targetDeviceId,
-			targetCap: link.target.cap
-		});
-		dependents.set(sKey, sList);
-	}
-	return {
-		targets,
-		dependents
-	};
-}
-//#endregion
-//#region src/builtins/device-manager/device-meta-store.ts
+//#region src/builtins/device-manager/device-event-propagator.ts
 /**
-* Meta persistence layer for the device-manager addon.
+* Walks the parent chain for every device-sourced event and re-emits a
+* copy on each ancestor scope with `via[]` populated.
 *
-* `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.
+* Design goals:
+*   - Transparent: drivers emit once on their own device scope; the
+*     framework handles fan-out. Zero provider boilerplate.
+*   - Anti-loop: events that already carry `via[]` are skipped (we only
+*     propagate ORIGINAL emissions).
+*   - Anti-cycle: the parent chain is bounded — if the device registry
+*     is corrupt and has a cycle, the walker caps at `MAX_CHAIN_DEPTH`
+*     and logs a warning.
+*   - Lazy: parent chain is resolved on-demand per event (no cached
+*     topology). The lookup is O(depth) which is ≤2 in practice.
 *
-* 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.
+* `via` contract (from SystemEvent.via JSDoc):
+*   - `via[0]` is the originating source (the device that produced the
+*     event). Subsequent entries walk up the parent chain.
+*   - On the re-emission, `source` is the ancestor at that level and
+*     `via[0..i]` is the prefix of the chain up to and including the
+*     first N ancestors below the current one.
+*
+* Example (grandchild → parent → grandparent):
+*   Original:  { source: {id: 7}, data: {...}, via: undefined }
+*   Re-emit 1: { source: {id: 4}, data: {...}, via: [{id: 7}] }
+*   Re-emit 2: { source: {id: 1}, data: {...}, via: [{id: 7}, {id: 4}] }
+*
+* A consumer listening at `source.id === 1` receives re-emit 2 (with
+* `via` showing the chain). A consumer listening at `source.id === 7`
+* with `via === undefined` receives the original only.
 */
-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
-	*  ownership without awaiting. Kept in sync with every register/remove and
-	*  warmed from persistence on boot. */
-	idToAddonId = /* @__PURE__ */ new Map();
-	/** Serialises every read-modify-write of the deviceMeta / deviceIndex blob
-	*  through one promise chain (see `withMetaWriteLock`). Per-instance state —
-	*  identical to the former `onInitialize` closure variable. */
-	metaWriteChain = Promise.resolve();
-	constructor(settings, registry, linkHost) {
-		this.settings = settings;
-		this.registry = registry;
-		this.linkHost = linkHost;
+/** Bounded walk — paranoia against corrupt device registries with cycles. */
+var MAX_CHAIN_DEPTH = 16;
+var DeviceEventPropagator = class {
+	opts;
+	unsubscribe = null;
+	constructor(opts) {
+		this.opts = opts;
 	}
-	readStore = async () => {
-		return await this.settings.readAddonStore();
-	};
-	readIndex = async () => {
-		return (await this.readStore()).deviceIndex ?? {};
-	};
-	readMeta = async () => {
-		return (await this.readStore()).deviceMeta ?? {};
-	};
-	/** Hardware-identity metadata map. Lives in a sibling key on the
-	*  device-manager addon store so its writers (`setMetadata`) never
-	*  collide with the lifecycle writers on `deviceMeta`
-	*  (`registerDevice` / `setName` / `setLocation` / `setDisabled`).
-	*  Single-writer per row eliminates the "writer X clobbers writer
-	*  Y's field" bug class — `setMetadata` is the only producer. */
-	readMetadataMap = async () => {
-		return (await this.readStore()).deviceMetadata ?? {};
-	};
-	withMetaWriteLock = async (fn) => {
-		const previous = this.metaWriteChain;
-		let release = () => {};
-		const next = new Promise((resolve) => {
-			release = resolve;
-		});
-		this.metaWriteChain = next;
-		try {
-			await previous.catch(() => {});
-			return await fn();
-		} finally {
-			release();
-		}
-	};
-	/**
-	* Resolve a numeric deviceId to the owning `(addonId, stableId)` pair.
-	* Scans persisted meta — live IDevice lookup (hub registry) is handled
-	* separately per call site so callers can decide whether to route to
-	* an in-process driver or to the cross-process `device-ops` bridge.
-	* Returns null when no device with that id is known to the hub.
-	*/
-	resolvePersistedById = async (deviceId) => {
-		const m = (await this.readMeta())[String(deviceId)];
-		if (!m) return null;
-		return {
-			addonId: m.addonId,
-			stableId: m.stableId,
-			meta: m
-		};
-	};
-	/** Direct children of a device: the union of the live registry's children
-	*  and the persisted-meta scan (`parentDeviceId === parentId`), deduplicated
-	*  and excluding self. Shared by the `remove` cascade and the `resetToSource`
-	*  resync purge (#19). */
-	directChildIds = async (parentId) => {
-		const ids = /* @__PURE__ */ new Set();
-		if (this.registry) for (const c of this.registry.getChildren(parentId)) ids.add(c.id);
-		const meta = await this.readMeta();
-		for (const m of Object.values(meta)) if (m.parentDeviceId === parentId) ids.add(m.id);
-		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;
-	};
-	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);
+	start() {
+		if (this.unsubscribe) return;
+		const unsub = this.opts.eventBus.subscribe({}, (ev) => this.handle(ev));
+		this.unsubscribe = unsub;
+	}
+	stop() {
+		if (!this.unsubscribe) return;
+		this.unsubscribe();
+		this.unsubscribe = null;
+	}
+	/** Exposed for tests — lets them inject events without the full bus. */
+	handle(ev) {
+		if (ev.via !== void 0) return;
+		if (ev.source.type !== "device") return;
+		const rawId = ev.source.id;
+		const deviceId = typeof rawId === "number" ? rawId : Number(rawId);
+		if (!Number.isFinite(deviceId)) return;
+		const chain = this.resolveParentChain(deviceId);
+		if (chain.length === 0) return;
+		const via = [ev.source];
+		for (const ancestorId of chain) {
+			const reEmission = {
+				...ev,
+				source: {
+					type: "device",
+					id: ancestorId
+				},
+				via: [...via]
+			};
+			this.opts.eventBus.emit(reEmission);
+			via.push({
+				type: "device",
+				id: ancestorId
+			});
 		}
-		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 ?? []) {
-				expectedSources.add(`${container}-${link.source.sourceKey}`);
-				const srcId = idByStableId.get(`${container}-${link.source.sourceKey}`);
-				if (srcId === void 0) continue;
-				entries.push({
-					targetDeviceId: targetId,
-					link,
-					sourceDeviceId: srcId
+	}
+	resolveParentChain(deviceId) {
+		const chain = [];
+		const seen = new Set([deviceId]);
+		let current = this.opts.getParentOf(deviceId);
+		while (current != null) {
+			if (seen.has(current)) {
+				this.opts.logger.warn("device-event-propagator: cycle detected in parent chain — aborting propagation", {
+					tags: { deviceId },
+					meta: {
+						cycleAt: current,
+						chainSoFar: [...chain]
+					}
+				});
+				return chain;
+			}
+			seen.add(current);
+			chain.push(current);
+			if (chain.length >= MAX_CHAIN_DEPTH) {
+				this.opts.logger.warn("device-event-propagator: chain depth limit hit — truncating", {
+					tags: { deviceId },
+					meta: {
+						depth: chain.length,
+						max: MAX_CHAIN_DEPTH
+					}
 				});
+				break;
 			}
+			current = this.opts.getParentOf(current);
 		}
-		const { targets, dependents } = buildLinkIndexes(entries);
-		this.linkHost.setLinkIndexes(targets, dependents, expectedSources);
-	};
+		return chain;
+	}
 };
 //#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);
-}
-/** 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 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 z.ZodNullable || schema instanceof z.ZodOptional || schema instanceof 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 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;
-}
+//#region src/builtins/device-manager/device-meta-actions.ts
 /**
-* 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.
+* Device meta-mutation + persistence actions for the device-manager addon —
+* the `IDeviceManagerProvider` write/load surface. Extracted verbatim from the
+* `onInitialize` provider literal as free functions taking a `ProviderContext`
+* (DI). Each function's input/return types are pinned to the cap contract via
+* `Parameters<IDeviceManagerProvider['x']>[0]` / `ReturnType<…>` so the typed
+* surface is identical to the inferred object-literal methods.
+*
+* Covers: id allocation + registration (allocateDeviceId, registerDevice,
+* removeDevice), config persistence (persistConfig, loadConfig), the meta
+* surface load (loadMeta, loadRuntimeState), every meta setter (setName,
+* setLocation, setType, setIntegrationId, setLinkDeviceId,
+* setPrimaryChildEntityId, setChildLayout, setDeviceLinks, setRole,
+* applyInitialMeta, setMetadata, setDisabled), and the location registry
+* (listLocations, addLocation, removeLocation).
+*
+* EXACT ordering and side effects preserved — notably registerDevice's
+* name-precedence reconcile + field-preservation spreads, the
+* withMetaWriteLock-serialised read-modify-writes, the event emissions, and the
+* link reverse-index rebuild gating. Pure refactor — no behavior change.
 */
-function mergeLinkedStatus(base, resolved, statusSchema) {
-	let draft = base;
-	let touched = false;
-	for (const { link, sourceValue } of resolved) {
-		if (sourceValue === void 0) continue;
-		draft = setByPath(draft, link.target.fieldPath, sourceValue);
-		touched = true;
-	}
-	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.
-*/
-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 —
-	* slices show up as `setCapSlice` calls trickle in.
-	*/
-	stateMirror = /* @__PURE__ */ new Map();
-	/**
-	* Per-device disk-write debouncer for runtime-state. `setCapSlice`
-	* updates the in-memory mirror synchronously and emits the change
-	* event immediately, but the disk write is coalesced.
-	*/
-	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) {
-		this.ctx = ctx;
-		this.linkHost = linkHost;
-	}
-	/**
-	* Single-cap mirror update — diff against the current mirror,
-	* persist the new slice in-memory, emit `DeviceStateChanged` for
-	* this cap. No-op on identical writes (both same shape and same
-	* values). Called by `setCapSlice` provider.
-	*/
-	applySingleCapUpdate(deviceId, capName, slice) {
-		let perCap = this.stateMirror.get(deviceId);
-		if (!perCap) {
-			perCap = /* @__PURE__ */ new Map();
-			this.stateMirror.set(deviceId, perCap);
-		}
-		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);
-	}
-	/**
-	* Debounced disk writer. Coalesces frequent writes (motion phase
-	* transitions, battery pushes) into one `writeDeviceRuntimeState`
-	* per `RUNTIME_STATE_DEBOUNCE_MS` window. Reads the per-device
-	* blob from the live mirror at flush time so the disk picture is
-	* always the latest state — no risk of writing a stale snapshot.
-	*/
-	scheduleRuntimeStateDiskWrite(deviceId, settings) {
-		let slot = this.runtimeStateDebounce.get(deviceId);
-		if (!slot) {
-			slot = {
-				timer: null,
-				inFlight: null
-			};
-			this.runtimeStateDebounce.set(deviceId, slot);
-		}
-		if (slot.timer) return;
-		slot.timer = setTimeout(() => {
-			slot.timer = null;
-			const blob = this.snapshotForDevice(deviceId);
-			const write = (async () => {
-				try {
-					await settings.writeDeviceRuntimeState(deviceId, blob);
-				} catch (err) {
-					this.ctx.logger.warn("writeDeviceRuntimeState failed", {
-						tags: { deviceId },
-						meta: { error: err instanceof Error ? err.message : String(err) }
-					});
-				} finally {
-					slot.inFlight = null;
-				}
-			})();
-			slot.inFlight = write;
-		}, DeviceStateMirror.RUNTIME_STATE_DEBOUNCE_MS);
-	}
-	/**
-	* One-shot mirror seed used by `loadRuntimeState` at boot so the
-	* hub knows about every persisted slice without waiting for the
-	* first `setCapSlice` call. No events emitted — this is
-	* initial-state population, not a transition.
-	*
-	* Callers that must not carry a stale per-session probe across a
-	* restart pass the blob through `withResetSessionProbe` first (see
-	* `loadRuntimeState`).
-	*/
-	seedMirror(deviceId, blob) {
-		let perCap = this.stateMirror.get(deviceId);
-		if (!perCap) {
-			perCap = /* @__PURE__ */ new Map();
-			this.stateMirror.set(deviceId, perCap);
-		}
-		for (const [capName, raw] of Object.entries(blob)) {
-			if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
-			perCap.set(capName, { ...raw });
-		}
-	}
-	/**
-	* The hub mirror's `feature-probe.lastProbedAt` is a PER-SESSION liveness
-	* signal — it means "this worker process completed a probe THIS session".
-	* Persisted runtime state carries the PRE-RESTART timestamp, which is stale
-	* after a hub or worker restart: the device has not re-probed yet. Seeding it
-	* verbatim makes `resolveDeviceProbed` report `probed:true` during the
-	* restart→reprobe window, which defeats the export carry-forward gate
-	* (`resolveExportFingerprint`, gated on `device.probed`) and posts a spurious
-	* partial `AddOrUpdateReport` to Alexa/HAP before the real probe lands.
-	*
-	* Reset `lastProbedAt` to 0 for the MIRROR seed only — `probed:false` carries
-	* the last-advertised fingerprint forward until the worker republishes a
-	* fresh probe (its post-probe `setCapSlice` raises `lastProbedAt` again, which
-	* also fires `DeviceReady`). The worker's returned `initialRuntimeState` blob
-	* is untouched, and every non-probe slice (e.g. `device-status`/online) is
-	* preserved.
-	*/
-	withResetSessionProbe(blob) {
-		const probe = blob["feature-probe"];
-		if (!probe || typeof probe !== "object" || Array.isArray(probe)) return blob;
-		return {
-			...blob,
-			"feature-probe": {
-				...probe,
-				lastProbedAt: 0
-			}
-		};
-	}
-	/**
-	* Resolve a device's REAL `online` flag for the persisted/forked-worker
-	* list branch. Forked workers own the live `IDevice` in their own process,
-	* so the hub registry can't read `device.online` directly. The owning
-	* driver instead publishes its liveness through the auto-registered
-	* `device-status` runtime-state slice (`markOnline` → `setCapState`), which
-	* the canonical `deviceState.setCapSlice` write entrypoint mirrors into the
-	* hub-side `stateMirror`. We read that mirrored slice here so the list
-	* payload reflects the device's actual reachability instead of a constant.
-	*
-	* Fallback (`fallbackOnline`) preserves the legacy behaviour when no slice
-	* has been published yet: a persisted device with a live registry is
-	* assumed online (it was successfully registered by its owning process),
-	* and the null-registry "offline view" keeps reporting offline. We never
-	* regress a device to offline merely because its mirror is empty.
-	*/
-	resolveDeviceOnline(deviceId, fallbackOnline) {
-		const raw = this.stateMirror.get(deviceId)?.get(deviceStatusCapability.name);
-		if (!raw) return fallbackOnline;
-		const parsed = DeviceStatusSchema.safeParse(raw);
-		if (!parsed.success) return fallbackOnline;
-		return parsed.data.online;
-	}
-	/**
-	* Derive the `probed` flag for an offline-view (forked-worker, not
-	* live in the hub registry) device projection. Reads the mirrored
-	* `feature-probe` slice the owning worker publishes. Mirrors the
-	* `toDeviceInfo` rule: no mirrored slice → ready (`true`, no probe seen);
-	* slice present → ready iff `lastProbedAt` has advanced past 0. The
-	* mirror is populated when the worker's first `setCapSlice` RPC arrives
-	* (BaseDevice seeds `feature-probe` `lastProbedAt:0` at construction, but
-	* cross-process delivery is async); until then the no-entry path returns
-	* `true` — a brief transient window, same as `resolveDeviceOnline`.
-	*/
-	resolveDeviceProbed(deviceId) {
-		const raw = this.stateMirror.get(deviceId)?.get("feature-probe");
-		if (!raw) return true;
-		return (typeof raw.lastProbedAt === "number" ? raw.lastProbedAt : 0) > 0;
-	}
-	snapshotForDevice(deviceId) {
-		const perCap = this.stateMirror.get(deviceId);
-		if (!perCap) return {};
-		const out = {};
-		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. 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 resolved = links.map((rl) => ({
-			link: rl.link,
-			sourceValue: applyTransform(getByPath(this.stateMirror.get(rl.sourceDeviceId)?.get(rl.link.source.cap), rl.link.source.fieldPath), rl.link.transform)
-		}));
-		const schema = this.linkHost.capabilityRegistry?.getDefinition(cap)?.status?.schema;
-		return mergeLinkedStatus(raw ? { ...raw } : {}, resolved, schema);
-	}
-	/**
-	* 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. The debounced disk
-	* writer must continue to call snapshotForDevice (raw truth).
-	*/
-	snapshotForDeviceOverlayed(deviceId) {
-		const perCap = this.stateMirror.get(deviceId);
-		if (!perCap) return {};
-		const out = {};
-		for (const capName of perCap.keys()) {
-			const s = this.overlayedSlice(deviceId, capName);
-			if (s) out[capName] = s;
-		}
-		return out;
-	}
-	/** Whole-system mirror dump (overlaid). Backs `deviceState.getAllSnapshots`. */
-	allSnapshotsOverlayed() {
-		const out = {};
-		for (const [deviceId, perCap] of this.stateMirror) {
-			const dev = {};
-			for (const [capName, slice] of perCap) dev[capName] = this.overlayedSlice(deviceId, capName) ?? { ...slice };
-			out[String(deviceId)] = dev;
-		}
-		return out;
-	}
-	emitStateChanged(deviceId, capName, slice) {
-		this.ctx.eventBus.emit({
-			id: randomUUID(),
-			timestamp: /* @__PURE__ */ new Date(),
-			source: {
-				type: "device",
-				id: deviceId
-			},
-			category: EventCategory.DeviceStateChanged,
-			data: {
-				deviceId,
-				capName,
-				slice
-			}
-		});
-	}
-	/** 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. */
-	async flushPendingWrites(settings) {
-		const pending = [];
-		for (const [deviceId, slot] of this.runtimeStateDebounce) {
-			if (slot.timer) {
-				clearTimeout(slot.timer);
-				slot.timer = null;
-				if (settings) {
-					const blob = this.snapshotForDevice(deviceId);
-					pending.push(settings.writeDeviceRuntimeState(deviceId, blob).catch((err) => {
-						this.ctx.logger.warn("shutdown writeDeviceRuntimeState failed", {
-							tags: { deviceId },
-							meta: { error: err instanceof Error ? err.message : String(err) }
-						});
-					}));
-				}
-			}
-			if (slot.inFlight) pending.push(slot.inFlight);
-		}
-		await Promise.all(pending);
-		this.runtimeStateDebounce.clear();
-	}
-};
-//#endregion
-//#region src/builtins/device-manager/device-meta-actions.ts
-/**
-* Device meta-mutation + persistence actions for the device-manager addon —
-* the `IDeviceManagerProvider` write/load surface. Extracted verbatim from the
-* `onInitialize` provider literal as free functions taking a `ProviderContext`
-* (DI). Each function's input/return types are pinned to the cap contract via
-* `Parameters<IDeviceManagerProvider['x']>[0]` / `ReturnType<…>` so the typed
-* surface is identical to the inferred object-literal methods.
-*
-* Covers: id allocation + registration (allocateDeviceId, registerDevice,
-* removeDevice), config persistence (persistConfig, loadConfig), the meta
-* surface load (loadMeta, loadRuntimeState), every meta setter (setName,
-* setLocation, setType, setIntegrationId, setLinkDeviceId,
-* setPrimaryChildEntityId, setChildLayout, setDeviceLinks, setRole,
-* applyInitialMeta, setMetadata, setDisabled), and the location registry
-* (listLocations, addLocation, removeLocation).
-*
-* EXACT ordering and side effects preserved — notably registerDevice's
-* name-precedence reconcile + field-preservation spreads, the
-* withMetaWriteLock-serialised read-modify-writes, the event emissions, and the
-* link reverse-index rebuild gating. Pure refactor — no behavior change.
-*/
-/**
-* Stamp (or update) the owning integration id on a device's meta row + emit
-* `DeviceMetaChanged`. The device-manager chokepoint shared by the
-* `setIntegrationId` cap handler AND the create/adopt forwarders (queries)
-* that stamp an integration's ownership onto every device it materializes.
-* Idempotent. Takes its low-level deps directly (not the full `ProviderContext`)
-* because `ProviderContext.stampIntegrationId` delegates HERE — passing the
-* context would be a capture cycle.
+* Stamp (or update) the owning integration id on a device's meta row + emit
+* `DeviceMetaChanged`. The device-manager chokepoint shared by the
+* `setIntegrationId` cap handler AND the create/adopt forwarders (queries)
+* that stamp an integration's ownership onto every device it materializes.
+* Idempotent. Takes its low-level deps directly (not the full `ProviderContext`)
+* because `ProviderContext.stampIntegrationId` delegates HERE — passing the
+* context would be a capture cycle.
 */
 async function stampIntegrationId(metaStore, settings, ctx, deviceId, integrationId) {
 	await metaStore.withMetaWriteLock(async () => {
@@ -2129,20 +1606,37 @@ async function loadMeta(pctx, input) {
 */
 async function setName(pctx, input) {
 	const { deviceId, name } = input;
+	const cascaded = [];
 	await pctx.metaStore.withMetaWriteLock(async () => {
 		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
 		if (!persisted) throw new Error(`[device-manager] setName: unknown device id=${deviceId}`);
 		const { meta: m } = persisted;
 		const key = String(deviceId);
+		const oldName = m.name;
 		const allMeta = await pctx.metaStore.readMeta();
-		await pctx.settings.writeAddonStore({ deviceMeta: {
+		const nextMeta = {
 			...allMeta,
 			[key]: {
 				...m,
 				name,
 				userNamed: true
 			}
-		} });
+		};
+		if (oldName.length > 0 && oldName !== name) for (const [childKey, childMeta] of Object.entries(allMeta)) {
+			if (childKey === key) continue;
+			if (!(childMeta.parentDeviceId === deviceId || childMeta.linkDeviceId === deviceId)) continue;
+			if (childMeta.name !== oldName && !childMeta.name.startsWith(`${oldName} `)) continue;
+			const childName = childMeta.name === oldName ? name : `${name}${childMeta.name.slice(oldName.length)}`;
+			nextMeta[childKey] = {
+				...childMeta,
+				name: childName
+			};
+			cascaded.push({
+				id: Number(childKey),
+				name: childName
+			});
+		}
+		await pctx.settings.writeAddonStore({ deviceMeta: nextMeta });
 	});
 	pctx.host.ctx.eventBus.emit({
 		id: randomUUID(),
@@ -2158,6 +1652,20 @@ async function setName(pctx, input) {
 			value: name
 		}
 	});
+	for (const child of cascaded) pctx.host.ctx.eventBus.emit({
+		id: randomUUID(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: child.id
+		},
+		category: EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId: child.id,
+			field: "name",
+			value: child.name
+		}
+	});
 }
 /**
 * Update the operator-organisational location label. `null`
@@ -2391,814 +1899,1338 @@ async function setDeviceLinks(pctx, input) {
 		category: EventCategory.DeviceMetaChanged,
 		data: {
 			deviceId,
-			field: "deviceLinks",
-			value: deviceLinks
+			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
+* `setIntegrationId`). Idempotent. `null` clears a previous role.
+*/
+async function setRole(pctx, input) {
+	const { deviceId, role } = input;
+	await pctx.metaStore.withMetaWriteLock(async () => {
+		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+		if (!persisted) throw new Error(`[device-manager] setRole: 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,
+				role
+			}
+		} });
+	});
+	pctx.host.ctx.eventBus.emit({
+		id: randomUUID(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: deviceId
+		},
+		category: EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId,
+			field: "role",
+			value: role
+		}
+	});
+}
+/**
+* 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),
+* then emits one `DeviceMetaChanged` event per field that was
+* supplied — preserving the exact semantics of the individual
+* setters (`setName` / `setLocation` / `setType` /
+* `setIntegrationId` / `setLinkDeviceId` / `setRole`). Omitted
+* fields are left untouched; `null` clears `location` /
+* `linkDeviceId` / `role`. Idempotent.
+*
+* Collapses the per-child meta pre-seed (up to 6 individual
+* setter round-trips, each its own lock + write) into one — the
+* dominant cost when the kernel's `spawnAccessoryChild` reconciles
+* a many-entity container.
+*/
+async function applyInitialMeta(pctx, input) {
+	const { deviceId, name, location, type, integrationId, linkDeviceId, role } = input;
+	await pctx.metaStore.withMetaWriteLock(async () => {
+		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+		if (!persisted) throw new Error(`[device-manager] applyInitialMeta: unknown device id=${deviceId}`);
+		const { meta: m } = persisted;
+		const key = String(deviceId);
+		const allMeta = await pctx.metaStore.readMeta();
+		const merged = {
+			...m,
+			...name !== void 0 ? { name } : {},
+			...location !== void 0 ? { location } : {},
+			...type !== void 0 ? { type } : {},
+			...integrationId !== void 0 ? { integrationId } : {},
+			...linkDeviceId !== void 0 ? { linkDeviceId } : {},
+			...role !== void 0 ? { role } : {}
+		};
+		await pctx.settings.writeAddonStore({ deviceMeta: {
+			...allMeta,
+			[key]: merged
+		} });
+	});
+	const emitMetaChanged = (field, value) => {
+		pctx.host.ctx.eventBus.emit({
+			id: randomUUID(),
+			timestamp: /* @__PURE__ */ new Date(),
+			source: {
+				type: "device",
+				id: deviceId
+			},
+			category: EventCategory.DeviceMetaChanged,
+			data: {
+				deviceId,
+				field,
+				value
+			}
+		});
+	};
+	if (name !== void 0) emitMetaChanged("name", name);
+	if (location !== void 0) emitMetaChanged("location", location);
+	if (type !== void 0) emitMetaChanged("type", type);
+	if (integrationId !== void 0) emitMetaChanged("integrationId", integrationId);
+	if (linkDeviceId !== void 0) emitMetaChanged("linkDeviceId", linkDeviceId);
+	if (role !== void 0) emitMetaChanged("role", role);
+}
+/**
+* Patch the device's hardware-identity metadata blob. Shallow
+* merge — `null` removes a key, anything else overwrites.
+* Drivers populate factual fields on first probe; operators
+* augment via the Device Info tab. Idempotent: a no-op patch
+* (every key already present with the same value) doesn't emit
+* the meta-changed event.
+*/
+async function setMetadata(pctx, input) {
+	const { deviceId, patch } = input;
+	const result = await pctx.metaStore.withMetaWriteLock(async () => {
+		if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] setMetadata: unknown device id=${deviceId}`);
+		const key = String(deviceId);
+		const map = await pctx.metaStore.readMetadataMap();
+		const next = { ...map[key] ?? {} };
+		let changed = false;
+		for (const [k, v] of Object.entries(patch)) if (v === null) {
+			if (k in next) {
+				delete next[k];
+				changed = true;
+			}
+		} else if (next[k] !== v) {
+			next[k] = v;
+			changed = true;
+		}
+		if (!changed) return { changed: false };
+		const hasFields = Object.keys(next).length > 0;
+		const updatedMap = { ...map };
+		if (hasFields) updatedMap[key] = next;
+		else delete updatedMap[key];
+		await pctx.settings.writeAddonStore({ deviceMetadata: updatedMap });
+		return {
+			changed: true,
+			finalMeta: hasFields ? next : null
+		};
+	});
+	if (!result.changed) return;
+	pctx.host.ctx.eventBus.emit({
+		id: randomUUID(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: deviceId
+		},
+		category: EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId,
+			field: "metadata",
+			value: result.finalMeta
+		}
+	});
+}
+/**
+* Soft-disable the device. Persisted on the meta row;
+* lifecycle gating is the driver's responsibility (BaseDevice
+* exposes `this.disabled` for the driver to consult at the top
+* of its lifecycle methods).
+*/
+async function setDisabled(pctx, input) {
+	const { deviceId, disabled } = input;
+	await pctx.metaStore.withMetaWriteLock(async () => {
+		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+		if (!persisted) throw new Error(`[device-manager] setDisabled: 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,
+				disabled
+			}
+		} });
+	});
+	pctx.host.ctx.eventBus.emit({
+		id: randomUUID(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: deviceId
+		},
+		category: EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId,
+			field: "disabled",
+			value: disabled
+		}
+	});
+}
+async function loadRuntimeState(pctx, input) {
+	const { deviceId } = input;
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) return {};
+	const data = await pctx.settings.readDeviceRuntimeState(deviceId);
+	pctx.host.seedMirror(deviceId, pctx.host.withResetSessionProbe(data));
+	return data;
+}
+/**
+* Union of (1) operator-curated location registry and (2) labels
+* currently in use on persisted devices. Case-insensitive
+* dedupe (preserves the first-seen casing). Sorted
+* case-insensitively for stable UI. Drives the Device Info
+* location autocomplete.
+*/
+async function listLocations(pctx) {
+	const store = await pctx.settings.readAddonStore();
+	const meta = store.deviceMeta ?? {};
+	const locations = store.locations ?? [];
+	const seen = /* @__PURE__ */ new Map();
+	const consider = (raw) => {
+		if (typeof raw !== "string") return;
+		const trimmed = raw.trim();
+		if (trimmed.length === 0) return;
+		const key = trimmed.toLowerCase();
+		if (!seen.has(key)) seen.set(key, trimmed);
+	};
+	for (const label of locations) consider(label);
+	for (const m of Object.values(meta)) consider(m.location);
+	return [...seen.values()].toSorted((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
+}
+/**
+* Add a label to the curated location registry. Idempotent:
+* existing entries (case-insensitive match) are silently kept.
+* Empty / whitespace-only inputs throw — operators must supply a
+* meaningful label.
+*/
+async function addLocation(pctx, input) {
+	const trimmed = input.name.trim();
+	if (trimmed.length === 0) throw new Error("[device-manager] addLocation: name must be non-empty");
+	const current = (await pctx.settings.readAddonStore()).locations ?? [];
+	if (current.some((l) => l.toLowerCase() === trimmed.toLowerCase())) return;
+	await pctx.settings.writeAddonStore({ locations: [...current, trimmed] });
+}
+/**
+* Remove a label from the curated registry. Match is
+* case-insensitive. Devices that still reference this label keep
+* their `meta.location` value (the registry is a suggestion
+* list, not a foreign key) — pass `cascade: true` to also clear
+* `setLocation` on every device that referenced this exact
+* label. Cascade only matches case-insensitively + trimmed, same
+* as the registry equality check.
+*/
+async function removeLocation(pctx, input) {
+	const trimmed = input.name.trim();
+	if (trimmed.length === 0) return;
+	const store = await pctx.settings.readAddonStore();
+	const current = store.locations ?? [];
+	const remaining = current.filter((l) => l.toLowerCase() !== trimmed.toLowerCase());
+	if (remaining.length !== current.length) await pctx.settings.writeAddonStore({ locations: remaining });
+	if (input.cascade !== true) return;
+	const meta = store.deviceMeta ?? {};
+	const updates = { ...meta };
+	const cleared = [];
+	for (const [key, m] of Object.entries(meta)) {
+		if (typeof m.location !== "string") continue;
+		if (m.location.trim().toLowerCase() !== trimmed.toLowerCase()) continue;
+		updates[key] = {
+			...m,
+			location: null
+		};
+		cleared.push(m.id);
+	}
+	if (cleared.length === 0) return;
+	await pctx.settings.writeAddonStore({ deviceMeta: updates });
+	for (const deviceId of cleared) pctx.host.ctx.eventBus.emit({
+		id: randomUUID(),
+		timestamp: /* @__PURE__ */ new Date(),
+		source: {
+			type: "device",
+			id: deviceId
+		},
+		category: EventCategory.DeviceMetaChanged,
+		data: {
+			deviceId,
+			field: "location",
+			value: null
 		}
 	});
 }
+//#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 } of entries) {
+		const tKey = `${targetDeviceId}:${link.target.cap}`;
+		const tList = targets.get(tKey) ?? [];
+		tList.push({
+			link,
+			sourceDeviceId
+		});
+		targets.set(tKey, tList);
+		const sKey = `${sourceDeviceId}:${link.source.cap}`;
+		const sList = dependents.get(sKey) ?? [];
+		sList.push({
+			targetDeviceId,
+			targetCap: link.target.cap
+		});
+		dependents.set(sKey, sList);
+	}
+	return {
+		targets,
+		dependents
+	};
+}
+//#endregion
+//#region src/builtins/device-manager/device-meta-store.ts
 /**
-* 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
-* `setIntegrationId`). Idempotent. `null` clears a previous role.
+* 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.
 */
-async function setRole(pctx, input) {
-	const { deviceId, role } = input;
-	await pctx.metaStore.withMetaWriteLock(async () => {
-		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
-		if (!persisted) throw new Error(`[device-manager] setRole: 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,
-				role
+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
+	*  ownership without awaiting. Kept in sync with every register/remove and
+	*  warmed from persistence on boot. */
+	idToAddonId = /* @__PURE__ */ new Map();
+	/** Serialises every read-modify-write of the deviceMeta / deviceIndex blob
+	*  through one promise chain (see `withMetaWriteLock`). Per-instance state —
+	*  identical to the former `onInitialize` closure variable. */
+	metaWriteChain = Promise.resolve();
+	constructor(settings, registry, linkHost) {
+		this.settings = settings;
+		this.registry = registry;
+		this.linkHost = linkHost;
+	}
+	readStore = async () => {
+		return await this.settings.readAddonStore();
+	};
+	readIndex = async () => {
+		return (await this.readStore()).deviceIndex ?? {};
+	};
+	readMeta = async () => {
+		return (await this.readStore()).deviceMeta ?? {};
+	};
+	/** Hardware-identity metadata map. Lives in a sibling key on the
+	*  device-manager addon store so its writers (`setMetadata`) never
+	*  collide with the lifecycle writers on `deviceMeta`
+	*  (`registerDevice` / `setName` / `setLocation` / `setDisabled`).
+	*  Single-writer per row eliminates the "writer X clobbers writer
+	*  Y's field" bug class — `setMetadata` is the only producer. */
+	readMetadataMap = async () => {
+		return (await this.readStore()).deviceMetadata ?? {};
+	};
+	withMetaWriteLock = async (fn) => {
+		const previous = this.metaWriteChain;
+		let release = () => {};
+		const next = new Promise((resolve) => {
+			release = resolve;
+		});
+		this.metaWriteChain = next;
+		try {
+			await previous.catch(() => {});
+			return await fn();
+		} finally {
+			release();
+		}
+	};
+	/**
+	* Resolve a numeric deviceId to the owning `(addonId, stableId)` pair.
+	* Scans persisted meta — live IDevice lookup (hub registry) is handled
+	* separately per call site so callers can decide whether to route to
+	* an in-process driver or to the cross-process `device-ops` bridge.
+	* Returns null when no device with that id is known to the hub.
+	*/
+	resolvePersistedById = async (deviceId) => {
+		const m = (await this.readMeta())[String(deviceId)];
+		if (!m) return null;
+		return {
+			addonId: m.addonId,
+			stableId: m.stableId,
+			meta: m
+		};
+	};
+	/** Direct children of a device: the union of the live registry's children
+	*  and the persisted-meta scan (`parentDeviceId === parentId`), deduplicated
+	*  and excluding self. Shared by the `remove` cascade and the `resetToSource`
+	*  resync purge (#19). */
+	directChildIds = async (parentId) => {
+		const ids = /* @__PURE__ */ new Set();
+		if (this.registry) for (const c of this.registry.getChildren(parentId)) ids.add(c.id);
+		const meta = await this.readMeta();
+		for (const m of Object.values(meta)) if (m.parentDeviceId === parentId) ids.add(m.id);
+		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;
+	};
+	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 ?? []) {
+				expectedSources.add(`${container}-${link.source.sourceKey}`);
+				const srcId = idByStableId.get(`${container}-${link.source.sourceKey}`);
+				if (srcId === void 0) continue;
+				entries.push({
+					targetDeviceId: targetId,
+					link,
+					sourceDeviceId: srcId
+				});
 			}
-		} });
-	});
-	pctx.host.ctx.eventBus.emit({
-		id: randomUUID(),
-		timestamp: /* @__PURE__ */ new Date(),
-		source: {
-			type: "device",
-			id: deviceId
-		},
-		category: EventCategory.DeviceMetaChanged,
-		data: {
-			deviceId,
-			field: "role",
-			value: role
 		}
-	});
-}
+		const { targets, dependents } = buildLinkIndexes(entries);
+		this.linkHost.setLinkIndexes(targets, dependents, expectedSources);
+	};
+};
+//#endregion
+//#region src/builtins/device-manager/device-queries.ts
 /**
-* 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),
-* then emits one `DeviceMetaChanged` event per field that was
-* supplied — preserving the exact semantics of the individual
-* setters (`setName` / `setLocation` / `setType` /
-* `setIntegrationId` / `setLinkDeviceId` / `setRole`). Omitted
-* fields are left untouched; `null` clears `location` /
-* `linkDeviceId` / `role`. Idempotent.
+* 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.
 *
-* Collapses the per-child meta pre-seed (up to 6 individual
-* setter round-trips, each its own lock + write) into one — the
-* dominant cost when the kernel's `spawnAccessoryChild` reconciles
-* a many-entity container.
+* 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 applyInitialMeta(pctx, input) {
-	const { deviceId, name, location, type, integrationId, linkDeviceId, role } = input;
-	await pctx.metaStore.withMetaWriteLock(async () => {
-		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
-		if (!persisted) throw new Error(`[device-manager] applyInitialMeta: unknown device id=${deviceId}`);
-		const { meta: m } = persisted;
-		const key = String(deviceId);
-		const allMeta = await pctx.metaStore.readMeta();
-		const merged = {
-			...m,
-			...name !== void 0 ? { name } : {},
-			...location !== void 0 ? { location } : {},
-			...type !== void 0 ? { type } : {},
-			...integrationId !== void 0 ? { integrationId } : {},
-			...linkDeviceId !== void 0 ? { linkDeviceId } : {},
-			...role !== void 0 ? { role } : {}
+async function listPersistedByAddon(pctx, input) {
+	const { addonId } = input;
+	const [index, meta] = await Promise.all([pctx.metaStore.readIndex(), pctx.metaStore.readMeta()]);
+	const stableIds = index[addonId] ?? [];
+	const byStableId = /* @__PURE__ */ new Map();
+	for (const m of Object.values(meta)) if (m.addonId === addonId) byStableId.set(m.stableId, m);
+	return stableIds.map((stableId) => {
+		const m = byStableId.get(stableId);
+		return {
+			id: m.id,
+			stableId,
+			type: m.type,
+			name: m.name,
+			location: m.location ?? null,
+			disabled: m.disabled ?? false,
+			parentDeviceId: m.parentDeviceId
 		};
-		await pctx.settings.writeAddonStore({ deviceMeta: {
-			...allMeta,
-			[key]: merged
-		} });
 	});
-	const emitMetaChanged = (field, value) => {
-		pctx.host.ctx.eventBus.emit({
-			id: randomUUID(),
-			timestamp: /* @__PURE__ */ new Date(),
-			source: {
-				type: "device",
-				id: deviceId
-			},
-			category: EventCategory.DeviceMetaChanged,
-			data: {
-				deviceId,
-				field,
-				value
-			}
+}
+async function listAll(pctx, input) {
+	const { addonId } = input;
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	const meta = await pctx.metaStore.readMeta();
+	const metadataMap = await pctx.metaStore.readMetadataMap();
+	if (pctx.registry) {
+		const liveEntries = addonId ? pctx.registry.getAllForAddon(addonId).map((device) => ({
+			addonId,
+			device
+		})) : pctx.registry.getAllWithAddonId();
+		for (const { addonId: aid, device } of liveEntries) {
+			const key = String(device.id);
+			const metadata = metadataMap[key] ?? null;
+			const metaRow = meta[key] ?? null;
+			results.push(toDeviceInfo(aid, device, metadata, metaRow));
+			seen.add(key);
+		}
+	}
+	const index = await pctx.metaStore.readIndex();
+	const metaByAddonStable = /* @__PURE__ */ new Map();
+	for (const m of Object.values(meta)) metaByAddonStable.set(`${m.addonId}${m.stableId}`, m);
+	const targetAddons = addonId ? [addonId] : Object.keys(index);
+	for (const aid of targetAddons) for (const stableId of index[aid] ?? []) {
+		const m = metaByAddonStable.get(`${aid}${stableId}`);
+		const key = String(m.id);
+		if (seen.has(key)) continue;
+		const persistedType = m.type;
+		const persistedConfig = await pctx.settings.readDeviceStore(m.id);
+		const metadata = metadataMap[key] ?? null;
+		results.push({
+			id: m.id,
+			stableId,
+			addonId: aid,
+			type: persistedType,
+			name: m?.name ?? stableId,
+			location: m?.location ?? null,
+			disabled: m?.disabled ?? false,
+			parentDeviceId: m?.parentDeviceId ?? null,
+			role: toDeviceRole(m?.role),
+			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
+			probed: pctx.host.resolveDeviceProbed(m.id),
+			features: persistedFeatures(m?.features),
+			isCamera: persistedType === DeviceType.Camera,
+			config: persistedConfig ?? {},
+			metadata,
+			...m?.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
+			...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 } : {},
+			...(() => {
+				const si = buildSourceInfoFromConfig(persistedConfig ?? {}, stableId, aid);
+				return si !== void 0 ? { sourceInfo: si } : {};
+			})()
 		});
+	}
+	return results;
+}
+async function getDevice(pctx, input) {
+	const { deviceId } = input;
+	if (pctx.registry) {
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) {
+			const key = String(found.device.id);
+			const [map, metaMap] = await Promise.all([pctx.metaStore.readMetadataMap(), pctx.metaStore.readMeta()]);
+			const metadata = map[key] ?? null;
+			const metaRow = metaMap[key] ?? null;
+			return toDeviceInfo(found.addonId, found.device, metadata, metaRow);
+		}
+	}
+	const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
+	if (!persisted) return null;
+	const { addonId: aid, stableId, meta: m } = persisted;
+	const persistedConfig = await pctx.settings.readDeviceStore(m.id);
+	const key = String(deviceId);
+	const metadata = (await pctx.metaStore.readMetadataMap())[key] ?? null;
+	const sourceInfoGetDevice = buildSourceInfoFromConfig(persistedConfig ?? {}, stableId, aid);
+	return {
+		id: deviceId,
+		stableId,
+		addonId: aid,
+		type: m.type,
+		name: m.name,
+		location: m.location ?? null,
+		disabled: m.disabled ?? false,
+		parentDeviceId: m.parentDeviceId,
+		role: toDeviceRole(m.role),
+		online: pctx.host.resolveDeviceOnline(deviceId, true),
+		probed: pctx.host.resolveDeviceProbed(deviceId),
+		features: persistedFeatures(m.features),
+		isCamera: false,
+		config: persistedConfig ?? {},
+		metadata,
+		...m.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
+		...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 } : {},
+		...sourceInfoGetDevice !== void 0 ? { sourceInfo: sourceInfoGetDevice } : {}
 	};
-	if (name !== void 0) emitMetaChanged("name", name);
-	if (location !== void 0) emitMetaChanged("location", location);
-	if (type !== void 0) emitMetaChanged("type", type);
-	if (integrationId !== void 0) emitMetaChanged("integrationId", integrationId);
-	if (linkDeviceId !== void 0) emitMetaChanged("linkDeviceId", linkDeviceId);
-	if (role !== void 0) emitMetaChanged("role", role);
 }
-/**
-* Patch the device's hardware-identity metadata blob. Shallow
-* merge — `null` removes a key, anything else overwrites.
-* Drivers populate factual fields on first probe; operators
-* augment via the Device Info tab. Idempotent: a no-op patch
-* (every key already present with the same value) doesn't emit
-* the meta-changed event.
-*/
-async function setMetadata(pctx, input) {
-	const { deviceId, patch } = input;
-	const result = await pctx.metaStore.withMetaWriteLock(async () => {
-		if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] setMetadata: unknown device id=${deviceId}`);
-		const key = String(deviceId);
-		const map = await pctx.metaStore.readMetadataMap();
-		const next = { ...map[key] ?? {} };
-		let changed = false;
-		for (const [k, v] of Object.entries(patch)) if (v === null) {
-			if (k in next) {
-				delete next[k];
-				changed = true;
-			}
-		} else if (next[k] !== v) {
-			next[k] = v;
-			changed = true;
+async function getChildren(pctx, input) {
+	const { parentDeviceId } = input;
+	let ownerAddonId = null;
+	if (pctx.registry) {
+		if (pctx.registry.getById(parentDeviceId)) ownerAddonId = pctx.registry.getAddonId(parentDeviceId);
+	}
+	if (!ownerAddonId) {
+		const persisted = await pctx.metaStore.resolvePersistedById(parentDeviceId);
+		if (!persisted) return [];
+		ownerAddonId = persisted.addonId;
+	}
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	const [index, meta, metadataMap] = await Promise.all([
+		pctx.metaStore.readIndex(),
+		pctx.metaStore.readMeta(),
+		pctx.metaStore.readMetadataMap()
+	]);
+	if (pctx.registry) {
+		const liveChildren = pctx.registry.getChildren(parentDeviceId);
+		for (const device of liveChildren) {
+			const key = String(device.id);
+			const metadata = metadataMap[key] ?? null;
+			const metaRow = meta[key] ?? null;
+			results.push(toDeviceInfo(ownerAddonId, device, metadata, metaRow));
+			seen.add(key);
+		}
+	}
+	const ownerMetaByStableId = /* @__PURE__ */ new Map();
+	for (const m of Object.values(meta)) if (m.addonId === ownerAddonId) ownerMetaByStableId.set(m.stableId, m);
+	const persistedChildren = (index[ownerAddonId] ?? []).filter((sid) => ownerMetaByStableId.get(sid)?.parentDeviceId === parentDeviceId);
+	for (const childStableId of persistedChildren) {
+		const m = ownerMetaByStableId.get(childStableId);
+		const key = String(m.id);
+		if (seen.has(key)) continue;
+		const persistedConfig = await pctx.settings.readDeviceStore(m.id);
+		const metadata = metadataMap[key] ?? null;
+		const sourceInfoChild = buildSourceInfoFromConfig(persistedConfig ?? {}, childStableId, ownerAddonId);
+		results.push({
+			id: m.id,
+			stableId: childStableId,
+			addonId: ownerAddonId,
+			type: m.type,
+			name: m.name,
+			location: m.location ?? null,
+			disabled: m.disabled ?? false,
+			parentDeviceId,
+			role: toDeviceRole(m.role),
+			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
+			probed: pctx.host.resolveDeviceProbed(m.id),
+			features: persistedFeatures(m.features),
+			isCamera: false,
+			config: persistedConfig ?? {},
+			metadata,
+			...m.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
+			...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 } : {},
+			...sourceInfoChild !== void 0 ? { sourceInfo: sourceInfoChild } : {}
+		});
+	}
+	return results;
+}
+async function getStreamSources(pctx, input) {
+	const { deviceId } = input;
+	if (pctx.registry) {
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) {
+			if (!isCameraDevice(found.device)) return [];
+			return (await found.device.getStreamSources()).map((s) => ({
+				id: s.id,
+				label: s.label,
+				protocol: s.protocol,
+				url: s.url,
+				resolution: s.resolution,
+				fps: s.fps,
+				bitrate: s.bitrate,
+				codec: s.codec,
+				profileHint: s.profileHint
+			}));
 		}
-		if (!changed) return { changed: false };
-		const hasFields = Object.keys(next).length > 0;
-		const updatedMap = { ...map };
-		if (hasFields) updatedMap[key] = next;
-		else delete updatedMap[key];
-		await pctx.settings.writeAddonStore({ deviceMetadata: updatedMap });
-		return {
-			changed: true,
-			finalMeta: hasFields ? next : null
-		};
-	});
-	if (!result.changed) return;
-	pctx.host.ctx.eventBus.emit({
-		id: randomUUID(),
-		timestamp: /* @__PURE__ */ new Date(),
-		source: {
-			type: "device",
-			id: deviceId
-		},
-		category: EventCategory.DeviceMetaChanged,
-		data: {
-			deviceId,
-			field: "metadata",
-			value: result.finalMeta
+	}
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
+	return (await pctx.requireDeviceOps(deviceId).getStreamSources({ deviceId })).map((s) => ({ ...s }));
+}
+async function getConfigSchema(pctx, input) {
+	const { deviceId } = input;
+	if (pctx.registry) {
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) return found.device.config.entries().map((entry) => ({
+			key: entry.key,
+			value: entry.value,
+			...entry.description !== void 0 ? { description: entry.description } : {}
+		}));
+	}
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
+	return (await pctx.requireDeviceOps(deviceId).getConfigEntries({ deviceId })).map((e) => ({ ...e }));
+}
+async function getSettingsSchema(pctx, input) {
+	const { deviceId } = input;
+	if (pctx.registry) {
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) return found.device.getSettingsUISchema();
+	}
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) return null;
+	return await pctx.requireDeviceOps(deviceId).getSettingsSchema({ deviceId }) ?? null;
+}
+async function updateConfig(pctx, input) {
+	const { deviceId } = input;
+	if (pctx.registry) {
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) {
+			await found.device.config.setAll(input.values);
+			return { success: true };
 		}
+	}
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
+	await pctx.requireDeviceOps(deviceId).setConfig({
+		deviceId,
+		values: input.values
 	});
+	return { success: true };
 }
-/**
-* Soft-disable the device. Persisted on the meta row;
-* lifecycle gating is the driver's responsibility (BaseDevice
-* exposes `this.disabled` for the driver to consult at the top
-* of its lifecycle methods).
-*/
-async function setDisabled(pctx, input) {
-	const { deviceId, disabled } = input;
-	await pctx.metaStore.withMetaWriteLock(async () => {
-		const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
-		if (!persisted) throw new Error(`[device-manager] setDisabled: 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,
-				disabled
-			}
-		} });
+async function enable(pctx, input) {
+	await pctx.provider.setDisabled({
+		deviceId: input.deviceId,
+		disabled: false
 	});
-	pctx.host.ctx.eventBus.emit({
-		id: randomUUID(),
-		timestamp: /* @__PURE__ */ new Date(),
-		source: {
-			type: "device",
-			id: deviceId
-		},
-		category: EventCategory.DeviceMetaChanged,
-		data: {
-			deviceId,
-			field: "disabled",
-			value: disabled
-		}
+	return { success: true };
+}
+async function disable(pctx, input) {
+	await pctx.provider.setDisabled({
+		deviceId: input.deviceId,
+		disabled: true
 	});
+	return { success: true };
 }
-async function loadRuntimeState(pctx, input) {
+async function remove(pctx, input) {
 	const { deviceId } = input;
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) return {};
-	const data = await pctx.settings.readDeviceRuntimeState(deviceId);
-	pctx.host.seedMirror(deviceId, pctx.host.withResetSessionProbe(data));
-	return data;
-}
-/**
-* Union of (1) operator-curated location registry and (2) labels
-* currently in use on persisted devices. Case-insensitive
-* dedupe (preserves the first-seen casing). Sorted
-* case-insensitively for stable UI. Drives the Device Info
-* location autocomplete.
-*/
-async function listLocations(pctx) {
-	const store = await pctx.settings.readAddonStore();
-	const meta = store.deviceMeta ?? {};
-	const locations = store.locations ?? [];
-	const seen = /* @__PURE__ */ new Map();
-	const consider = (raw) => {
-		if (typeof raw !== "string") return;
-		const trimmed = raw.trim();
-		if (trimmed.length === 0) return;
-		const key = trimmed.toLowerCase();
-		if (!seen.has(key)) seen.set(key, trimmed);
-	};
-	for (const label of locations) consider(label);
-	for (const m of Object.values(meta)) consider(m.location);
-	return [...seen.values()].toSorted((a, b) => a.localeCompare(b, void 0, { sensitivity: "base" }));
-}
-/**
-* Add a label to the curated location registry. Idempotent:
-* existing entries (case-insensitive match) are silently kept.
-* Empty / whitespace-only inputs throw — operators must supply a
-* meaningful label.
-*/
-async function addLocation(pctx, input) {
-	const trimmed = input.name.trim();
-	if (trimmed.length === 0) throw new Error("[device-manager] addLocation: name must be non-empty");
-	const current = (await pctx.settings.readAddonStore()).locations ?? [];
-	if (current.some((l) => l.toLowerCase() === trimmed.toLowerCase())) return;
-	await pctx.settings.writeAddonStore({ locations: [...current, trimmed] });
-}
-/**
-* Remove a label from the curated registry. Match is
-* case-insensitive. Devices that still reference this label keep
-* their `meta.location` value (the registry is a suggestion
-* list, not a foreign key) — pass `cascade: true` to also clear
-* `setLocation` on every device that referenced this exact
-* label. Cascade only matches case-insensitively + trimmed, same
-* as the registry equality check.
-*/
-async function removeLocation(pctx, input) {
-	const trimmed = input.name.trim();
-	if (trimmed.length === 0) return;
-	const store = await pctx.settings.readAddonStore();
-	const current = store.locations ?? [];
-	const remaining = current.filter((l) => l.toLowerCase() !== trimmed.toLowerCase());
-	if (remaining.length !== current.length) await pctx.settings.writeAddonStore({ locations: remaining });
-	if (input.cascade !== true) return;
-	const meta = store.deviceMeta ?? {};
-	const updates = { ...meta };
-	const cleared = [];
-	for (const [key, m] of Object.entries(meta)) {
-		if (typeof m.location !== "string") continue;
-		if (m.location.trim().toLowerCase() !== trimmed.toLowerCase()) continue;
-		updates[key] = {
-			...m,
-			location: null
-		};
-		cleared.push(m.id);
-	}
-	if (cleared.length === 0) return;
-	await pctx.settings.writeAddonStore({ deviceMeta: updates });
-	for (const deviceId of cleared) pctx.host.ctx.eventBus.emit({
-		id: randomUUID(),
-		timestamp: /* @__PURE__ */ new Date(),
-		source: {
-			type: "device",
-			id: deviceId
-		},
-		category: EventCategory.DeviceMetaChanged,
-		data: {
-			deviceId,
-			field: "location",
-			value: null
+	const removeOne = async (id) => {
+		if (pctx.registry) {
+			const live = resolveDeviceById(pctx.registry, id);
+			if (live) {
+				const deviceName = live.device.name;
+				await live.device.removeDevice();
+				pctx.registry.remove(id);
+				await pctx.provider.removeDevice({ deviceId: id });
+				pctx.host.ctx.logger.info("removed hub-local device", { tags: {
+					deviceId: id,
+					deviceName
+				} });
+				return;
+			}
 		}
-	});
+		const persisted = await pctx.metaStore.resolvePersistedById(id);
+		if (!persisted) return;
+		const { meta: persistedMeta } = persisted;
+		try {
+			await pctx.requireDeviceOps(id).removeDevice({ deviceId: id });
+		} catch (err) {
+			pctx.host.ctx.logger.warn("remove via device-ops failed — clearing persistence anyway", {
+				tags: {
+					deviceId: id,
+					deviceName: persistedMeta.name
+				},
+				meta: { error: errMsg(err) }
+			});
+		}
+		await pctx.provider.removeDevice({ deviceId: id });
+	};
+	const removeCascade = async (id) => {
+		for (const childId of await pctx.metaStore.directChildIds(id)) await removeCascade(childId);
+		await removeOne(id);
+	};
+	await removeCascade(deviceId);
+	return { success: true };
 }
-//#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.
+* Cascade-delete every top-level device whose `integrationId`
+* matches. Enumerates a SNAPSHOT of the meta map so concurrent
+* removals don't clobber each other. Only top-level parents are
+* enumerated — children cascade via the per-parent `removeCascade`
+* inside the delegated `remove` call. Idempotent: devices with no
+* `integrationId` never match.
 */
-async function listPersistedByAddon(pctx, input) {
-	const { addonId } = input;
-	const [index, meta] = await Promise.all([pctx.metaStore.readIndex(), pctx.metaStore.readMeta()]);
-	const stableIds = index[addonId] ?? [];
-	const byStableId = /* @__PURE__ */ new Map();
-	for (const m of Object.values(meta)) if (m.addonId === addonId) byStableId.set(m.stableId, m);
-	return stableIds.map((stableId) => {
-		const m = byStableId.get(stableId);
-		return {
-			id: m.id,
-			stableId,
-			type: m.type,
-			name: m.name,
-			location: m.location ?? null,
-			disabled: m.disabled ?? false,
-			parentDeviceId: m.parentDeviceId
-		};
+async function removeByIntegration(pctx, input) {
+	const { integrationId } = input;
+	const meta = await pctx.metaStore.readMeta();
+	const parentKeys = Object.keys(meta).filter((key) => {
+		const m = meta[key];
+		return m !== void 0 && m.integrationId === integrationId && m.parentDeviceId === null;
 	});
+	let removed = 0;
+	for (const _key of parentKeys) {
+		const m = meta[_key];
+		if (!m) continue;
+		await pctx.provider.remove({ deviceId: m.id });
+		removed++;
+	}
+	return { removed };
 }
-async function listAll(pctx, input) {
-	const { addonId } = input;
-	const results = [];
-	const seen = /* @__PURE__ */ new Set();
-	const meta = await pctx.metaStore.readMeta();
-	const metadataMap = await pctx.metaStore.readMetadataMap();
+async function getStreamProfileMap(pctx, input) {
+	if (!pctx.registry) return {};
+	const found = resolveDeviceById(pctx.registry, input.deviceId);
+	if (!found) return {};
+	const storedMap = found.device.config.entries().find((e) => e.key === "_profileMap")?.value;
+	if (storedMap !== void 0 && typeof storedMap === "object" && storedMap !== null) return storedMap;
+	if (!isCameraDevice(found.device)) return {};
+	const sources = await found.device.getStreamSources();
+	const profileMap = {};
+	for (const s of sources) if (s.profileHint && s.id) profileMap[s.profileHint] = s.id;
+	return profileMap;
+}
+async function setStreamProfileMap(pctx, input) {
+	const { deviceId } = input;
 	if (pctx.registry) {
-		const liveEntries = addonId ? pctx.registry.getAllForAddon(addonId).map((device) => ({
-			addonId,
-			device
-		})) : pctx.registry.getAllWithAddonId();
-		for (const { addonId: aid, device } of liveEntries) {
-			const key = String(device.id);
-			const metadata = metadataMap[key] ?? null;
-			const metaRow = meta[key] ?? null;
-			results.push(toDeviceInfo(aid, device, metadata, metaRow));
-			seen.add(key);
+		const found = resolveDeviceById(pctx.registry, deviceId);
+		if (found) {
+			await found.device.config.setAll({ _profileMap: input.profileMap });
+			return { success: true };
 		}
 	}
-	const index = await pctx.metaStore.readIndex();
-	const metaByAddonStable = /* @__PURE__ */ new Map();
-	for (const m of Object.values(meta)) metaByAddonStable.set(`${m.addonId}${m.stableId}`, m);
-	const targetAddons = addonId ? [addonId] : Object.keys(index);
-	for (const aid of targetAddons) for (const stableId of index[aid] ?? []) {
-		const m = metaByAddonStable.get(`${aid}${stableId}`);
-		const key = String(m.id);
-		if (seen.has(key)) continue;
-		const persistedType = m.type;
-		const persistedConfig = await pctx.settings.readDeviceStore(m.id);
-		const metadata = metadataMap[key] ?? null;
-		results.push({
-			id: m.id,
-			stableId,
-			addonId: aid,
-			type: persistedType,
-			name: m?.name ?? stableId,
-			location: m?.location ?? null,
-			disabled: m?.disabled ?? false,
-			parentDeviceId: m?.parentDeviceId ?? null,
-			role: toDeviceRole(m?.role),
-			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
-			probed: pctx.host.resolveDeviceProbed(m.id),
-			features: persistedFeatures(m?.features),
-			isCamera: persistedType === DeviceType.Camera,
-			config: persistedConfig ?? {},
-			metadata,
-			...m?.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
-			...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 } : {},
-			...(() => {
-				const si = buildSourceInfoFromConfig(persistedConfig ?? {}, stableId, aid);
-				return si !== void 0 ? { sourceInfo: si } : {};
-			})()
-		});
+	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
+	await pctx.requireDeviceOps(deviceId).setConfig({
+		deviceId,
+		values: { _profileMap: input.profileMap }
+	});
+	return { success: true };
+}
+async function probeStreams(pctx, input) {
+	const streamProbe = pctx.host.ctx.kernel.streamProbe;
+	if (!streamProbe) return [];
+	const sources = await pctx.provider.getStreamSources({ deviceId: input.deviceId });
+	const results = [];
+	for (const s of sources) {
+		if (!s.url) continue;
+		try {
+			const metadata = await streamProbe.probe(s.url, { force: true });
+			results.push({
+				streamId: s.id,
+				width: metadata.width,
+				height: metadata.height,
+				codec: metadata.codec,
+				fps: metadata.fps,
+				bitrateKbps: metadata.bitrateKbps
+			});
+		} catch (err) {
+			pctx.host.ctx.logger.debug("streamProbe.probe failed — returning placeholder", { meta: {
+				deviceId: input.deviceId,
+				streamId: s.id,
+				error: err instanceof Error ? err.message : String(err)
+			} });
+			results.push({ streamId: s.id });
+		}
 	}
 	return results;
 }
-async function getDevice(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) {
-			const key = String(found.device.id);
-			const [map, metaMap] = await Promise.all([pctx.metaStore.readMetadataMap(), pctx.metaStore.readMeta()]);
-			const metadata = map[key] ?? null;
-			const metaRow = metaMap[key] ?? null;
-			return toDeviceInfo(found.addonId, found.device, metadata, metaRow);
+async function discoverDevices(pctx, input) {
+	const dp = await pctx.host.requireDeviceProvider(input.addonId);
+	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device discovery`);
+	return (await dp.discoverDevices({})).map((d) => ({
+		stableId: d.stableId,
+		type: d.type,
+		suggestedName: d.suggestedName,
+		prefilledConfig: d.prefilledConfig
+	}));
+}
+async function adoptDevice(pctx, input) {
+	const dp = await pctx.host.requireDeviceProvider(input.addonId);
+	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device adoption`);
+	const summary = await dp.adoptDiscoveredDevice({ candidate: input.candidate });
+	if (input.integrationId !== void 0) try {
+		await pctx.stampIntegrationId(summary.id, input.integrationId);
+	} catch (err) {
+		pctx.host.ctx.logger.warn("adoptDevice: integrationId stamp failed (device adopted)", {
+			tags: {
+				deviceId: summary.id,
+				integrationId: input.integrationId
+			},
+			meta: { error: errMsg(err) }
+		});
+	}
+	return summary;
+}
+async function getCreationSchema(pctx, input) {
+	const dp = await pctx.host.requireDeviceProvider(input.addonId);
+	if (!await dp.supportsManualCreation({})) return null;
+	return await dp.getChildCreationSchema({ type: input.type }) ?? null;
+}
+async function createDevice(pctx, input) {
+	const dp = await pctx.host.requireDeviceProvider(input.addonId);
+	if (!await dp.supportsManualCreation({})) throw new Error(`Addon "${input.addonId}" does not support manual device creation`);
+	const summary = await dp.createDevice({
+		type: input.type,
+		config: input.config
+	});
+	if (input.integrationId !== void 0) try {
+		await pctx.stampIntegrationId(summary.id, input.integrationId);
+	} catch (err) {
+		pctx.host.ctx.logger.warn("createDevice: integrationId stamp failed (device created)", {
+			tags: {
+				deviceId: summary.id,
+				integrationId: input.integrationId
+			},
+			meta: { error: errMsg(err) }
+		});
+	}
+	return summary;
+}
+async function testCreationField(pctx, input) {
+	return (await pctx.host.requireDeviceProvider(input.addonId)).testCreationField({
+		type: input.type,
+		key: input.key,
+		value: input.value,
+		...input.formValues !== void 0 ? { formValues: input.formValues } : {}
+	});
+}
+async function adoptionListCandidates(pctx, input) {
+	const { addonId, ...rest } = input;
+	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).listCandidates(rest);
+}
+async function adoptionRefresh(pctx, input) {
+	const { addonId, integrationId } = input;
+	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).refresh({ integrationId });
+}
+async function adoptionAdopt(pctx, input) {
+	const { addonId, ...rest } = input;
+	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).adopt(rest);
+}
+async function adoptionRelease(pctx, input) {
+	const { addonId, ...rest } = input;
+	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).release(rest);
+}
+async function adoptionResync(pctx, input) {
+	const { camDeviceId, resetToSource } = input;
+	let owningAddonId = pctx.registry?.getAddonId(camDeviceId) ?? null;
+	if (!owningAddonId) owningAddonId = (await pctx.metaStore.resolvePersistedById(camDeviceId))?.addonId ?? null;
+	if (!owningAddonId) throw new Error(`adoptionResync: device ${camDeviceId} not found`);
+	let removedChildren = 0;
+	if (resetToSource === true) {
+		const childIds = await pctx.metaStore.directChildIds(camDeviceId);
+		for (const childId of childIds) {
+			await pctx.provider.remove({ deviceId: childId });
+			removedChildren += 1;
 		}
+		pctx.host.ctx.logger.info("resetToSource purge before resync", { tags: {
+			deviceId: camDeviceId,
+			removedChildren
+		} });
 	}
-	const persisted = await pctx.metaStore.resolvePersistedById(deviceId);
-	if (!persisted) return null;
-	const { addonId: aid, stableId, meta: m } = persisted;
-	const persistedConfig = await pctx.settings.readDeviceStore(m.id);
-	const key = String(deviceId);
-	const metadata = (await pctx.metaStore.readMetadataMap())[key] ?? null;
-	const sourceInfoGetDevice = buildSourceInfoFromConfig(persistedConfig ?? {}, stableId, aid);
 	return {
-		id: deviceId,
-		stableId,
-		addonId: aid,
-		type: m.type,
-		name: m.name,
-		location: m.location ?? null,
-		disabled: m.disabled ?? false,
-		parentDeviceId: m.parentDeviceId,
-		role: toDeviceRole(m.role),
-		online: pctx.host.resolveDeviceOnline(deviceId, true),
-		probed: pctx.host.resolveDeviceProbed(deviceId),
-		features: persistedFeatures(m.features),
-		isCamera: false,
-		config: persistedConfig ?? {},
-		metadata,
-		...m.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
-		...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 } : {},
-		...sourceInfoGetDevice !== void 0 ? { sourceInfo: sourceInfoGetDevice } : {}
+		...await (await pctx.host.requireDeviceAdoptionProvider(owningAddonId)).resync({
+			camDeviceId,
+			resetToSource
+		}),
+		removedChildren
 	};
 }
-async function getChildren(pctx, input) {
-	const { parentDeviceId } = input;
-	let ownerAddonId = null;
-	if (pctx.registry) {
-		if (pctx.registry.getById(parentDeviceId)) ownerAddonId = pctx.registry.getAddonId(parentDeviceId);
+async function testField(pctx, input) {
+	const { deviceId } = input;
+	let owningAddonId = null;
+	if (pctx.registry) owningAddonId = pctx.registry.getAddonId(deviceId);
+	if (!owningAddonId) owningAddonId = (await pctx.metaStore.resolvePersistedById(deviceId))?.addonId ?? null;
+	if (!owningAddonId) throw new Error(`Device with id ${deviceId} not found`);
+	const dp = await pctx.host.waitDeviceProvider(owningAddonId);
+	if (!dp) return {
+		status: "ok",
+		labels: [],
+		error: void 0
+	};
+	if (typeof dp.testCreationField !== "function") return {
+		status: "ok",
+		labels: [],
+		error: void 0
+	};
+	return dp.testCreationField({
+		type: DeviceType.Camera,
+		key: input.key,
+		value: input.value
+	});
+}
+//#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);
+}
+/** 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 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 z.ZodNullable || schema instanceof z.ZodOptional || schema instanceof z.ZodDefault) {
+		const inner = asZodType(schema.unwrap());
+		return inner ? unwrapSchema(inner) : schema;
 	}
-	if (!ownerAddonId) {
-		const persisted = await pctx.metaStore.resolvePersistedById(parentDeviceId);
-		if (!persisted) return [];
-		ownerAddonId = persisted.addonId;
+	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 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;
+}
+/**
+* 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.
+*/
+function mergeLinkedStatus(base, resolved, statusSchema) {
+	let draft = base;
+	let touched = false;
+	for (const { link, sourceValue } of resolved) {
+		if (sourceValue === void 0) continue;
+		draft = setByPath(draft, link.target.fieldPath, sourceValue);
+		touched = true;
 	}
-	const results = [];
-	const seen = /* @__PURE__ */ new Set();
-	const [index, meta, metadataMap] = await Promise.all([
-		pctx.metaStore.readIndex(),
-		pctx.metaStore.readMeta(),
-		pctx.metaStore.readMetadataMap()
-	]);
-	if (pctx.registry) {
-		const liveChildren = pctx.registry.getChildren(parentDeviceId);
-		for (const device of liveChildren) {
-			const key = String(device.id);
-			const metadata = metadataMap[key] ?? null;
-			const metaRow = meta[key] ?? null;
-			results.push(toDeviceInfo(ownerAddonId, device, metadata, metaRow));
-			seen.add(key);
+	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.
+*/
+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 —
+	* slices show up as `setCapSlice` calls trickle in.
+	*/
+	stateMirror = /* @__PURE__ */ new Map();
+	/**
+	* Per-device disk-write debouncer for runtime-state. `setCapSlice`
+	* updates the in-memory mirror synchronously and emits the change
+	* event immediately, but the disk write is coalesced.
+	*/
+	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) {
+		this.ctx = ctx;
+		this.linkHost = linkHost;
+	}
+	/**
+	* Single-cap mirror update — diff against the current mirror,
+	* persist the new slice in-memory, emit `DeviceStateChanged` for
+	* this cap. No-op on identical writes (both same shape and same
+	* values). Called by `setCapSlice` provider.
+	*/
+	applySingleCapUpdate(deviceId, capName, slice) {
+		let perCap = this.stateMirror.get(deviceId);
+		if (!perCap) {
+			perCap = /* @__PURE__ */ new Map();
+			this.stateMirror.set(deviceId, perCap);
 		}
+		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);
 	}
-	const ownerMetaByStableId = /* @__PURE__ */ new Map();
-	for (const m of Object.values(meta)) if (m.addonId === ownerAddonId) ownerMetaByStableId.set(m.stableId, m);
-	const persistedChildren = (index[ownerAddonId] ?? []).filter((sid) => ownerMetaByStableId.get(sid)?.parentDeviceId === parentDeviceId);
-	for (const childStableId of persistedChildren) {
-		const m = ownerMetaByStableId.get(childStableId);
-		const key = String(m.id);
-		if (seen.has(key)) continue;
-		const persistedConfig = await pctx.settings.readDeviceStore(m.id);
-		const metadata = metadataMap[key] ?? null;
-		const sourceInfoChild = buildSourceInfoFromConfig(persistedConfig ?? {}, childStableId, ownerAddonId);
-		results.push({
-			id: m.id,
-			stableId: childStableId,
-			addonId: ownerAddonId,
-			type: m.type,
-			name: m.name,
-			location: m.location ?? null,
-			disabled: m.disabled ?? false,
-			parentDeviceId,
-			role: toDeviceRole(m.role),
-			online: pctx.host.resolveDeviceOnline(m.id, pctx.registry !== null),
-			probed: pctx.host.resolveDeviceProbed(m.id),
-			features: persistedFeatures(m.features),
-			isCamera: false,
-			config: persistedConfig ?? {},
-			metadata,
-			...m.integrationId !== void 0 ? { integrationId: m.integrationId } : {},
-			...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 } : {},
-			...sourceInfoChild !== void 0 ? { sourceInfo: sourceInfoChild } : {}
-		});
+	/**
+	* Debounced disk writer. Coalesces frequent writes (motion phase
+	* transitions, battery pushes) into one `writeDeviceRuntimeState`
+	* per `RUNTIME_STATE_DEBOUNCE_MS` window. Reads the per-device
+	* blob from the live mirror at flush time so the disk picture is
+	* always the latest state — no risk of writing a stale snapshot.
+	*/
+	scheduleRuntimeStateDiskWrite(deviceId, settings) {
+		let slot = this.runtimeStateDebounce.get(deviceId);
+		if (!slot) {
+			slot = {
+				timer: null,
+				inFlight: null
+			};
+			this.runtimeStateDebounce.set(deviceId, slot);
+		}
+		if (slot.timer) return;
+		slot.timer = setTimeout(() => {
+			slot.timer = null;
+			const blob = this.snapshotForDevice(deviceId);
+			const write = (async () => {
+				try {
+					await settings.writeDeviceRuntimeState(deviceId, blob);
+				} catch (err) {
+					this.ctx.logger.warn("writeDeviceRuntimeState failed", {
+						tags: { deviceId },
+						meta: { error: err instanceof Error ? err.message : String(err) }
+					});
+				} finally {
+					slot.inFlight = null;
+				}
+			})();
+			slot.inFlight = write;
+		}, DeviceStateMirror.RUNTIME_STATE_DEBOUNCE_MS);
 	}
-	return results;
-}
-async function getStreamSources(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) {
-			if (!isCameraDevice(found.device)) return [];
-			return (await found.device.getStreamSources()).map((s) => ({
-				id: s.id,
-				label: s.label,
-				protocol: s.protocol,
-				url: s.url,
-				resolution: s.resolution,
-				fps: s.fps,
-				bitrate: s.bitrate,
-				codec: s.codec,
-				profileHint: s.profileHint
-			}));
+	/**
+	* One-shot mirror seed used by `loadRuntimeState` at boot so the
+	* hub knows about every persisted slice without waiting for the
+	* first `setCapSlice` call. No events emitted — this is
+	* initial-state population, not a transition.
+	*
+	* Callers that must not carry a stale per-session probe across a
+	* restart pass the blob through `withResetSessionProbe` first (see
+	* `loadRuntimeState`).
+	*/
+	seedMirror(deviceId, blob) {
+		let perCap = this.stateMirror.get(deviceId);
+		if (!perCap) {
+			perCap = /* @__PURE__ */ new Map();
+			this.stateMirror.set(deviceId, perCap);
+		}
+		for (const [capName, raw] of Object.entries(blob)) {
+			if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
+			perCap.set(capName, { ...raw });
 		}
 	}
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
-	return (await pctx.requireDeviceOps(deviceId).getStreamSources({ deviceId })).map((s) => ({ ...s }));
-}
-async function getConfigSchema(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) return found.device.config.entries().map((entry) => ({
-			key: entry.key,
-			value: entry.value,
-			...entry.description !== void 0 ? { description: entry.description } : {}
-		}));
+	/**
+	* The hub mirror's `feature-probe.lastProbedAt` is a PER-SESSION liveness
+	* signal — it means "this worker process completed a probe THIS session".
+	* Persisted runtime state carries the PRE-RESTART timestamp, which is stale
+	* after a hub or worker restart: the device has not re-probed yet. Seeding it
+	* verbatim makes `resolveDeviceProbed` report `probed:true` during the
+	* restart→reprobe window, which defeats the export carry-forward gate
+	* (`resolveExportFingerprint`, gated on `device.probed`) and posts a spurious
+	* partial `AddOrUpdateReport` to Alexa/HAP before the real probe lands.
+	*
+	* Reset `lastProbedAt` to 0 for the MIRROR seed only — `probed:false` carries
+	* the last-advertised fingerprint forward until the worker republishes a
+	* fresh probe (its post-probe `setCapSlice` raises `lastProbedAt` again, which
+	* also fires `DeviceReady`). The worker's returned `initialRuntimeState` blob
+	* is untouched, and every non-probe slice (e.g. `device-status`/online) is
+	* preserved.
+	*/
+	withResetSessionProbe(blob) {
+		const probe = blob["feature-probe"];
+		if (!probe || typeof probe !== "object" || Array.isArray(probe)) return blob;
+		return {
+			...blob,
+			"feature-probe": {
+				...probe,
+				lastProbedAt: 0
+			}
+		};
 	}
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
-	return (await pctx.requireDeviceOps(deviceId).getConfigEntries({ deviceId })).map((e) => ({ ...e }));
-}
-async function getSettingsSchema(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) return found.device.getSettingsUISchema();
+	/**
+	* Resolve a device's REAL `online` flag for the persisted/forked-worker
+	* list branch. Forked workers own the live `IDevice` in their own process,
+	* so the hub registry can't read `device.online` directly. The owning
+	* driver instead publishes its liveness through the auto-registered
+	* `device-status` runtime-state slice (`markOnline` → `setCapState`), which
+	* the canonical `deviceState.setCapSlice` write entrypoint mirrors into the
+	* hub-side `stateMirror`. We read that mirrored slice here so the list
+	* payload reflects the device's actual reachability instead of a constant.
+	*
+	* Fallback (`fallbackOnline`) preserves the legacy behaviour when no slice
+	* has been published yet: a persisted device with a live registry is
+	* assumed online (it was successfully registered by its owning process),
+	* and the null-registry "offline view" keeps reporting offline. We never
+	* regress a device to offline merely because its mirror is empty.
+	*/
+	resolveDeviceOnline(deviceId, fallbackOnline) {
+		const raw = this.stateMirror.get(deviceId)?.get(deviceStatusCapability.name);
+		if (!raw) return fallbackOnline;
+		const parsed = DeviceStatusSchema.safeParse(raw);
+		if (!parsed.success) return fallbackOnline;
+		return parsed.data.online;
 	}
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) return null;
-	return await pctx.requireDeviceOps(deviceId).getSettingsSchema({ deviceId }) ?? null;
-}
-async function updateConfig(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) {
-			await found.device.config.setAll(input.values);
-			return { success: true };
-		}
+	/**
+	* Derive the `probed` flag for an offline-view (forked-worker, not
+	* live in the hub registry) device projection. Reads the mirrored
+	* `feature-probe` slice the owning worker publishes. Mirrors the
+	* `toDeviceInfo` rule: no mirrored slice → ready (`true`, no probe seen);
+	* slice present → ready iff `lastProbedAt` has advanced past 0. The
+	* mirror is populated when the worker's first `setCapSlice` RPC arrives
+	* (BaseDevice seeds `feature-probe` `lastProbedAt:0` at construction, but
+	* cross-process delivery is async); until then the no-entry path returns
+	* `true` — a brief transient window, same as `resolveDeviceOnline`.
+	*/
+	resolveDeviceProbed(deviceId) {
+		const raw = this.stateMirror.get(deviceId)?.get("feature-probe");
+		if (!raw) return true;
+		return (typeof raw.lastProbedAt === "number" ? raw.lastProbedAt : 0) > 0;
 	}
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
-	await pctx.requireDeviceOps(deviceId).setConfig({
-		deviceId,
-		values: input.values
-	});
-	return { success: true };
-}
-async function enable(pctx, input) {
-	await pctx.provider.setDisabled({
-		deviceId: input.deviceId,
-		disabled: false
-	});
-	return { success: true };
-}
-async function disable(pctx, input) {
-	await pctx.provider.setDisabled({
-		deviceId: input.deviceId,
-		disabled: true
-	});
-	return { success: true };
-}
-async function remove(pctx, input) {
-	const { deviceId } = input;
-	const removeOne = async (id) => {
-		if (pctx.registry) {
-			const live = resolveDeviceById(pctx.registry, id);
-			if (live) {
-				const deviceName = live.device.name;
-				await live.device.removeDevice();
-				pctx.registry.remove(id);
-				await pctx.provider.removeDevice({ deviceId: id });
-				pctx.host.ctx.logger.info("removed hub-local device", { tags: {
-					deviceId: id,
-					deviceName
-				} });
-				return;
-			}
-		}
-		const persisted = await pctx.metaStore.resolvePersistedById(id);
-		if (!persisted) return;
-		const { meta: persistedMeta } = persisted;
-		try {
-			await pctx.requireDeviceOps(id).removeDevice({ deviceId: id });
-		} catch (err) {
-			pctx.host.ctx.logger.warn("remove via device-ops failed — clearing persistence anyway", {
-				tags: {
-					deviceId: id,
-					deviceName: persistedMeta.name
-				},
-				meta: { error: errMsg(err) }
-			});
-		}
-		await pctx.provider.removeDevice({ deviceId: id });
-	};
-	const removeCascade = async (id) => {
-		for (const childId of await pctx.metaStore.directChildIds(id)) await removeCascade(childId);
-		await removeOne(id);
-	};
-	await removeCascade(deviceId);
-	return { success: true };
-}
-/**
-* Cascade-delete every top-level device whose `integrationId`
-* matches. Enumerates a SNAPSHOT of the meta map so concurrent
-* removals don't clobber each other. Only top-level parents are
-* enumerated — children cascade via the per-parent `removeCascade`
-* inside the delegated `remove` call. Idempotent: devices with no
-* `integrationId` never match.
-*/
-async function removeByIntegration(pctx, input) {
-	const { integrationId } = input;
-	const meta = await pctx.metaStore.readMeta();
-	const parentKeys = Object.keys(meta).filter((key) => {
-		const m = meta[key];
-		return m !== void 0 && m.integrationId === integrationId && m.parentDeviceId === null;
-	});
-	let removed = 0;
-	for (const _key of parentKeys) {
-		const m = meta[_key];
-		if (!m) continue;
-		await pctx.provider.remove({ deviceId: m.id });
-		removed++;
+	snapshotForDevice(deviceId) {
+		const perCap = this.stateMirror.get(deviceId);
+		if (!perCap) return {};
+		const out = {};
+		for (const [k, v] of perCap) out[k] = { ...v };
+		return out;
 	}
-	return { removed };
-}
-async function getStreamProfileMap(pctx, input) {
-	if (!pctx.registry) return {};
-	const found = resolveDeviceById(pctx.registry, input.deviceId);
-	if (!found) return {};
-	const storedMap = found.device.config.entries().find((e) => e.key === "_profileMap")?.value;
-	if (storedMap !== void 0 && typeof storedMap === "object" && storedMap !== null) return storedMap;
-	if (!isCameraDevice(found.device)) return {};
-	const sources = await found.device.getStreamSources();
-	const profileMap = {};
-	for (const s of sources) if (s.profileHint && s.id) profileMap[s.profileHint] = s.id;
-	return profileMap;
-}
-async function setStreamProfileMap(pctx, input) {
-	const { deviceId } = input;
-	if (pctx.registry) {
-		const found = resolveDeviceById(pctx.registry, deviceId);
-		if (found) {
-			await found.device.config.setAll({ _profileMap: input.profileMap });
-			return { success: true };
+	/**
+	* 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. 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 resolved = links.map((rl) => ({
+			link: rl.link,
+			sourceValue: applyTransform(getByPath(this.stateMirror.get(rl.sourceDeviceId)?.get(rl.link.source.cap), rl.link.source.fieldPath), rl.link.transform)
+		}));
+		const schema = this.linkHost.capabilityRegistry?.getDefinition(cap)?.status?.schema;
+		return mergeLinkedStatus(raw ? { ...raw } : {}, resolved, schema);
+	}
+	/**
+	* 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. The debounced disk
+	* writer must continue to call snapshotForDevice (raw truth).
+	*/
+	snapshotForDeviceOverlayed(deviceId) {
+		const perCap = this.stateMirror.get(deviceId);
+		if (!perCap) return {};
+		const out = {};
+		for (const capName of perCap.keys()) {
+			const s = this.overlayedSlice(deviceId, capName);
+			if (s) out[capName] = s;
 		}
+		return out;
 	}
-	if (!await pctx.metaStore.resolvePersistedById(deviceId)) throw new Error(`[device-manager] Device with id ${deviceId} not found`);
-	await pctx.requireDeviceOps(deviceId).setConfig({
-		deviceId,
-		values: { _profileMap: input.profileMap }
-	});
-	return { success: true };
-}
-async function probeStreams(pctx, input) {
-	const streamProbe = pctx.host.ctx.kernel.streamProbe;
-	if (!streamProbe) return [];
-	const sources = await pctx.provider.getStreamSources({ deviceId: input.deviceId });
-	const results = [];
-	for (const s of sources) {
-		if (!s.url) continue;
-		try {
-			const metadata = await streamProbe.probe(s.url, { force: true });
-			results.push({
-				streamId: s.id,
-				width: metadata.width,
-				height: metadata.height,
-				codec: metadata.codec,
-				fps: metadata.fps,
-				bitrateKbps: metadata.bitrateKbps
-			});
-		} catch (err) {
-			pctx.host.ctx.logger.debug("streamProbe.probe failed — returning placeholder", { meta: {
-				deviceId: input.deviceId,
-				streamId: s.id,
-				error: err instanceof Error ? err.message : String(err)
-			} });
-			results.push({ streamId: s.id });
+	/** Whole-system mirror dump (overlaid). Backs `deviceState.getAllSnapshots`. */
+	allSnapshotsOverlayed() {
+		const out = {};
+		for (const [deviceId, perCap] of this.stateMirror) {
+			const dev = {};
+			for (const [capName, slice] of perCap) dev[capName] = this.overlayedSlice(deviceId, capName) ?? { ...slice };
+			out[String(deviceId)] = dev;
 		}
+		return out;
 	}
-	return results;
-}
-async function discoverDevices(pctx, input) {
-	const dp = await pctx.host.requireDeviceProvider(input.addonId);
-	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device discovery`);
-	return (await dp.discoverDevices({})).map((d) => ({
-		stableId: d.stableId,
-		type: d.type,
-		suggestedName: d.suggestedName,
-		prefilledConfig: d.prefilledConfig
-	}));
-}
-async function adoptDevice(pctx, input) {
-	const dp = await pctx.host.requireDeviceProvider(input.addonId);
-	if (!await dp.supportsDiscovery({})) throw new Error(`Addon "${input.addonId}" does not support device adoption`);
-	const summary = await dp.adoptDiscoveredDevice({ candidate: input.candidate });
-	if (input.integrationId !== void 0) try {
-		await pctx.stampIntegrationId(summary.id, input.integrationId);
-	} catch (err) {
-		pctx.host.ctx.logger.warn("adoptDevice: integrationId stamp failed (device adopted)", {
-			tags: {
-				deviceId: summary.id,
-				integrationId: input.integrationId
+	emitStateChanged(deviceId, capName, slice) {
+		this.ctx.eventBus.emit({
+			id: randomUUID(),
+			timestamp: /* @__PURE__ */ new Date(),
+			source: {
+				type: "device",
+				id: deviceId
 			},
-			meta: { error: errMsg(err) }
+			category: EventCategory.DeviceStateChanged,
+			data: {
+				deviceId,
+				capName,
+				slice
+			}
 		});
 	}
-	return summary;
-}
-async function getCreationSchema(pctx, input) {
-	const dp = await pctx.host.requireDeviceProvider(input.addonId);
-	if (!await dp.supportsManualCreation({})) return null;
-	return await dp.getChildCreationSchema({ type: input.type }) ?? null;
-}
-async function createDevice(pctx, input) {
-	const dp = await pctx.host.requireDeviceProvider(input.addonId);
-	if (!await dp.supportsManualCreation({})) throw new Error(`Addon "${input.addonId}" does not support manual device creation`);
-	const summary = await dp.createDevice({
-		type: input.type,
-		config: input.config
-	});
-	if (input.integrationId !== void 0) try {
-		await pctx.stampIntegrationId(summary.id, input.integrationId);
-	} catch (err) {
-		pctx.host.ctx.logger.warn("createDevice: integrationId stamp failed (device created)", {
-			tags: {
-				deviceId: summary.id,
-				integrationId: input.integrationId
-			},
-			meta: { error: errMsg(err) }
-		});
+	/** 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);
 	}
-	return summary;
-}
-async function testCreationField(pctx, input) {
-	return (await pctx.host.requireDeviceProvider(input.addonId)).testCreationField({
-		type: input.type,
-		key: input.key,
-		value: input.value,
-		...input.formValues !== void 0 ? { formValues: input.formValues } : {}
-	});
-}
-async function adoptionListCandidates(pctx, input) {
-	const { addonId, ...rest } = input;
-	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).listCandidates(rest);
-}
-async function adoptionRefresh(pctx, input) {
-	const { addonId, integrationId } = input;
-	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).refresh({ integrationId });
-}
-async function adoptionAdopt(pctx, input) {
-	const { addonId, ...rest } = input;
-	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).adopt(rest);
-}
-async function adoptionRelease(pctx, input) {
-	const { addonId, ...rest } = input;
-	return (await pctx.host.requireDeviceAdoptionProvider(addonId)).release(rest);
-}
-async function adoptionResync(pctx, input) {
-	const { camDeviceId, resetToSource } = input;
-	let owningAddonId = pctx.registry?.getAddonId(camDeviceId) ?? null;
-	if (!owningAddonId) owningAddonId = (await pctx.metaStore.resolvePersistedById(camDeviceId))?.addonId ?? null;
-	if (!owningAddonId) throw new Error(`adoptionResync: device ${camDeviceId} not found`);
-	let removedChildren = 0;
-	if (resetToSource === true) {
-		const childIds = await pctx.metaStore.directChildIds(camDeviceId);
-		for (const childId of childIds) {
-			await pctx.provider.remove({ deviceId: childId });
-			removedChildren += 1;
+	/** 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. */
+	async flushPendingWrites(settings) {
+		const pending = [];
+		for (const [deviceId, slot] of this.runtimeStateDebounce) {
+			if (slot.timer) {
+				clearTimeout(slot.timer);
+				slot.timer = null;
+				if (settings) {
+					const blob = this.snapshotForDevice(deviceId);
+					pending.push(settings.writeDeviceRuntimeState(deviceId, blob).catch((err) => {
+						this.ctx.logger.warn("shutdown writeDeviceRuntimeState failed", {
+							tags: { deviceId },
+							meta: { error: err instanceof Error ? err.message : String(err) }
+						});
+					}));
+				}
+			}
+			if (slot.inFlight) pending.push(slot.inFlight);
 		}
-		pctx.host.ctx.logger.info("resetToSource purge before resync", { tags: {
-			deviceId: camDeviceId,
-			removedChildren
-		} });
+		await Promise.all(pending);
+		this.runtimeStateDebounce.clear();
 	}
-	return {
-		...await (await pctx.host.requireDeviceAdoptionProvider(owningAddonId)).resync({
-			camDeviceId,
-			resetToSource
-		}),
-		removedChildren
-	};
-}
-async function testField(pctx, input) {
-	const { deviceId } = input;
-	let owningAddonId = null;
-	if (pctx.registry) owningAddonId = pctx.registry.getAddonId(deviceId);
-	if (!owningAddonId) owningAddonId = (await pctx.metaStore.resolvePersistedById(deviceId))?.addonId ?? null;
-	if (!owningAddonId) throw new Error(`Device with id ${deviceId} not found`);
-	const dp = await pctx.host.waitDeviceProvider(owningAddonId);
-	if (!dp) return {
-		status: "ok",
-		labels: [],
-		error: void 0
-	};
-	if (typeof dp.testCreationField !== "function") return {
-		status: "ok",
-		labels: [],
-		error: void 0
-	};
-	return dp.testCreationField({
-		type: DeviceType.Camera,
-		key: input.key,
-		value: input.value
-	});
-}
+};
 //#endregion
 //#region src/builtins/device-manager/device-sync-resolvers.ts
 /**
@@ -3300,31 +3332,6 @@ async function resolveLinkedStatus(pctx, input) {
 }
 //#endregion
 //#region src/builtins/device-manager/device-manager.addon.ts
-/**
-* Device Manager addon — hub-side singleton that unifies device persistence,
-* live registry queries, and all management operations into a single
-* tRPC-routable capability.
-*
-* Persistence strategy: all device data is stored via `ctx.settings`, the same
-* settings API every other addon uses. No raw SQLite access.
-*
-*   Addon store layout:
-*     deviceIndex  → Record<addonId, stableId[]>          (which devices exist per addon)
-*     deviceMeta   → Record<numericId, DeviceMeta>        (keyed by numeric device id;
-*                                                          addonId + stableId are FIELDS on the record)
-*
-*   Device store (per-device config):
-*     readDeviceStore(numericDeviceId)  → config blob
-*     writeDeviceStore(numericDeviceId, patch)
-*
-* Live registry: resolved from the kernel capability registry after Phase 2.
-* This gives direct access to in-memory IDevice instances registered by provider addons.
-* The DeviceManagerAddon is the single owner of the live device operations API.
-*
-* Replaces:
-*   - `device-persistence` capability (absorbed here)
-*   - live operations previously served by `device-management.router.ts`
-*/
 var DeviceManagerAddon = class extends BaseAddon {
 	constructor() {
 		super({});
@@ -3490,6 +3497,26 @@ var DeviceManagerAddon = class extends BaseAddon {
 		if (!provider) throw new Error(`Device-adoption provider "${addonId}" not found or not registered`);
 		return provider;
 	}
+	/** Addon ids that currently register a `device-provider`. */
+	listDeviceProviderIds() {
+		return (this.capabilityRegistry?.listCapabilities().find((c) => c.name === "device-provider"))?.providers ?? [];
+	}
+	/** "provider-gree" → "Gree" — a human label for the discovery modal. */
+	discoveryProviderLabel(addonId) {
+		const base = addonId.replace(/^addon-(provider-)?/, "").replace(/^provider-/, "");
+		return base.length > 0 ? base.charAt(0).toUpperCase() + base.slice(1) : addonId;
+	}
+	/** Provider ids that report `supportsDiscovery() === true` (probed in parallel). */
+	async listDiscoveryCapableProviderIds() {
+		const ids = this.listDeviceProviderIds();
+		return (await Promise.all(ids.map(async (addonId) => {
+			try {
+				return await (await this.requireDeviceProvider(addonId)).supportsDiscovery({}) ? addonId : null;
+			} catch {
+				return null;
+			}
+		}))).filter((id) => id !== null);
+	}
 	/** Build the dependency context the extracted binding resolvers consume. */
 	get bindingsDeps() {
 		return {
@@ -3625,11 +3652,54 @@ var DeviceManagerAddon = class extends BaseAddon {
 			getCreationSchema: (input) => getCreationSchema(pctx, input),
 			createDevice: (input) => createDevice(pctx, input),
 			testCreationField: (input) => testCreationField(pctx, input),
+			adoptionListCandidateFilters: async (input) => {
+				return (await this.requireDeviceAdoptionProvider(input.addonId)).listCandidateFilters({ integrationId: input.integrationId });
+			},
 			adoptionListCandidates: (input) => adoptionListCandidates(pctx, input),
 			adoptionRefresh: (input) => adoptionRefresh(pctx, input),
 			adoptionAdopt: (input) => adoptionAdopt(pctx, input),
 			adoptionRelease: (input) => adoptionRelease(pctx, input),
 			adoptionResync: (input) => adoptionResync(pctx, input),
+			discoveryProviders: async () => {
+				return { providers: (await this.listDiscoveryCapableProviderIds()).map((addonId) => ({
+					addonId,
+					label: this.discoveryProviderLabel(addonId)
+				})) };
+			},
+			discoverAllProviders: async () => {
+				const ids = await this.listDiscoveryCapableProviderIds();
+				return { groups: await Promise.all(ids.map(async (addonId) => {
+					const label = this.discoveryProviderLabel(addonId);
+					try {
+						return {
+							addonId,
+							label,
+							candidates: await (await this.requireDeviceProvider(addonId)).discoverDevices({}),
+							error: null
+						};
+					} catch (err) {
+						this.ctx.logger.warn("discovery provider scan failed", { meta: {
+							addonId,
+							error: err instanceof Error ? err.message : String(err)
+						} });
+						return {
+							addonId,
+							label,
+							candidates: [],
+							error: err instanceof Error ? err.message : String(err)
+						};
+					}
+				})) };
+			},
+			discoverProvider: async (input) => {
+				return { candidates: await (await this.requireDeviceProvider(input.addonId)).discoverDevices({ params: input.params }) };
+			},
+			providerCreationType: async (input) => {
+				return (await this.requireDeviceProvider(input.addonId)).getManualCreationType({});
+			},
+			providerDiscoveryParamsSchema: async (input) => {
+				return (await this.requireDeviceProvider(input.addonId)).getDiscoveryParamsSchema({});
+			},
 			testField: (input) => testField(pctx, input),
 			getBindings: async (input) => {
 				const result = await this.getBindings({ deviceId: input.deviceId });