@camstack/core 0.1.37 → 0.1.39

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

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { BaseAddon, CAP_NAMES_WITH_STATUS, DeviceFeature, DeviceType, EventCategory, WELL_KNOWN_TAB_MAP, deviceManagerCapability, deviceStateCapability, errMsg } from "@camstack/types";
+import { BaseAddon, CAP_NAMES_WITH_STATUS, DeviceFeature, DeviceType, EventCategory, STREAM_PROFILE_META, WELL_KNOWN_TAB_MAP, buildStreamParamsConfigSchema, deviceManagerCapability, deviceStateCapability, errMsg, isDeviceConfigCap, parseStreamParamsFormPatch } from "@camstack/types";
 //#region src/builtins/device-manager/device-event-propagator.ts
 /**
 * Walks the parent chain for every device-sourced event and re-emits a
@@ -107,6 +107,34 @@ var DeviceEventPropagator = class {
 		return chain;
 	}
 };
+/**
+* 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-manager.addon.ts
 /**
@@ -133,6 +161,28 @@ var DeviceEventPropagator = class {
 *   - `device-persistence` capability (absorbed here)
 *   - live operations previously served by `device-management.router.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.
+*
+* Falls back to a message-substring check for serialised errors that arrive
+* across the Moleculer transport as plain objects rather than real instances.
+*/
+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);
@@ -355,11 +405,21 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 	static RUNTIME_STATE_DEBOUNCE_MS = 1e3;
 	/**
 	* Cross-process native-provider cache: deviceId (numeric) → capName → { addonId, nodeId }.
-	* Kept in sync with `device.bindings-changed` events emitted by forked
-	* workers. Union'd into `getBindings` so hub-side consumers see every
-	* native cap regardless of which process owns the IDevice. No persistence
-	* — entries re-register when the worker restarts. Purged on
-	* `$node.disconnected` to avoid stale routing after a worker crash.
+	* Kept in sync with `DeviceBindingsChanged` push events emitted by forked
+	* workers on `ctx.registerNativeCap` / device removal. Union'd into
+	* `getBindings` so hub-side consumers see every native cap regardless of
+	* which process owns the IDevice.
+	*
+	* No persistence — entries re-populate when the worker re-handshakes or
+	* re-emits its native-cap registrations after restart. Entries that were
+	* lost in the Moleculer transport handshake window are recovered lazily:
+	* `resolveNativeCapOwnerSync` and `getBindings` fall through to
+	* `ctx.kernel.listClusterNativeCaps()` (the handshake-fed
+	* `HubNodeRegistry`) when the push-based cache misses.
+	*
+	* The previous pull-based recovery (`syncWorkerNativeCaps`, driven by
+	* `$node.connected` + `addon.restarted`) has been removed in Task 13 —
+	* the D3 re-handshake after device restore is the reliable replacement.
 	*/
 	remoteNativeCaps = /* @__PURE__ */ new Map();
 	/** Wait for a device-provider by addonId, returning null on timeout. */
@@ -383,79 +443,34 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 		return "hub";
 	}
 	/**
-	* Active discovery of native caps registered on a worker node.
-	* Called from the `$node.connected` handler to recover from lost
-	* `DeviceBindingsChanged` broadcasts after worker restart.
+	* 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
+	* `remoteNativeCaps` cache misses — covers the Moleculer transport
+	* handshake window where `DeviceBindingsChanged` events were lost but the
+	* D3 re-handshake (post device restore) has already populated the registry.
 	*
-	* Iterates the broker's service registry, picks
-	* `<addonId>.native-provider.<capName>` services owned by the
-	* connected node, calls each service's `$listDeviceIds` action to
-	* fetch the deviceIds the worker has registered that cap on, then
-	* writes entries into `remoteNativeCaps`.
-	*
-	* Best-effort: per-service failures are logged and swallowed so a
-	* single bad service doesn't abort the whole rebuild.
+	* Returns `null` when the entry is genuinely not present in the cluster
+	* view (cap not registered on any worker for that device).
 	*/
