@camstack/types 1.0.5 → 1.0.6

package/dist/sleep-D7JeS58T.mjs

@@ -0,0 +1,3507 @@
+import { z } from "zod";
+//#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/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.
+*
+* 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).
+*/
+function normalizeAddonInitResult(result) {
+	if (result == null) return;
+	if (Array.isArray(result)) return { providers: result };
+	return result;
+}
+//#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$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()
+	}).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()
+});
+//#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/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/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/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"
+	}
+};
+/**
+* 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/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/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/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 = 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 = 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)),
+		/**
+		* 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)),
+		/**
+		* 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/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
+export { SubscribeFramesInputSchema as $, ReadinessTimeoutError as A, CameraStreamSchema as B, asNumber as C, parseJsonUnknown as D, parseJsonObject as E, BrokerStatusSchema as F, FrameHandleSchema as G, DecodedFrameSchema as H, CAM_PROFILE_ORDER as I, ProfileSlotStatusSchema as J, ProfileRtspEntrySchema as K, CamProfileSchema as L, readinessKey as M, scopeKey as N, DATAPLANE_SECRET_HEADER as O, BrokerStatsSchema as P, SubscribeAudioChunksResultSchema as Q, CamStreamKindSchema as R, asJsonObject as S, parseJsonArray as T, EncodedPacketSchema as U, DecodedAudioChunkSchema as V, FrameHandleFormatSchema as W, StreamSourceSchema as X, StreamSourceEntrySchema$1 as Y, SubscribeAudioChunksInputSchema as Z, DeviceFeature as _, adminUiCapability as a, BaseAddon as at, asBoolean as b, createMirrorSource as c, createEvent as ct, DEVICE_STATUS_METHOD as d, WELL_KNOWN_TABS as dt, SubscribeFramesResultSchema as et, event as f, WELL_KNOWN_TAB_MAP as ft, ChargingStatus as g, method as h, DisposerChain as ht, deviceOpsCapability as i, selectAssignedProfileSlots as it, emitDownForOwnedCaps as j, ReadinessRegistry as k, createSliceHandle as l, emitReadiness as lt, isDeviceConfigCap as m, EventCategory as mt, sleepCancellable as n, makeSourceBrokerId as nt, createDeviceProxy as o, normalizeAddonInitResult as ot, expandCapMethods as p, hydrateSchema as pt, ProfileSlotSchema as q, RawStateResultSchema as r, parseProfileBrokerId as rt, createLazyTrpcSource as s, createDurableState as st, sleep as t, makeProfileBrokerId as tt, DEVICE_SETTINGS_CONTRIBUTION_METHODS as u, isEvent as ut, DeviceRole as v, asString as w, asJsonArray as x, DeviceType as y, CamStreamResolutionSchema as z };