@camstack/types 1.1.45 → 1.1.46

package/dist/addon.js

@@ -1,11 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BdhADtqT.js");
+const require_sleep = require("./sleep-Vh_bux78.js");
+const require_event_category = require("./event-category-BXd6yeJi.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 exports.BaseAddon = require_sleep.BaseAddon;
 exports.DATAPLANE_SECRET_HEADER = require_sleep.DATAPLANE_SECRET_HEADER;
 exports.DeviceType = require_sleep.DeviceType;
 exports.DisposerChain = require_sleep.DisposerChain;
-exports.EventCategory = require_sleep.EventCategory;
+exports.EventCategory = require_event_category.EventCategory;
 exports.ReadinessRegistry = require_sleep.ReadinessRegistry;
 exports.ReadinessTimeoutError = require_sleep.ReadinessTimeoutError;
 exports.adminUiCapability = require_sleep.adminUiCapability;

package/dist/addon.mjs

@@ -1,3 +1,4 @@
-import { A as parseJsonUnknown, D as asString, I as scopeKey, M as ReadinessRegistry, N as ReadinessTimeoutError, S as DeviceType, T as asJsonObject, a as viewerUiCapability, bt as EventCategory, ct as BaseAddon, ft as emitReadiness, i as deviceOpsCapability, j as DATAPLANE_SECRET_HEADER, lt as normalizeAddonInitResult, m as expandCapMethods, o as adminUiCapability, s as createDeviceProxy, t as sleep, xt as DisposerChain } from "./sleep-_sv7WKkq.mjs";
+import { A as parseJsonUnknown, D as asString, I as scopeKey, M as ReadinessRegistry, N as ReadinessTimeoutError, S as DeviceType, T as asJsonObject, a as viewerUiCapability, bt as DisposerChain, ct as BaseAddon, ft as emitReadiness, i as deviceOpsCapability, j as DATAPLANE_SECRET_HEADER, lt as normalizeAddonInitResult, m as expandCapMethods, o as adminUiCapability, s as createDeviceProxy, t as sleep } from "./sleep-Br7r_3fq.mjs";
+import { t as EventCategory } from "./event-category-CFZs3jI4.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 export { BaseAddon, DATAPLANE_SECRET_HEADER, DeviceType, DisposerChain, EventCategory, ReadinessRegistry, ReadinessTimeoutError, adminUiCapability, asJsonObject, asString, createDeviceProxy, deviceOpsCapability, emitReadiness, errMsg, expandCapMethods, normalizeAddonInitResult, parseJsonUnknown, scopeKey, sleep, viewerUiCapability };

package/dist/capabilities/webrtc-session.cap.d.ts

@@ -275,6 +275,13 @@ export declare const webrtcSessionCapability: {
                 sessionId: z.ZodOptional<z.ZodString>;
                 extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strip>>>;
+            hints: z.ZodOptional<z.ZodObject<{
+                viewportWidth: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                viewportHeight: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                devicePixelRatio: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                downlinkMbps: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+                prefersTier: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>, z.ZodObject<{
             sessionId: z.ZodString;
             sdpAnswer: z.ZodString;

package/dist/enums.js

@@ -0,0 +1,15 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_event_category = require("./event-category-BXd6yeJi.js");
+//#region src/enums/event-source-type.ts
+var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
+	EventSourceType["Addon"] = "addon";
+	EventSourceType["Core"] = "core";
+	EventSourceType["Device"] = "device";
+	EventSourceType["Provider"] = "provider";
+	EventSourceType["System"] = "system";
+	return EventSourceType;
+}({});
+//#endregion
+exports.EventCategory = require_event_category.EventCategory;
+exports.EventSourceType = EventSourceType;
+exports.EventSourceType$1 = EventSourceType;

package/dist/enums.mjs

@@ -0,0 +1,12 @@
+import { t as EventCategory } from "./event-category-CFZs3jI4.mjs";
+//#region src/enums/event-source-type.ts
+var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
+	EventSourceType["Addon"] = "addon";
+	EventSourceType["Core"] = "core";
+	EventSourceType["Device"] = "device";
+	EventSourceType["Provider"] = "provider";
+	EventSourceType["System"] = "system";
+	return EventSourceType;
+}({});
+//#endregion
+export { EventCategory, EventSourceType };

package/dist/event-category-BXd6yeJi.js

@@ -0,0 +1,547 @@
+//#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";
+	/**
+	* The cluster camera-source OWNER changed (`clusterRoles.ingestNode`).
+	* Emitted by addon-pipeline-orchestrator whenever it (re)derives node
+	* capabilities — at boot, on agent online/offline, and on an ingest-node
+	* flip. Carries the resolved `ownerNodeId`. The stream-broker consumes it to
+	* keep its ingest-owner-gate decision current WITHOUT a per-`ensureBroker`
+	* cross-process `getIngestOwner` query (push the authority's decision instead
+	* of polling it on the hot path). Idempotent state — re-emitted on every
+	* topology change, so a dropped event self-heals on the next one (plus the
+	* broker's long backstop reconcile query).
+	*/
+	EventCategory["PipelineIngestOwnerChanged"] = "pipeline.ingest-owner-changed";
+	/**
+	* 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";
+	/**
+	* Unified track-lifecycle event: ONE category carrying `phase:
+	* 'start' | 'update' | 'end'` with a rich, typed
+	* `PipelineAnalyticsTrackLifecyclePayload`. Supersedes the thin
+	* `PipelineAnalyticsTrackStarted` / `PipelineAnalyticsTrackEnded`
+	* pair — a consumer subscribes once and branches on `phase`.
+	*/
+	EventCategory["PipelineAnalyticsTrackLifecycle"] = "pipeline-analytics.track-lifecycle";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'start'`). Kept as a soft alias — no known subscribers.
+	*/
+	EventCategory["PipelineAnalyticsTrackStarted"] = "pipeline-analytics.track-started";
+	/**
+	* @deprecated Superseded by {@link PipelineAnalyticsTrackLifecycle}
+	* (`phase:'end'`). Kept as a soft alias — no known subscribers.
+	*/
+	EventCategory["PipelineAnalyticsTrackEnded"] = "pipeline-analytics.track-ended";
+	EventCategory["PipelineAnalyticsDetectionEvent"] = "pipeline-analytics.detection-event";
+	EventCategory["PipelineAnalyticsFrameTracked"] = "pipeline-analytics.frame-tracked";
+	/**
+	* Fired by `addon-post-analysis` when a parked (stationary) object appears
+	* (a track was promoted to a stationary-registry entry) or departs (the
+	* object moved / was removed). Telemetry (D8): lossy, drives a UI refresh of
+	* the dedicated "Stationary" section — never the live event feed. Payload:
+	* `{ deviceId, entryId, className, phase:'appeared'|'departed', timestamp }`.
+	*/
+	EventCategory["PipelineAnalyticsStationaryChanged"] = "pipeline-analytics.stationary-changed";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery face row changes:
+	* `kind:'buffered'` a new detected face was persisted, `'assigned'` /
+	* `'unassigned'` its identity link changed, `'deleted'` the row was
+	* removed. Telemetry semantics (D8): a lost event only delays a refresh,
+	* never a correctness issue. Payload `PipelineAnalyticsFaceGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsFaceGalleryChanged"] = "pipeline-analytics.face-gallery-changed";
+	/**
+	* Fired by `addon-post-analysis` whenever a gallery plate row changes:
+	* `kind:'buffered'` a new read was persisted (`PlateRecognizer.onTrackEnd`),
+	* `'assigned'` / `'unassigned'` its vehicle link changed
+	* (`PlateGalleryProvider`), `'deleted'` the row was removed. Telemetry
+	* semantics (D8): a lost event only delays a refresh, never a correctness
+	* issue. Payload `PipelineAnalyticsPlateGalleryChangedPayload`.
+	*/
+	EventCategory["PipelineAnalyticsPlateGalleryChanged"] = "pipeline-analytics.plate-gallery-changed";
+	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";
+	/**
+	* Progress update from a running model conversion job.
+	* Payload: `{ kind: 'model-convert', phase, sessionId?, pct?, detail? }`.
+	* Emitted by `addon-model-studio` on the converting node.
+	*/
+	EventCategory["ModelConvertProgress"] = "model-convert.progress";
+	return EventCategory;
+}({});
+//#endregion
+Object.defineProperty(exports, "EventCategory", {
+	enumerable: true,
+	get: function() {
+		return EventCategory;
+	}
+});