-	async discoverWorkerNativeCaps(connectedNodeId, _connectedAddonId) {
-		const cluster = this.ctx.kernel.cluster;
-		if (!cluster) return;
-		const broker = cluster.broker;
-		const services = broker.registry?.getServiceList?.({
-			onlyAvailable: true,
-			withActions: false
-		}) ?? [];
-		const NATIVE_INFIX = ".native-provider.";
-		const matched = services.filter((s) => s.nodeID === connectedNodeId && s.name.includes(NATIVE_INFIX));
-		if (matched.length === 0) return;
-		for (const svc of matched) {
-			const idx = svc.name.indexOf(NATIVE_INFIX);
-			if (idx <= 0) continue;
-			const addonId = svc.name.slice(0, idx);
-			const capName = svc.name.slice(idx + 17);
-			if (!addonId || !capName) continue;
-			try {
-				const action = `${svc.name}.$listDeviceIds`;
-				const deviceIds = await broker.call?.(action, {}, { nodeID: connectedNodeId });
-				if (!deviceIds || deviceIds.length === 0) continue;
-				for (const deviceId of deviceIds) {
-					if (this.capabilityRegistry?.getNativeAddonId(capName, deviceId)) continue;
-					let perDevice = this.remoteNativeCaps.get(deviceId);
-					if (!perDevice) {
-						perDevice = /* @__PURE__ */ new Map();
-						this.remoteNativeCaps.set(deviceId, perDevice);
-					}
-					perDevice.set(capName, {
-						addonId,
-						nodeId: connectedNodeId
-					});
-				}
-				this.ctx.logger.debug("worker native-cap discovered", { meta: {
-					nodeId: connectedNodeId,
-					addonId,
-					capName,
-					deviceIds
-				} });
-			} catch (err) {
-				this.ctx.logger.debug("worker native-cap $listDeviceIds failed", { meta: {
-					service: svc.name,
-					nodeId: connectedNodeId,
-					error: errMsg(err)
-				} });
-			}
-		}
-		this.ctx.logger.info("worker native-cap discovery completed", { meta: {
-			nodeId: connectedNodeId,
-			services: matched.length
-		} });
+	resolveRemoteNativeCapFromRegistry(capName, deviceId) {
+		const clusterCaps = this.ctx.kernel.listClusterNativeCaps?.();
+		if (!clusterCaps) return null;
+		for (const entry of clusterCaps) if (entry.capName === capName && entry.deviceId === deviceId && entry.addonId) return {
+			addonId: entry.addonId,
+			nodeId: entry.nodeId
+		};
+		return null;
 	}
 	async getBindings(input) {
 		const storeKey = String(input.deviceId);
 		const perDevice = (await this.readBindingsStore()).deviceBindings[storeKey] ?? {};
 		const entries = [];
 		const seenCaps = /* @__PURE__ */ new Set();
+		const resolveRemote = (capName) => this.remoteNativeCaps.get(input.deviceId)?.get(capName) ?? this.resolveRemoteNativeCapFromRegistry(capName, input.deviceId);
 		for (const [capName, { wrapperAddonId }] of Object.entries(perDevice)) {
 			const hubLocalNative = this.capabilityRegistry?.getNativeAddonId(capName, input.deviceId) ?? null;
-			const remoteNative = this.remoteNativeCaps.get(input.deviceId)?.get(capName) ?? null;
+			const remoteNative = resolveRemote(capName);
 			const nativeAddonId = hubLocalNative ?? remoteNative?.addonId ?? "";
 			const nativeNodeId = hubLocalNative ? this.ctx.kernel.localNodeId ?? "hub" : remoteNative?.nodeId ?? this.ctx.kernel.localNodeId ?? "hub";
 			if (wrapperAddonId === null && !nativeAddonId) {
@@ -471,13 +486,12 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			});
 			seenCaps.add(capName);
 		}
-		const remote = this.remoteNativeCaps.get(input.deviceId);
 		if (this.capabilityRegistry) for (const capName of this.capabilityRegistry.getCapsWithDefaultWrapper()) {
 			if (seenCaps.has(capName)) continue;
 			const defaultWrapperAddonId = this.capabilityRegistry.getDefaultWrapperForCap(capName);
 			if (!defaultWrapperAddonId) continue;
 			const hubLocalNative = this.capabilityRegistry.getNativeAddonId(capName, input.deviceId) ?? null;
-			const remoteNative = remote?.get(capName) ?? null;
+			const remoteNative = resolveRemote(capName);
 			const nativeAddonId = hubLocalNative ?? remoteNative?.addonId ?? "";
 			entries.push({
 				capName,
@@ -500,7 +514,8 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			});
 			seenCaps.add(capName);
 		}
-		if (remote) for (const [capName, info] of remote) {
+		const pushFed = this.remoteNativeCaps.get(input.deviceId);
+		if (pushFed) for (const [capName, info] of pushFed) {
 			if (seenCaps.has(capName)) continue;
 			entries.push({
 				capName,
@@ -511,6 +526,22 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			});
 			seenCaps.add(capName);
 		}
+		const clusterCaps = this.ctx.kernel.listClusterNativeCaps?.();
+		if (clusterCaps) for (const entry of clusterCaps) {
+			if (entry.deviceId !== input.deviceId) continue;
+			if (seenCaps.has(entry.capName)) continue;
+			if (!entry.addonId) continue;
+			const localNodeId = this.ctx.kernel.localNodeId ?? "hub";
+			if (entry.nodeId === localNodeId) continue;
+			entries.push({
+				capName: entry.capName,
+				kind: "native",
+				providerAddonId: entry.addonId,
+				providerNodeId: entry.nodeId,
+				nativeAddonId: entry.addonId
+			});
+			seenCaps.add(entry.capName);
+		}
 		return {
 			deviceId: input.deviceId,
 			entries
@@ -556,42 +587,26 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			return null;
 		}
 		const method = kind === "settings" ? "getDeviceSettingsContribution" : "getDeviceLiveContribution";
-		const contributors = [];
-		for (const info of registry.listCapabilities()) {
-			if (!registry.getDefinition(info.name)?.exposesDeviceSettings) continue;
-			const seen = /* @__PURE__ */ new Set();
-			const sorted = [...info.providers].sort((a, b) => a.length - b.length);
-			for (const addonId of sorted) {
-				if (addonId.includes("::native-")) continue;
-				const baseId = addonId.includes("@") ? addonId.slice(0, addonId.indexOf("@")) : addonId;
-				if (seen.has(baseId)) continue;
-				seen.add(baseId);
-				contributors.push({
-					capName: info.name,
-					addonId
-				});
-			}
-		}
-		const results = await Promise.all(contributors.map(async ({ capName, addonId }) => {
-			const provider = registry.getProviderByAddon(capName, addonId);
-			if (!provider) throw new Error(`[device-manager] capability "${capName}" lists provider "${addonId}" but getProviderByAddon returned null — registry inconsistency`);
+		const { entries: bindingEntries } = await this.getBindings({ deviceId });
+		const results = await Promise.all(bindingEntries.map(async (entry) => {
+			const def = registry.getDefinition(entry.capName);
+			if (isDeviceConfigCap(def)) return this.deriveDeviceConfigContribution(registry, def, entry, deviceId, kind);
+			if (!def?.exposesDeviceSettings) return null;
+			const provider = registry.getProviderForDevice(entry.capName, deviceId);
+			if (!provider) return null;
 			try {
 				const contribution = await provider[method]({ deviceId });
 				if (!contribution) return null;
-				return {
-					capName,
-					addonId,
-					contribution: tagContribution(toWireShape(contribution), capName, addonId, kind)
-				};
+				return tagContribution(toWireShape(contribution), entry.capName, entry.providerAddonId, kind);
 			} catch (err) {
 				const msg = err instanceof Error ? err.message : String(err);
 				this.ctx.logger.warn("contribution method failed", {
 					tags: {
 						deviceId,
-						addonId
+						addonId: entry.providerAddonId
 					},
 					meta: {
-						capName,
+						capName: entry.capName,
 						method,
 						error: msg
 					}
@@ -600,11 +615,75 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			}
 		}));
 		const base = kind === "settings" ? await this.buildBaseDeviceSection(deviceId) : null;
-		const parts = [...base ? [tagContribution(base, "device-manager", "device-manager", kind)] : [], ...results.filter((r) => r !== null).map((r) => r.contribution)];
+		const parts = [...base ? [tagContribution(base, "device-manager", "device-manager", kind)] : [], ...results.filter((r) => r !== null)];
 		if (parts.length === 0) return null;
 		return mergeAggregates(parts);
 	}
 	/**
+	* D14: framework-derived device-config contribution.
+	*
+	* `kind === 'live'` — device-config caps contribute nothing to the live
+	* aggregate (they hold editable config, not live observables).
+	*
+	* `ui.kind === 'widget'` — emits a single structural `type:'widget'`
+	* section; the widget self-persists via the cap's own mutations.
+	*
+	* `ui.kind === 'derived-form'` — calls `getOptions`/`getStatus` on the
+	* bound provider, runs the registered pure builder, and returns the
+	* derived form sections. Returns null when the camera exposes nothing
+	* configurable or the provider is not yet registered.
+	*/
+	async deriveDeviceConfigContribution(registry, def, entry, deviceId, kind) {
+		if (kind === "live") return null;
+		const ui = def.deviceConfig.ui;
+		if (ui.kind === "widget") return tagContribution({ sections: [{
+			id: `${entry.capName}-widget`,
+			title: ui.label,
+			tab: ui.tab,
+			order: ui.order ?? 0,
+			...ui.topTab ? { location: "top-tab" } : {},
+			fields: [{
+				type: "widget",
+				key: `${entry.capName}Widget`,
+				label: ui.label,
+				widgetId: ui.widgetId
+			}]
+		}] }, entry.capName, entry.providerAddonId, kind);
+		const provider = registry.getProviderForDevice(entry.capName, deviceId);
+		if (!provider || typeof provider.getOptions !== "function") return null;
+		try {
+			const options = await provider.getOptions({ deviceId });
+			const status = typeof provider.getStatus === "function" ? await provider.getStatus({ deviceId }) : null;
+			const derived = deriveFormContribution(ui.builderId, options, status ?? null);
+			if (!derived) return null;
+			return tagContribution({
+				...derived.tabs ? { tabs: derived.tabs.map((t) => ({ ...t })) } : {},
+				sections: derived.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]
+				}))
+			}, entry.capName, entry.providerAddonId, kind);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			this.ctx.logger.warn("device-config derivation failed", {
+				tags: {
+					deviceId,
+					addonId: entry.providerAddonId
+				},
+				meta: {
+					capName: entry.capName,
+					error: msg
+				}
+			});
+			return null;
+		}
+	}
+	/**
 	* Build the device-manager's own contribution to the aggregator — the
 	* device identity (id, stableId, addonId, type, online) + the
 	* driver-specific config exposed by the device class via
@@ -674,8 +753,8 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 				}] : []
 			]
 		}];
-		const driverSchema = await this.resolveDriverConfigSchema(deviceId, hubLocal);
-		if (driverSchema) for (const section of driverSchema.sections) sections.push({
+		const driverResult = await this.resolveDriverConfigSchema(deviceId, hubLocal);
+		if (driverResult.status === "ok") for (const section of driverResult.schema.sections) sections.push({
 			id: section.id,
 			title: section.title,
 			tab: section.tab ?? "general",
@@ -684,9 +763,22 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			...section.description !== void 0 ? { description: section.description } : {},
 			...section.columns !== void 0 ? { columns: section.columns } : {}
 		});
+		else if (driverResult.status === "unavailable") sections.push({
+			id: "driver-settings-unavailable",
+			title: "Driver Settings",
+			tab: "general",
+			order: 1,
+			fields: [{
+				type: "info",
+				key: "driver-settings-unavailable-notice",
+				label: "Temporarily unavailable",
+				content: "Driver settings are temporarily unavailable — the addon may be restarting. Refresh the page in a moment.",
+				variant: "warning"
+			}]
+		});
 		return {
 			sections,
-			...driverSchema?.tabs ? { tabs: [...driverSchema.tabs] } : {}
+			...driverResult.status === "ok" && driverResult.schema.tabs ? { tabs: [...driverResult.schema.tabs] } : {}
 		};
 	}
 	/**
@@ -699,7 +791,7 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			addonId: local,
 			nodeId: this.ctx.kernel.localNodeId ?? "hub"
 		};
-		const remote = this.remoteNativeCaps.get(deviceId)?.get("device-ops") ?? null;
+		const remote = this.remoteNativeCaps.get(deviceId)?.get("device-ops") ?? this.resolveRemoteNativeCapFromRegistry("device-ops", deviceId);
 		return remote ? {
 			addonId: remote.addonId,
 			nodeId: remote.nodeId
@@ -735,7 +827,7 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 					out[capName] = null;
 					return;
 				}
-				const provider = registry.getNativeProvider(capName, input.deviceId);
+				const provider = registry.getProviderForDevice(capName, input.deviceId);
 				if (!provider || typeof provider.getStatus !== "function") {
 					out[capName] = null;
 					return;
@@ -776,27 +868,54 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 	* devices call `getSettingsUISchema()` directly; forked-worker devices
 	* go through the `device-ops.getSettingsSchema` cap method on the
 	* numeric-id-keyed native registry.
+	*
+	* Returns a discriminated result so callers can distinguish three states:
+	*   'ok'          – schema obtained successfully
+	*   'none'        – driver genuinely has no settings schema
+	*   'unavailable' – worker was unreachable after retries (transient)
 	*/
 	async resolveDriverConfigSchema(deviceId, hubLocal) {
 		if (hubLocal) {
 			const schema = hubLocal.device.getSettingsUISchema();
-			return schema.sections.length === 0 ? null : toWireShape(schema);
+			return schema.sections.length === 0 ? { status: "none" } : {
+				status: "ok",
+				schema: toWireShape(schema)
+			};
 		}
 		const ops = this.capabilityRegistry?.getNativeProvider("device-ops", deviceId);
-		if (!ops) return null;
-		try {
-			const schema = await ops.getSettingsSchema({ deviceId });
-			if (!schema) return null;
-			const wire = schema;
-			return wire.sections.length === 0 ? null : toWireShape(wire);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			this.ctx.logger.warn("cross-process getSettingsSchema failed", {
-				tags: { deviceId },
-				meta: { error: msg }
-			});
-			return null;
+		if (!ops) return { status: "none" };
+		const MAX_RETRIES = 2;
+		const RETRY_DELAY_MS = 750;
+		let lastErr;
+		for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+			if (attempt > 0) await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+			try {
+				const schema = await ops.getSettingsSchema({ deviceId });
+				if (!schema) return { status: "none" };
+				const wire = schema;
+				return wire.sections.length === 0 ? { status: "none" } : {
+					status: "ok",
+					schema: toWireShape(wire)
+				};
+			} catch (err) {
+				lastErr = err;
+				if (!isTransientMoleculerError(err)) break;
+				if (attempt < MAX_RETRIES) this.ctx.logger.debug("cross-process getSettingsSchema transient failure, retrying", {
+					tags: { deviceId },
+					meta: {
+						attempt: attempt + 1,
+						maxRetries: MAX_RETRIES,
+						error: errMsg(err)
+					}
+				});
+			}
 		}
+		const msg = errMsg(lastErr);
+		this.ctx.logger.warn("cross-process getSettingsSchema failed after retries — driver settings temporarily unavailable", {
+			tags: { deviceId },
+			meta: { error: msg }
+		});
+		return { status: "unavailable" };
 	}
 	async updateDeviceField(input) {
 		if (input.writerCapName === "device-manager") {
@@ -816,16 +935,38 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 		}
 		const registry = this.capabilityRegistry;
 		if (!registry) throw new Error("[device-manager] updateDeviceField requires capability registry — unavailable on this node");
-		if (!registry.getDefinition(input.writerCapName)?.exposesDeviceSettings) throw new Error(`[device-manager] cap "${input.writerCapName}" does not expose device settings`);
-		const provider = registry.getProviderByAddon(input.writerCapName, input.writerAddonId);
-		if (!provider) throw new Error(`[device-manager] provider "${input.writerAddonId}" not registered for cap "${input.writerCapName}"`);
-		await provider.applyDeviceSettingsPatch({
+		const def = registry.getDefinition(input.writerCapName);
+		if (isDeviceConfigCap(def)) {
+			if (def.deviceConfig.ui.kind === "widget") return { success: true };
+			const dcProvider = registry.getProviderForDevice(input.writerCapName, input.deviceId);
+			if (!dcProvider) throw new Error(`[device-manager] no provider for device-config cap "${input.writerCapName}" on device ${input.deviceId}`);
+			await applyDerivedFormPatch(def.deviceConfig.ui.builderId, { [input.key]: input.value }, (profile, patch) => dcProvider.setProfile({
+				deviceId: input.deviceId,
+				profile,
+				patch
+			}));
+			return { success: true };
+		}
+		if (!def?.exposesDeviceSettings) throw new Error(`[device-manager] cap "${input.writerCapName}" does not expose device settings`);
+		await this.resolveContributionProvider(registry, def, input.writerCapName, input.writerAddonId, input.deviceId).applyDeviceSettingsPatch({
 			deviceId: input.deviceId,
 			patch: { [input.key]: input.value }
 		});
 		return { success: true };
 	}
 	/**
+	* Resolve the `DeviceSettingsContribution` provider that owns a tagged
+	* field. System-scoped caps resolve via `getProviderByAddon`; native
+	* device-scoped caps (registered per-device via `registerNativeCap`)
+	* live in the separate native map and resolve via `getNativeProvider`.
+	* Throws only if BOTH lookups miss.
+	*/
+	resolveContributionProvider(registry, _def, writerCapName, writerAddonId, deviceId) {
+		const provider = registry.getProviderForDevice(writerCapName, deviceId);
+		if (provider) return provider;
+		throw new Error(`[device-manager] no provider for cap "${writerCapName}" (addon "${writerAddonId}") on device ${deviceId}`);
+	}
+	/**
 	* Batched counterpart of `updateDeviceField`. Groups changes by
 	* `(writerCapName, writerAddonId)` so each contributor receives a
 	* single `applyDeviceSettingsPatch` with all of its updates merged —
@@ -883,10 +1024,20 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 		}
 		const registry = this.capabilityRegistry;
 		if (!registry) throw new Error("[device-manager] capability registry unavailable");
-		if (!registry.getDefinition(group.writerCapName)?.exposesDeviceSettings) throw new Error(`[device-manager] cap "${group.writerCapName}" does not expose device settings`);
-		const provider = registry.getProviderByAddon(group.writerCapName, group.writerAddonId);
-		if (!provider) throw new Error(`[device-manager] provider "${group.writerAddonId}" not registered for cap "${group.writerCapName}"`);
-		await provider.applyDeviceSettingsPatch({
+		const def = registry.getDefinition(group.writerCapName);
+		if (isDeviceConfigCap(def)) {
+			if (def.deviceConfig.ui.kind === "widget") return;
+			const dcProvider = registry.getProviderForDevice(group.writerCapName, deviceId);
+			if (!dcProvider) throw new Error(`[device-manager] no provider for device-config cap "${group.writerCapName}" on device ${deviceId}`);
+			await applyDerivedFormPatch(def.deviceConfig.ui.builderId, group.patch, (profile, patch) => dcProvider.setProfile({
+				deviceId,
+				profile,
+				patch
+			}));
+			return;
+		}
+		if (!def?.exposesDeviceSettings) throw new Error(`[device-manager] cap "${group.writerCapName}" does not expose device settings`);
+		await this.resolveContributionProvider(registry, def, group.writerCapName, group.writerAddonId, deviceId).applyDeviceSettingsPatch({
 			deviceId,
 			patch: group.patch
 		});
@@ -1040,35 +1191,6 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 				idToAddonId.set(m.id, key.slice(0, sep));
 			}
 		}
-		if (cluster) cluster.broker.localBus.on("$node.connected", (payload) => {
-			const connectedNodeId = payload.node.id;
-			const lastSlash = connectedNodeId.lastIndexOf("/");
-			if (lastSlash < 0) return;
-			const connectedAddonId = connectedNodeId.slice(lastSlash + 1);
-			if (connectedAddonId.length === 0) return;
-			for (const [deviceId, ownerAddonId] of idToAddonId) {
-				if (ownerAddonId !== connectedAddonId) continue;
-				if (this.capabilityRegistry?.getNativeAddonId("device-ops", deviceId)) continue;
-				let perDevice = this.remoteNativeCaps.get(deviceId);
-				if (!perDevice) {
-					perDevice = /* @__PURE__ */ new Map();
-					this.remoteNativeCaps.set(deviceId, perDevice);
-				}
-				if (!perDevice.has("device-ops")) perDevice.set("device-ops", {
-					addonId: connectedAddonId,
-					nodeId: connectedNodeId
-				});
-			}
-			setTimeout(() => {
-				this.discoverWorkerNativeCaps(connectedNodeId, connectedAddonId).catch((err) => {
-					this.ctx.logger.warn("worker native-cap discovery failed", { meta: {
-						nodeId: connectedNodeId,
-						addonId: connectedAddonId,
-						error: errMsg(err)
-					} });
-				});
-			}, 500);
-		});
 		const allocateNextDeviceId = async () => {
 			const current = (await readStore()).nextDeviceId ?? 1;
 			await settings.writeAddonStore({ nextDeviceId: current + 1 });
@@ -1091,12 +1213,14 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 			*  so the hub only synthesizes a cross-process proxy when the cap is
 			*  actually published — never on speculative device ownership.
 			*
-			*  Consults hub-local registrations first (in-process natives),
-			*  then the `remoteNativeCaps` map populated from
-			*  `DeviceBindingsChanged` events emitted by forked-worker
-			*  `registerNativeCap` calls. Both are generic: any addon that hosts
-			*  devices and registers caps via the standard context API shows up
-			*  here without per-addon branching.
+			*  Resolution order:
+			*   1. Hub-local `capabilityRegistry` (in-process natives — fastest path).
+			*   2. Push-fed `remoteNativeCaps` cache (`DeviceBindingsChanged` events
+			*      from forked workers — accurate in steady state).
+			*   3. Handshake-fed `HubNodeRegistry` via `listClusterNativeCaps()`
+			*      (D3 re-handshake after device restore — covers the Moleculer
+			*      transport window where push events were lost). This is the
+			*      reliable replacement for the deleted `syncWorkerNativeCaps` pull.
 			*/
 			resolveNativeCapOwnerSync: (capName, deviceId) => {
 				const localAddonId = this.capabilityRegistry?.getNativeAddonId(capName, deviceId) ?? null;
@@ -1109,7 +1233,7 @@ var DeviceManagerAddon = class DeviceManagerAddon extends BaseAddon {
 					addonId: remote.addonId,
 					nodeId: remote.nodeId
 				};
-				return null;
+				return this.resolveRemoteNativeCapFromRegistry(capName, deviceId);
 			},
 			/** Idempotent numeric-id reservation. Callers invoke this before
 			*  constructing the owning `IDevice` so `DeviceContext.id` is bound