@camstack/types 1.0.5 → 1.0.6

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import { $ as SubscribeFramesInputSchema, A as ReadinessTimeoutError, B as CameraStreamSchema, C as asNumber, D as parseJsonUnknown, E as parseJsonObject, F as BrokerStatusSchema, G as FrameHandleSchema, H as DecodedFrameSchema, I as CAM_PROFILE_ORDER, J as ProfileSlotStatusSchema, K as ProfileRtspEntrySchema, L as CamProfileSchema, M as readinessKey, N as scopeKey, O as DATAPLANE_SECRET_HEADER, P as BrokerStatsSchema, Q as SubscribeAudioChunksResultSchema, R as CamStreamKindSchema, S as asJsonObject, T as parseJsonArray, U as EncodedPacketSchema, V as DecodedAudioChunkSchema, W as FrameHandleFormatSchema, X as StreamSourceSchema, Y as StreamSourceEntrySchema, Z as SubscribeAudioChunksInputSchema, _ as DeviceFeature, a as adminUiCapability, at as BaseAddon, b as asBoolean, c as createMirrorSource, ct as createEvent, d as DEVICE_STATUS_METHOD, dt as WELL_KNOWN_TABS, et as SubscribeFramesResultSchema, f as event, ft as WELL_KNOWN_TAB_MAP, g as ChargingStatus, h as method, ht as DisposerChain, i as deviceOpsCapability, it as selectAssignedProfileSlots, j as emitDownForOwnedCaps, k as ReadinessRegistry, l as createSliceHandle, lt as emitReadiness, m as isDeviceConfigCap, mt as EventCategory, n as sleepCancellable, nt as makeSourceBrokerId, o as createDeviceProxy, ot as normalizeAddonInitResult, p as expandCapMethods, pt as hydrateSchema, q as ProfileSlotSchema, r as RawStateResultSchema, rt as parseProfileBrokerId, s as createLazyTrpcSource, st as createDurableState, t as sleep, tt as makeProfileBrokerId, u as DEVICE_SETTINGS_CONTRIBUTION_METHODS, ut as isEvent, v as DeviceRole, w as asString, x as asJsonArray, y as DeviceType, z as CamStreamResolutionSchema } from "./sleep-D7JeS58T.mjs";
+import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 import { z } from "zod";
 //#region src/health/wiring-health.ts
 /**
@@ -60,71 +62,6 @@ var MODEL_FORMATS = [
 	"pt"
 ];
 //#endregion
-//#region src/disposer-chain.ts
-var DisposerChain = class {
-	disposers = [];
-	disposed = false;
-	onError;
-	constructor(opts = {}) {
-		this.onError = opts.onError ?? ((err, index) => {
-			console.error(`[DisposerChain] disposer #${index} threw`, err);
-		});
-	}
-	/**
-	* Register a teardown callback. Returns an unregister function so
-	* callers can drop a single disposer without disposing the whole
-	* chain.
-	*
-	* If the chain has already been disposed, the callback runs immediately
-	* (sync) — this matches the “register-after-shutdown” edge case where
-	* an addon's late initialization races with kernel restart.
-	*/
-	add(fn) {
-		if (this.disposed) {
-			try {
-				const result = fn();
-				if (result && typeof result.then === "function") result.catch((err) => this.onError(err, -1));
-			} catch (err) {
-				this.onError(err, -1);
-			}
-			return () => void 0;
-		}
-		this.disposers.push(fn);
-		return () => {
-			const idx = this.disposers.indexOf(fn);
-			if (idx >= 0) this.disposers.splice(idx, 1);
-		};
-	}
-	/** True after `dispose()` has been called at least once. */
-	get isDisposed() {
-		return this.disposed;
-	}
-	/** Number of disposers currently registered. */
-	get size() {
-		return this.disposers.length;
-	}
-	/**
-	* Run every registered disposer in LIFO order. Idempotent: subsequent
-	* calls do nothing. Awaits async disposers so callers can sequence
-	* shutdown → restart correctly.
-	*/
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		const drain = this.disposers.slice().toReversed();
-		this.disposers = [];
-		for (let i = 0; i < drain.length; i++) {
-			const fn = drain[i];
-			try {
-				const result = fn();
-				if (result && typeof result.then === "function") await result;
-			} catch (err) {
-				this.onError(err, drain.length - 1 - i);
-			}
-		}
-	}
-};
-//#endregion
 //#region src/interfaces/addon.ts
 var DEFAULT_ADDON_PLACEMENT = "hub-only";
 /**
@@ -149,1299 +86,29 @@ function isAgentOnlyPlacement(decl) {
 	return resolveAddonExecution(decl).placement === "agent-only";
 }
 /**
-* Convenience accessor — the declared co-location group label, or
-* `undefined` when the addon declares no group (→ its own dedicated
-* runner). Callers that need the runner id should use `resolveRunnerId`.
-*/
-function resolveAddonGroup(decl) {
-	return resolveAddonExecution(decl).group;
-}
-/**
-* Resolve the runner id an addon belongs to. This is the single
-* authority for the hub↔runner topology:
-*   - declared `group` present → the runner id is the group name
-*     (shared with every other addon declaring the same group);
-*   - no `group` declared → the runner id is the addon id itself
-*     (its own dedicated runner — one addon, one process).
-*
-* The runner's Moleculer nodeID is `${parentNodeId}/${runnerId}`.
-*/
-function resolveRunnerId(decl, addonId) {
-	return decl.execution?.group ?? addonId;
-}
-/** Convenience accessor — the resolved placement (defaults to `hub-only`). */
-function resolveAddonPlacement(decl) {
-	return resolveAddonExecution(decl).placement;
-}
-//#endregion
-//#region src/enums/event-category.ts
-var EventCategory = /* @__PURE__ */ function(EventCategory) {
-	EventCategory["SystemBoot"] = "system.boot";
-	EventCategory["SystemAddonsReady"] = "system.addons-ready";
-	EventCategory["SystemRestarting"] = "system.restarting";
-	/**
-	* Fired exactly once after the hub finishes booting following a
-	* restart that was triggered by `RestartCoordinator` (today: framework
-	* live-update). Payload is the marker that was on disk at boot
-	* (`PendingRestartMarkerPayload`); admin UI listens for it to display a
-	* success toast describing what changed.
-	*
-	* Spec: docs/superpowers/specs/2026-05-14-framework-live-update-design.md
-	*/
-	EventCategory["SystemRestartCompleted"] = "system.restart-completed";
-	/**
-	* Readiness transition for a capability provider. Every producer emits
-	* this event on `onInitialize` completion, `onDestroy`, and
-	* `$node.reconnect`; every consumer that needs to gate on a cross-process
-	* cap subscribes via the kernel's readiness module (`awaitReady` /
-	* `onReadyState`) instead of polling. Payload is
-	* `SystemReadyStatePayload` — see event-bus.ts.
-	*/
-	EventCategory["SystemReadyState"] = "system.ready-state";
-	EventCategory["AddonStarted"] = "addon.started";
-	EventCategory["AddonStopped"] = "addon.stopped";
-	EventCategory["AddonRestarted"] = "addon.restarted";
-	EventCategory["AddonUpdated"] = "addon.updated";
-	EventCategory["AddonInstalled"] = "addon.installed";
-	EventCategory["AddonUninstalled"] = "addon.uninstalled";
-	EventCategory["AddonCrashed"] = "addon.crashed";
-	EventCategory["AddonError"] = "addon.error";
-	EventCategory["AddonPageReady"] = "addon.page-ready";
-	EventCategory["AddonWidgetReady"] = "addon.widget-ready";
-	/**
-	* Addon failed to load (import or initialize). Emitted by the kernel's
-	* AddonHealthMonitor only AFTER the boot grace period ends — failures
-	* during the first 5 minutes are silently retried without alerting
-	* (slow-starting addons must have time to come up). Post-grace, this
-	* event is emitted exactly once per failure-streak; AlertCenter
-	* consumes it to create a persistent operator-visible alert.
-	*
-	* Payload: `{ packageName, addonId?, error: { message, stack }, retryCount, nextRetryAt }`.
-	*/
-	EventCategory["AddonLoadFailed"] = "addon.load-failed";
-	/**
-	* Addon recovered from a previous failure. Emitted when an addon
-	* transitions from `failed` back to `healthy` (typically via the
-	* monitor's auto-retry loop, or after manual `addons.retryLoad`).
-	* AlertCenter dismisses the corresponding `AddonLoadFailed` alert
-	* on this event.
-	*/
-	EventCategory["AddonLoadRecovered"] = "addon.load-recovered";
-	/**
-	* Monitor scheduled the next retry for a failed addon. Transient —
-	* surfaced to the UI for live-updating the "next retry in Ns"
-	* countdown on the Addons page row, NOT persisted as an alert.
-	*/
-	EventCategory["AddonRetryScheduled"] = "addon.retry-scheduled";
-	/**
-	* Monitor is attempting to reload a failed addon NOW. UI uses this
-	* to show a spinner during the retry attempt. Same transient nature
-	* as AddonRetryScheduled.
-	*/
-	EventCategory["AddonRetryAttempting"] = "addon.retry-attempting";
-	EventCategory["DeviceRegistered"] = "device.registered";
-	EventCategory["DeviceUnregistered"] = "device.unregistered";
-	EventCategory["DeviceEnabled"] = "device.enabled";
-	EventCategory["DeviceDisabled"] = "device.disabled";
-	EventCategory["DeviceSettingsUpdated"] = "device.settings-updated";
-	/**
-	* Emitted when the set of native capability providers bound to a device
-	* changes — e.g. an addon registers a new native cap via
-	* `DeviceContext.registerNativeCap`, or all native bindings for a device
-	* are cleared on removal. Hub consumers re-resolve device-proxy routes
-	* when this fires.
-	*/
-	EventCategory["DeviceBindingsChanged"] = "device.bindings-changed";
-	/**
-	* Emitted when the operator-organisational meta surface changes
-	* (`name` / `location` / `disabled`). Payload: `{deviceId, field,
-	* value}`. Live consumers (UI device list, alert center) react
-	* without polling. Distinct from `DeviceSettingsUpdated` which
-	* fires on hardware-config changes (host/port/credentials/etc).
-	*/
-	EventCategory["DeviceMetaChanged"] = "device.meta-changed";
-	/**
-	* Emitted by `BaseDevice.updateSourceInfo()` after a successful patch
-	* to the device's upstream-system identity / rendering envelope. The
-	* full new SourceInfo travels in the payload so cross-process listeners
-	* (UI, export adapters) don't need to re-read the meta blob.
-	*
-	* Payload: `{deviceId, sourceInfo}`.
-	*
-	* Distinct from `DeviceMetaChanged` which covers the operator-edited
-	* surface (`name` / `location` / `disabled`). The two share the
-	* persistence layer (both ride on `device-manager.setMetadata` for
-	* SourceInfo, or `setName`/`setLocation`/`setDisabled` for the meta
-	* fields) but consumers care about different subsets.
-	*/
-	EventCategory["DeviceSourceInfoChanged"] = "device.source-info-changed";
-	/**
-	* Emitted by DeviceStreamWiringService after a successful
-	* `stream-broker.registerDeviceStreams` call. Payload includes
-	* deviceId — consumers look up the full registered device info via
-	* `brokerManager.getRegisteredDevice(deviceId)`.
-	*
-	* Replaces the legacy `StreamRouterService.onDeviceRegistered` callback.
-	*/
-	EventCategory["DeviceStreamsRegistered"] = "device.streams-registered";
-	/**
-	* Device-level "fully provisioned" signal — the EXPORT trigger. Emitted once
-	* a device's persisted export-relevant shape (its `DeviceFeature` set) is
-	* established or changes, carrying `{deviceId, fingerprint, generation}`.
-	* Export adapters (Alexa / HAP) react to THIS instead of the chatty per-cap
-	* `DeviceBindingsChanged`, turning a boot's incomplete→complete trickle into
-	* one clean delta. `fingerprint` is `canonicalDeviceFingerprint(shape)`.
-	*
-	* Spec: docs/superpowers/specs/2026-06-01-alexa-hap-export-reconciler-design.md
-	*/
-	EventCategory["DeviceProvisioned"] = "device.provisioned";
-	/**
-	* Fires once when a device's initial feature-probe completes successfully
-	* (lastProbedAt 0→>0); exported shape is now stable. Telemetry (may be
-	* dropped) — consumers MUST also gate on the device record's `probed` flag.
-	*/
-	EventCategory["DeviceReady"] = "device.ready";
-	EventCategory["IntegrationEnabled"] = "integration.enabled";
-	EventCategory["IntegrationDisabled"] = "integration.disabled";
-	EventCategory["IntegrationDeleted"] = "integration.deleted";
-	/** Emitted when a broker connection's status flips (connected /
-	*  disconnected / error). Carries `{ brokerId, status, error? }`. */
-	EventCategory["BrokerStatusChanged"] = "broker.status-changed";
-	/** Emitted for every subscription-matched message routed by a
-	*  broker provider. Carries `{ brokerId, subscriptionId, key, payload }`.
-	*  Consumers filter by `brokerId` + `subscriptionId` in the handler. */
-	EventCategory["BrokerMessage"] = "broker.message";
-	EventCategory["ProviderStarted"] = "provider.started";
-	EventCategory["ProviderStopped"] = "provider.stopped";
-	EventCategory["ProcessCrashed"] = "process.crashed";
-	EventCategory["ProcessRestartScheduled"] = "process.restart_scheduled";
-	EventCategory["ProcessRestarted"] = "process.restarted";
-	EventCategory["RecordingStarted"] = "recording.started";
-	EventCategory["RecordingStopped"] = "recording.stopped";
-	EventCategory["RecordingError"] = "recording.error";
-	EventCategory["RecordingHealthDegraded"] = "recording.health.degraded";
-	EventCategory["RecordingStorageCritical"] = "recording.storage.critical";
-	EventCategory["RecordingSegmentWritten"] = "recording.segment.written";
-	EventCategory["RecordingPolicyFallback"] = "recording.policy.fallback";
-	EventCategory["RecordingRetentionCompleted"] = "recording.retention.completed";
-	EventCategory["DetectionEvent"] = "detection.event";
-	EventCategory["SessionTrackNew"] = "session.track.new";
-	EventCategory["SessionTrackExpired"] = "session.track.expired";
-	EventCategory["BenchmarkProgress"] = "benchmark.progress";
-	EventCategory["PlatformProbePhase"] = "platform-probe.phase";
-	EventCategory["PipelineProgress"] = "pipeline.progress";
-	/** Per-frame execution trace emitted by the pipeline executor for live observability. */
-	EventCategory["PipelineTrace"] = "pipeline.trace";
-	/**
-	* Raw inference output emitted by `addon-pipeline-runner` after running the
-	* detection pipeline on a frame. Carries the `FrameResult` (with
-	* `detections[]`, `width`/`height`, timing debug) — never the frame
-	* buffer itself. Hub-side consumers (analysis pipeline, class filters,
-	* notifications) subscribe to this and re-emit `detection.result` after
-	* post-processing.
-	*/
-	EventCategory["PipelineInferenceResult"] = "pipeline.inference-result";
-	/**
-	* Camera lifecycle event emitted by `addon-pipeline-orchestrator` when it
-	* assigns or unassigns a camera to/from an agent. Carries no frame data;
-	* pure observability for UI dashboards and metrics consumers.
-	*/
-	EventCategory["PipelineCameraAssigned"] = "pipeline.camera-assigned";
-	EventCategory["PipelineCameraUnassigned"] = "pipeline.camera-unassigned";
-	/**
-	* Per-camera pipeline config was mutated by the orchestrator
-	* (3-level settings change via `setAgentAddonDefaults` /
-	* `setCameraStepToggle` / `setCameraPipelineForAgent` or a
-	* pipeline-scoped `applyDeviceSettingsPatch`). Orchestrator
-	* subscribes to its own emission to hot-reload the assigned runner
-	* via `attachCamera` so the next frame executes against the new
-	* engine/steps without waiting for a rebalance or the next
-	* `DeviceStreamsRegistered` cycle.
-	*/
-	EventCategory["PipelineCameraUpdated"] = "pipeline.camera-updated";
-	/**
-	* Periodic snapshot of per-node pipeline-runner load
-	* (`RunnerLocalLoad`). Emitted ~1Hz by every runner so UI dashboards
-	* subscribe instead of polling `pipelineRunner.getLocalLoad`.
-	* `nodeId` carried in the payload + on `event.source.nodeId`.
-	*/
-	EventCategory["PipelineRunnerLoadSnapshot"] = "pipeline.runner-load-snapshot";
-	/**
-	* Periodic snapshot of per-camera pipeline metrics (`CameraMetrics`
-	* + `deviceId` + `nodeId`). Emitted ~1Hz by every runner for each
-	* attached camera. UI subscribes to drive overlay phase / fps /
-	* inference time without polling `getCameraMetrics`.
-	*/
-	EventCategory["PipelineCameraMetricsSnapshot"] = "pipeline.camera-metrics-snapshot";
-	/**
-	* Periodic snapshot of stream-broker per-broker statistics (input
-	* fps, decoded fps, bitrate, codec). Emitted ~1Hz by every
-	* stream-broker process for each active broker so the UI can drive
-	* the Stream / Cluster dashboards without polling
-	* `streamBroker.listAllProfileSlots` and friends.
-	*/
-	EventCategory["StreamBrokerMetricsSnapshot"] = "stream-broker.metrics-snapshot";
-	/**
-	* Cap event fired by `stream-broker` when a profile slot enters
-	* "demanded" state — a cam stream has been assigned and at least one
-	* consumer (RTSP restream, decoded subscriber, WebRTC session, …) is
-	* present. Camera-provider addons (Reolink Baichuan push, …)
-	* subscribe to this category to start their underlying transport
-	* lazily. Payload: `{ deviceId, camStreamId, profile }`.
-	*/
-	EventCategory["StreamBrokerOnCamStreamDemand"] = "stream-broker.onCamStreamDemand";
-	/**
-	* Cap event fired by `stream-broker` when the last consumer leaves a
-	* previously-demanded cam stream. Providers tear down their
-	* underlying transport on receipt. Payload: `{ deviceId, camStreamId }`.
-	*/
-	EventCategory["StreamBrokerOnCamStreamIdle"] = "stream-broker.onCamStreamIdle";
-	/**
-	* Cap event fired by `stream-broker` when a broker fails to dial a
-	* managed-loopback source (today: `pull-rfc4571`) and the publisher
-	* needs to refresh the cached URL. The lib's TCP server idle-tears-down
-	* on its own schedule, so a re-publish with a fresh `host:port` is the
-	* only way to keep the broker dialable. Camera providers (Reolink
-	* Baichuan native, …) subscribe and respond by re-running their publish
-	* pipeline.
-	* Payload: `{ deviceId, camStreamId, brokerId }`.
-	*/
-	EventCategory["StreamBrokerOnRequestStreamSourceRefresh"] = "stream-broker.onRequestStreamSourceRefresh";
-	/**
-	* A camera provider changed a device's stream parameters (codec /
-	* resolution / bitrate / a stream added or removed). A LOW-LATENCY NUDGE
-	* for the stream-broker's catalog reconcile: it carries NO authoritative
-	* data — the broker re-PULLS that device's `stream-catalog` cap on receipt
-	* (the 30s reconcile poll is the backstop if this nudge is dropped). Emitted
-	* by providers from `stream-params.setProfile`. Payload: `{ deviceId }`.
-	*/
-	EventCategory["StreamParamsChanged"] = "stream-params.changed";
-	/**
-	* Generic per-device runtime-state change. Fired by `device-manager`
-	* whenever a persisted slice in any cap's `runtimeState` shape
-	* mutates. Payload: `{deviceId, capName, slice}`. Subscribers are
-	* the `deviceState` cap router (cross-process listeners) and the
-	* deviceProxy reactive bindings (`device.state.<capName>.value`).
-	* Cap-specific events (`battery.onStatusChanged`, …) still fire
-	* — they're authoritative for callers that want a typed payload
-	* without filtering on `capName`.
-	*/
-	EventCategory["DeviceStateChanged"] = "device.state-changed";
-	/**
-	* Cap event fired by every device that registers the `battery`
-	* capability. Mirrors the cap definition's `onStatusChanged`. Carries
-	* `{ deviceId, status: BatteryStatus }`. Subscribers (alert center,
-	* snapshot wrapper, UI) react to charge/sleep transitions without
-	* polling `batteryCapability.getStatus`.
-	*/
-	EventCategory["BatteryOnStatusChanged"] = "battery.onStatusChanged";
-	/**
-	* Emitted by the battery cap provider WHEN `wakeForStream` enters the
-	* "wake in progress" window — between the Baichuan wake-up issue and
-	* the camera's first dialed-back RTP packet. The stream-broker
-	* manager subscribes to flip the per-broker placeholder reason to
-	* `'waking'` so viewers see a labelled "WAKING UP" tile instead of
-	* the generic `'reconnecting'` frame. Carries `{ deviceId }`. The
-	* complementary "wake complete" signal is the existing
-	* `BatteryOnStatusChanged { sleeping: false }` event.
-	*/
-	EventCategory["BatteryOnWakeStarted"] = "battery.onWakeStarted";
-	/**
-	* Cap event fired by every device that registers the `doorbell`
-	* capability. Mirrors `doorbellCapability.events.onPressed`. Carries
-	* `{ deviceId, timestamp }`. Operators consuming the UI subscribe
-	* here to render transient ring toasts and a "Recent presses" row
-	* on the device detail page.
-	*/
-	EventCategory["DoorbellOnPressed"] = "doorbell.onPressed";
-	/**
-	* Cap event fired by every device that registers the `event-emitter`
-	* capability. Mirrors `eventEmitterCapability.events.onEvent`. Carries
-	* `{ deviceId, eventType, data, timestamp, seq }` — the device's EXACT
-	* declared event verbatim (NO normalization). Subscribers (UI event
-	* stream, advanced-notifier rules) react to fired events without
-	* holding a cap reference.
-	*/
-	EventCategory["EventEmitted"] = "event-emitter.event";
-	/**
-	* Periodic snapshot of the per-node detection-pipeline engine
-	* registry (loaded engines, models resident, in-use cameras, idle
-	* TTL). Emitted ~0.2Hz (every 5 s) by every detection-pipeline
-	* process. The Engines tab subscribes to drive its inventory view
-	* without polling `pipelineExecutor.listLoadedEngines`.
-	*/
-	EventCategory["PipelineEngineMetricsSnapshot"] = "pipeline.engine-metrics-snapshot";
-	/**
-	* Per-node detection-engine runtime-provisioning transition. Emitted by
-	* the detection-pipeline provider on every state change of its lazy
-	* engine-provisioning machine (idle → installing → verifying → ready,
-	* or → failed with a `nextRetryAt`). Payload is the
-	* `EngineProvisioningState` snapshot; `event.source.nodeId` carries the
-	* node. The Pipeline page subscribes to drive a live "installing
-	* OpenVINO… / ready" indicator per node without polling
-	* `pipelineExecutor.getEngineProvisioning`. Telemetry-grade (D8): the UI
-	* also reads the cap snapshot on mount / reconnect. Phase 2.
-	*/
-	EventCategory["PipelineEngineProvisioning"] = "pipeline.engine-provisioning";
-	/**
-	* Cluster topology snapshot. Carries the same payload returned by
-	* `nodes.topology` (every reachable node + addons + processes).
-	* Emitted by the hub on any agent / addon lifecycle change
-	* (debounced) plus a periodic safety net. Replaces UI polling on
-	* `nodes.topology` — admin-ui dashboards subscribe to drive the
-	* cluster view directly from the event payload.
-	*/
-	EventCategory["ClusterTopologySnapshot"] = "cluster.topology-snapshot";
-	/**
-	* Periodic per-node system metrics snapshot (CPU / memory / GPU /
-	* disk / network). Emitted ~0.2 Hz by the metrics-provider addon
-	* for each node. Drives the dashboard SystemStatus / ProcessResources
-	* widgets without polling `metricsProvider.getCurrent`.
-	*/
-	EventCategory["MetricsNodeResourcesSnapshot"] = "metrics.node-resources-snapshot";
-	/**
-	* Periodic per-node process-tree snapshot (camstack-related pids
-	* with ghost / managed / root classification). Emitted ~0.2 Hz by
-	* the metrics-provider addon. Drives the Cluster → Processes tab
-	* without polling `metricsProvider.listNodeProcesses`.
-	*/
-	EventCategory["MetricsNodeProcessesSnapshot"] = "metrics.node-processes-snapshot";
-	/**
-	* Capability binding change event emitted by `addon-pipeline-orchestrator`
-	* when a user changes which addon implements a cap on a node. Subscribed
-	* by every kernel process to update its local `preferredProviderRegistry`
-	* so future capability lookups respect the new binding.
-	*/
-	/**
-	* A capability binding was changed for a node — addon X now provides
-	* capability `cap` on node `nodeId`. Lives under the generic
-	* `capability.*` namespace because capability bindings are a kernel-
-	* level concept used by many addons, not strictly pipeline-scoped.
-	*/
-	EventCategory["CapabilityBindingChanged"] = "capability.binding-changed";
-	EventCategory["ModelDownloadProgress"] = "model.download.progress";
-	EventCategory["AgentRegistered"] = "agent.registered";
-	EventCategory["AgentUnregistered"] = "agent.unregistered";
-	EventCategory["AgentOnline"] = "agent.online";
-	EventCategory["AgentOffline"] = "agent.offline";
-	/** Forked worker process (e.g. hub/pipeline) connected to the broker. */
-	EventCategory["WorkerOnline"] = "worker.online";
-	/** Forked worker process disconnected from the broker. */
-	EventCategory["WorkerOffline"] = "worker.offline";
-	EventCategory["AgentTaskDispatched"] = "agent.task.dispatched";
-	EventCategory["AgentTaskAssigned"] = "agent.task.assigned";
-	EventCategory["AgentTrpcConnected"] = "agent.trpc.connected";
-	EventCategory["AgentWsConnected"] = "agent.ws.connected";
-	EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
-	EventCategory["AgentBackupActivated"] = "agent.backup.activated";
-	EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
-	/**
-	* Per-agent hwaccel preference changed (user override set, cleared, or
-	* re-probed). Observability event — decoders pull the current pref at
-	* `createSession`, so running sessions keep their current backend until
-	* they rotate naturally (camera add/remove, stream restart). Future
-	* work can wire a listener in stream-broker that force-rotates live
-	* sessions; for now this event powers logs + admin-UI toast feedback.
-	*/
-	EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
-	EventCategory["MotionAnalysis"] = "detection.motion-analysis";
-	/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
-	EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
-	/**
-	* Per-camera motion phase transition (`watching ↔ active`) emitted
-	* by the runner. Mirrors the `motion.onMotionChanged` cap event
-	* surface — payload `MotionOnMotionChangedPayload` carries
-	* `{deviceId, detected, timestamp, source, regions?}`. Subscribers
-	* include addons that need to react to motion state without
-	* polling the runtime-state mirror.
-	*/
-	EventCategory["MotionOnMotionChanged"] = "motion.on-motion-changed";
-	EventCategory["DetectionResult"] = "detection.result";
-	EventCategory["DetectionRaw"] = "detection.raw";
-	EventCategory["DetectionCameraNative"] = "detection.camera-native";
-	/**
-	* Canonical per-chunk live audio pipeline output. Payload is
-	* `PipelineAudioInferenceResultPayload` carrying a full `AudioResult`
-	* (level + detections + debug). Lives on the pipeline.* namespace
-	* alongside `pipeline.inference-result` (video) for symmetry.
-	*/
-	EventCategory["PipelineAudioInferenceResult"] = "pipeline.audio-inference-result";
-	EventCategory["DetectionPhaseTransition"] = "detection.phase-transition";
-	EventCategory["ProviderMotion"] = "provider.motion";
-	EventCategory["ProviderDetection"] = "provider.detection";
-	EventCategory["EnrichmentEmbeddingStored"] = "enrichment.embedding.stored";
-	EventCategory["EnrichmentSceneStateChanged"] = "enrichment.scene.state-changed";
-	EventCategory["EnrichmentActivitySummary"] = "enrichment.activity.summary";
-	EventCategory["PipelineAnalyticsTrackStarted"] = "pipeline-analytics.track-started";
-	EventCategory["PipelineAnalyticsTrackEnded"] = "pipeline-analytics.track-ended";
-	EventCategory["PipelineAnalyticsDetectionEvent"] = "pipeline-analytics.detection-event";
-	EventCategory["PipelineAnalyticsFrameTracked"] = "pipeline-analytics.frame-tracked";
-	EventCategory["FrigateLiveEvent"] = "frigate.live-event";
-	EventCategory["CameraStreamsProfileSlotsChanged"] = "camera-streams.onProfileSlotsChanged";
-	/**
-	* Stream-broker health watchdog. Per-broker (deviceId/profile) emission.
-	* `stream.offline` fires after STREAM_STALE_TIMEOUT_MS without an encoded
-	* packet on an active broker. `stream.online` fires on first packet
-	* after a stale gap (or on initial first packet). Payload includes
-	* the assigned camStreamId as `profileKey`.
-	*/
-	EventCategory["StreamOnline"] = "stream.online";
-	EventCategory["StreamOffline"] = "stream.offline";
-	EventCategory["NetworkTunnelStarted"] = "network.tunnel.started";
-	EventCategory["NetworkTunnelStopped"] = "network.tunnel.stopped";
-	/** Fired by the `local-network` cap when the host's interface set
-	*  changes (new IP from DHCP, VPN connect, docker bridge added). */
-	EventCategory["LocalNetworkChanged"] = "network.local.changed";
-	/**
-	* Fired by a `mesh-network` provider (Tailscale, …) when its
-	* mesh-reachable host changes (join / leave / MagicDNS or 100.x IP
-	* change). Lets `local-network` fold the mesh endpoint into its
-	* connection-endpoint list without a cross-package import. Payload
-	* carries the preferred host (`host: ''` = no longer reachable),
-	* the hub port, and the scheme. Telemetry-grade (D8): consumers
-	* pull-reconcile from the provider's `getStatus` on reconnect. */
-	EventCategory["MeshNetworkChanged"] = "network.mesh.changed";
-	EventCategory["BackupCompleted"] = "backup.completed";
-	EventCategory["BackupRestored"] = "backup.restored";
-	EventCategory["NotificationDispatched"] = "notification.dispatched";
-	EventCategory["NotificationFailed"] = "notification.failed";
-	EventCategory["DeviceUpdated"] = "device.updated";
-	/**
-	* Transport-level connectivity. Emitted by the device driver when
-	* the underlying control socket actually connects / disconnects
-	* (Baichuan TCP, ONVIF probe response, RTSP DESCRIBE, …) — NOT for
-	* power-state transitions on a battery camera. For battery wake /
-	* doze cycles see `DeviceAwake` / `DeviceSleeping`.
-	*/
-	EventCategory["DeviceOnline"] = "device.online";
-	/**
-	* Stream-broker watchdog — emitted when no encoded packet has been
-	* received for STREAM_STALE_TIMEOUT_MS on an active broker (rtsp or
-	* push). Paired with DeviceOnline which fires on first packet after
-	* a stale gap. Payload: DeviceStreamHealthPayload.
-	*/
-	EventCategory["DeviceOffline"] = "device.offline";
-	/**
-	* Battery cam woke up — physical power-state transition reported
-	* by the device firmware. Distinct from `DeviceOnline` so a UI panel
-	* watching power state doesn't flap on every UDP socket reconnect.
-	*/
-	EventCategory["DeviceAwake"] = "device.awake";
-	/**
-	* Battery cam went to sleep. See `DeviceAwake`.
-	*/
-	EventCategory["DeviceSleeping"] = "device.sleeping";
-	EventCategory["RetentionCleanup"] = "retention.cleanup";
-	/**
-	* Legacy bulk-update progress snapshot (payload `BulkUpdateState`). No longer
-	* emitted — F3 removed the coordinator that produced it; "Update all" now runs
-	* as one lifecycle engine job (`AddonsJobProgress`/`AddonsJobLog`). Retained
-	* (with `BulkUpdateState`) only to avoid regenerating the event maps; removed
-	* in F4 once live bulk progress is re-implemented over the engine events.
-	*/
-	EventCategory["AddonsBulkUpdateProgress"] = "addons.bulk-update-progress";
-	EventCategory["AddonsJobProgress"] = "addons.job-progress";
-	EventCategory["AddonsJobLog"] = "addons.job-log";
-	/**
-	* A container's child visibility toggled (hidden/shown). Emitted by the
-	* `accessories` cap when a child device is hidden or revealed.
-	* Payload: `{ deviceId, childDeviceId, hidden }`.
-	*/
-	EventCategory["AccessoriesChildVisibilityChanged"] = "accessories.onChildVisibilityChanged";
-	/**
-	* A container's child set changed (children added/removed/reordered).
-	* Payload: `{ deviceId, childDeviceIds, hiddenChildIds }`.
-	*/
-	EventCategory["AccessoriesChanged"] = "accessories.onAccessoriesChanged";
-	return EventCategory;
-}({});
-//#endregion
-//#region src/interfaces/config-ui.ts
-/** Predefined tabs with standard label, icon, and sort order.
-*
-*  Pipeline (renamed Orchestrator in the UI) holds the four
-*  pipeline-orchestrator sections: General, Object Detection, Audio,
-*  and Cluster Assignment. Motion stays its own tab.
-*  `streaming` remains for older payloads that haven't been retagged. */
-var WELL_KNOWN_TABS = [
-	{
-		id: "overview",
-		label: "Overview",
-		icon: "layout-dashboard",
-		order: -10
-	},
-	{
-		id: "general",
-		label: "General",
-		icon: "settings",
-		order: 0
-	},
-	{
-		id: "image",
-		label: "Image",
-		icon: "image",
-		order: 5
-	},
-	{
-		id: "light",
-		label: "Light",
-		icon: "lightbulb",
-		order: 7
-	},
-	{
-		id: "motion",
-		label: "Motion",
-		icon: "activity",
-		order: 10
-	},
-	{
-		id: "audio",
-		label: "Audio",
-		icon: "mic",
-		order: 12
-	},
-	{
-		id: "alarms",
-		label: "Alarms",
-		icon: "bell-ring",
-		order: 13
-	},
-	{
-		id: "snapshot",
-		label: "Snapshot",
-		icon: "camera",
-		order: 15
-	},
-	{
-		id: "osd",
-		label: "OSD",
-		icon: "type",
-		order: 18
-	},
-	{
-		id: "stream-broker",
-		label: "Stream Broker",
-		icon: "radio",
-		order: 20
-	},
-	{
-		id: "streaming",
-		label: "Streaming",
-		icon: "video",
-		order: 35
-	},
-	{
-		id: "ptz",
-		label: "PTZ",
-		icon: "move",
-		order: 40
-	},
-	{
-		id: "consumables",
-		label: "Consumables",
-		icon: "recycle",
-		order: 44
-	},
-	{
-		id: "pipeline",
-		label: "Detection Pipeline",
-		icon: "cpu",
-		order: 39
-	},
-	{
-		id: "detection-pipeline",
-		label: "Detection pipeline",
-		icon: "cpu",
-		order: 39
-	},
-	{
-		id: "zones",
-		label: "Detection",
-		icon: "shapes",
-		order: 38
-	},
-	{
-		id: "analytics",
-		label: "Analytics",
-		icon: "activity",
-		order: 37
-	},
-	{
-		id: "live-stats",
-		label: "Live Stats",
-		icon: "activity",
-		order: 39
-	},
-	{
-		id: "recording",
-		label: "Recording",
-		icon: "circle-dot",
-		order: 40
-	},
-	{
-		id: "engine",
-		label: "Inference Engine",
-		icon: "zap",
-		order: 41
-	},
-	{
-		id: "scheduler",
-		label: "Scheduler",
-		icon: "list-checks",
-		order: 42
-	},
-	{
-		id: "decoder",
-		label: "Decoder",
-		icon: "film",
-		order: 43
-	},
-	{
-		id: "notifications",
-		label: "Notifications",
-		icon: "bell",
-		order: 50
-	},
-	{
-		id: "network",
-		label: "Network",
-		icon: "globe",
-		order: 60
-	},
-	{
-		id: "storage",
-		label: "Storage",
-		icon: "hard-drive",
-		order: 70
-	},
-	{
-		id: "advanced",
-		label: "Advanced",
-		icon: "wrench",
-		order: 100
-	}
-];
-/** Lookup map for well-known tabs by ID. */
-var WELL_KNOWN_TAB_MAP = Object.fromEntries(WELL_KNOWN_TABS.map((t) => [t.id, t]));
-/**
-* Field types that never carry a value (separator, info, button). Used by
-* `hydrateSchema` to skip the `value` injection for structural-only fields.
-*/
-function isValuelessField(field) {
-	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
-}
-/**
-* Merge a `ConfigUISchema` with a raw `values` record into a
-* `ConfigUISchemaWithValues`. Used by every `get*Settings` backend endpoint
-* before returning to the admin UI. Groups are walked recursively.
-*
-* For each leaf field:
-*   - structural fields (`separator`, `info`, `button`) pass through unchanged
-*   - other fields get `value = values[key] ?? field.default ?? null`
-*
-* Unknown keys in `values` (keys not declared in the schema) are silently
-* ignored — they don't contribute to the output. Missing keys fall back to
-* the schema default or `null`. This mirrors the old backend behaviour where
-* `FormBuilder` rendered `values[key] ?? field.default`.
-*/
-function hydrateSchema(schema, values) {
-	return {
-		...schema.tabs ? { tabs: [...schema.tabs] } : {},
-		sections: schema.sections.map((section) => ({
-			...section,
-			fields: section.fields.map((field) => hydrateField(field, values))
-		}))
-	};
-}
-function hydrateField(field, values) {
-	if (isValuelessField(field)) return field;
-	if (field.type === "group") {
-		const hydratedChildren = field.fields.map((child) => hydrateField(child, values));
-		return {
-			...field,
-			fields: hydratedChildren
-		};
-	}
-	if (field.type === "sub-tabs") {
-		const hydratedTabs = field.tabs.map((tab) => ({
-			...tab,
-			fields: tab.fields.map((child) => hydrateField(child, values))
-		}));
-		return {
-			...field,
-			tabs: hydratedTabs
-		};
-	}
-	const key = field.key;
-	const storedValue = Object.prototype.hasOwnProperty.call(values, key) ? values[key] : void 0;
-	const defaultValue = field.default;
-	if (field.multiple) {
-		const stored = Array.isArray(storedValue) ? storedValue : storedValue !== void 0 && storedValue !== null ? [storedValue] : [];
-		const itemFallback = field.multiple.itemDefault !== void 0 ? field.multiple.itemDefault : defaultValue !== void 0 ? defaultValue : typeOf(field) === "string" ? "" : null;
-		const minCount = Math.max(field.multiple.min, stored.length);
-		const items = [];
-		for (let i = 0; i < minCount; i++) items.push(i < stored.length ? stored[i] : itemFallback);
-		return {
-			...field,
-			value: items
-		};
-	}
-	const rawValue = storedValue !== void 0 ? storedValue : defaultValue !== void 0 ? defaultValue : null;
-	if (field.type === "password") return {
-		...field,
-		value: ""
-	};
-	const value = field.type === "textarea" && field.isJson && rawValue !== null && typeof rawValue === "object" ? JSON.stringify(rawValue, null, 2) : rawValue;
-	return {
-		...field,
-		value
-	};
-}
-/**
-* Rough "value family" classifier used by `hydrateField`'s multiple
-* fallback to pick a sensible zero-value when no `itemDefault` / no
-* field `default` / no stored value is available.
-*/
-function typeOf(field) {
-	switch (field.type) {
-		case "text":
-		case "textarea":
-		case "password":
-		case "color":
-		case "probe":
-		case "timezone":
-		case "datetime": return "string";
-		case "number":
-		case "slider": return "number";
-		case "boolean": return "boolean";
-		default: return "other";
-	}
-}
-//#endregion
-//#region src/interfaces/event-bus.ts
-/**
-* Narrow a SystemEvent to a typed event by checking its category.
-* Returns `true` (and narrows the type) if the category matches.
-*
-* @example
-* ```typescript
-* eventBus.subscribe({ category: 'addon.started' }, (event) => {
-*   if (isEvent(event, 'addon.started')) {
-*     event.data.addonId  // ✓ typed as string
-*   }
-* })
-* ```
-*/
-function isEvent(event, category) {
-	return event.category === category;
-}
-/**
-* Create a typed event with less boilerplate.
-*
-* @example
-* ```typescript
-* eventBus.emit(createEvent('addon.started', { type: 'addon', id: 'pipeline' }, {
-*   addonId: 'pipeline',
-*   packageVersion: '0.1.8',
-* }))
-* ```
-*/
-function createEvent(category, source, data) {
-	return {
-		id: typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2),
-		timestamp: /* @__PURE__ */ new Date(),
-		source,
-		category,
-		data
-	};
-}
-/**
-* Emit a `system.ready-state` event for a capability. Caller supplies a
-* per-process `generation` string — stable across a single process
-* lifetime, changes on restart — which consumer-side registries use to
-* derive a monotonic `epoch` without requiring the emitter to
-* coordinate.
-*/
-function emitReadiness(bus, params) {
-	const ts = params.ts ?? Date.now();
-	bus.emit(createEvent("system.ready-state", {
-		type: "capability",
-		id: params.capName,
-		nodeId: params.sourceNodeId
-	}, {
-		capName: params.capName,
-		scope: params.scope,
-		state: params.state,
-		generation: params.generation,
-		sourceNodeId: params.sourceNodeId,
-		ts
-	}));
-}
-//#endregion
-//#region src/addon/durable-state.ts
-/**
-* Build a {@link DurableState} over a single store key. Transport-agnostic:
-* `read`/`write` are the addon-store or device-store accessors. The whole
-* validated value round-trips on every read/write — the schema is the
-* single source of truth for what is persisted, so no hand-listed field
-* set can drop a key on save.
-*/
-function createDurableState(deps) {
-	const get = async () => {
-		const raw = (await deps.read())[deps.key];
-		if (raw === void 0) return deps.fallback;
-		const parsed = deps.schema.safeParse(raw);
-		if (!parsed.success) {
-			deps.onParseError?.(deps.key, parsed.error);
-			return deps.fallback;
-		}
-		return parsed.data;
-	};
-	const set = async (next) => {
-		const validated = deps.schema.parse(next);
-		await deps.write({ [deps.key]: validated });
-	};
-	const update = async (fn) => {
-		await set(fn(await get()));
-	};
-	return {
-		get,
-		set,
-		update
-	};
-}
-//#endregion
-//#region src/addon/base-addon.ts
-/**
-* Base class for CamStack addons. Eliminates settings boilerplate:
-*
-* - Typed `config` property with automatic resolution from store + defaults
-* - `getGlobalSettings()` / `updateGlobalSettings()` auto-implemented
-* - `getAddonSettings()` / `updateAddonSettings()` auto-implemented
-* - `getDeviceSettings()` / `updateDeviceSettings()` auto-implemented
-* - `ctx` accessor for the AddonContext (no manual `this.ctxRef` storage)
-* - `field()` helper that constrains field keys to TConfig keys
-* - `schema()` helper that validates the full schema structure
-*
-* Subclasses override:
-* - `onInitialize()` — addon-specific init logic, return ProviderRegistration[]
-* - `onShutdown()` — cleanup
-* - `globalSettingsSchema()` / `deviceSettingsSchema()` — UI schemas
-*
-* @example
-* ```ts
-* interface MyConfig {
-*   maxRetries: number
-*   endpoint: string
-* }
-*
-* export default class MyAddon extends BaseAddon<MyConfig> {
-*   constructor() {
-*     super({ maxRetries: 3, endpoint: 'http://localhost' })
-*   }
-*
-*   protected globalSettingsSchema() {
-*     return this.schema({
-*       sections: [{
-*         id: 'main', title: 'Settings',
-*         fields: [
-*           this.field({ type: 'number', key: 'maxRetries', label: 'Max Retries', default: 3 }),
-*           this.field({ type: 'text', key: 'endpoint', label: 'Endpoint' }),
-*         ],
-*       }],
-*     })
-*   }
-*
-*   protected async onInitialize(): Promise<ProviderRegistration[]> {
-*     const client = new Client(this.config.endpoint, this.config.maxRetries)
-*     return [{ capability: 'my-feature', provider: client }]
-*   }
-* }
-* ```
-*/
-var BaseAddon = class {
-	_ctx = null;
-	_config;
-	/**
-	* Per-process random id used as the `generation` stamp on every
-	* `system.ready-state` event this addon emits. Constant for the
-	* lifetime of this addon instance (== one process boot); consumer-
-	* side registries derive a monotonic `epoch` by watching for
-	* generation transitions.
-	*/
-	_readinessGeneration = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : Math.random().toString(36).slice(2, 14);
-	/** Capability names this addon registered at init — used to emit matching `down` events on shutdown. */
-	_registeredCapNames = [];
-	/** Default config values. Provided via constructor. */
-	defaults;
-	constructor(defaults) {
-		this.defaults = defaults;
-		this._config = { ...defaults };
-	}
-	/**
-	* Override to opt out of the automatic `system.ready-state` emission.
-	* Returns `true` by default — addons that don't map cleanly to the
-	* readiness protocol (e.g. pure collection providers whose readiness
-	* is already reported per-device by upstream) can override to `false`
-	* and emit manually.
-	*/
-	get autoEmitReadiness() {
-		return true;
-	}
-	/** The AddonContext, available after initialize(). */
-	get ctx() {
-		if (!this._ctx) throw new Error(`${this.constructor.name}: ctx accessed before initialize()`);
-		return this._ctx;
-	}
-	/**
-	* Non-throwing ctx accessor for code paths that can legitimately run
-	* before `initialize()` has resolved — most commonly cap handlers the
-	* hub invokes eagerly at page load (device-details aggregator pings
-	* every addon's `getDeviceSettingsContribution` as soon as the page
-	* mounts). Prefer `ctx` for the normal case; reach for this only in
-	* capability methods that may be queried before the addon is wired up.
-	*/
-	get ctxIfReady() {
-		return this._ctx;
-	}
-	/** Current resolved config (defaults merged with persisted store values). */
-	get config() {
-		return this._config;
-	}
-	async initialize(context) {
-		this._ctx = context;
-		await this.resolveConfig();
-		const result = await this.onInitialize();
-		this.emitLifecycle(EventCategory.AddonStarted);
-		const normalized = normalizeAddonInitResult(result);
-		const providers = normalized && "providers" in normalized && normalized.providers ? normalized.providers : [];
-		this._registeredCapNames = providers.map((p) => p.capability.name);
-		return normalized;
-	}
-	/**
-	* Called by the isolated-process runner AFTER `broker.start()`.
-	* In-process addons never need this because the hub broker is already
-	* running when `initialize()` fires. For forked children the broker
-	* starts AFTER `initialize()`, so the readiness emit inside initialize()
-	* fires before the broker can broadcast it. This method re-emits the
-	* ready state once the transport is live.
-	*/
-	postBrokerStart() {
-		if (this.autoEmitReadiness && this._registeredCapNames.length > 0) this.emitReadinessForProviders("ready");
-	}
-	/**
-	* Called by the isolated-process runner / agent bootstrap once the broker
-	* has started AND the hub node is connected — the moment `ctx.api.*` calls
-	* to hub-provided capabilities become safe. Wrap any bootstrap work that
-	* must query the hub (device restore, settings fetch, initial sync) in
-	* `onHubConnected()` rather than `onInitialize()` — during `initialize()`
-	* on a worker the broker is not yet connected and remote cap calls either
-	* time out or throw "Service not found".
-	*
-	* Default implementation is a no-op. Override in subclasses that need it.
-	* Never fires on hub-local in-process addons (the hub is its own node).
-	*/
-	async onHubReachable() {}
-	async shutdown() {
-		this.emitLifecycle(EventCategory.AddonStopped);
-		if (this.autoEmitReadiness) this.emitReadinessForProviders("down");
-		await this.onShutdown();
-		for (const unsub of this._subscriptions) unsub();
-		this._subscriptions = [];
-		this._ctx = null;
-	}
-	/** Addon-specific cleanup. Override if needed. */
-	async onShutdown() {}
-	/**
-	* Called after config is resolved during updateGlobalSettings/updateAddonSettings.
-	* Override to react to config changes (e.g. restart a sampler, reconnect a service).
-	* Not called during initialize() — use onInitialize() for initial setup.
-	*/
-	async onConfigChanged() {}
-	/**
-	* Create a ConfigField with `key` constrained to keys of TConfig.
-	* Provides autocomplete and compile-time validation.
-	*/
-	field(field) {
-		return field;
-	}
-	/**
-	* Create a full ConfigUISchema with typed sections.
-	* Fields created via `this.field()` get key validation automatically.
-	*/
-	schema(schema) {
-		return schema;
-	}
-	/** Override to provide global-level settings UI schema. */
-	globalSettingsSchema(_cap) {
-		return null;
-	}
-	/** Override to provide device-level settings UI schema. */
-	deviceSettingsSchema() {
-		return null;
-	}
-	async getGlobalSettings(overlay, cap) {
-		const schema = this.globalSettingsSchema(cap);
-		if (!schema) return { sections: [] };
-		const raw = await this._ctx?.settings?.readAddonStore() ?? {};
-		return hydrateSchema(schema, overlay ? {
-			...raw,
-			...overlay
-		} : raw);
-	}
-	async updateGlobalSettings(patch) {
-		await this._ctx?.settings?.writeAddonStore(patch);
-		await this.resolveConfig();
-		await this.onConfigChanged();
-		this.emitLifecycle(EventCategory.AddonUpdated, { level: "global" });
-		this.maybeAutoRestart(patch, this.globalSettingsSchema());
-	}
-	/**
-	* If any field in `patch` is marked `requiresRestart` in `schema`,
-	* schedule an addon restart for the next tick. Deferred via
-	* `setImmediate` so the tRPC mutation that triggered the write has
-	* time to return its response before the addon is torn down and
-	* re-initialised by `AddonRegistryService.restartAddon`.
-	*/
-	maybeAutoRestart(patch, schema) {
-		if (!schema) return;
-		const restartKeys = /* @__PURE__ */ new Set();
-		for (const section of schema.sections) for (const field of section.fields) {
-			if (field.type === "separator" || field.type === "info") continue;
-			if (field.requiresRestart) restartKeys.add(field.key);
-		}
-		if (restartKeys.size === 0) return;
-		if (!Object.keys(patch).some((k) => restartKeys.has(k))) return;
-		const ctx = this._ctx;
-		if (!ctx) return;
-		const addonId = ctx.id;
-		setImmediate(() => {
-			ctx.api.addons?.restartAddon?.mutate({ addonId }).then(() => {
-				ctx.logger.info("addon auto-restart triggered by restart-required setting change", { meta: { changedFields: Object.keys(patch).filter((k) => restartKeys.has(k)) } });
-			}).catch((err) => {
-				ctx.logger.error("addon auto-restart failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
-			});
-		});
-	}
-	async getDeviceSettings(deviceId) {
-		const schema = this.deviceSettingsSchema();
-		if (!schema) return { sections: [] };
-		return hydrateSchema(schema, await this._ctx?.settings?.readDeviceStore(deviceId) ?? {});
-	}
-	async updateDeviceSettings(deviceId, patch) {
-		await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
-	}
-	_subscriptions = [];
-	/**
-	* Subscribe to an event bus category. The subscription is automatically
-	* unsubscribed on shutdown — no manual cleanup needed.
-	*
-	* @example
-	* ```ts
-	* this.subscribe({ category: EventCategory.DeviceRegistered }, (event) => {
-	*   void this.handleDevice(event)
-	* })
-	* ```
-	*/
-	/**
-	* Subscribe to `system.ready-state` events for one or more capabilities.
-	* Abstracts the boilerplate type-narrowing + nodeId extraction that every
-	* resilience subscription duplicates. Cleanup is automatic (registered on
-	* `_subscriptions` like a normal `subscribe` call).
-	*/
-	watchCapability(capNames, handlers) {
-		const nameSet = new Set(Array.isArray(capNames) ? capNames : [capNames]);
-		this.subscribe({ category: "system.ready-state" }, (event) => {
-			const data = event.data;
-			if (typeof data.capName !== "string") return;
-			if (!nameSet.has(data.capName)) return;
-			if (data.scope?.type !== "node") return;
-			const nodeId = data.scope.nodeId;
-			if (typeof nodeId !== "string" || nodeId.length === 0) return;
-			const capName = data.capName;
-			if (data.state === "down") handlers.onDown?.(nodeId, capName);
-			else if (data.state === "ready") handlers.onReady?.(nodeId, capName);
-		});
-	}
-	subscribe(filter, handler) {
-		const unsub = this.ctx.eventBus.subscribe(filter, handler);
-		this._subscriptions.push(unsub);
-	}
-	emitLifecycle(category, data) {
-		try {
-			const ctx = this._ctx;
-			if (!ctx) return;
-			ctx.eventBus.emit({
-				id: `${ctx.id}-${Date.now()}`,
-				timestamp: /* @__PURE__ */ new Date(),
-				source: {
-					type: "addon",
-					id: ctx.id,
-					nodeId: ctx.kernel.localNodeId ?? "hub"
-				},
-				category,
-				data: {
-					addonId: ctx.id,
-					...data
-				}
-			});
-		} catch {}
-	}
-	/**
-	* Emit a `system.ready-state` event for every capability this addon
-	* registered at init. Scope is `{type:'node', nodeId}` — readiness is
-	* tied to the node that hosts the provider. Consumers that care about
-	* per-device readiness can subscribe with `{type:'device', ...}` if
-	* the provider emits at finer granularity (collection addons may
-	* opt-out via `autoEmitReadiness` and emit manually).
-	*/
-	emitReadinessForProviders(state) {
-		const ctx = this._ctx;
-		if (!ctx) return;
-		if (this._registeredCapNames.length === 0) return;
-		const rawNodeId = ctx.kernel?.localNodeId ?? "hub";
-		const nodeId = rawNodeId.includes("/") ? rawNodeId.split("/")[0] : rawNodeId;
-		for (const capName of this._registeredCapNames) try {
-			emitReadiness(ctx.eventBus, {
-				capName,
-				scope: {
-					type: "node",
-					nodeId
-				},
-				state,
-				generation: this._readinessGeneration,
-				sourceNodeId: nodeId
-			});
-		} catch {}
-	}
-	/**
-	* Resolve the shared models directory path via the storage capability.
-	* Falls back to `camstack-data/models` if storage is unavailable.
-	* Used by inference addons (detection-pipeline, audio-classifier, embedding-encoder).
-	*/
-	async resolveModelsDir() {
-		return this.ctx.api.storage.resolve.query({
-			location: "models",
-			relativePath: ""
-		}).catch(() => "camstack-data/models");
-	}
-	/**
-	* Access the runtime capability registry for in-process provider lookups.
-	* Returns null if the registry is not available (e.g. on agents).
-	* Used by addons that consume other capabilities directly (snapshot, stream-broker, enrichment).
-	*/
-	get capabilities() {
-		return this.ctx.capabilities ?? null;
-	}
-	/**
-	* Resolve config by merging defaults with persisted store values.
-	* Called automatically during initialize() and after every updateSettings().
-	*
-	* The merge is shallow: each key in `defaults` is checked against the store.
-	* Only keys present in defaults are read — the store can contain extra keys
-	* (e.g. from older versions) without polluting the typed config.
-	*/
-	async resolveConfig() {
-		const stored = await this.readAddonStoreWithRetry();
-		const resolved = { ...this.defaults };
-		for (const key of Object.keys(this.defaults)) {
-			const storedValue = stored[key];
-			if (storedValue !== void 0 && storedValue !== null) {
-				const defaultType = typeof this.defaults[key];
-				if (typeof storedValue === defaultType) resolved[key] = storedValue;
-			}
-		}
-		this._config = resolved;
-	}
-	/**
-	* Typed durable handle over ONE key of this addon's store. The whole
-	* Zod-validated value round-trips on every read/write — no hand-listed
-	* fields, so a field can never be silently dropped on persist. Reads use
-	* the same retry budget as config resolution; a corrupt/legacy blob logs
-	* a warning and falls back rather than crashing boot.
-	*/
-	state(key, schema, fallback) {
-		return createDurableState({
-			key,
-			schema,
-			fallback,
-			read: () => this.readAddonStoreWithRetry(),
-			write: async (patch) => {
-				await this._ctx?.settings?.writeAddonStore(patch);
-			},
-			onParseError: (k, e) => this._ctx?.logger?.warn?.(`durable-state: stored "${k}" failed validation — using fallback`, { meta: {
-				addonId: this._ctx?.id,
-				key: k,
-				error: String(e)
-			} })
-		});
-	}
-	/** Per-device variant of {@link state}, backed by the per-device store. */
-	deviceState(deviceId, key, schema, fallback) {
-		return createDurableState({
-			key,
-			schema,
-			fallback,
-			read: async () => await this._ctx?.settings?.readDeviceStore(deviceId) ?? {},
-			write: async (patch) => {
-				await this._ctx?.settings?.writeDeviceStore(deviceId, patch);
-			},
-			onParseError: (k, e) => this._ctx?.logger?.warn?.(`durable-state: stored device ${deviceId} "${k}" failed validation — using fallback`, { meta: {
-				addonId: this._ctx?.id,
-				deviceId,
-				key: k,
-				error: String(e)
-			} })
-		});
-	}
-	/**
-	* Wrap `ctx.settings.readAddonStore()` with a short retry budget so a
-	* transient settings-store outage (mid-restart of sqlite-settings, tsx-watch
-	* swap, or any race where the SqliteSettingsBackend is between shutdown and
-	* re-initialize) doesn't propagate up into `initialize()` and leave the
-	* addon permanently broken.
-	*
-	* Retry only the two known infra fingerprints. Anything else propagates so
-	* real bugs surface immediately. After the budget expires we fall back to
-	* `{}` (defaults) — the addon's first successful patch will rehydrate.
-	*/
-	async readAddonStoreWithRetry() {
-		const settings = this._ctx?.settings;
-		if (!settings) return {};
-		const delaysMs = [
-			150,
-			350,
-			600,
-			900
-		];
-		let lastErr;
-		for (let attempt = 0; attempt <= delaysMs.length; attempt++) try {
-			return await settings.readAddonStore() ?? {};
-		} catch (err) {
-			lastErr = err;
-			const msg = err instanceof Error ? err.message : String(err);
-			if (!(msg.includes("SqliteSettingsBackend not initialized") || msg.includes("provider not available"))) throw err;
-			if (attempt === delaysMs.length) break;
-			await new Promise((r) => setTimeout(r, delaysMs[attempt]));
-		}
-		this._ctx?.logger?.warn?.("readAddonStore: settings-store unavailable after retries — using defaults", { meta: { error: lastErr instanceof Error ? lastErr.message : String(lastErr) } });
-		return {};
-	}
-};
-/**
-* Normalize an `ICamstackAddon.initialize()` return value into the
-* `AddonInitResult` envelope. Arrays are wrapped into `{ providers }`;
-* envelopes pass through; void stays void.
+* Convenience accessor — the declared co-location group label, or
+* `undefined` when the addon declares no group (→ its own dedicated
+* runner). Callers that need the runner id should use `resolveRunnerId`.
+*/
+function resolveAddonGroup(decl) {
+	return resolveAddonExecution(decl).group;
+}
+/**
+* Resolve the runner id an addon belongs to. This is the single
+* authority for the hub↔runner topology:
+*   - declared `group` present → the runner id is the group name
+*     (shared with every other addon declaring the same group);
+*   - no `group` declared → the runner id is the addon id itself
+*     (its own dedicated runner — one addon, one process).
 *
-* Exported so the kernel boot path and the backend addon registry can
-* share the same normalizer instead of duplicating the shim. Addons that
-* extend `BaseAddon` already emit the envelope, so this helper is only a
-* safety net for direct `ICamstackAddon` implementations (mostly tests).
+* The runner's Moleculer nodeID is `${parentNodeId}/${runnerId}`.
 */
-function normalizeAddonInitResult(result) {
-	if (result == null) return;
-	if (Array.isArray(result)) return { providers: result };
-	return result;
+function resolveRunnerId(decl, addonId) {
+	return decl.execution?.group ?? addonId;
+}
+/** Convenience accessor — the resolved placement (defaults to `hub-only`). */
+function resolveAddonPlacement(decl) {
+	return resolveAddonExecution(decl).placement;
 }
 //#endregion
 //#region src/addon/build-addon-route-provider.ts
@@ -1655,465 +322,90 @@ var TIMEZONES = [
 		dst: US_DST
 	},
 	{
-		id: "America/Chicago",
-		label: "America/Chicago (UTC−6 / CDT)",
-		region: "Americas",
-		stdOffsetMinutes: -360,
-		dst: US_DST
-	},
-	{
-		id: "America/Denver",
-		label: "America/Denver (UTC−7 / MDT)",
-		region: "Americas",
-		stdOffsetMinutes: -420,
-		dst: US_DST
-	},
-	{
-		id: "America/Los_Angeles",
-		label: "America/Los Angeles (UTC−8 / PDT)",
-		region: "Americas",
-		stdOffsetMinutes: -480,
-		dst: US_DST
-	},
-	{
-		id: "America/Sao_Paulo",
-		label: "America/Sao Paulo (UTC−3)",
-		region: "Americas",
-		stdOffsetMinutes: -180,
-		dst: null
-	},
-	{
-		id: "Asia/Dubai",
-		label: "Asia/Dubai (UTC+4)",
-		region: "Asia",
-		stdOffsetMinutes: 240,
-		dst: null
-	},
-	{
-		id: "Asia/Kolkata",
-		label: "Asia/Kolkata (UTC+5:30)",
-		region: "Asia",
-		stdOffsetMinutes: 330,
-		dst: null
-	},
-	{
-		id: "Asia/Singapore",
-		label: "Asia/Singapore (UTC+8)",
-		region: "Asia",
-		stdOffsetMinutes: 480,
-		dst: null
-	},
-	{
-		id: "Asia/Shanghai",
-		label: "Asia/Shanghai (UTC+8)",
-		region: "Asia",
-		stdOffsetMinutes: 480,
-		dst: null
-	},
-	{
-		id: "Asia/Tokyo",
-		label: "Asia/Tokyo (UTC+9)",
-		region: "Asia",
-		stdOffsetMinutes: 540,
-		dst: null
-	},
-	{
-		id: "Australia/Sydney",
-		label: "Australia/Sydney (UTC+10 / AEDT)",
-		region: "Oceania",
-		stdOffsetMinutes: 600,
-		dst: {
-			offsetHours: 1,
-			startMonth: 10,
-			startWeekIndex: 1,
-			startWeekday: "Sunday",
-			startHour: 2,
-			endMonth: 4,
-			endWeekIndex: 1,
-			endWeekday: "Sunday",
-			endHour: 3
-		}
-	}
-];
-/** Resolve an IANA id to its `Timezone`, or `undefined` if unknown. */
-function findTimezone(id) {
-	return TIMEZONES.find((tz) => tz.id === id);
-}
-//#endregion
-//#region src/capabilities/schemas/streaming-shared.ts
-/** Shared Zod schemas used across streaming capabilities. */
-var CamProfileSchema = z.enum([
-	"high",
-	"mid",
-	"low"
-]);
-/** Canonical ordering. Hard-coded; never sorted. */
-var CAM_PROFILE_ORDER = [
-	"high",
-	"mid",
-	"low"
-];
-var CamStreamKindSchema = z.enum([
-	"pull-rtsp",
-	"pull-rtmp",
-	"pull-http",
-	"pull-rfc4571",
-	"push-annexb",
-	"derived"
-]);
-var CamStreamResolutionSchema = z.object({
-	width: z.number().int().positive(),
-	height: z.number().int().positive()
-});
-var CameraStreamSchema = z.object({
-	/** Stable, provider-assigned id unique within the (deviceId) scope. */
-	camStreamId: z.string().min(1),
-	deviceId: z.number().int().nonnegative(),
-	kind: CamStreamKindSchema,
-	/** Required for pull-* kinds. Ignored for push-annexb. */
-	url: z.string().optional(),
-	codec: z.string().optional(),
-	resolution: CamStreamResolutionSchema.optional(),
-	fps: z.number().positive().optional(),
-	/** Human label surfaced in the Admin UI "Camera Stream" dropdown. */
-	label: z.string().optional(),
-	/**
-	* Device-level features the publisher advertised (e.g. `battery-operated`).
-	* The broker, snapshot orchestrator, and prebuffer manager all consult
-	* this list to derive policy — relaxed stall watchdog for battery
-	* cams, prebuffer off by default, longer snapshot rate-limit, etc.
-	*
-	* Single source of truth replacing per-stream flags like the
-	* historical `allowStall`: if the publisher knows the camera is
-	* battery-powered, every downstream service derives the right policy
-	* from this list.
-	*/
-	deviceFeatures: z.array(z.string()).optional(),
-	/**
-	* Whether this stream participates in the broker's automatic profile
-	* assignment (`computeInitialAssignment`). Defaults to `true`. Publishers
-	* use `false` when they want a stream to be SELECTABLE in the UI but not
-	* picked by default — e.g. Reolink publishes its native Baichuan streams
-	* as `autoEligible: true` (the recommended path) and its RTSP / RTMP
-	* mirrors as `autoEligible: false` (still pickable per slot, just not
-	* the auto choice). Manual `assignProfile` calls remain valid for
-	* non-eligible streams.
-	*/
-	autoEligible: z.boolean().optional(),
-	/**
-	* Transport-specific opaque metadata. The broker passes it through to
-	* the source reader without inspecting it. Currently used by
-	* `pull-rfc4571` streams to carry the upstream SDP (so the reader can
-	* route RTP packets to the right depacketizer without an in-band
-	* DESCRIBE phase). Other kinds typically leave it undefined.
-	*/
-	metadata: z.record(z.string(), z.unknown()).optional()
-});
-var ProfileSlotStatusSchema = z.enum([
-	"unassigned",
-	"idle",
-	"connecting",
-	"streaming",
-	"error"
-]);
-var ProfileSlotSchema = z.object({
-	deviceId: z.number().int().nonnegative(),
-	profile: CamProfileSchema,
-	/** Broker id the rest of the system addresses: `${deviceId}/${profile}`. */
-	brokerId: z.string(),
-	/** `null` when the profile is unassigned. */
-	sourceCamStreamId: z.string().nullable(),
-	status: ProfileSlotStatusSchema,
-	resolution: CamStreamResolutionSchema.optional(),
-	codec: z.string().optional(),
-	preBufferSec: z.number().nonnegative().optional(),
-	errorMessage: z.string().optional()
-});
-/** The canonical consumer-facing broker id for a device profile. */
-function makeProfileBrokerId(deviceId, profile) {
-	return `${deviceId}/${profile}`;
-}
-/**
-* The broker id keying a physical SOURCE stream: `${deviceId}/${camStreamId}`.
-* This is the broker's internal source key (`brokerIdFor` in the manager) — a
-* `camStreamId` like `native:main` — as opposed to the public profile alias
-* {@link makeProfileBrokerId}. Used to resolve a source's restream endpoint
-* (e.g. routing a transcode's ffmpeg input through the broker so it rides the
-* single source dial instead of opening a second camera connection).
-*/
-function makeSourceBrokerId(deviceId, camStreamId) {
-	return `${deviceId}/${camStreamId}`;
-}
-/**
-* Inverse of {@link makeProfileBrokerId}. Returns `null` when the string is
-* not a canonical `${deviceId}/${profile}` id — e.g. a broker-internal
-* cam-stream id (`5/native:main`), a derived/adaptive ref, or a malformed
-* value. So a caller can safely distinguish "addresses a public profile"
-* from "addresses something broker-internal".
-*/
-function parseProfileBrokerId(brokerId) {
-	const slash = brokerId.indexOf("/");
-	if (slash <= 0) return null;
-	const idPart = brokerId.slice(0, slash);
-	const profilePart = brokerId.slice(slash + 1);
-	if (!/^\d+$/.test(idPart)) return null;
-	const parsed = CamProfileSchema.safeParse(profilePart);
-	if (!parsed.success) return null;
-	return {
-		deviceId: Number(idPart),
-		profile: parsed.data
-	};
-}
-/**
-* The profile slots worth consuming/recording: ASSIGNED only
-* (`sourceCamStreamId != null`), DEDUPED by physical source so the same
-* camera encoder is never subscribed/recorded twice, ordered high→mid→low.
-* Optionally scoped to one `deviceId`. Pure; never mutates the input.
-*
-* Recording `main` and `mid` when both point at the same `sourceCamStreamId`
-* would dial the camera's internal stream twice for no benefit — this is the
-* dedup that prevents that.
-*/
-function selectAssignedProfileSlots(slots, deviceId) {
-	const ordered = [...slots].filter((s) => deviceId === void 0 || s.deviceId === deviceId).toSorted((a, b) => CAM_PROFILE_ORDER.indexOf(a.profile) - CAM_PROFILE_ORDER.indexOf(b.profile));
-	const seenSources = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const s of ordered) {
-		const src = s.sourceCamStreamId;
-		if (src === null) continue;
-		if (seenSources.has(src)) continue;
-		seenSources.add(src);
-		out.push(s);
-	}
-	return out;
-}
-/**
-* Zod schema for StreamSourceEntry — the canonical stream descriptor
-* exposed by ICameraDevice.getStreamSources() and consumed by the broker.
-*/
-var StreamSourceEntrySchema = z.object({
-	id: z.string(),
-	label: z.string(),
-	protocol: z.enum([
-		"rtsp",
-		"rtmp",
-		"annexb",
-		"http-mjpeg",
-		"webrtc",
-		"custom"
-	]),
-	url: z.string().optional(),
-	resolution: z.object({
-		width: z.number(),
-		height: z.number()
-	}).readonly().optional(),
-	fps: z.number().optional(),
-	bitrate: z.number().optional(),
-	codec: z.string().optional(),
-	profileHint: CamProfileSchema.optional()
-});
-var StreamSourceSchema = z.object({
-	type: z.string(),
-	url: z.string(),
-	videoCodec: z.string().optional(),
-	audioCodec: z.string().optional(),
-	metadata: z.record(z.string(), z.unknown()).readonly().optional()
-});
-var EncodedPacketSchema = z.object({
-	type: z.enum(["video", "audio"]),
-	data: z.instanceof(Uint8Array),
-	pts: z.number(),
-	dts: z.number(),
-	keyframe: z.boolean(),
-	codec: z.string()
-});
-var DecodedFrameSchema = z.object({
-	data: z.instanceof(Uint8Array),
-	width: z.number(),
-	height: z.number(),
-	format: z.enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]),
-	timestamp: z.number()
-});
-/**
-* Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
-* frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
-* interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
-* method (`pullHandles`) can carry handles over tRPC / Moleculer.
-*
-* The `satisfies` assertion below pins this schema to the interface: if a
-* field is added to / removed from `FrameHandle` without a matching schema
-* edit, `z.infer<typeof FrameHandleSchema>` stops being assignable to
-* `FrameHandle` and the build fails — no silent drift.
-*/
-var FrameHandleSchema = z.object({
-	shmId: z.string(),
-	slot: z.number().int().nonnegative(),
-	seq: z.number().int().nonnegative(),
-	width: z.number().int().positive(),
-	height: z.number().int().positive(),
-	format: z.enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]),
-	pts: z.number(),
-	byteLength: z.number().int().nonnegative(),
-	nodeId: z.string(),
-	slotCount: z.number().int().positive()
-});
-/**
-* Pixel format a frame-handle subscriber can request from the broker
-* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
-* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
-* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
-* payload, and no decoded-frame consumer requests it over the shm plane.
-*/
-var FrameHandleFormatSchema = z.enum([
-	"rgb",
-	"bgr",
-	"yuv420",
-	"gray"
-]);
-/**
-* Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
-* broker for a `FrameHandle` stream of one `format`; the broker maintains one
-* shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
-* subscriber (motion) and an `rgb` subscriber (detection) each read the format
-* they asked for with no broker-side conversion.
-*/
-var SubscribeFramesInputSchema = z.object({
-	brokerId: z.string(),
-	format: FrameHandleFormatSchema,
-	/**
-	* Optional reader-side cadence hint in frames per second. The broker does
-	* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
-	* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
-	* the consumer can pace its own `pullFrameHandles` polling.
-	*/
-	maxFps: z.number().positive().optional(),
-	/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
-	tag: z.string().optional()
-});
-/**
-* Result of `stream-broker.subscribeFrames`. The consumer then polls
-* `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
-* `FrameHandle` to a `FrameRingReader`.
-*/
-var SubscribeFramesResultSchema = z.object({
-	/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
-	subscriptionId: z.string(),
-	/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
-	maxFps: z.number().nonnegative()
-});
-/**
-* Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
-* `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
-* sample bytes plus the track parameters a consumer needs to interpret them.
-*
-* Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
-* Float32 PCM), so unlike video frames they ship their bytes INLINE over
-* tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
-* (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
-* / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
-*/
-var DecodedAudioChunkSchema = z.object({
-	data: z.instanceof(Uint8Array),
-	sampleRate: z.number().int().positive(),
-	channels: z.number().int().positive(),
-	timestamp: z.number()
-});
-/**
-* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
-* handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
-* asks the broker for the decoded audio-chunk stream of one broker; the
-* broker keeps a per-subscription bounded FIFO queue the consumer drains via
-* `pullAudioChunks`.
-*/
-var SubscribeAudioChunksInputSchema = z.object({
-	brokerId: z.string(),
-	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
-	tag: z.string().optional()
-});
-/** Result of `stream-broker.subscribeAudioChunks`. */
-var SubscribeAudioChunksResultSchema = z.object({ 
-/** Opaque id passed to `pullAudioChunks` / `unsubscribeAudioChunks`. */
-subscriptionId: z.string() });
-var BrokerStatusSchema = z.enum([
-	"idle",
-	"connecting",
-	"streaming",
-	"error",
-	"stopped"
-]);
-var BrokerStatsSchema = z.object({
-	status: BrokerStatusSchema,
-	inputFps: z.number(),
-	decodeFps: z.number(),
-	encodedSubscribers: z.number(),
-	decodedSubscribers: z.number(),
-	uptimeMs: z.number(),
-	bitrateKbps: z.number(),
-	idrIntervalMs: z.number(),
-	codec: z.string().optional(),
-	totalBytes: z.number(),
-	packetCount: z.number(),
-	rtspClients: z.number(),
-	pipeClients: z.number(),
-	preBufferSec: z.number(),
-	preBufferMs: z.number(),
-	preBufferPackets: z.number(),
-	/**
-	* Moleculer node id of the decoder provider currently servicing this
-	* stream's decoded subscribers. `null` until the deferred decoder is
-	* created (no decoded clients yet, or codec not detected). Surfaces the
-	* runtime decoder placement so the UI can show "Decoder: <agent>" without
-	* a separate cap call per broker.
-	*/
-	decoderNodeId: z.string().nullable(),
-	/**
-	* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
-	* when the stream has no audio track or the broker is in cold start.
-	* `supported = false` means the codec was detected but the local
-	* decoder pipeline cannot produce PCM chunks (e.g. AAC without the
-	* AAC pipeline wired). Surfaced in the UI device-overview so operators
-	* can pre-pick the audio-analysis model that matches the codec.
-	*/
-	audio: z.object({
-		codec: z.string(),
-		sampleRate: z.number(),
-		channels: z.number(),
-		supported: z.boolean()
-	}).nullable().optional()
-});
-/**
-* Exporter-facing "profile restream" entry. Returned by
-* `cameraStreams.getProfileRtspEntries` — one per ASSIGNED profile slot
-* (high/mid/low). `brokerId` is the PROFILE-keyed broker id
-* (`${deviceId}/${profile}`, e.g. `15/high`); its `url` is a broker
-* RTSP restream that aliases the profile's assigned source broker, so
-* every consumer dialling a profile converges on the same single pull.
-* `codec`/`resolution` describe the assigned SOURCE camStream (for the
-* `auto` resolution-closest pick). Distinct from `RtspRestreamEntry`
-* (raw per-camStream, live-view only).
-*/
-var ProfileRtspEntrySchema = z.object({
-	profile: CamProfileSchema,
-	/** Profile-keyed broker id, format `${deviceId}/${profile}` (e.g. `"15/high"`). */
-	brokerId: z.string(),
-	url: z.string(),
-	mutedUrl: z.string(),
-	enabled: z.boolean(),
-	codec: z.string().optional(),
-	resolution: CamStreamResolutionSchema.optional()
-});
+		id: "America/Chicago",
+		label: "America/Chicago (UTC−6 / CDT)",
+		region: "Americas",
+		stdOffsetMinutes: -360,
+		dst: US_DST
+	},
+	{
+		id: "America/Denver",
+		label: "America/Denver (UTC−7 / MDT)",
+		region: "Americas",
+		stdOffsetMinutes: -420,
+		dst: US_DST
+	},
+	{
+		id: "America/Los_Angeles",
+		label: "America/Los Angeles (UTC−8 / PDT)",
+		region: "Americas",
+		stdOffsetMinutes: -480,
+		dst: US_DST
+	},
+	{
+		id: "America/Sao_Paulo",
+		label: "America/Sao Paulo (UTC−3)",
+		region: "Americas",
+		stdOffsetMinutes: -180,
+		dst: null
+	},
+	{
+		id: "Asia/Dubai",
+		label: "Asia/Dubai (UTC+4)",
+		region: "Asia",
+		stdOffsetMinutes: 240,
+		dst: null
+	},
+	{
+		id: "Asia/Kolkata",
+		label: "Asia/Kolkata (UTC+5:30)",
+		region: "Asia",
+		stdOffsetMinutes: 330,
+		dst: null
+	},
+	{
+		id: "Asia/Singapore",
+		label: "Asia/Singapore (UTC+8)",
+		region: "Asia",
+		stdOffsetMinutes: 480,
+		dst: null
+	},
+	{
+		id: "Asia/Shanghai",
+		label: "Asia/Shanghai (UTC+8)",
+		region: "Asia",
+		stdOffsetMinutes: 480,
+		dst: null
+	},
+	{
+		id: "Asia/Tokyo",
+		label: "Asia/Tokyo (UTC+9)",
+		region: "Asia",
+		stdOffsetMinutes: 540,
+		dst: null
+	},
+	{
+		id: "Australia/Sydney",
+		label: "Australia/Sydney (UTC+10 / AEDT)",
+		region: "Oceania",
+		stdOffsetMinutes: 600,
+		dst: {
+			offsetHours: 1,
+			startMonth: 10,
+			startWeekIndex: 1,
+			startWeekday: "Sunday",
+			startHour: 2,
+			endMonth: 4,
+			endWeekIndex: 1,
+			endWeekday: "Sunday",
+			endHour: 3
+		}
+	}
+];
+/** Resolve an IANA id to its `Timezone`, or `undefined` if unknown. */
+function findTimezone(id) {
+	return TIMEZONES.find((tz) => tz.id === id);
+}
 //#endregion
 //#region src/interfaces/recording-config.ts
 /**
@@ -2306,375 +598,6 @@ function migrateConfigToBands(config) {
 	return schedules.map((schedule) => bandFromSchedule(schedule, bandMode, config));
 }
 //#endregion
-//#region src/readiness/readiness-registry.ts
-var ReadinessTimeoutError = class extends Error {
-	capName;
-	scope;
-	waitedMs;
-	constructor(capName, scope, waitedMs) {
-		super(`Timed out waiting for ${capName} (${scopeKey(scope)}) to become ready after ${waitedMs}ms`);
-		this.name = "ReadinessTimeoutError";
-		this.capName = capName;
-		this.scope = scope;
-		this.waitedMs = waitedMs;
-	}
-};
-/**
-* Build a canonical string key for a `(capName, scope)` pair. Used as
-* the snapshot map key and for log/debug output.
-*/
-function readinessKey(capName, scope) {
-	return `${capName}|${scopeKey(scope)}`;
-}
-function scopeKey(scope) {
-	switch (scope.type) {
-		case "global": return "global";
-		case "node": return `node:${scope.nodeId}`;
-		case "device": return `device:${scope.deviceId}`;
-	}
-}
-function scopesEqual(a, b) {
-	if (a.type !== b.type) return false;
-	if (a.type === "global" || b.type === "global") return true;
-	if (a.type === "node" && b.type === "node") return a.nodeId === b.nodeId;
-	if (a.type === "device" && b.type === "device") return a.deviceId === b.deviceId;
-	return false;
-}
-var ReadinessRegistry = class {
-	bus;
-	sourceNodeId;
-	logger;
-	now;
-	generation;
-	snapshot = /* @__PURE__ */ new Map();
-	subscriptions = /* @__PURE__ */ new Set();
-	unsubscribeBus;
-	unsubscribeAgentOffline;
-	constructor(options) {
-		this.bus = options.eventBus;
-		this.sourceNodeId = options.sourceNodeId;
-		this.logger = options.logger;
-		this.now = options.now ?? (() => Date.now());
-		this.generation = options.generation ?? randomGeneration();
-		this.unsubscribeBus = this.bus.subscribe({ category: "system.ready-state" }, (event) => this.ingest(event.data));
-		this.unsubscribeAgentOffline = this.bus.subscribe({ category: "agent.offline" }, (event) => this.synthesizeDownForNode(event.data.agentId));
-		if (typeof this.bus.getRecent === "function") try {
-			const recent = this.bus.getRecent({ category: "system.ready-state" });
-			for (const event of recent) this.ingest(event.data);
-		} catch {}
-	}
-	/** Release the event-bus subscription. Idempotent. */
-	close() {
-		this.unsubscribeBus();
-		this.unsubscribeAgentOffline();
-		this.subscriptions.clear();
-	}
-	/** Current snapshot for a `(capName, scope)` pair, or `null` if never seen. */
-	get(capName, scope) {
-		return this.snapshot.get(readinessKey(capName, scope)) ?? null;
-	}
-	/**
-	* Serializable snapshot for cross-process transport. Returns an array
-	* of `ReadinessRecord` plain objects — safe for MsgPack / JSON
-	* transport. Used by the hub's `$readiness.getSnapshot` Moleculer
-	* action; consumers hydrate their local registry from the result.
-	*/
-	getSnapshotForTransport() {
-		return Array.from(this.snapshot.values());
-	}
-	/**
-	* Hydrate the snapshot from an authoritative source. Entries already
-	* present locally are skipped — live deltas (received via the event
-	* bus subscription) always take precedence over the snapshot. For
-	* each newly hydrated entry, a one-shot transition is dispatched to
-	* matching subscriptions so pending `awaitReady` callers unblock
-	* without having to wait for a fresh event.
-	*
-	* Local `epoch` is reset to 1 per entry — consumer-side epoch is
-	* derived from observed generation transitions, so this mirrors the
-	* value that would have been assigned had the consumer observed the
-	* first `ready` event directly.
-	*/
-	hydrate(records) {
-		const now = this.now();
-		for (const record of records) {
-			const key = readinessKey(record.capName, record.scope);
-			if (this.snapshot.has(key)) continue;
-			const hydrated = {
-				capName: record.capName,
-				scope: record.scope,
-				state: record.state,
-				generation: record.generation,
-				epoch: 1,
-				lastChange: now,
-				sourceNodeId: record.sourceNodeId
-			};
-			this.snapshot.set(key, hydrated);
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → ${record.state} (hydrated, gen=${record.generation.slice(0, 6)})`);
-			const transition = {
-				capName: record.capName,
-				scope: record.scope,
-				state: record.state,
-				epoch: 1,
-				generation: record.generation,
-				sourceNodeId: "hydrated",
-				ts: now,
-				durationInPrevState: 0
-			};
-			for (const sub of this.subscriptions) {
-				if (sub.capName !== record.capName) continue;
-				if (!scopesEqual(sub.scope, record.scope)) continue;
-				try {
-					sub.handler(transition);
-				} catch (err) {
-					this.logger?.warn(`readiness hydrate handler threw for ${record.capName}: ${err.message ?? String(err)}`);
-				}
-			}
-		}
-	}
-	/** Shallow copy of the full snapshot — mainly for diagnostics/tests. */
-	getAll() {
-		return new Map(this.snapshot);
-	}
-	/**
-	* Emit a `ready` transition for a locally-owned capability. The
-	* payload carries this registry's `generation` so remote registries
-	* can derive their own `epoch`.
-	*/
-	emitReady(capName, scope) {
-		this.emitTransition(capName, scope, "ready");
-	}
-	emitStarting(capName, scope) {
-		this.emitTransition(capName, scope, "starting");
-	}
-	emitDown(capName, scope) {
-		this.emitTransition(capName, scope, "down");
-	}
-	/**
-	* One-shot: resolve once the cap is `ready`. Reads the snapshot
-	* first — if already ready, resolves synchronously on the next tick.
-	*
-	* Default behaviour is **wait indefinitely** (timeoutMs = `Infinity`):
-	* the orchestrator and other callers never want to attach a camera
-	* with empty steps just because a cap took longer than 30s to come
-	* up. Pass an explicit finite `timeoutMs` to bound the wait, or an
-	* `AbortSignal` to cancel externally. `Infinity` is honoured natively
-	* — no `setTimeout` is registered (Node's setTimeout silently clamps
-	* values above ~24.8d, so we must skip the timer entirely).
-	*/
-	awaitReady(capName, scope, opts = {}) {
-		const timeoutMs = opts.timeoutMs ?? Number.POSITIVE_INFINITY;
-		const start = this.now();
-		if (this.get(capName, scope)?.state === "ready") return Promise.resolve();
-		if (opts.signal?.aborted) return Promise.reject(opts.signal.reason ?? /* @__PURE__ */ new Error("aborted"));
-		return new Promise((resolve, reject) => {
-			let settled = false;
-			const unsubscribe = this.onReadyState(capName, scope, (t) => {
-				if (t.state !== "ready") return;
-				if (settled) return;
-				settled = true;
-				cleanup();
-				resolve();
-			});
-			const timer = !Number.isFinite(timeoutMs) ? null : setTimeout(() => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				reject(new ReadinessTimeoutError(capName, scope, this.now() - start));
-			}, timeoutMs);
-			const pendingLogTimer = setInterval(() => {
-				if (settled) return;
-				this.logger?.warn(`readiness: still awaiting ${capName} (${scopeKey(scope)}) after ${this.now() - start}ms`);
-			}, 3e4);
-			if (typeof pendingLogTimer.unref === "function") pendingLogTimer.unref();
-			const onAbort = () => {
-				if (settled) return;
-				settled = true;
-				cleanup();
-				reject(opts.signal?.reason ?? /* @__PURE__ */ new Error("aborted"));
-			};
-			opts.signal?.addEventListener("abort", onAbort, { once: true });
-			function cleanup() {
-				unsubscribe();
-				if (timer !== null) clearTimeout(timer);
-				clearInterval(pendingLogTimer);
-				opts.signal?.removeEventListener("abort", onAbort);
-			}
-		});
-	}
-	/**
-	* Observable: every transition (starting/ready/down) dispatches to
-	* `handler`. On subscription, if the snapshot has a current state,
-	* the handler fires ONCE asynchronously with that state as the
-	* initial transition (duration = 0) so late subscribers can pick up
-	* current state without racing the next transition.
-	*
-	* Returns an unsubscribe function.
-	*/
-	onReadyState(capName, scope, handler) {
-		const sub = {
-			capName,
-			scope,
-			handler
-		};
-		this.subscriptions.add(sub);
-		const current = this.get(capName, scope);
-		if (current !== null) queueMicrotask(() => {
-			if (!this.subscriptions.has(sub)) return;
-			handler({
-				capName,
-				scope,
-				state: current.state,
-				epoch: current.epoch,
-				generation: current.generation,
-				sourceNodeId: this.sourceNodeId,
-				ts: current.lastChange,
-				durationInPrevState: 0
-			});
-		});
-		return () => {
-			this.subscriptions.delete(sub);
-		};
-	}
-	emitTransition(capName, scope, state) {
-		const ts = this.now();
-		this.bus.emit(createEvent("system.ready-state", {
-			type: "capability",
-			id: capName,
-			nodeId: this.sourceNodeId
-		}, {
-			capName,
-			scope,
-			state,
-			generation: this.generation,
-			sourceNodeId: this.sourceNodeId,
-			ts
-		}));
-	}
-	/**
-	* Update snapshot + dispatch to subscribers. Idempotent: same
-	* `generation + state` replay is a no-op for both snapshot and
-	* subscribers.
-	*
-	* Defensive against malformed payloads (legal reason: a mock bus's
-	* `getRecent` may ignore the category filter and replay unrelated
-	* events when we hydrate at construction time).
-	*/
-	ingest(payload) {
-		if (typeof payload?.capName !== "string") return;
-		if (payload.state !== "ready" && payload.state !== "starting" && payload.state !== "down") return;
-		if (typeof payload.generation !== "string") return;
-		if (payload.scope?.type !== "global" && payload.scope?.type !== "node" && payload.scope?.type !== "device") return;
-		const key = readinessKey(payload.capName, payload.scope);
-		const prev = this.snapshot.get(key) ?? null;
-		const now = this.now();
-		let epoch;
-		if (prev === null) epoch = payload.state === "ready" ? 1 : 0;
-		else if (prev.generation !== payload.generation && payload.state === "ready") epoch = prev.epoch + 1;
-		else epoch = prev.epoch;
-		if (prev !== null && prev.generation === payload.generation && prev.state === payload.state) return;
-		const durationInPrevState = prev === null ? 0 : Math.max(0, now - prev.lastChange);
-		const next = {
-			capName: payload.capName,
-			scope: payload.scope,
-			state: payload.state,
-			generation: payload.generation,
-			epoch,
-			lastChange: now,
-			sourceNodeId: payload.sourceNodeId
-		};
-		this.snapshot.set(key, next);
-		const transition = {
-			capName: payload.capName,
-			scope: payload.scope,
-			state: payload.state,
-			epoch,
-			generation: payload.generation,
-			sourceNodeId: payload.sourceNodeId,
-			ts: payload.ts,
-			durationInPrevState
-		};
-		if (this.logger) this.logger.debug(`readiness: ${payload.capName} (${scopeKey(payload.scope)}) → ${payload.state} epoch=${epoch} gen=${payload.generation.slice(0, 6)} (prev ${durationInPrevState}ms)`);
-		for (const sub of this.subscriptions) {
-			if (sub.capName !== payload.capName) continue;
-			if (!scopesEqual(sub.scope, payload.scope)) continue;
-			try {
-				sub.handler(transition);
-			} catch (err) {
-				this.logger?.warn(`readiness handler threw for ${payload.capName}: ${err.message ?? String(err)}`);
-			}
-		}
-	}
-	/**
-	* `agent.offline` demux. When an agent disconnects ungracefully,
-	* its BaseAddon's shutdown hook doesn't fire — consumers would
-	* otherwise keep waiting on a stale `ready`. Walk the snapshot and
-	* synthesize a `down` transition for every node-scoped record bound
-	* to the disconnected `nodeId`, skipping records already `down`.
-	*
-	* Synthesis is LOCAL: we don't re-emit on the bus. Every registry
-	* (one per process) receives the same `agent.offline` and reacts
-	* independently, which means no duplicated downs and no central
-	* supervisor required.
-	*/
-	synthesizeDownForNode(offlineNodeId) {
-		const now = this.now();
-		for (const [key, record] of this.snapshot) {
-			if (record.state === "down") continue;
-			if (!(record.scope.type === "node" && record.scope.nodeId === offlineNodeId || record.scope.type === "device" && record.sourceNodeId === offlineNodeId)) continue;
-			const durationInPrevState = Math.max(0, now - record.lastChange);
-			const next = {
-				...record,
-				state: "down",
-				lastChange: now
-			};
-			this.snapshot.set(key, next);
-			const transition = {
-				capName: record.capName,
-				scope: record.scope,
-				state: "down",
-				epoch: record.epoch,
-				generation: record.generation,
-				sourceNodeId: this.sourceNodeId,
-				ts: now,
-				durationInPrevState
-			};
-			if (this.logger) this.logger.debug(`readiness: ${record.capName} (${scopeKey(record.scope)}) → down (synthesized from agent.offline ${offlineNodeId})`);
-			for (const sub of this.subscriptions) {
-				if (sub.capName !== record.capName) continue;
-				if (!scopesEqual(sub.scope, record.scope)) continue;
-				try {
-					sub.handler(transition);
-				} catch (err) {
-					this.logger?.warn(`readiness handler threw during agent.offline demux for ${record.capName}: ${err.message ?? String(err)}`);
-				}
-			}
-		}
-	}
-};
-function randomGeneration() {
-	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
-	return Math.random().toString(36).slice(2, 14);
-}
-/**
-* Given a list of `(capName, scope)` pairs that a just-disconnected
-* node owned, emit a `down` transition for each. Callers (kernel
-* supervisor, hub `$node.disconnected` handler) wire this up once they
-* know which caps the node held.
-*/
-function emitDownForOwnedCaps(registry, owned) {
-	for (const { capName, scope } of owned) registry.emitDown(capName, scope);
-}
-//#endregion
-//#region src/interfaces/addon-data-plane.ts
-/**
-* Per-listener shared-secret header the hub injects on every reverse-proxied
-* data-plane request and the addon's framework wrapper validates — so only the
-* hub can reach the addon's `127.0.0.1` listener. Defined here (shared by the
-* core proxy and the kernel listener) to keep both off a kernel↔core import.
-*/
-var DATAPLANE_SECRET_HEADER = "x-camstack-dataplane-secret";
-//#endregion
 //#region src/interfaces/storage-location.ts
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -3212,66 +1135,6 @@ var RUNTIME_DEFAULTS = {
 	"auth.tokenExpiry": "24h"
 };
 //#endregion
-//#region src/utils/json-safe.ts
-/**
-* Type-safe JSON parsing helpers.
-*
-* `JSON.parse` is typed as `any` in lib.es5.d.ts, which triggers
-* `no-unsafe-*` ESLint rules and destroys downstream inference. These
-* wrappers return `unknown` — callers narrow structurally via type
-* guards, `typeof` checks, or helpers like `asRecord`/`asString`.
-*/
-/**
-* Parse JSON and return it as `unknown` — the only entry point for untrusted JSON.
-*
-* The optional generic overload `parseJsonUnknown<T>(text)` returns `T` for
-* call sites that know the shape at parse time (e.g. MQTT payloads with a
-* known protocol schema). This is a **type-level bridge only** — no runtime
-* validation is performed. Callers that need runtime validation should parse
-* as `unknown` and narrow via Zod or structural guards.
-*/
-function parseJsonUnknown(text) {
-	return JSON.parse(text);
-}
-/** Narrow an unknown value to a plain `Record<string, unknown>` or return null. */
-function asJsonObject(value) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
-	return { ...value };
-}
-/** Narrow an unknown value to a `readonly unknown[]` or return an empty array. */
-function asJsonArray(value) {
-	return Array.isArray(value) ? value : [];
-}
-/** Safe string extraction from an unknown record field. */
-function asString(value, fallback = "") {
-	return typeof value === "string" ? value : fallback;
-}
-/** Safe number extraction from an unknown record field. */
-function asNumber(value, fallback = 0) {
-	return typeof value === "number" ? value : fallback;
-}
-/** Safe boolean extraction from an unknown record field. */
-function asBoolean(value, fallback = false) {
-	return typeof value === "boolean" ? value : fallback;
-}
-/** Parse JSON + narrow to object in one step. */
-function parseJsonObject(text) {
-	try {
-		return asJsonObject(parseJsonUnknown(text));
-	} catch {
-		return null;
-	}
-}
-/** Parse JSON + narrow to array in one step. */
-function parseJsonArray(text) {
-	try {
-		const parsed = parseJsonUnknown(text);
-		return Array.isArray(parsed) ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-//#endregion
 //#region src/utils/hf-url.ts
 function hfModelUrl(repo, path) {
 	return `https://huggingface.co/${repo}/resolve/main/${path}`;
@@ -3518,18 +1381,6 @@ function requiresPython(runtime) {
 	return runtime === "coreml" || runtime === "pytorch" || runtime === "openvino";
 }
 //#endregion
-//#region src/utils/err-msg.ts
-/**
-import { errMsg } from '@camstack/types'
-* Extract a human-readable message from an unknown error value.
-* Replaces the ubiquitous `errMsg(err)` pattern.
-*/
-function errMsg(err) {
-	if (err instanceof Error) return err.message;
-	if (typeof err === "string") return err;
-	return String(err);
-}
-//#endregion
 //#region src/utils/run-inference-step.ts
 /**
 * Execute an inference function with timing and error capture.
@@ -4344,290 +2195,6 @@ var DEVICE_TYPE_INFO = { ["camera"]: {
 	icon: "camera"
 } };
 //#endregion
-//#region src/device/device-type.ts
-var DeviceType = /* @__PURE__ */ function(DeviceType) {
-	DeviceType["Camera"] = "camera";
-	DeviceType["Hub"] = "hub";
-	DeviceType["Light"] = "light";
-	DeviceType["Siren"] = "siren";
-	DeviceType["Switch"] = "switch";
-	DeviceType["Sensor"] = "sensor";
-	DeviceType["Thermostat"] = "thermostat";
-	DeviceType["Button"] = "button";
-	/** Generic stateless event emitter — carries a device's EXACT declared
-	*  event vocabulary verbatim (no normalization). Installed with the
-	*  `event-emitter` cap. Sources: HA `event.*` entities (structured) and
-	*  HA bus events (e.g. `zha_event`, generic). */
-	DeviceType["EventEmitter"] = "event-emitter";
-	/** Firmware/software update entity — current vs available version,
-	*  updatable flag, update state, and an install action. Installed with
-	*  the `update` cap. Sources: Homematic firmware-update channels (and
-	*  reusable by other providers, e.g. HA `update.*` entities). */
-	DeviceType["Update"] = "update";
-	DeviceType["Generic"] = "generic";
-	/** Generic notification delivery target (HA `notify.<service>`, future
-	*  Telegram / Discord / ntfy / SMTP, …). One device per delivery
-	*  endpoint; the `notifier` cap defines the send surface. */
-	DeviceType["Notifier"] = "notifier";
-	/** Pre-recorded action sequence with optional parameters
-	*  (HA `script.*`). Runnable via `script-runner` cap. */
-	DeviceType["Script"] = "script";
-	/** Automation rule (HA `automation.*`) — enable/disable + manual
-	*  trigger surface exposed via `automation-control` cap. */
-	DeviceType["Automation"] = "automation";
-	/** Door / smart lock device (HA `lock.*`). `lock-control` cap. */
-	DeviceType["Lock"] = "lock";
-	/** Window covering, blinds, garage door, valve, etc. (HA `cover.*`,
-	*  `valve.*`). `cover` cap with sub-roles for variant. */
-	DeviceType["Cover"] = "cover";
-	/** Pipe / water / gas valve with open/close/stop and optional
-	*  position (HA `valve.*`). `valve` cap — a cover-sibling actuator
-	*  modelled on the same open/closed lifecycle. */
-	DeviceType["Valve"] = "valve";
-	/** Humidifier / dehumidifier with on/off + target humidity + mode
-	*  (HA `humidifier.*`). `humidifier` cap — a climate-family actuator
-	*  modelled on the same target / mode lifecycle. */
-	DeviceType["Humidifier"] = "humidifier";
-	/** Water heater / boiler with target temperature + operation mode +
-	*  away mode (HA `water_heater.*`). `water-heater` cap — a
-	*  climate-family actuator. */
-	DeviceType["WaterHeater"] = "water-heater";
-	/** Ceiling / standing / exhaust fan (HA `fan.*`). `fan-control` cap. */
-	DeviceType["Fan"] = "fan";
-	/** Audio / video playback endpoint (HA `media_player.*`). Disjoint from
-	*  the camera surface — those use `Camera`. `media-player` cap. */
-	DeviceType["MediaPlayer"] = "media-player";
-	/** Security panel / alarm system (HA `alarm_control_panel.*`).
-	*  `alarm-panel` cap. */
-	DeviceType["AlarmPanel"] = "alarm-panel";
-	/** Generic user-settable input (HA `number` / `input_number` / `select`
-	*  / `input_select` / `text` / `input_text` / `input_datetime`).
-	*  Sub-type via `DeviceRole`: NumericControl / SelectControl /
-	*  TextControl / DateTimeControl. */
-	DeviceType["Control"] = "control";
-	/** Person / device-tracker presence (HA `person.*`, `device_tracker.*`).
-	*  `presence` cap. */
-	DeviceType["Presence"] = "presence";
-	/** Weather provider (HA `weather.*`). Tier-3, low MVP priority.
-	*  `weather` cap. */
-	DeviceType["Weather"] = "weather";
-	/** Robot vacuum (HA `vacuum.*`). Tier-3. `vacuum-control` cap. */
-	DeviceType["Vacuum"] = "vacuum";
-	/** Robotic lawn mower (HA `lawn_mower.*`). Tier-3.
-	*  `lawn-mower-control` cap. */
-	DeviceType["LawnMower"] = "lawn-mower";
-	/** Physical HA device group — parent container for entity-children
-	*  adopted from a single HA device entry. Not renderable as a
-	*  standalone device; exists only to anchor child entities. */
-	DeviceType["Container"] = "container";
-	/** Single still-image entity (HA `image.*`). Read-only display of an
-	*  `entity_picture` signed URL the browser loads directly. `image` cap. */
-	DeviceType["Image"] = "image";
-	return DeviceType;
-}({});
-var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
-	DeviceFeature["BatteryOperated"] = "battery-operated";
-	DeviceFeature["Rebootable"] = "rebootable";
-	/**
-	* Device supports an on-demand re-sync of its derived spec with its
-	* upstream source — drives the generic Re-sync button. The owning
-	* provider implements the action via the `device-adoption.resync` cap.
-	*/
-	DeviceFeature["Resyncable"] = "resyncable";
-	DeviceFeature["NativeSnapshot"] = "native-snapshot";
-	DeviceFeature["DoorbellButton"] = "doorbell-button";
-	DeviceFeature["TwoWayAudio"] = "two-way-audio";
-	DeviceFeature["PanTiltZoom"] = "pan-tilt-zoom";
-	/**
-	* Camera supports the on-firmware autotrack subsystem (subject-
-	* following). Distinct from `PanTiltZoom` because not every PTZ
-	* camera ships autotrack — the admin UI uses this flag to gate
-	* the autotrack toggle / settings card without re-deriving from
-	* the cap registry. Mirrors `ptz-autotrack` cap registration:
-	* driver sets this feature when probe confirms the firmware
-	* surface, and registers the cap in the same code path.
-	*/
-	DeviceFeature["PtzAutotrack"] = "ptz-autotrack";
-	/**
-	* Accessory exposes a "trigger on motion" toggle — the parent camera's
-	* motion detection automatically activates this device. Mirrors
-	* `motion-trigger` cap registration: drivers set this feature in the
-	* same code path that calls `ctx.registerNativeCap(motionTriggerCapability, ...)`.
-	*
-	* Used by admin UI (gate the in-hero `MotionTriggerToggle` against a
-	* fast scalar without binding fetch), notifier rules, and `listAll`
-	* filters that want "all devices with on-motion behaviour".
-	*/
-	DeviceFeature["MotionTrigger"] = "motion-trigger";
-	/** Light supports rgb-triplet color via `color` cap. */
-	DeviceFeature["LightColorRgb"] = "light-color-rgb";
-	/** Light supports HSV color via `color` cap. */
-	DeviceFeature["LightColorHsv"] = "light-color-hsv";
-	/** Light supports color-temperature (mired) via `color` cap. */
-	DeviceFeature["LightColorMired"] = "light-color-mired";
-	/** Thermostat supports a `heat_cool` dual setpoint (targetLow +
-	*  targetHigh). Gates the range slider UI. */
-	DeviceFeature["ClimateDualSetpoint"] = "climate-dual-setpoint";
-	/** Thermostat exposes target humidity and/or current humidity
-	*  readings. Gates the humidity controls. */
-	DeviceFeature["ClimateHumidity"] = "climate-humidity";
-	/** Thermostat exposes a fan-mode selector. */
-	DeviceFeature["ClimateFanMode"] = "climate-fan-mode";
-	/** Thermostat exposes preset modes (eco / away / sleep / vendor). */
-	DeviceFeature["ClimatePreset"] = "climate-preset";
-	/** Cover exposes intermediate position control (0..100). Gates the
-	*  position slider UI. */
-	DeviceFeature["CoverPositionable"] = "cover-positionable";
-	/** Cover exposes slat-tilt control. Gates the tilt slider UI. */
-	DeviceFeature["CoverTilt"] = "cover-tilt";
-	/** Valve exposes intermediate position control (0..100). Gates the
-	*  position slider / drag surface UI. */
-	DeviceFeature["ValvePositionable"] = "valve-positionable";
-	/** Fan exposes a speed-percentage setter. Gates the speed slider UI. */
-	DeviceFeature["FanSpeed"] = "fan-speed";
-	/** Fan exposes a preset mode selector. */
-	DeviceFeature["FanPreset"] = "fan-preset";
-	/** Fan exposes blade direction (forward/reverse) — typical of
-	*  ceiling fans. */
-	DeviceFeature["FanDirection"] = "fan-direction";
-	/** Fan exposes an oscillation toggle. */
-	DeviceFeature["FanOscillating"] = "fan-oscillating";
-	/** Lock requires a PIN code on lock/unlock. Gates the code-entry
-	*  field on the UI lock-controls panel. */
-	DeviceFeature["LockPinRequired"] = "lock-pin-required";
-	/** Lock supports a latch-release ("open door") action distinct from
-	*  unlock. Mirrors HA `LockEntityFeature.OPEN` (bit 1) in
-	*  `supported_features`. Gates the Open Door button in the UI. */
-	DeviceFeature["LockOpen"] = "lock-open";
-	/** Media player exposes a seek-to-position surface. */
-	DeviceFeature["MediaPlayerSeek"] = "media-player-seek";
-	/** Media player exposes a volume-level setter. */
-	DeviceFeature["MediaPlayerVolume"] = "media-player-volume";
-	/** Media player exposes a mute toggle distinct from volume=0. */
-	DeviceFeature["MediaPlayerMute"] = "media-player-mute";
-	/** Media player exposes a shuffle toggle. */
-	DeviceFeature["MediaPlayerShuffle"] = "media-player-shuffle";
-	/** Media player exposes a repeat mode (off / all / one). */
-	DeviceFeature["MediaPlayerRepeat"] = "media-player-repeat";
-	/** Media player exposes a source / input selector. */
-	DeviceFeature["MediaPlayerSelectSource"] = "media-player-select-source";
-	/** Media player exposes a play-arbitrary-media surface (URL / id). */
-	DeviceFeature["MediaPlayerPlayMedia"] = "media-player-play-media";
-	/** Media player exposes next-track. */
-	DeviceFeature["MediaPlayerNext"] = "media-player-next";
-	/** Media player exposes previous-track. */
-	DeviceFeature["MediaPlayerPrevious"] = "media-player-previous";
-	/** Media player exposes stop distinct from pause. */
-	DeviceFeature["MediaPlayerStop"] = "media-player-stop";
-	/** Alarm panel requires a PIN code on arm/disarm. */
-	DeviceFeature["AlarmPinRequired"] = "alarm-pin-required";
-	/** Presence device carries GPS coordinates (lat/lng/accuracy) in
-	*  addition to a textual location. */
-	DeviceFeature["PresenceGps"] = "presence-gps";
-	/** Notifier accepts an inline / URL image attachment. */
-	DeviceFeature["NotifierImage"] = "notifier-image";
-	/** Notifier accepts a priority hint (high/normal/low). */
-	DeviceFeature["NotifierPriority"] = "notifier-priority";
-	/** Notifier accepts a free-form `data` payload for platform-specific
-	*  fields. */
-	DeviceFeature["NotifierData"] = "notifier-data";
-	/** Notifier supports interactive action buttons / callbacks. */
-	DeviceFeature["NotifierActions"] = "notifier-actions";
-	/** Notifier supports per-call recipient targeting (multi-user). */
-	DeviceFeature["NotifierRecipients"] = "notifier-recipients";
-	/** Script runner accepts a variables map on each run invocation. */
-	DeviceFeature["ScriptVariables"] = "script-variables";
-	/** Automation `trigger` accepts a skipCondition flag — fires the
-	*  automation's actions while bypassing its condition block. */
-	DeviceFeature["AutomationSkipCondition"] = "automation-skip-condition";
-	return DeviceFeature;
-}({});
-var ChargingStatus = /* @__PURE__ */ function(ChargingStatus) {
-	ChargingStatus["ChargingDC"] = "charging-dc";
-	ChargingStatus["ChargingSolar"] = "charging-solar";
-	ChargingStatus["NotCharging"] = "not-charging";
-	return ChargingStatus;
-}({});
-/**
-* Semantic role a device plays within its parent. Populated by driver
-* addons when creating accessory devices (Reolink siren/floodlight/
-* PIR/chime/autotrack/doorbell, ONVIF relay outputs, …). Used by the
-* admin UI to pick icons, labels, and widgets — a `Switch` with
-* `role: Floodlight` renders as a bulb with a brightness slider,
-* whereas a `Switch` with `role: Siren` renders as a klaxon.
-*
-* Undefined for top-level devices (cameras, NVRs, hubs). Persisted in
-* sqlite as a nullable TEXT column — old rows keep working unchanged.
-*/
-var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
-	DeviceRole["Siren"] = "siren";
-	DeviceRole["Floodlight"] = "floodlight";
-	DeviceRole["Spotlight"] = "spotlight";
-	DeviceRole["PirSensor"] = "pir-sensor";
-	DeviceRole["Chime"] = "chime";
-	DeviceRole["Autotrack"] = "autotrack";
-	DeviceRole["Nightvision"] = "nightvision";
-	DeviceRole["PrivacyMask"] = "privacy-mask";
-	DeviceRole["Doorbell"] = "doorbell";
-	/** Virtual HA toggle (input_boolean.*) — distinguishable from a
-	*  real Switch device for UI rendering / export adapters. */
-	DeviceRole["BinaryHelper"] = "binary-helper";
-	/** Generic motion / occupancy / moving event source. Distinct from
-	*  the camera accessory PirSensor role: that one is a camera child;
-	*  this is a standalone HA / 3rd-party motion sensor. */
-	DeviceRole["MotionSensor"] = "motion-sensor";
-	DeviceRole["ContactSensor"] = "contact-sensor";
-	DeviceRole["LeakSensor"] = "leak-sensor";
-	DeviceRole["SmokeSensor"] = "smoke-sensor";
-	DeviceRole["COSensor"] = "co-sensor";
-	DeviceRole["GasSensor"] = "gas-sensor";
-	DeviceRole["TamperSensor"] = "tamper-sensor";
-	DeviceRole["VibrationSensor"] = "vibration-sensor";
-	DeviceRole["ConnectivitySensor"] = "connectivity-sensor";
-	DeviceRole["SoundSensor"] = "sound-sensor";
-	/** Fallback for `binary_sensor` without a known `device_class`. */
-	DeviceRole["BinarySensor"] = "binary-sensor";
-	DeviceRole["TemperatureSensor"] = "temperature-sensor";
-	DeviceRole["HumiditySensor"] = "humidity-sensor";
-	DeviceRole["AmbientLightSensor"] = "ambient-light-sensor";
-	DeviceRole["PressureSensor"] = "pressure-sensor";
-	DeviceRole["PowerSensor"] = "power-sensor";
-	DeviceRole["EnergySensor"] = "energy-sensor";
-	DeviceRole["VoltageSensor"] = "voltage-sensor";
-	DeviceRole["CurrentSensor"] = "current-sensor";
-	DeviceRole["AirQualitySensor"] = "air-quality-sensor";
-	/** Battery level (numeric % via `sensor` OR low-bool via
-	*  `binary_sensor` — the cap distinguishes via the value type). */
-	DeviceRole["BatterySensor"] = "battery-sensor";
-	/** Fallback for `sensor` numeric without a known `device_class`. */
-	DeviceRole["NumericSensor"] = "numeric-sensor";
-	/** String / enum state (HA `sensor` with `state_class: enum` or
-	*  `attributes.options`). */
-	DeviceRole["EnumSensor"] = "enum-sensor";
-	/** Date / timestamp state (HA `sensor` with `device_class: timestamp`
-	*  or `date`). The slice carries the raw ISO string verbatim (hosted on
-	*  the `enum-sensor` cap); the UI renders it locale-formatted. */
-	DeviceRole["DateTimeSensor"] = "datetime-sensor";
-	/** Last-resort fallback when nothing else matches. */
-	DeviceRole["GenericSensor"] = "generic-sensor";
-	DeviceRole["NumericControl"] = "numeric-control";
-	DeviceRole["SelectControl"] = "select-control";
-	DeviceRole["TextControl"] = "text-control";
-	DeviceRole["DateTimeControl"] = "datetime-control";
-	/** Mobile push notifier (HA `notify.mobile_app_*`) — supports
-	*  rich features (image, priority, channel routing). */
-	DeviceRole["MobilePushNotifier"] = "mobile-push-notifier";
-	/** Chat / messaging service (HA `notify.telegram_*`,
-	*  `notify.discord_*`, etc.). */
-	DeviceRole["MessagingNotifier"] = "messaging-notifier";
-	/** Email-based delivery (HA `notify.smtp`, etc.). */
-	DeviceRole["EmailNotifier"] = "email-notifier";
-	/** Fallback when the notifier service name doesn't match a known
-	*  pattern. */
-	DeviceRole["GenericNotifier"] = "generic-notifier";
-	return DeviceRole;
-}({});
-//#endregion
 //#region src/device/accessory.ts
 /**
 * Accessory device helpers — shared across drivers.
@@ -5193,148 +2760,12 @@ var airQualitySensorCapability = {
 	mode: "singleton",
 	deviceTypes: [DeviceType.Sensor],
 	methods: {},
-	status: {
-		schema: AirQualitySensorStatusSchema,
-		kind: "push"
-	},
-	runtimeState: AirQualitySensorStatusSchema
-};
-//#endregion
-//#region src/capabilities/capability-definition.ts
-/**
-* Generic types for capability definitions.
-*
-* A capability is defined with Zod schemas for methods, events, and settings.
-* TypeScript types are inferred via z.infer<> — zero duplication.
-*
-* Pattern:
-*   1. Define Zod schemas for data, methods, settings
-*   2. Export const capabilityDef = { ... } satisfies CapabilityDefinition
-*   3. Export type IProvider = InferProvider<typeof capabilityDef>
-*   4. Addon implements IProvider
-*   5. Registry auto-mounts tRPC router from definition.methods
-*/
-/**
-* Output schema shared by the contribution + live methods.
-*
-* Mirrors the `ConfigUISchemaWithValues` shape (sections[] + optional
-* tabs[]) without importing from `../interfaces/config-ui.js` — a
-* concrete-but-lenient Zod object keeps tRPC output inference happy
-* (using `z.unknown()` here collapses unrelated router branches to
-* `unknown` when the generator re-inlines the huge AppRouter type).
-*
-* `.passthrough()` on sections/fields accepts whatever FormBuilder
-* extensions the caller adds (showWhen, displayScale, …) without
-* rebuilding every time a new field kind is introduced.
-*/
-var ContributionSectionSchema = z.object({
-	id: z.string(),
-	title: z.string(),
-	description: z.string().optional(),
-	style: z.enum(["card", "accordion"]).optional(),
-	defaultCollapsed: z.boolean().optional(),
-	columns: z.union([
-		z.literal(1),
-		z.literal(2),
-		z.literal(3),
-		z.literal(4)
-	]).optional(),
-	tab: z.string().optional(),
-	location: z.enum(["settings", "top-tab"]).optional(),
-	order: z.number().optional(),
-	fields: z.array(z.any())
-});
-var ContributionTabSchema = z.object({
-	id: z.string(),
-	label: z.string(),
-	icon: z.string(),
-	order: z.number().optional()
-});
-var ContributionOutputSchema = z.object({
-	tabs: z.array(ContributionTabSchema).optional(),
-	sections: z.array(ContributionSectionSchema)
-}).nullable();
-var DEVICE_SETTINGS_CONTRIBUTION_METHODS = {
-	getDeviceSettingsContribution: {
-		input: z.object({ deviceId: z.number() }),
-		output: ContributionOutputSchema,
-		kind: "query",
-		auth: "protected"
-	},
-	getDeviceLiveContribution: {
-		input: z.object({ deviceId: z.number() }),
-		output: ContributionOutputSchema,
-		kind: "query",
-		auth: "protected"
-	},
-	applyDeviceSettingsPatch: {
-		input: z.object({
-			deviceId: z.number(),
-			patch: z.record(z.string(), z.unknown())
-		}),
-		output: z.object({ success: z.literal(true) }),
-		kind: "mutation",
-		auth: "admin"
-	}
+	status: {
+		schema: AirQualitySensorStatusSchema,
+		kind: "push"
+	},
+	runtimeState: AirQualitySensorStatusSchema
 };
-/**
-* Schema for the `getStatus` method auto-injected when a cap declares
-* `status`. The runtime shape of the output is the cap's own
-* `status.schema` — but at codegen time we need a concrete Zod to emit
-* a typed tRPC route, so we keep the output as `z.unknown().nullable()`
-* here and tighten it on the client side via the generated
-* `CapStatusTypeMap` (see `scripts/generate-cap-status-types.ts`).
-*/
-var DEVICE_STATUS_METHOD = { getStatus: {
-	input: z.object({ deviceId: z.number() }),
-	output: z.unknown().nullable(),
-	kind: "query",
-	auth: "protected"
-} };
-/**
-* Expand a cap def's methods map with every auto-injected method:
-*   - `exposesDeviceSettings: true`      → 3 contribution methods
-*   - `status: {...}`                    → `getStatus`
-*
-* Callers walk `expandCapMethods(def)` instead of `def.methods` when
-* they need the effective runtime method surface (Moleculer actions,
-* proxy shape, tRPC router entries). The cap def stays the single
-* source of truth. Providers still declare their concrete `methods`
-* block; the expansion happens at every consumption point, so there's
-* no accidental divergence between the declared surface and what's
-* actually mounted.
-*/
-function expandCapMethods(def) {
-	let out = def.methods;
-	if (def.exposesDeviceSettings) out = {
-		...DEVICE_SETTINGS_CONTRIBUTION_METHODS,
-		...out
-	};
-	if (def.status) out = {
-		...DEVICE_STATUS_METHOD,
-		...out
-	};
-	return out;
-}
-/** Shorthand to define a method schema */
-function method(input, output, options) {
-	return {
-		input,
-		output,
-		kind: options?.kind ?? "query",
-		auth: options?.auth ?? "protected",
-		...options?.access !== void 0 ? { access: options.access } : {},
-		timeoutMs: options?.timeoutMs
-	};
-}
-/** Shorthand to define an event schema */
-function event(data) {
-	return { data };
-}
-/** Type guard: does this cap declare the D14 device-config archetype? */
-function isDeviceConfigCap(def) {
-	return def?.deviceConfig !== void 0;
-}
 //#endregion
 //#region src/capabilities/alarm-panel.cap.ts
 /**
@@ -12248,767 +9679,6 @@ function enumerateSchemaFields(schema, prefix = "") {
 	return out;
 }
 //#endregion
-//#region src/device/device-state-handle.ts
-var DEVICE_STATE_EVENT_CATEGORY = "device.state-changed";
-/**
-* Lazy tRPC source — the default behavior. Maintains a per-key local
-* cache (`{deviceId}:{capName}` → last slice), one shared
-* `live.onEvent` bridge that fans out into the listener map, and
-* `refresh` round-trips through `deviceState.getCapSlice`.
-*
-* The bridge is opened on first `watch()` and closed when the last
-* watcher unsubscribes — keeps idle handles cheap.
-*/
-function createLazyTrpcSource(api) {
-	const cache = /* @__PURE__ */ new Map();
-	const listeners = /* @__PURE__ */ new Map();
-	let bridge = null;
-	const keyOf = (deviceId, capName) => `${deviceId}:${capName}`;
-	const ensureBridge = () => {
-		if (bridge) return;
-		if (!api.live?.onEvent) return;
-		bridge = api.live.onEvent.subscribe({ category: DEVICE_STATE_EVENT_CATEGORY }, { onData: (evt) => {
-			const data = evt.data;
-			if (!data || typeof data.deviceId !== "number" || typeof data.capName !== "string") return;
-			const k = keyOf(data.deviceId, data.capName);
-			cache.set(k, data.slice);
-			const set = listeners.get(k);
-			if (!set) return;
-			for (const cb of set) try {
-				cb(data.slice);
-			} catch {}
-		} });
-	};
-	const closeBridgeIfIdle = () => {
-		if (!bridge) return;
-		if (listeners.size > 0) return;
-		bridge.unsubscribe();
-		bridge = null;
-	};
-	return {
-		read(deviceId, capName) {
-			return cache.get(keyOf(deviceId, capName));
-		},
-		async refresh(deviceId, capName) {
-			const slice = await api.deviceState.getCapSlice.query({
-				deviceId,
-				capName
-			});
-			const k = keyOf(deviceId, capName);
-			cache.set(k, slice ?? void 0);
-			const set = listeners.get(k);
-			if (set) for (const cb of set) try {
-				cb(slice ?? void 0);
-			} catch {}
-		},
-		watch(deviceId, capName, cb) {
-			const k = keyOf(deviceId, capName);
-			let set = listeners.get(k);
-			if (!set) {
-				set = /* @__PURE__ */ new Set();
-				listeners.set(k, set);
-			}
-			set.add(cb);
-			ensureBridge();
-			return () => {
-				set.delete(cb);
-				if (set.size === 0) listeners.delete(k);
-				closeBridgeIfIdle();
-			};
-		},
-		async write(deviceId, capName, slice) {
-			await api.deviceState.setCapSlice.mutate({
-				deviceId,
-				capName,
-				slice
-			});
-		}
-	};
-}
-/**
-* Mirror source — reads from a shared map populated by a
-* `SystemManager` warm-boot + push event handler. Refresh is a no-op
-* (the SystemManager owns the update loop). `watch()` registers in a
-* shared listener set — the SystemManager calls these from its single
-* `device.state-changed` subscription.
-*
-* The mirror map and listener map are passed in by reference so the
-* SystemManager can mutate both as events arrive.
-*/
-function createMirrorSource(mirror, listeners, api) {
-	const keyOf = (deviceId, capName) => `${deviceId}:${capName}`;
-	return {
-		read(deviceId, capName) {
-			return mirror.get(deviceId)?.get(capName);
-		},
-		async refresh() {},
-		watch(deviceId, capName, cb) {
-			const k = keyOf(deviceId, capName);
-			let set = listeners.get(k);
-			if (!set) {
-				set = /* @__PURE__ */ new Set();
-				listeners.set(k, set);
-			}
-			set.add(cb);
-			return () => {
-				set.delete(cb);
-				if (set.size === 0) listeners.delete(k);
-			};
-		},
-		async write(deviceId, capName, slice) {
-			if (!api) throw new Error("createMirrorSource: write requires an api reference — pass it as the third argument when constructing the source");
-			await api.deviceState.setCapSlice.mutate({
-				deviceId,
-				capName,
-				slice
-			});
-		}
-	};
-}
-/**
-* Build a `SliceHandle<T>` bound to `(deviceId, capName)`. Caller
-* provides the type parameter — codegen passes
-* `InferRuntimeState<typeof <cap>>` so consumers see the cap's typed
-* shape:
-*
-*   const dev = createDeviceProxy(api, binding)
-*   dev.state.battery.value           // BatteryStatus | undefined
-*   dev.state.battery.value?.percentage
-*
-* Two-arg form (deprecated path, kept for spec compatibility):
-* passes the api directly, builds a per-handle lazy source. New
-* code should pre-build a single source and reuse it across handles
-* via the explicit `source` form.
-*/
-function createSliceHandle(source, deviceId, capName) {
-	const src = isSource(source) ? source : createLazyTrpcSource(source);
-	return {
-		get value() {
-			return src.read(deviceId, capName);
-		},
-		refresh() {
-			return src.refresh(deviceId, capName);
-		},
-		subscribe(cb) {
-			const unwatch = src.watch(deviceId, capName, (slice) => {
-				try {
-					cb(slice);
-				} catch {}
-			});
-			try {
-				cb(src.read(deviceId, capName));
-			} catch {}
-			if (src.read(deviceId, capName) === void 0) src.refresh(deviceId, capName).catch(() => void 0);
-			return unwatch;
-		},
-		async set(slice) {
-			await src.write(deviceId, capName, slice);
-		},
-		async patch(partial) {
-			const next = {
-				...src.read(deviceId, capName),
-				...partial
-			};
-			await src.write(deviceId, capName, next);
-		}
-	};
-}
-function isSource(x) {
-	return typeof x.read === "function" && typeof x.watch === "function";
-}
-//#endregion
-//#region src/generated/device-proxy.ts
-/**
-* Build a DeviceProxy that pre-binds deviceId + nodeId on every method call
-* and dispatches through the existing cap-router tRPC procedures.
-*
-* Optional `opts.stateSource` lets a SystemManager pass a shared mirror
-* source so every device proxy reads from the same in-memory map and
-* shares the warm-boot/push-event update loop. When omitted, a per-proxy
-* lazy tRPC source is created — the path used by `ctx.fetchDevice` and
-* `BackendClient.fetchDevice` for one-off reads.
-*
-* The returned proxy's `binding` field is set to the input `binding`
-* by default — callers that want to expose a different value (e.g. the
-* SDK's `System` patches it from a shared cache) can overwrite the
-* field on the returned object.
-*/
-function createDeviceProxy(api, binding, opts) {
-	const typedApi = api;
-	const stateSource = opts?.stateSource ?? createLazyTrpcSource(api);
-	/** Merge `{deviceId, nodeId?}` into the caller-supplied input. */
-	function mergeInput(input, nodeId) {
-		const base = typeof input === "object" && input !== null ? input : {};
-		return nodeId !== void 0 ? {
-			...base,
-			deviceId: binding.deviceId,
-			nodeId
-		} : {
-			...base,
-			deviceId: binding.deviceId
-		};
-	}
-	/**
-	* Invoke `api.<capProp>.<method>.{query|mutate|subscribe}(merged)`.
-	* Returns `any` so the caller-side per-method declaration assigns
-	* cleanly into the strongly-typed `InferDeviceProxyCap<...>` shape on
-	* the `DeviceProxy` interface — the proxy's contract is enforced by
-	* the interface, not the dispatch helper.
-	*/
-	function callLeaf(capProp, method, kind, merged, push) {
-		const leaf = typedApi[capProp]?.[method];
-		if (!leaf) throw new Error(`DeviceProxy: api has no '${capProp}.${method}'`);
-		const fn = leaf;
-		if (kind === "mutation") return fn.mutate(merged);
-		if (kind === "subscription") return fn.subscribe(merged, push);
-		return fn.query(merged);
-	}
-	/**
-	* Device-scoped cap dispatch. Looks up the binding entry for `capName`
-	* to pin the call to the worker that owns the per-device provider; when
-	* no entry exists (cluster-wide singletons like `zones` /
-	* `zone-rules` / `audio-metrics` that don't register per-device
-	* natives), nodeId is omitted and the cap-router's `resolveProvider`
-	* falls through to the local provider — a Moleculer bridge proxy when
-	* the actual singleton lives in a worker.
-	*/
-	function dispatch(capName, capProp, method, kind, input, push) {
-		return callLeaf(capProp, method, kind, mergeInput(input, binding.entries.find((e) => e.capName === capName)?.providerNodeId), push);
-	}
-	/**
-	* System-cap dispatch. No binding gate — system caps are cluster-wide
-	* singletons; the nodeId is left absent so caps that load-balance (e.g.
-	* `pipeline-runner`) can resolve their own target node.
-	*/
-	function dispatchSystem(capProp, method, kind, input, push) {
-		return callLeaf(capProp, method, kind, mergeInput(input, void 0), push);
-	}
-	return {
-		deviceId: binding.deviceId,
-		binding,
-		state: {
-			airQualitySensor: createSliceHandle(stateSource, binding.deviceId, "air-quality-sensor"),
-			alarmPanel: createSliceHandle(stateSource, binding.deviceId, "alarm-panel"),
-			ambientLightSensor: createSliceHandle(stateSource, binding.deviceId, "ambient-light-sensor"),
-			audioMetrics: createSliceHandle(stateSource, binding.deviceId, "audio-metrics"),
-			automationControl: createSliceHandle(stateSource, binding.deviceId, "automation-control"),
-			battery: createSliceHandle(stateSource, binding.deviceId, "battery"),
-			binary: createSliceHandle(stateSource, binding.deviceId, "binary"),
-			brightness: createSliceHandle(stateSource, binding.deviceId, "brightness"),
-			cameraStreams: createSliceHandle(stateSource, binding.deviceId, "camera-streams"),
-			carbonMonoxide: createSliceHandle(stateSource, binding.deviceId, "carbon-monoxide"),
-			climateControl: createSliceHandle(stateSource, binding.deviceId, "climate-control"),
-			color: createSliceHandle(stateSource, binding.deviceId, "color"),
-			connectivity: createSliceHandle(stateSource, binding.deviceId, "connectivity"),
-			consumables: createSliceHandle(stateSource, binding.deviceId, "consumables"),
-			contact: createSliceHandle(stateSource, binding.deviceId, "contact"),
-			control: createSliceHandle(stateSource, binding.deviceId, "control"),
-			cover: createSliceHandle(stateSource, binding.deviceId, "cover"),
-			deviceDiscovery: createSliceHandle(stateSource, binding.deviceId, "device-discovery"),
-			deviceStatus: createSliceHandle(stateSource, binding.deviceId, "device-status"),
-			doorbell: createSliceHandle(stateSource, binding.deviceId, "doorbell"),
-			enumSensor: createSliceHandle(stateSource, binding.deviceId, "enum-sensor"),
-			eventEmitter: createSliceHandle(stateSource, binding.deviceId, "event-emitter"),
-			fanControl: createSliceHandle(stateSource, binding.deviceId, "fan-control"),
-			featureProbe: createSliceHandle(stateSource, binding.deviceId, "feature-probe"),
-			flood: createSliceHandle(stateSource, binding.deviceId, "flood"),
-			gas: createSliceHandle(stateSource, binding.deviceId, "gas"),
-			humidifier: createSliceHandle(stateSource, binding.deviceId, "humidifier"),
-			humiditySensor: createSliceHandle(stateSource, binding.deviceId, "humidity-sensor"),
-			image: createSliceHandle(stateSource, binding.deviceId, "image"),
-			lawnMowerControl: createSliceHandle(stateSource, binding.deviceId, "lawn-mower-control"),
-			lockControl: createSliceHandle(stateSource, binding.deviceId, "lock-control"),
-			mediaPlayer: createSliceHandle(stateSource, binding.deviceId, "media-player"),
-			motion: createSliceHandle(stateSource, binding.deviceId, "motion"),
-			motionTrigger: createSliceHandle(stateSource, binding.deviceId, "motion-trigger"),
-			motionZones: createSliceHandle(stateSource, binding.deviceId, "motion-zones"),
-			nativeObjectDetection: createSliceHandle(stateSource, binding.deviceId, "native-object-detection"),
-			notifier: createSliceHandle(stateSource, binding.deviceId, "notifier"),
-			numericSensor: createSliceHandle(stateSource, binding.deviceId, "numeric-sensor"),
-			powerMeter: createSliceHandle(stateSource, binding.deviceId, "power-meter"),
-			presence: createSliceHandle(stateSource, binding.deviceId, "presence"),
-			pressureSensor: createSliceHandle(stateSource, binding.deviceId, "pressure-sensor"),
-			privacyMask: createSliceHandle(stateSource, binding.deviceId, "privacy-mask"),
-			ptzAutotrack: createSliceHandle(stateSource, binding.deviceId, "ptz-autotrack"),
-			scriptRunner: createSliceHandle(stateSource, binding.deviceId, "script-runner"),
-			smoke: createSliceHandle(stateSource, binding.deviceId, "smoke"),
-			streamParams: createSliceHandle(stateSource, binding.deviceId, "stream-params"),
-			switch: createSliceHandle(stateSource, binding.deviceId, "switch"),
-			tamper: createSliceHandle(stateSource, binding.deviceId, "tamper"),
-			temperatureSensor: createSliceHandle(stateSource, binding.deviceId, "temperature-sensor"),
-			update: createSliceHandle(stateSource, binding.deviceId, "update"),
-			vacuumControl: createSliceHandle(stateSource, binding.deviceId, "vacuum-control"),
-			valve: createSliceHandle(stateSource, binding.deviceId, "valve"),
-			vibration: createSliceHandle(stateSource, binding.deviceId, "vibration"),
-			waterHeater: createSliceHandle(stateSource, binding.deviceId, "water-heater"),
-			weather: createSliceHandle(stateSource, binding.deviceId, "weather"),
-			zoneAnalytics: createSliceHandle(stateSource, binding.deviceId, "zone-analytics"),
-			zoneRules: createSliceHandle(stateSource, binding.deviceId, "zone-rules"),
-			zones: createSliceHandle(stateSource, binding.deviceId, "zones")
-		},
-		accessories: {
-			setChildHidden: (input) => dispatch("accessories", "accessories", "setChildHidden", "mutation", input),
-			getStatus: (input) => dispatch("accessories", "accessories", "getStatus", "query", input)
-		},
-		airQualitySensor: { getStatus: (input) => dispatch("air-quality-sensor", "airQualitySensor", "getStatus", "query", input) },
-		alarmPanel: {
-			arm: (input) => dispatch("alarm-panel", "alarmPanel", "arm", "mutation", input),
-			disarm: (input) => dispatch("alarm-panel", "alarmPanel", "disarm", "mutation", input),
-			trigger: (input) => dispatch("alarm-panel", "alarmPanel", "trigger", "mutation", input),
-			getStatus: (input) => dispatch("alarm-panel", "alarmPanel", "getStatus", "query", input)
-		},
-		ambientLightSensor: { getStatus: (input) => dispatch("ambient-light-sensor", "ambientLightSensor", "getStatus", "query", input) },
-		audioAnalysis: {
-			resolveDeviceSettings: (input) => dispatch("audio-analysis", "audioAnalysis", "resolveDeviceSettings", "query", input),
-			getDeviceSettingsContribution: (input) => dispatch("audio-analysis", "audioAnalysis", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("audio-analysis", "audioAnalysis", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("audio-analysis", "audioAnalysis", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		audioMetrics: {
-			getCurrentSnapshot: (input) => dispatch("audio-metrics", "audioMetrics", "getCurrentSnapshot", "query", input),
-			getHistory: (input) => dispatch("audio-metrics", "audioMetrics", "getHistory", "query", input)
-		},
-		automationControl: {
-			enable: (input) => dispatch("automation-control", "automationControl", "enable", "mutation", input),
-			disable: (input) => dispatch("automation-control", "automationControl", "disable", "mutation", input),
-			trigger: (input) => dispatch("automation-control", "automationControl", "trigger", "mutation", input),
-			getStatus: (input) => dispatch("automation-control", "automationControl", "getStatus", "query", input)
-		},
-		battery: {
-			wakeForStream: (input) => dispatch("battery", "battery", "wakeForStream", "mutation", input),
-			getStatus: (input) => dispatch("battery", "battery", "getStatus", "query", input)
-		},
-		binary: { getStatus: (input) => dispatch("binary", "binary", "getStatus", "query", input) },
-		brightness: {
-			setBrightness: (input) => dispatch("brightness", "brightness", "setBrightness", "mutation", input),
-			getStatus: (input) => dispatch("brightness", "brightness", "getStatus", "query", input)
-		},
-		button: { press: (input) => dispatch("button", "button", "press", "mutation", input) },
-		cameraCredentials: {
-			getCredentials: (input) => dispatch("camera-credentials", "cameraCredentials", "getCredentials", "query", input),
-			getStatus: (input) => dispatch("camera-credentials", "cameraCredentials", "getStatus", "query", input)
-		},
-		cameraStreams: {
-			getCameraStreams: (input) => dispatch("camera-streams", "cameraStreams", "getCameraStreams", "query", input),
-			getBrokerStreams: (input) => dispatch("camera-streams", "cameraStreams", "getBrokerStreams", "query", input),
-			getRtspEntries: (input) => dispatch("camera-streams", "cameraStreams", "getRtspEntries", "query", input),
-			getProfileRtspEntries: (input) => dispatch("camera-streams", "cameraStreams", "getProfileRtspEntries", "query", input),
-			pickStream: (input) => dispatch("camera-streams", "cameraStreams", "pickStream", "query", input)
-		},
-		carbonMonoxide: { getStatus: (input) => dispatch("carbon-monoxide", "carbonMonoxide", "getStatus", "query", input) },
-		climateControl: {
-			setMode: (input) => dispatch("climate-control", "climateControl", "setMode", "mutation", input),
-			setFanMode: (input) => dispatch("climate-control", "climateControl", "setFanMode", "mutation", input),
-			setPreset: (input) => dispatch("climate-control", "climateControl", "setPreset", "mutation", input),
-			setTarget: (input) => dispatch("climate-control", "climateControl", "setTarget", "mutation", input),
-			setTargetRange: (input) => dispatch("climate-control", "climateControl", "setTargetRange", "mutation", input),
-			setTargetHumidity: (input) => dispatch("climate-control", "climateControl", "setTargetHumidity", "mutation", input),
-			getStatus: (input) => dispatch("climate-control", "climateControl", "getStatus", "query", input)
-		},
-		color: {
-			setColor: (input) => dispatch("color", "color", "setColor", "mutation", input),
-			getStatus: (input) => dispatch("color", "color", "getStatus", "query", input)
-		},
-		connectivity: { getStatus: (input) => dispatch("connectivity", "connectivity", "getStatus", "query", input) },
-		consumables: {
-			reset: (input) => dispatch("consumables", "consumables", "reset", "mutation", input),
-			getStatus: (input) => dispatch("consumables", "consumables", "getStatus", "query", input)
-		},
-		contact: { getStatus: (input) => dispatch("contact", "contact", "getStatus", "query", input) },
-		control: {
-			setValue: (input) => dispatch("control", "control", "setValue", "mutation", input),
-			getStatus: (input) => dispatch("control", "control", "getStatus", "query", input)
-		},
-		cover: {
-			open: (input) => dispatch("cover", "cover", "open", "mutation", input),
-			close: (input) => dispatch("cover", "cover", "close", "mutation", input),
-			stop: (input) => dispatch("cover", "cover", "stop", "mutation", input),
-			setPosition: (input) => dispatch("cover", "cover", "setPosition", "mutation", input),
-			setTiltPosition: (input) => dispatch("cover", "cover", "setTiltPosition", "mutation", input),
-			getStatus: (input) => dispatch("cover", "cover", "getStatus", "query", input)
-		},
-		detectionPipeline: {
-			getDeviceSettingsContribution: (input) => dispatch("detection-pipeline", "detectionPipeline", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("detection-pipeline", "detectionPipeline", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("detection-pipeline", "detectionPipeline", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		deviceDiscovery: {
-			listDiscovered: (input) => dispatch("device-discovery", "deviceDiscovery", "listDiscovered", "query", input),
-			refreshDiscovery: (input) => dispatch("device-discovery", "deviceDiscovery", "refreshDiscovery", "mutation", input),
-			adoptDevice: (input) => dispatch("device-discovery", "deviceDiscovery", "adoptDevice", "mutation", input),
-			releaseDevice: (input) => dispatch("device-discovery", "deviceDiscovery", "releaseDevice", "mutation", input),
-			getStatus: (input) => dispatch("device-discovery", "deviceDiscovery", "getStatus", "query", input)
-		},
-		deviceOps: {
-			getStreamSources: (input) => dispatch("device-ops", "deviceOps", "getStreamSources", "query", input),
-			getConfigEntries: (input) => dispatch("device-ops", "deviceOps", "getConfigEntries", "query", input),
-			setConfig: (input) => dispatch("device-ops", "deviceOps", "setConfig", "mutation", input),
-			runAction: (input) => dispatch("device-ops", "deviceOps", "runAction", "mutation", input),
-			removeDevice: (input) => dispatch("device-ops", "deviceOps", "removeDevice", "mutation", input),
-			getSettingsSchema: (input) => dispatch("device-ops", "deviceOps", "getSettingsSchema", "query", input),
-			getRawState: (input) => dispatch("device-ops", "deviceOps", "getRawState", "query", input)
-		},
-		deviceStatus: { getStatus: (input) => dispatch("device-status", "deviceStatus", "getStatus", "query", input) },
-		doorbell: { getStatus: (input) => dispatch("doorbell", "doorbell", "getStatus", "query", input) },
-		enumSensor: { getStatus: (input) => dispatch("enum-sensor", "enumSensor", "getStatus", "query", input) },
-		eventEmitter: { getStatus: (input) => dispatch("event-emitter", "eventEmitter", "getStatus", "query", input) },
-		events: {
-			getEvents: (input) => dispatch("events", "events", "getEvents", "query", input),
-			getEventThumbnail: (input) => dispatch("events", "events", "getEventThumbnail", "query", input),
-			getEventClipUrl: (input) => dispatch("events", "events", "getEventClipUrl", "query", input)
-		},
-		fanControl: {
-			setPercentage: (input) => dispatch("fan-control", "fanControl", "setPercentage", "mutation", input),
-			setPreset: (input) => dispatch("fan-control", "fanControl", "setPreset", "mutation", input),
-			setDirection: (input) => dispatch("fan-control", "fanControl", "setDirection", "mutation", input),
-			setOscillating: (input) => dispatch("fan-control", "fanControl", "setOscillating", "mutation", input),
-			getStatus: (input) => dispatch("fan-control", "fanControl", "getStatus", "query", input)
-		},
-		featureProbe: { getStatus: (input) => dispatch("feature-probe", "featureProbe", "getStatus", "query", input) },
-		flood: { getStatus: (input) => dispatch("flood", "flood", "getStatus", "query", input) },
-		gas: { getStatus: (input) => dispatch("gas", "gas", "getStatus", "query", input) },
-		humidifier: {
-			setOn: (input) => dispatch("humidifier", "humidifier", "setOn", "mutation", input),
-			setTargetHumidity: (input) => dispatch("humidifier", "humidifier", "setTargetHumidity", "mutation", input),
-			setMode: (input) => dispatch("humidifier", "humidifier", "setMode", "mutation", input),
-			getStatus: (input) => dispatch("humidifier", "humidifier", "getStatus", "query", input)
-		},
-		humiditySensor: { getStatus: (input) => dispatch("humidity-sensor", "humiditySensor", "getStatus", "query", input) },
-		image: { getStatus: (input) => dispatch("image", "image", "getStatus", "query", input) },
-		intercom: {
-			startSession: (input) => dispatch("intercom", "intercom", "startSession", "mutation", input),
-			handleAnswer: (input) => dispatch("intercom", "intercom", "handleAnswer", "mutation", input),
-			stopSession: (input) => dispatch("intercom", "intercom", "stopSession", "mutation", input),
-			startTalkSession: (input) => dispatch("intercom", "intercom", "startTalkSession", "mutation", input),
-			pushTalkAudio: (input) => dispatch("intercom", "intercom", "pushTalkAudio", "mutation", input),
-			endTalkSession: (input) => dispatch("intercom", "intercom", "endTalkSession", "mutation", input),
-			getStatus: (input) => dispatch("intercom", "intercom", "getStatus", "query", input)
-		},
-		lawnMowerControl: {
-			startMowing: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "startMowing", "mutation", input),
-			pause: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "pause", "mutation", input),
-			dock: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "dock", "mutation", input),
-			getStatus: (input) => dispatch("lawn-mower-control", "lawnMowerControl", "getStatus", "query", input)
-		},
-		lockControl: {
-			lock: (input) => dispatch("lock-control", "lockControl", "lock", "mutation", input),
-			unlock: (input) => dispatch("lock-control", "lockControl", "unlock", "mutation", input),
-			open: (input) => dispatch("lock-control", "lockControl", "open", "mutation", input),
-			getStatus: (input) => dispatch("lock-control", "lockControl", "getStatus", "query", input)
-		},
-		mediaPlayer: {
-			play: (input) => dispatch("media-player", "mediaPlayer", "play", "mutation", input),
-			pause: (input) => dispatch("media-player", "mediaPlayer", "pause", "mutation", input),
-			stop: (input) => dispatch("media-player", "mediaPlayer", "stop", "mutation", input),
-			next: (input) => dispatch("media-player", "mediaPlayer", "next", "mutation", input),
-			previous: (input) => dispatch("media-player", "mediaPlayer", "previous", "mutation", input),
-			seek: (input) => dispatch("media-player", "mediaPlayer", "seek", "mutation", input),
-			setVolume: (input) => dispatch("media-player", "mediaPlayer", "setVolume", "mutation", input),
-			setMute: (input) => dispatch("media-player", "mediaPlayer", "setMute", "mutation", input),
-			setShuffle: (input) => dispatch("media-player", "mediaPlayer", "setShuffle", "mutation", input),
-			setRepeat: (input) => dispatch("media-player", "mediaPlayer", "setRepeat", "mutation", input),
-			selectSource: (input) => dispatch("media-player", "mediaPlayer", "selectSource", "mutation", input),
-			playMedia: (input) => dispatch("media-player", "mediaPlayer", "playMedia", "mutation", input),
-			getStatus: (input) => dispatch("media-player", "mediaPlayer", "getStatus", "query", input)
-		},
-		motion: {
-			isDetected: (input) => dispatch("motion", "motion", "isDetected", "query", input),
-			getStatus: (input) => dispatch("motion", "motion", "getStatus", "query", input)
-		},
-		motionDetection: {
-			analyze: (input) => dispatch("motion-detection", "motionDetection", "analyze", "mutation", input),
-			removeCamera: (input) => dispatch("motion-detection", "motionDetection", "removeCamera", "mutation", input),
-			reset: (input) => dispatch("motion-detection", "motionDetection", "reset", "mutation", input),
-			getDeviceSettingsContribution: (input) => dispatch("motion-detection", "motionDetection", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("motion-detection", "motionDetection", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("motion-detection", "motionDetection", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		motionTrigger: {
-			setMotionTrigger: (input) => dispatch("motion-trigger", "motionTrigger", "setMotionTrigger", "mutation", input),
-			getStatus: (input) => dispatch("motion-trigger", "motionTrigger", "getStatus", "query", input)
-		},
-		motionZones: {
-			getOptions: (input) => dispatch("motion-zones", "motionZones", "getOptions", "query", input),
-			setZone: (input) => dispatch("motion-zones", "motionZones", "setZone", "mutation", input),
-			getStatus: (input) => dispatch("motion-zones", "motionZones", "getStatus", "query", input)
-		},
-		nativeObjectDetection: {
-			setEnabled: (input) => dispatch("native-object-detection", "nativeObjectDetection", "setEnabled", "mutation", input),
-			getStatus: (input) => dispatch("native-object-detection", "nativeObjectDetection", "getStatus", "query", input)
-		},
-		notifier: {
-			send: (input) => dispatch("notifier", "notifier", "send", "mutation", input),
-			cancel: (input) => dispatch("notifier", "notifier", "cancel", "mutation", input),
-			getStatus: (input) => dispatch("notifier", "notifier", "getStatus", "query", input)
-		},
-		numericSensor: { getStatus: (input) => dispatch("numeric-sensor", "numericSensor", "getStatus", "query", input) },
-		osd: {
-			setOverlay: (input) => dispatch("osd", "osd", "setOverlay", "mutation", input),
-			getStatus: (input) => dispatch("osd", "osd", "getStatus", "query", input)
-		},
-		pipelineAnalytics: {
-			getActiveTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getActiveTracks", "query", input),
-			getTrack: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrack", "query", input),
-			listTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "listTracks", "query", input),
-			clearTracks: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "clearTracks", "mutation", input),
-			getMotionEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getMotionEvents", "query", input),
-			getObjectEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getObjectEvents", "query", input),
-			getAudioEvents: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getAudioEvents", "query", input),
-			getEventDensity: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventDensity", "query", input),
-			pruneEventsBefore: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "pruneEventsBefore", "mutation", input),
-			getEventMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getEventMedia", "query", input),
-			getTrackMedia: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getTrackMedia", "query", input),
-			getDeviceSettingsContribution: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("pipeline-analytics", "pipelineAnalytics", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		powerMeter: { getStatus: (input) => dispatch("power-meter", "powerMeter", "getStatus", "query", input) },
-		presence: { getStatus: (input) => dispatch("presence", "presence", "getStatus", "query", input) },
-		pressureSensor: { getStatus: (input) => dispatch("pressure-sensor", "pressureSensor", "getStatus", "query", input) },
-		privacyMask: {
-			getOptions: (input) => dispatch("privacy-mask", "privacyMask", "getOptions", "query", input),
-			setMask: (input) => dispatch("privacy-mask", "privacyMask", "setMask", "mutation", input),
-			getStatus: (input) => dispatch("privacy-mask", "privacyMask", "getStatus", "query", input)
-		},
-		ptz: {
-			move: (input) => dispatch("ptz", "ptz", "move", "mutation", input),
-			continuousMove: (input) => dispatch("ptz", "ptz", "continuousMove", "mutation", input),
-			stop: (input) => dispatch("ptz", "ptz", "stop", "mutation", input),
-			getPresets: (input) => dispatch("ptz", "ptz", "getPresets", "query", input),
-			goToPreset: (input) => dispatch("ptz", "ptz", "goToPreset", "mutation", input),
-			savePreset: (input) => dispatch("ptz", "ptz", "savePreset", "mutation", input),
-			deletePreset: (input) => dispatch("ptz", "ptz", "deletePreset", "mutation", input),
-			getOptions: (input) => dispatch("ptz", "ptz", "getOptions", "query", input),
-			goHome: (input) => dispatch("ptz", "ptz", "goHome", "mutation", input),
-			getPosition: (input) => dispatch("ptz", "ptz", "getPosition", "query", input),
-			setAutofocus: (input) => dispatch("ptz", "ptz", "setAutofocus", "mutation", input),
-			getStatus: (input) => dispatch("ptz", "ptz", "getStatus", "query", input)
-		},
-		ptzAutotrack: {
-			getStatus: (input) => dispatch("ptz-autotrack", "ptzAutotrack", "getStatus", "query", input),
-			setEnabled: (input) => dispatch("ptz-autotrack", "ptzAutotrack", "setEnabled", "mutation", input),
-			getSettings: (input) => dispatch("ptz-autotrack", "ptzAutotrack", "getSettings", "query", input),
-			setSettings: (input) => dispatch("ptz-autotrack", "ptzAutotrack", "setSettings", "mutation", input)
-		},
-		reboot: { reboot: (input) => dispatch("reboot", "reboot", "reboot", "mutation", input) },
-		scriptRunner: {
-			run: (input) => dispatch("script-runner", "scriptRunner", "run", "mutation", input),
-			stop: (input) => dispatch("script-runner", "scriptRunner", "stop", "mutation", input),
-			getStatus: (input) => dispatch("script-runner", "scriptRunner", "getStatus", "query", input)
-		},
-		smoke: { getStatus: (input) => dispatch("smoke", "smoke", "getStatus", "query", input) },
-		snapshot: {
-			getSnapshot: (input) => dispatch("snapshot", "snapshot", "getSnapshot", "query", input),
-			invalidateCache: (input) => dispatch("snapshot", "snapshot", "invalidateCache", "mutation", input),
-			getStatus: (input) => dispatch("snapshot", "snapshot", "getStatus", "query", input),
-			getDeviceSettingsContribution: (input) => dispatch("snapshot", "snapshot", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatch("snapshot", "snapshot", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatch("snapshot", "snapshot", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		streamCatalog: { getCatalog: (input) => dispatch("stream-catalog", "streamCatalog", "getCatalog", "query", input) },
-		streamParams: {
-			getOptions: (input) => dispatch("stream-params", "streamParams", "getOptions", "query", input),
-			setProfile: (input) => dispatch("stream-params", "streamParams", "setProfile", "mutation", input),
-			getConfigSchema: (input) => dispatch("stream-params", "streamParams", "getConfigSchema", "query", input),
-			getStatus: (input) => dispatch("stream-params", "streamParams", "getStatus", "query", input)
-		},
-		switch: {
-			setState: (input) => dispatch("switch", "switch", "setState", "mutation", input),
-			getStatus: (input) => dispatch("switch", "switch", "getStatus", "query", input)
-		},
-		tamper: { getStatus: (input) => dispatch("tamper", "tamper", "getStatus", "query", input) },
-		temperatureSensor: { getStatus: (input) => dispatch("temperature-sensor", "temperatureSensor", "getStatus", "query", input) },
-		update: {
-			installUpdate: (input) => dispatch("update", "update", "installUpdate", "mutation", input),
-			getStatus: (input) => dispatch("update", "update", "getStatus", "query", input)
-		},
-		vacuumControl: {
-			start: (input) => dispatch("vacuum-control", "vacuumControl", "start", "mutation", input),
-			pause: (input) => dispatch("vacuum-control", "vacuumControl", "pause", "mutation", input),
-			stop: (input) => dispatch("vacuum-control", "vacuumControl", "stop", "mutation", input),
-			returnToBase: (input) => dispatch("vacuum-control", "vacuumControl", "returnToBase", "mutation", input),
-			locate: (input) => dispatch("vacuum-control", "vacuumControl", "locate", "mutation", input),
-			setFanSpeed: (input) => dispatch("vacuum-control", "vacuumControl", "setFanSpeed", "mutation", input),
-			getStatus: (input) => dispatch("vacuum-control", "vacuumControl", "getStatus", "query", input)
-		},
-		valve: {
-			open: (input) => dispatch("valve", "valve", "open", "mutation", input),
-			close: (input) => dispatch("valve", "valve", "close", "mutation", input),
-			stop: (input) => dispatch("valve", "valve", "stop", "mutation", input),
-			setPosition: (input) => dispatch("valve", "valve", "setPosition", "mutation", input),
-			getStatus: (input) => dispatch("valve", "valve", "getStatus", "query", input)
-		},
-		vibration: { getStatus: (input) => dispatch("vibration", "vibration", "getStatus", "query", input) },
-		videoclips: {
-			listClips: (input) => dispatch("videoclips", "videoclips", "listClips", "query", input),
-			getClipPlayback: (input) => dispatch("videoclips", "videoclips", "getClipPlayback", "query", input)
-		},
-		waterHeater: {
-			setTargetTemp: (input) => dispatch("water-heater", "waterHeater", "setTargetTemp", "mutation", input),
-			setOperationMode: (input) => dispatch("water-heater", "waterHeater", "setOperationMode", "mutation", input),
-			setAway: (input) => dispatch("water-heater", "waterHeater", "setAway", "mutation", input),
-			getStatus: (input) => dispatch("water-heater", "waterHeater", "getStatus", "query", input)
-		},
-		weather: { getStatus: (input) => dispatch("weather", "weather", "getStatus", "query", input) },
-		webrtcSession: {
-			listStreams: (input) => dispatch("webrtc-session", "webrtcSession", "listStreams", "query", input),
-			createSession: (input) => dispatch("webrtc-session", "webrtcSession", "createSession", "mutation", input),
-			handleOffer: (input) => dispatch("webrtc-session", "webrtcSession", "handleOffer", "mutation", input),
-			handleAnswer: (input) => dispatch("webrtc-session", "webrtcSession", "handleAnswer", "mutation", input),
-			addIceCandidate: (input) => dispatch("webrtc-session", "webrtcSession", "addIceCandidate", "mutation", input),
-			getIceCandidates: (input) => dispatch("webrtc-session", "webrtcSession", "getIceCandidates", "query", input),
-			closeSession: (input) => dispatch("webrtc-session", "webrtcSession", "closeSession", "mutation", input),
-			hasAdaptiveBitrate: (input) => dispatch("webrtc-session", "webrtcSession", "hasAdaptiveBitrate", "query", input),
-			getSessionState: (input) => dispatch("webrtc-session", "webrtcSession", "getSessionState", "query", input)
-		},
-		zoneAnalytics: {
-			getCurrentSnapshot: (input) => dispatch("zone-analytics", "zoneAnalytics", "getCurrentSnapshot", "query", input),
-			getZoneHistory: (input) => dispatch("zone-analytics", "zoneAnalytics", "getZoneHistory", "query", input),
-			getCameraHistory: (input) => dispatch("zone-analytics", "zoneAnalytics", "getCameraHistory", "query", input),
-			getUnzonedHistory: (input) => dispatch("zone-analytics", "zoneAnalytics", "getUnzonedHistory", "query", input)
-		},
-		zoneRules: {
-			listRules: (input) => dispatch("zone-rules", "zoneRules", "listRules", "query", input),
-			setRules: (input) => dispatch("zone-rules", "zoneRules", "setRules", "mutation", input)
-		},
-		zones: {
-			listZones: (input) => dispatch("zones", "zones", "listZones", "query", input),
-			addZone: (input) => dispatch("zones", "zones", "addZone", "mutation", input),
-			removeZone: (input) => dispatch("zones", "zones", "removeZone", "mutation", input),
-			updateZone: (input) => dispatch("zones", "zones", "updateZone", "mutation", input)
-		},
-		addonSettings: {
-			getDeviceSettings: (input) => dispatchSystem("addonSettings", "getDeviceSettings", "query", input),
-			updateDeviceSettings: (input) => dispatchSystem("addonSettings", "updateDeviceSettings", "mutation", input)
-		},
-		cameraPipelineConfig: {
-			getDeviceSettingsContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("cameraPipelineConfig", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("cameraPipelineConfig", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		deviceAdoption: { getStatus: (input) => dispatchSystem("deviceAdoption", "getStatus", "query", input) },
-		deviceExport: {
-			getDeviceSettingsContribution: (input) => dispatchSystem("deviceExport", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("deviceExport", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("deviceExport", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		deviceManager: {
-			loadConfig: (input) => dispatchSystem("deviceManager", "loadConfig", "query", input),
-			loadRuntimeState: (input) => dispatchSystem("deviceManager", "loadRuntimeState", "query", input),
-			loadMeta: (input) => dispatchSystem("deviceManager", "loadMeta", "query", input),
-			setName: (input) => dispatchSystem("deviceManager", "setName", "mutation", input),
-			setLocation: (input) => dispatchSystem("deviceManager", "setLocation", "mutation", input),
-			setType: (input) => dispatchSystem("deviceManager", "setType", "mutation", input),
-			setIntegrationId: (input) => dispatchSystem("deviceManager", "setIntegrationId", "mutation", input),
-			setLinkDeviceId: (input) => dispatchSystem("deviceManager", "setLinkDeviceId", "mutation", input),
-			setPrimaryChildEntityId: (input) => dispatchSystem("deviceManager", "setPrimaryChildEntityId", "mutation", input),
-			setChildLayout: (input) => dispatchSystem("deviceManager", "setChildLayout", "mutation", input),
-			setDeviceLinks: (input) => dispatchSystem("deviceManager", "setDeviceLinks", "mutation", input),
-			getWireableFields: (input) => dispatchSystem("deviceManager", "getWireableFields", "query", input),
-			setRole: (input) => dispatchSystem("deviceManager", "setRole", "mutation", input),
-			applyInitialMeta: (input) => dispatchSystem("deviceManager", "applyInitialMeta", "mutation", input),
-			setMetadata: (input) => dispatchSystem("deviceManager", "setMetadata", "mutation", input),
-			setDisabled: (input) => dispatchSystem("deviceManager", "setDisabled", "mutation", input),
-			getDevice: (input) => dispatchSystem("deviceManager", "getDevice", "query", input),
-			getStreamSources: (input) => dispatchSystem("deviceManager", "getStreamSources", "query", input),
-			getConfigSchema: (input) => dispatchSystem("deviceManager", "getConfigSchema", "query", input),
-			getSettingsSchema: (input) => dispatchSystem("deviceManager", "getSettingsSchema", "query", input),
-			updateConfig: (input) => dispatchSystem("deviceManager", "updateConfig", "mutation", input),
-			enable: (input) => dispatchSystem("deviceManager", "enable", "mutation", input),
-			disable: (input) => dispatchSystem("deviceManager", "disable", "mutation", input),
-			remove: (input) => dispatchSystem("deviceManager", "remove", "mutation", input),
-			getStreamProfileMap: (input) => dispatchSystem("deviceManager", "getStreamProfileMap", "query", input),
-			setStreamProfileMap: (input) => dispatchSystem("deviceManager", "setStreamProfileMap", "mutation", input),
-			probeStreams: (input) => dispatchSystem("deviceManager", "probeStreams", "mutation", input),
-			getBindings: (input) => dispatchSystem("deviceManager", "getBindings", "query", input),
-			getAllBindings: (input) => dispatchSystem("deviceManager", "getAllBindings", "query", input),
-			setWrapperActive: (input) => dispatchSystem("deviceManager", "setWrapperActive", "mutation", input),
-			getDeviceSettingsAggregate: (input) => dispatchSystem("deviceManager", "getDeviceSettingsAggregate", "query", input),
-			getDeviceLiveInfoAggregate: (input) => dispatchSystem("deviceManager", "getDeviceLiveInfoAggregate", "query", input),
-			getDeviceAggregate: (input) => dispatchSystem("deviceManager", "getDeviceAggregate", "query", input),
-			runDeviceAction: (input) => dispatchSystem("deviceManager", "runDeviceAction", "mutation", input),
-			updateDeviceField: (input) => dispatchSystem("deviceManager", "updateDeviceField", "mutation", input),
-			updateDeviceFieldsBatch: (input) => dispatchSystem("deviceManager", "updateDeviceFieldsBatch", "mutation", input),
-			testField: (input) => dispatchSystem("deviceManager", "testField", "mutation", input),
-			getDeviceStatusAggregate: (input) => dispatchSystem("deviceManager", "getDeviceStatusAggregate", "query", input)
-		},
-		deviceState: {
-			getSnapshot: (input) => dispatchSystem("deviceState", "getSnapshot", "query", input),
-			getCapSlice: (input) => dispatchSystem("deviceState", "getCapSlice", "query", input),
-			setCapSlice: (input) => dispatchSystem("deviceState", "setCapSlice", "mutation", input)
-		},
-		faceGallery: { getFaceByTrack: (input) => dispatchSystem("faceGallery", "getFaceByTrack", "query", input) },
-		networkQuality: {
-			getDeviceStats: (input) => dispatchSystem("networkQuality", "getDeviceStats", "query", input),
-			reportClientStats: (input) => dispatchSystem("networkQuality", "reportClientStats", "mutation", input)
-		},
-		pipelineExecutor: {
-			runPipeline: (input) => dispatchSystem("pipelineExecutor", "runPipeline", "mutation", input),
-			runPipelineBatch: (input) => dispatchSystem("pipelineExecutor", "runPipelineBatch", "mutation", input)
-		},
-		pipelineOrchestrator: {
-			assignPipeline: (input) => dispatchSystem("pipelineOrchestrator", "assignPipeline", "mutation", input),
-			unassignPipeline: (input) => dispatchSystem("pipelineOrchestrator", "unassignPipeline", "mutation", input),
-			getPipelineAssignment: (input) => dispatchSystem("pipelineOrchestrator", "getPipelineAssignment", "query", input),
-			getCameraMetrics: (input) => dispatchSystem("pipelineOrchestrator", "getCameraMetrics", "query", input),
-			assignDecoder: (input) => dispatchSystem("pipelineOrchestrator", "assignDecoder", "mutation", input),
-			unassignDecoder: (input) => dispatchSystem("pipelineOrchestrator", "unassignDecoder", "mutation", input),
-			assignAudio: (input) => dispatchSystem("pipelineOrchestrator", "assignAudio", "mutation", input),
-			unassignAudio: (input) => dispatchSystem("pipelineOrchestrator", "unassignAudio", "mutation", input),
-			getAudioAssignment: (input) => dispatchSystem("pipelineOrchestrator", "getAudioAssignment", "query", input),
-			getAudioAssignments: (input) => dispatchSystem("pipelineOrchestrator", "getAudioAssignments", "query", input),
-			getDecoderAssignment: (input) => dispatchSystem("pipelineOrchestrator", "getDecoderAssignment", "query", input),
-			getCameraSettings: (input) => dispatchSystem("pipelineOrchestrator", "getCameraSettings", "query", input),
-			setCameraStepToggle: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepToggle", "mutation", input),
-			getCameraStepOverrides: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStepOverrides", "query", input),
-			setCameraStepOverride: (input) => dispatchSystem("pipelineOrchestrator", "setCameraStepOverride", "mutation", input),
-			setCameraPipelineForAgent: (input) => dispatchSystem("pipelineOrchestrator", "setCameraPipelineForAgent", "mutation", input),
-			resolvePipeline: (input) => dispatchSystem("pipelineOrchestrator", "resolvePipeline", "query", input),
-			getCameraStatus: (input) => dispatchSystem("pipelineOrchestrator", "getCameraStatus", "query", input),
-			getDeviceSettingsContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("pipelineOrchestrator", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("pipelineOrchestrator", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		pipelineRunner: {
-			detachCamera: (input) => dispatchSystem("pipelineRunner", "detachCamera", "mutation", input),
-			getCameraMetrics: (input) => dispatchSystem("pipelineRunner", "getCameraMetrics", "query", input)
-		},
-		plateGallery: {
-			listPlates: (input) => dispatchSystem("plateGallery", "listPlates", "query", input),
-			getPlateByTrack: (input) => dispatchSystem("plateGallery", "getPlateByTrack", "query", input)
-		},
-		recording: {
-			getAvailability: (input) => dispatchSystem("recording", "getAvailability", "query", input),
-			getDaysWithRecordings: (input) => dispatchSystem("recording", "getDaysWithRecordings", "query", input),
-			getPlaybackManifest: (input) => dispatchSystem("recording", "getPlaybackManifest", "query", input),
-			getDeviceConfig: (input) => dispatchSystem("recording", "getDeviceConfig", "query", input),
-			locateSegment: (input) => dispatchSystem("recording", "locateSegment", "query", input),
-			readSegmentBytes: (input) => dispatchSystem("recording", "readSegmentBytes", "query", input),
-			setDeviceConfig: (input) => dispatchSystem("recording", "setDeviceConfig", "mutation", input),
-			rescanStorage: (input) => dispatchSystem("recording", "rescanStorage", "mutation", input),
-			pruneFootage: (input) => dispatchSystem("recording", "pruneFootage", "mutation", input),
-			getStatus: (input) => dispatchSystem("recording", "getStatus", "query", input),
-			getDeviceSettingsContribution: (input) => dispatchSystem("recording", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("recording", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("recording", "applyDeviceSettingsPatch", "mutation", input)
-		},
-		snapshotProvider: {
-			supportsDevice: (input) => dispatchSystem("snapshotProvider", "supportsDevice", "query", input),
-			getSnapshot: (input) => dispatchSystem("snapshotProvider", "getSnapshot", "query", input)
-		},
-		streamBroker: {
-			publishCameraStream: (input) => dispatchSystem("streamBroker", "publishCameraStream", "mutation", input),
-			retractCameraStream: (input) => dispatchSystem("streamBroker", "retractCameraStream", "mutation", input),
-			assignProfile: (input) => dispatchSystem("streamBroker", "assignProfile", "mutation", input),
-			unassignProfile: (input) => dispatchSystem("streamBroker", "unassignProfile", "mutation", input),
-			restartProfile: (input) => dispatchSystem("streamBroker", "restartProfile", "mutation", input),
-			getDeviceSettingsContribution: (input) => dispatchSystem("streamBroker", "getDeviceSettingsContribution", "query", input),
-			getDeviceLiveContribution: (input) => dispatchSystem("streamBroker", "getDeviceLiveContribution", "query", input),
-			applyDeviceSettingsPatch: (input) => dispatchSystem("streamBroker", "applyDeviceSettingsPatch", "mutation", input)
-		}
-	};
-}
-//#endregion
 //#region src/utils/zone-rule-eval.ts
 /**
 * Evaluate `rules` against `items`. Returns the items partitioned
@@ -13332,7 +10002,8 @@ function createSystemProxy(api) {
 			listAddonInstances: (input) => dispatch("metricsProvider", "listAddonInstances", "query", input),
 			getAddonStats: (input) => dispatch("metricsProvider", "getAddonStats", "query", input),
 			listNodeProcesses: (input) => dispatch("metricsProvider", "listNodeProcesses", "query", input),
-			killProcess: (input) => dispatch("metricsProvider", "killProcess", "mutation", input)
+			killProcess: (input) => dispatch("metricsProvider", "killProcess", "mutation", input),
+			dumpHeapSnapshot: (input) => dispatch("metricsProvider", "dumpHeapSnapshot", "mutation", input)
 		},
 		mqttBroker: {
 			listBrokers: (input) => dispatch("mqttBroker", "listBrokers", "query", input),
@@ -15096,20 +11767,6 @@ var logDestinationCapability = {
 	}
 };
 //#endregion
-//#region src/capabilities/admin-ui.cap.ts
-var StaticDirOutputSchema = z.object({ staticDir: z.string() });
-var VersionOutputSchema = z.object({ version: z.string() });
-var adminUiCapability = {
-	name: "admin-ui",
-	scope: "system",
-	mode: "singleton",
-	internal: true,
-	methods: {
-		getStaticDir: method(z.void(), StaticDirOutputSchema),
-		getVersion: method(z.void(), VersionOutputSchema)
-	}
-};
-//#endregion
 //#region src/schemas/auth-records.ts
 /**
 * Zod schemas for persisted record types.
@@ -19468,7 +16125,20 @@ var DiskSpaceInfoSchema = z.object({
 var PidResourceStatsSchema = z.object({
 	pid: z.number(),
 	cpu: z.number(),
-	memory: z.number()
+	memory: z.number(),
+	/**
+	* Private (anonymous) resident bytes — the per-process V8 heap + native
+	* allocations NOT shared with other processes (Linux RssAnon). This is the
+	* "real" per-runner cost; summing it across runners is meaningful, unlike
+	* `memory` (RSS), which double-counts the shared mmap'd framework code.
+	* Undefined where /proc is unavailable (e.g. macOS).
+	*/
+	privateBytes: z.number().optional(),
+	/**
+	* Shared file-backed resident bytes (Linux RssFile) — mmap'd framework/lib
+	* code shared copy-on-write across runners. Undefined on macOS.
+	*/
+	sharedBytes: z.number().optional()
 });
 var AddonInstanceSchema = z.object({
 	addonId: z.string(),
@@ -19517,6 +16187,17 @@ var KillProcessResultSchema = z.object({
 	reason: z.string().optional(),
 	signal: z.enum(["SIGTERM", "SIGKILL"]).optional()
 });
+var DumpHeapSnapshotInputSchema = z.object({ 
+/** The addon whose runner should dump a heap snapshot. */
+addonId: z.string() });
+var DumpHeapSnapshotResultSchema = z.object({
+	success: z.boolean(),
+	/** Path of the written .heapsnapshot inside the runner's container/host. */
+	path: z.string().optional(),
+	/** Process pid that was signalled. */
+	pid: z.number().optional(),
+	reason: z.string().optional()
+});
 var SystemMetricsSchema = z.object({
 	cpuPercent: z.number(),
 	memoryPercent: z.number(),
@@ -19577,6 +16258,17 @@ var metricsProviderCapability = {
 		killProcess: method(KillProcessInputSchema, KillProcessResultSchema, {
 			kind: "mutation",
 			auth: "admin"
+		}),
+		/**
+		* Tell the addon's forked runner to write a V8 heap snapshot to disk (via
+		* SIGUSR2 — the runner's diagnostic handler). Also logs its
+		* `process.memoryUsage()` + heap-space breakdown. Refuses pids not in the
+		* live `listNodeProcesses()` snapshot. Use for deep per-addon memory
+		* attribution; copy the returned path off the node to analyze.
+		*/
+		dumpHeapSnapshot: method(DumpHeapSnapshotInputSchema, DumpHeapSnapshotResultSchema, {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -20090,124 +16782,6 @@ var recordingCapability = {
 	}
 };
 //#endregion
-//#region src/capabilities/device-ops.cap.ts
-/**
-* device-ops — device-scoped cap that unifies the per-IDevice operations
-* previously routed through the `.device-ops` Moleculer bridge service.
-*
-* Each worker that hosts live `IDevice` instances auto-registers a native
-* provider for this cap (per device) backed by its local
-* `DeviceRegistry`. Hub-side callers reach it transparently through
-* `ctx.fetchDevice(id).deviceOps.*` — the DeviceProxy injects
-* `deviceId` + `nodeId` and dispatches through the standard cap-router,
-* so there's no parallel bridge path anymore.
-*
-* The surface is intentionally small — every method corresponds to a
-* single action on the live `IDevice` (or `ICameraDevice` for
-* `getStreamSources`). Richer orchestration (enable/disable with
-* integration plumbing, bulk updates) stays in the `device-manager` cap;
-* `device-ops` is the per-device primitive the device-manager routes to.
-*/
-var StreamSourceEntrySchema$1 = z.object({
-	id: z.string(),
-	label: z.string(),
-	protocol: z.enum([
-		"rtsp",
-		"rtmp",
-		"annexb",
-		"http-mjpeg",
-		"webrtc",
-		"custom"
-	]),
-	url: z.string().optional(),
-	resolution: z.object({
-		width: z.number(),
-		height: z.number()
-	}).optional(),
-	fps: z.number().optional(),
-	bitrate: z.number().optional(),
-	codec: z.string().optional(),
-	profileHint: CamProfileSchema.optional(),
-	sdp: z.string().optional()
-});
-var ConfigEntrySchema$1 = z.object({
-	key: z.string(),
-	value: z.unknown()
-});
-var RawStateResultSchema = z.object({
-	/** Originating provider id, e.g. 'homeassistant' | 'reolink' | 'hikvision'. */
-	source: z.string(),
-	/** Opaque, DISPLAY-SAFE upstream blob (no secrets/PII). */
-	data: z.record(z.string(), z.unknown())
-});
-var deviceOpsCapability = {
-	name: "device-ops",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	methods: {
-		/**
-		* Return stream sources for camera-like devices. Non-camera devices
-		* return an empty array (the bridge did the same; preserved for compat).
-		*/
-		getStreamSources: method(z.object({ deviceId: z.number() }), z.array(StreamSourceEntrySchema$1)),
-		/**
-		* Return the device's config entries (key + current value). Used by
-		* the device-manager aggregator when reading the driver's schema+values.
-		*/
-		getConfigEntries: method(z.object({ deviceId: z.number() }), z.array(ConfigEntrySchema$1)),
-		/**
-		* Bulk-apply a config patch via `IDevice.config.setAll`. Covers the
-		* updateConfig / setStreamProfileMap / enable-as-config paths from
-		* the old bridge.
-		*/
-		setConfig: method(z.object({
-			deviceId: z.number(),
-			values: z.record(z.string(), z.unknown())
-		}), z.void(), { kind: "mutation" }),
-		/**
-		* Invoke a device custom action on a forked/remote device (the
-		* cross-process transport for `IDevice.runDeviceAction`). Mirrors
-		* `setConfig` — the device-manager calls this when the device is not
-		* hub-local.
-		*/
-		runAction: method(z.object({
-			deviceId: z.number(),
-			action: z.string().min(1),
-			input: z.unknown()
-		}), z.unknown(), { kind: "mutation" }),
-		/**
-		* Invoke `IDevice.removeDevice()` so the driver can release resources
-		* (close sockets, stop background tasks, …). The device-manager still
-		* performs its own persistence cleanup before/after this call.
-		*/
-		removeDevice: method(z.object({ deviceId: z.number() }), z.void(), { kind: "mutation" }),
-		/**
-		* Build the ConfigUISchema (FormBuilder input shape) from the device's
-		* Zod config schema. Runs on the worker that owns the IDevice so the
-		* Zod types stay local (they're function references, not
-		* serializable). Returns a fully JSON-serializable schema with
-		* sections/fields the admin UI renders directly.
-		*
-		* Needed because the hub-side `device-manager.getSettingsSchema`
-		* couldn't reach forked-worker devices — it had no registry entry
-		* and no cross-process lookup, so the UI silently rendered an empty
-		* settings panel for every worker-owned device.
-		*
-		* Returns `null` when the device isn't found on this worker.
-		*/
-		getSettingsSchema: method(z.object({ deviceId: z.number() }), z.unknown().nullable()),
-		/**
-		* Opt-in: return the device's RAW upstream state (the provider's
-		* cached values) as a display-safe `{ source, data }` blob. Returns
-		* `null` when the device exposes no raw state — the State panel hides
-		* its Raw toggle in that case. One-shot (read the provider's existing
-		* cache; no upstream round-trip).
-		*/
-		getRawState: method(z.object({ deviceId: z.number() }), RawStateResultSchema.nullable(), { auth: "protected" })
-	}
-};
-//#endregion
 //#region src/capabilities/camera-credentials.cap.ts
 /**
 * camera-credentials — device-scoped cap exposing the camera's network
@@ -25791,6 +22365,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"metricsProvider.dumpHeapSnapshot": {
+		capName: "metrics-provider",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"metricsProvider.getAddonStats": {
 		capName: "metrics-provider",
 		capScope: "system",
@@ -28619,59 +25199,6 @@ function cellsToRects(cells, gridWidth, gridHeight, maxRegions) {
 	}));
 }
 //#endregion
-//#region src/utils/sleep.ts
-/**
-* Promise-based timer helpers — used everywhere the codebase needs to
-* wait, back off, or schedule a retry. Before these helpers landed, each
-* call site re-implemented `new Promise(r => setTimeout(r, ms))` inline,
-* with subtle variations (some swallowing cancellation, some not). Two
-* shapes cover every observed use case:
-*
-*  - {@link sleep} for a plain, uncancellable wait — the default choice.
-*  - {@link sleepCancellable} for a wait that wakes early when an
-*    abort signal trips, used by long-running pollers whose teardown
-*    must stop a pending backoff promptly.
-*/
-/**
-* Resolve after `ms` milliseconds. Never rejects, never cancels. The
-* sleep cannot be interrupted; for a wakeable variant use
-* {@link sleepCancellable}.
-*
-* `ms <= 0` resolves on the next microtask via `setTimeout(0)`, which
-* still gives the event loop a chance to drain — useful for breaking
-* up tight async loops without changing call-site semantics.
-*/
-function sleep(ms) {
-	return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
-}
-/**
-* Resolve after `ms` milliseconds OR when `signal.aborted` flips,
-* whichever fires first. The returned promise never rejects — aborted
-* sleeps resolve normally so callers can model "wait or wake" without
-* try/catch noise.
-*
-*   await sleepCancellable(backoffMs, lifecycle.abortSignal)
-*   if (lifecycle.aborted) return
-*
-* If `signal` is already aborted at call time the helper resolves on
-* the next microtask.
-*/
-function sleepCancellable(ms, signal) {
-	if (signal.aborted) return Promise.resolve();
-	return new Promise((resolve) => {
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, Math.max(0, ms));
-		const onAbort = () => {
-			clearTimeout(timer);
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
-//#endregion
 //#region src/helpers/bind-addon-actions.ts
 /**
 * Bind an addon's custom-action catalog to its tRPC surface, returning a