@camstack/types 1.0.5 → 1.0.7

package/dist/sleep-p-5TJ_dy.js

@@ -0,0 +1,3920 @@
+let zod = require("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, _nodeId) {
+		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, _nodeId) {
+		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 = zod.z.enum([
+	"high",
+	"mid",
+	"low"
+]);
+/** Canonical ordering. Hard-coded; never sorted. */
+var CAM_PROFILE_ORDER = [
+	"high",
+	"mid",
+	"low"
+];
+var CamStreamKindSchema = zod.z.enum([
+	"pull-rtsp",
+	"pull-rtmp",
+	"pull-http",
+	"pull-rfc4571",
+	"push-annexb",
+	"derived"
+]);
+var CamStreamResolutionSchema = zod.z.object({
+	width: zod.z.number().int().positive(),
+	height: zod.z.number().int().positive()
+});
+var CameraStreamSchema = zod.z.object({
+	/** Stable, provider-assigned id unique within the (deviceId) scope. */
+	camStreamId: zod.z.string().min(1),
+	deviceId: zod.z.number().int().nonnegative(),
+	kind: CamStreamKindSchema,
+	/** Required for pull-* kinds. Ignored for push-annexb. */
+	url: zod.z.string().optional(),
+	codec: zod.z.string().optional(),
+	resolution: CamStreamResolutionSchema.optional(),
+	fps: zod.z.number().positive().optional(),
+	/** Human label surfaced in the Admin UI "Camera Stream" dropdown. */
+	label: zod.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: zod.z.array(zod.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: zod.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: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var ProfileSlotStatusSchema = zod.z.enum([
+	"unassigned",
+	"idle",
+	"connecting",
+	"streaming",
+	"error"
+]);
+var ProfileSlotSchema = zod.z.object({
+	deviceId: zod.z.number().int().nonnegative(),
+	profile: CamProfileSchema,
+	/** Broker id the rest of the system addresses: `${deviceId}/${profile}`. */
+	brokerId: zod.z.string(),
+	/** `null` when the profile is unassigned. */
+	sourceCamStreamId: zod.z.string().nullable(),
+	status: ProfileSlotStatusSchema,
+	resolution: CamStreamResolutionSchema.optional(),
+	codec: zod.z.string().optional(),
+	preBufferSec: zod.z.number().nonnegative().optional(),
+	errorMessage: zod.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 = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	protocol: zod.z.enum([
+		"rtsp",
+		"rtmp",
+		"annexb",
+		"http-mjpeg",
+		"webrtc",
+		"custom"
+	]),
+	url: zod.z.string().optional(),
+	resolution: zod.z.object({
+		width: zod.z.number(),
+		height: zod.z.number()
+	}).readonly().optional(),
+	fps: zod.z.number().optional(),
+	bitrate: zod.z.number().optional(),
+	codec: zod.z.string().optional(),
+	profileHint: CamProfileSchema.optional()
+});
+var StreamSourceSchema = zod.z.object({
+	type: zod.z.string(),
+	url: zod.z.string(),
+	videoCodec: zod.z.string().optional(),
+	audioCodec: zod.z.string().optional(),
+	metadata: zod.z.record(zod.z.string(), zod.z.unknown()).readonly().optional()
+});
+var EncodedPacketSchema = zod.z.object({
+	type: zod.z.enum(["video", "audio"]),
+	data: zod.z.instanceof(Uint8Array),
+	pts: zod.z.number(),
+	dts: zod.z.number(),
+	keyframe: zod.z.boolean(),
+	codec: zod.z.string()
+});
+var DecodedFrameSchema = zod.z.object({
+	data: zod.z.instanceof(Uint8Array),
+	width: zod.z.number(),
+	height: zod.z.number(),
+	format: zod.z.enum([
+		"jpeg",
+		"rgb",
+		"bgr",
+		"yuv420",
+		"gray"
+	]),
+	timestamp: zod.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 = zod.z.object({
+	shmId: zod.z.string(),
+	slot: zod.z.number().int().nonnegative(),
+	seq: zod.z.number().int().nonnegative(),
+	width: zod.z.number().int().positive(),
+	height: zod.z.number().int().positive(),
+	format: zod.z.enum([
+		"jpeg",
+		"rgb",
+		"bgr",
+		"yuv420",
+		"gray"
+	]),
+	pts: zod.z.number(),
+	byteLength: zod.z.number().int().nonnegative(),
+	nodeId: zod.z.string(),
+	slotCount: zod.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 = zod.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 = zod.z.object({
+	brokerId: zod.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: zod.z.number().positive().optional(),
+	/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
+	tag: zod.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 = zod.z.object({
+	/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
+	subscriptionId: zod.z.string(),
+	/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
+	maxFps: zod.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 = zod.z.object({
+	data: zod.z.instanceof(Uint8Array),
+	sampleRate: zod.z.number().int().positive(),
+	channels: zod.z.number().int().positive(),
+	timestamp: zod.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 = zod.z.object({
+	brokerId: zod.z.string(),
+	/** Short caller-identity tag (`audio-analyzer`, …) for `listClients`. */
+	tag: zod.z.string().optional()
+});
+/** Result of `stream-broker.subscribeAudioChunks`. */
+var SubscribeAudioChunksResultSchema = zod.z.object({ 
+/** Opaque id passed to `pullAudioChunks` / `unsubscribeAudioChunks`. */
+subscriptionId: zod.z.string() });
+var BrokerStatusSchema = zod.z.enum([
+	"idle",
+	"connecting",
+	"streaming",
+	"error",
+	"stopped"
+]);
+var BrokerStatsSchema = zod.z.object({
+	status: BrokerStatusSchema,
+	inputFps: zod.z.number(),
+	decodeFps: zod.z.number(),
+	encodedSubscribers: zod.z.number(),
+	decodedSubscribers: zod.z.number(),
+	uptimeMs: zod.z.number(),
+	bitrateKbps: zod.z.number(),
+	idrIntervalMs: zod.z.number(),
+	codec: zod.z.string().optional(),
+	totalBytes: zod.z.number(),
+	packetCount: zod.z.number(),
+	rtspClients: zod.z.number(),
+	pipeClients: zod.z.number(),
+	preBufferSec: zod.z.number(),
+	preBufferMs: zod.z.number(),
+	preBufferPackets: zod.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: zod.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: zod.z.object({
+		codec: zod.z.string(),
+		sampleRate: zod.z.number(),
+		channels: zod.z.number(),
+		supported: zod.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 = zod.z.object({
+	profile: CamProfileSchema,
+	/** Profile-keyed broker id, format `${deviceId}/${profile}` (e.g. `"15/high"`). */
+	brokerId: zod.z.string(),
+	url: zod.z.string(),
+	mutedUrl: zod.z.string(),
+	enabled: zod.z.boolean(),
+	codec: zod.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 = zod.z.object({
+	id: zod.z.string(),
+	title: zod.z.string(),
+	description: zod.z.string().optional(),
+	style: zod.z.enum(["card", "accordion"]).optional(),
+	defaultCollapsed: zod.z.boolean().optional(),
+	columns: zod.z.union([
+		zod.z.literal(1),
+		zod.z.literal(2),
+		zod.z.literal(3),
+		zod.z.literal(4)
+	]).optional(),
+	tab: zod.z.string().optional(),
+	location: zod.z.enum(["settings", "top-tab"]).optional(),
+	order: zod.z.number().optional(),
+	fields: zod.z.array(zod.z.any())
+});
+var ContributionTabSchema = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	icon: zod.z.string(),
+	order: zod.z.number().optional()
+});
+var ContributionOutputSchema = zod.z.object({
+	tabs: zod.z.array(ContributionTabSchema).optional(),
+	sections: zod.z.array(ContributionSectionSchema)
+}).nullable();
+var DEVICE_SETTINGS_CONTRIBUTION_METHODS = {
+	getDeviceSettingsContribution: {
+		input: zod.z.object({ deviceId: zod.z.number() }),
+		output: ContributionOutputSchema,
+		kind: "query",
+		auth: "protected"
+	},
+	getDeviceLiveContribution: {
+		input: zod.z.object({ deviceId: zod.z.number() }),
+		output: ContributionOutputSchema,
+		kind: "query",
+		auth: "protected"
+	},
+	applyDeviceSettingsPatch: {
+		input: zod.z.object({
+			deviceId: zod.z.number(),
+			patch: zod.z.record(zod.z.string(), zod.z.unknown())
+		}),
+		output: zod.z.object({ success: zod.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: zod.z.object({ deviceId: zod.z.number() }),
+	output: zod.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 = zod.z.object({ staticDir: zod.z.string() });
+var VersionOutputSchema = zod.z.object({ version: zod.z.string() });
+var adminUiCapability = {
+	name: "admin-ui",
+	scope: "system",
+	mode: "singleton",
+	internal: true,
+	methods: {
+		getStaticDir: method(zod.z.void(), StaticDirOutputSchema),
+		getVersion: method(zod.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 = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	protocol: zod.z.enum([
+		"rtsp",
+		"rtmp",
+		"annexb",
+		"http-mjpeg",
+		"webrtc",
+		"custom"
+	]),
+	url: zod.z.string().optional(),
+	resolution: zod.z.object({
+		width: zod.z.number(),
+		height: zod.z.number()
+	}).optional(),
+	fps: zod.z.number().optional(),
+	bitrate: zod.z.number().optional(),
+	codec: zod.z.string().optional(),
+	profileHint: CamProfileSchema.optional(),
+	sdp: zod.z.string().optional()
+});
+var ConfigEntrySchema = zod.z.object({
+	key: zod.z.string(),
+	value: zod.z.unknown()
+});
+var RawStateResultSchema = zod.z.object({
+	/** Originating provider id, e.g. 'homeassistant' | 'reolink' | 'hikvision'. */
+	source: zod.z.string(),
+	/** Opaque, DISPLAY-SAFE upstream blob (no secrets/PII). */
+	data: zod.z.record(zod.z.string(), zod.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(zod.z.object({ deviceId: zod.z.number() }), zod.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(zod.z.object({ deviceId: zod.z.number() }), zod.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(zod.z.object({
+			deviceId: zod.z.number(),
+			values: zod.z.record(zod.z.string(), zod.z.unknown())
+		}), zod.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(zod.z.object({
+			deviceId: zod.z.number(),
+			action: zod.z.string().min(1),
+			input: zod.z.unknown()
+		}), zod.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(zod.z.object({ deviceId: zod.z.number() }), zod.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(zod.z.object({ deviceId: zod.z.number() }), zod.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(zod.z.object({ deviceId: zod.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
+Object.defineProperty(exports, "BaseAddon", {
+	enumerable: true,
+	get: function() {
+		return BaseAddon;
+	}
+});
+Object.defineProperty(exports, "BrokerStatsSchema", {
+	enumerable: true,
+	get: function() {
+		return BrokerStatsSchema;
+	}
+});
+Object.defineProperty(exports, "BrokerStatusSchema", {
+	enumerable: true,
+	get: function() {
+		return BrokerStatusSchema;
+	}
+});
+Object.defineProperty(exports, "CAM_PROFILE_ORDER", {
+	enumerable: true,
+	get: function() {
+		return CAM_PROFILE_ORDER;
+	}
+});
+Object.defineProperty(exports, "CamProfileSchema", {
+	enumerable: true,
+	get: function() {
+		return CamProfileSchema;
+	}
+});
+Object.defineProperty(exports, "CamStreamKindSchema", {
+	enumerable: true,
+	get: function() {
+		return CamStreamKindSchema;
+	}
+});
+Object.defineProperty(exports, "CamStreamResolutionSchema", {
+	enumerable: true,
+	get: function() {
+		return CamStreamResolutionSchema;
+	}
+});
+Object.defineProperty(exports, "CameraStreamSchema", {
+	enumerable: true,
+	get: function() {
+		return CameraStreamSchema;
+	}
+});
+Object.defineProperty(exports, "ChargingStatus", {
+	enumerable: true,
+	get: function() {
+		return ChargingStatus;
+	}
+});
+Object.defineProperty(exports, "DATAPLANE_SECRET_HEADER", {
+	enumerable: true,
+	get: function() {
+		return DATAPLANE_SECRET_HEADER;
+	}
+});
+Object.defineProperty(exports, "DEVICE_SETTINGS_CONTRIBUTION_METHODS", {
+	enumerable: true,
+	get: function() {
+		return DEVICE_SETTINGS_CONTRIBUTION_METHODS;
+	}
+});
+Object.defineProperty(exports, "DEVICE_STATUS_METHOD", {
+	enumerable: true,
+	get: function() {
+		return DEVICE_STATUS_METHOD;
+	}
+});
+Object.defineProperty(exports, "DecodedAudioChunkSchema", {
+	enumerable: true,
+	get: function() {
+		return DecodedAudioChunkSchema;
+	}
+});
+Object.defineProperty(exports, "DecodedFrameSchema", {
+	enumerable: true,
+	get: function() {
+		return DecodedFrameSchema;
+	}
+});
+Object.defineProperty(exports, "DeviceFeature", {
+	enumerable: true,
+	get: function() {
+		return DeviceFeature;
+	}
+});
+Object.defineProperty(exports, "DeviceRole", {
+	enumerable: true,
+	get: function() {
+		return DeviceRole;
+	}
+});
+Object.defineProperty(exports, "DeviceType", {
+	enumerable: true,
+	get: function() {
+		return DeviceType;
+	}
+});
+Object.defineProperty(exports, "DisposerChain", {
+	enumerable: true,
+	get: function() {
+		return DisposerChain;
+	}
+});
+Object.defineProperty(exports, "EncodedPacketSchema", {
+	enumerable: true,
+	get: function() {
+		return EncodedPacketSchema;
+	}
+});
+Object.defineProperty(exports, "EventCategory", {
+	enumerable: true,
+	get: function() {
+		return EventCategory;
+	}
+});
+Object.defineProperty(exports, "FrameHandleFormatSchema", {
+	enumerable: true,
+	get: function() {
+		return FrameHandleFormatSchema;
+	}
+});
+Object.defineProperty(exports, "FrameHandleSchema", {
+	enumerable: true,
+	get: function() {
+		return FrameHandleSchema;
+	}
+});
+Object.defineProperty(exports, "ProfileRtspEntrySchema", {
+	enumerable: true,
+	get: function() {
+		return ProfileRtspEntrySchema;
+	}
+});
+Object.defineProperty(exports, "ProfileSlotSchema", {
+	enumerable: true,
+	get: function() {
+		return ProfileSlotSchema;
+	}
+});
+Object.defineProperty(exports, "ProfileSlotStatusSchema", {
+	enumerable: true,
+	get: function() {
+		return ProfileSlotStatusSchema;
+	}
+});
+Object.defineProperty(exports, "RawStateResultSchema", {
+	enumerable: true,
+	get: function() {
+		return RawStateResultSchema;
+	}
+});
+Object.defineProperty(exports, "ReadinessRegistry", {
+	enumerable: true,
+	get: function() {
+		return ReadinessRegistry;
+	}
+});
+Object.defineProperty(exports, "ReadinessTimeoutError", {
+	enumerable: true,
+	get: function() {
+		return ReadinessTimeoutError;
+	}
+});
+Object.defineProperty(exports, "StreamSourceEntrySchema", {
+	enumerable: true,
+	get: function() {
+		return StreamSourceEntrySchema$1;
+	}
+});
+Object.defineProperty(exports, "StreamSourceSchema", {
+	enumerable: true,
+	get: function() {
+		return StreamSourceSchema;
+	}
+});
+Object.defineProperty(exports, "SubscribeAudioChunksInputSchema", {
+	enumerable: true,
+	get: function() {
+		return SubscribeAudioChunksInputSchema;
+	}
+});
+Object.defineProperty(exports, "SubscribeAudioChunksResultSchema", {
+	enumerable: true,
+	get: function() {
+		return SubscribeAudioChunksResultSchema;
+	}
+});
+Object.defineProperty(exports, "SubscribeFramesInputSchema", {
+	enumerable: true,
+	get: function() {
+		return SubscribeFramesInputSchema;
+	}
+});
+Object.defineProperty(exports, "SubscribeFramesResultSchema", {
+	enumerable: true,
+	get: function() {
+		return SubscribeFramesResultSchema;
+	}
+});
+Object.defineProperty(exports, "WELL_KNOWN_TABS", {
+	enumerable: true,
+	get: function() {
+		return WELL_KNOWN_TABS;
+	}
+});
+Object.defineProperty(exports, "WELL_KNOWN_TAB_MAP", {
+	enumerable: true,
+	get: function() {
+		return WELL_KNOWN_TAB_MAP;
+	}
+});
+Object.defineProperty(exports, "adminUiCapability", {
+	enumerable: true,
+	get: function() {
+		return adminUiCapability;
+	}
+});
+Object.defineProperty(exports, "asBoolean", {
+	enumerable: true,
+	get: function() {
+		return asBoolean;
+	}
+});
+Object.defineProperty(exports, "asJsonArray", {
+	enumerable: true,
+	get: function() {
+		return asJsonArray;
+	}
+});
+Object.defineProperty(exports, "asJsonObject", {
+	enumerable: true,
+	get: function() {
+		return asJsonObject;
+	}
+});
+Object.defineProperty(exports, "asNumber", {
+	enumerable: true,
+	get: function() {
+		return asNumber;
+	}
+});
+Object.defineProperty(exports, "asString", {
+	enumerable: true,
+	get: function() {
+		return asString;
+	}
+});
+Object.defineProperty(exports, "createDeviceProxy", {
+	enumerable: true,
+	get: function() {
+		return createDeviceProxy;
+	}
+});
+Object.defineProperty(exports, "createDurableState", {
+	enumerable: true,
+	get: function() {
+		return createDurableState;
+	}
+});
+Object.defineProperty(exports, "createEvent", {
+	enumerable: true,
+	get: function() {
+		return createEvent;
+	}
+});
+Object.defineProperty(exports, "createLazyTrpcSource", {
+	enumerable: true,
+	get: function() {
+		return createLazyTrpcSource;
+	}
+});
+Object.defineProperty(exports, "createMirrorSource", {
+	enumerable: true,
+	get: function() {
+		return createMirrorSource;
+	}
+});
+Object.defineProperty(exports, "createSliceHandle", {
+	enumerable: true,
+	get: function() {
+		return createSliceHandle;
+	}
+});
+Object.defineProperty(exports, "deviceOpsCapability", {
+	enumerable: true,
+	get: function() {
+		return deviceOpsCapability;
+	}
+});
+Object.defineProperty(exports, "emitDownForOwnedCaps", {
+	enumerable: true,
+	get: function() {
+		return emitDownForOwnedCaps;
+	}
+});
+Object.defineProperty(exports, "emitReadiness", {
+	enumerable: true,
+	get: function() {
+		return emitReadiness;
+	}
+});
+Object.defineProperty(exports, "event", {
+	enumerable: true,
+	get: function() {
+		return event;
+	}
+});
+Object.defineProperty(exports, "expandCapMethods", {
+	enumerable: true,
+	get: function() {
+		return expandCapMethods;
+	}
+});
+Object.defineProperty(exports, "hydrateSchema", {
+	enumerable: true,
+	get: function() {
+		return hydrateSchema;
+	}
+});
+Object.defineProperty(exports, "isDeviceConfigCap", {
+	enumerable: true,
+	get: function() {
+		return isDeviceConfigCap;
+	}
+});
+Object.defineProperty(exports, "isEvent", {
+	enumerable: true,
+	get: function() {
+		return isEvent;
+	}
+});
+Object.defineProperty(exports, "makeProfileBrokerId", {
+	enumerable: true,
+	get: function() {
+		return makeProfileBrokerId;
+	}
+});
+Object.defineProperty(exports, "makeSourceBrokerId", {
+	enumerable: true,
+	get: function() {
+		return makeSourceBrokerId;
+	}
+});
+Object.defineProperty(exports, "method", {
+	enumerable: true,
+	get: function() {
+		return method;
+	}
+});
+Object.defineProperty(exports, "normalizeAddonInitResult", {
+	enumerable: true,
+	get: function() {
+		return normalizeAddonInitResult;
+	}
+});
+Object.defineProperty(exports, "parseJsonArray", {
+	enumerable: true,
+	get: function() {
+		return parseJsonArray;
+	}
+});
+Object.defineProperty(exports, "parseJsonObject", {
+	enumerable: true,
+	get: function() {
+		return parseJsonObject;
+	}
+});
+Object.defineProperty(exports, "parseJsonUnknown", {
+	enumerable: true,
+	get: function() {
+		return parseJsonUnknown;
+	}
+});
+Object.defineProperty(exports, "parseProfileBrokerId", {
+	enumerable: true,
+	get: function() {
+		return parseProfileBrokerId;
+	}
+});
+Object.defineProperty(exports, "readinessKey", {
+	enumerable: true,
+	get: function() {
+		return readinessKey;
+	}
+});
+Object.defineProperty(exports, "scopeKey", {
+	enumerable: true,
+	get: function() {
+		return scopeKey;
+	}
+});
+Object.defineProperty(exports, "selectAssignedProfileSlots", {
+	enumerable: true,
+	get: function() {
+		return selectAssignedProfileSlots;
+	}
+});
+Object.defineProperty(exports, "sleep", {
+	enumerable: true,
+	get: function() {
+		return sleep;
+	}
+});
+Object.defineProperty(exports, "sleepCancellable", {
+	enumerable: true,
+	get: function() {
+		return sleepCancellable;
+	}
+});