@camstack/types 0.1.14 → 0.1.16

package/dist/capabilities/device-manager.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-manager.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-manager.cap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AACrD,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAA;AAUvE;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBA2B3B,CAAA;AAEF,eAAO,MAAM,iBAAiB;;;;iBAI5B,CAAA;AAEF,OAAO,EAAE,uBAAuB,EAAE,CAAA;AAElC,eAAO,MAAM,oBAAoB;;;;;;;;;iBAc/B,CAAA;AAEF;;;6EAG6E;AAC7E,eAAO,MAAM,gBAAgB;;;;;;;;;;iBAU3B,CAAA;AAgBF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBAyBtC,CAAA;AAEF,eAAO,MAAM,yBAAyB;;iBAEpC,CAAA;AAEF,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAA;AAIF,eAAO,MAAM,uBAAuB;;;;;QAOhC;;;6EAGqE;;;;;;;QAOrE,+FAA+F;;;;;;;;;;;;;;QAG/F,6FAA6F;;;;QAG7F,uEAAuE;;;;;QAGvE,kEAAkE;;;;QAMlE,iEAAiE;;;;QAMjE;;;kDAG0C;;;;;;;;;;;;;;QAM1C;6DACqD;;;;;QAOrD;yBACiB;;;;;QAOjB;;;;+DAIuD;;;;;QAUvD;;;;;0EAKkE;;QAMlE;;8CAEsC;;;;QAOtC;;;;yEAIiE;;;;;QAOjE;6DACqD;;;;;QAOrD,6DAA6D;;;;;;;;;;;;;QAQ7D,wEAAwE;;;;;;;;;;;;;;;;;;;QAMxE,+CAA+C;;;;;;;;;;;;;;;;;;;QAM/C,+DAA+D;;;;;;;;;;;;;;;;;;;QAQ/D,8CAA8C;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAM9C,mEAAmE;;;;;;;;QAMnE,+EAA+E;;;;QAQ/E,mDAAmD;;;;;;;QAUnD,8DAA8D;;;;;;QAO9D,gEAAgE;;;;;;QAOhE,qGAAqG;;;;;;QASrG,iGAAiG;;;;QAMjG,wFAAwF;;;;;;;QAUxF,oGAAoG;;;;;;;;;;;QASpG;;;;WAIG;;;;;;;;;;;;;;;;QAeH;;;;;;;WAOG;;;;;;;;;;;;;;QAeH;;;;WAIG;;;;;;;QAYH;;;;;WAKG;;;;QAMH;;;;;;;;WAQG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoCH;;;;;;;WAOG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAmBH;;;;;;WAMG;;;;;;;;;;;;;;;;;QA4BH,2DAA2D;;;;;;;;;QAO3D,oEAAoE;;;;;;;;;;;;;;;;;;;;QAUpE;;;WAGG;;;;;QASH,8DAA8D;;;;;;;;;;;;;;;;QAW9D;;;;;;;WAOG;;;;;;;;;;;;;;;QAaH;;;WAGG;;;;;;;;;;;;;QAWH;;;;;;;;;;;;;;;;;;WAkBG;;;;;;CASkC,CAAA;AAEzC,MAAM,MAAM,sBAAsB,GAAG,OAAO,4BAA4B,EAAE,aAAa,CAAC,OAAO,uBAAuB,CAAC,CAAA;AACvH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/capabilities/device-ops.cap.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const deviceOpsCapability: {
+    readonly name: "device-ops";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly methods: {
+        /**
+         * Return stream sources for camera-like devices. Non-camera devices
+         * return an empty array (the bridge did the same; preserved for compat).
+         */
+        readonly getStreamSources: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            protocol: z.ZodEnum<{
+                custom: "custom";
+                rtsp: "rtsp";
+                rtmp: "rtmp";
+                webrtc: "webrtc";
+                annexb: "annexb";
+                "http-mjpeg": "http-mjpeg";
+            }>;
+            url: z.ZodOptional<z.ZodString>;
+            resolution: z.ZodOptional<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            fps: z.ZodOptional<z.ZodNumber>;
+            bitrate: z.ZodOptional<z.ZodNumber>;
+            codec: z.ZodOptional<z.ZodString>;
+            profileHint: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>;
+            sdp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Return the device's config entries (key + current value). Used by
+         * the device-manager aggregator when reading the driver's schema+values.
+         */
+        readonly getConfigEntries: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnknown;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Bulk-apply a config patch via `IDevice.config.setAll`. Covers the
+         * updateConfig / setStreamProfileMap / enable-as-config paths from
+         * the old bridge.
+         */
+        readonly setConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodVoid, "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.
+         */
+        readonly removeDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodVoid, "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.
+         */
+        readonly getSettingsSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodNullable<z.ZodUnknown>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IDeviceOpsProvider = InferProvider<typeof deviceOpsCapability>;
+//# sourceMappingURL=device-ops.cap.d.ts.map

package/dist/capabilities/device-ops.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-ops.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-ops.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAqClG,eAAO,MAAM,mBAAmB;;;;;QAK5B;;;WAGG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMH;;;WAGG;;;;;;;QAMH;;;;WAIG;;;;;QAUH;;;;WAIG;;;;QAOH;;;;;;;;;;;;;WAaG;;;;;CAMkC,CAAA;AAEzC,MAAM,MAAM,kBAAkB,GAAG,aAAa,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/capabilities/device-provider.cap.d.ts

@@ -0,0 +1,151 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+declare const ProviderStatusSchema: z.ZodObject<{
+    connected: z.ZodBoolean;
+    deviceCount: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const DiscoveredDeviceSchema: z.ZodObject<{
+    externalId: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Candidate handed back from discovery and accepted by
+ * `adoptDiscoveredDevice`. Shape mirrors the in-process
+ * `DiscoveredDevice` interface used by `DeviceDiscovery`.
+ */
+declare const DiscoveryCandidateSchema: z.ZodObject<{
+    stableId: z.ZodString;
+    type: z.ZodEnum<typeof DeviceType>;
+    suggestedName: z.ZodString;
+    prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Flat device summary returned by `createDevice` / `adoptDiscoveredDevice`.
+ * Mirrors `toDeviceShape()` output in `device-management.router.ts` so the
+ * tRPC layer can pass it through without reshaping.
+ */
+declare const DeviceSummarySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    stableId: z.ZodString;
+    addonId: z.ZodString;
+    type: z.ZodString;
+    name: z.ZodString;
+    parentDeviceId: z.ZodNullable<z.ZodNumber>;
+    online: z.ZodBoolean;
+    features: z.ZodArray<z.ZodString>;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Result of a live field test (e.g. probing an RTSP URL during device
+ * creation). Matches the UI-side `FieldProbeResult` in
+ * `interfaces/config-ui.ts` — the admin `FormBuilder` renders the
+ * returned `labels` as chips next to the input.
+ */
+declare const FieldProbeResultSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+    }>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const deviceProviderCapability: {
+    readonly name: "device-provider";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly methods: {
+        readonly start: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        readonly stop: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodVoid, "mutation">;
+        readonly getStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            connected: z.ZodBoolean;
+            deviceCount: z.ZodNumber;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getDevices: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly supportsDiscovery: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly discoverDevices: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            stableId: z.ZodString;
+            type: z.ZodEnum<typeof DeviceType>;
+            suggestedName: z.ZodString;
+            prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>, "mutation">;
+        readonly adoptDiscoveredDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            candidate: z.ZodObject<{
+                stableId: z.ZodString;
+                type: z.ZodEnum<typeof DeviceType>;
+                suggestedName: z.ZodString;
+                prefilledConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodNumber;
+            stableId: z.ZodString;
+            addonId: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodString;
+            parentDeviceId: z.ZodNullable<z.ZodNumber>;
+            online: z.ZodBoolean;
+            features: z.ZodArray<z.ZodString>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, "mutation">;
+        readonly supportsManualCreation: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodBoolean, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Fetch the creation form schema for a given DeviceType. Returns
+         * `null` when the provider does not support manually creating
+         * devices of that type. The output is a `ConfigUISchema` — the
+         * router type-asserts it at the boundary.
+         */
+        readonly getChildCreationSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            type: z.ZodEnum<typeof DeviceType>;
+        }, z.core.$strip>, z.ZodUnknown, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly createDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            type: z.ZodEnum<typeof DeviceType>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            id: z.ZodNumber;
+            stableId: z.ZodString;
+            addonId: z.ZodString;
+            type: z.ZodString;
+            name: z.ZodString;
+            parentDeviceId: z.ZodNullable<z.ZodNumber>;
+            online: z.ZodBoolean;
+            features: z.ZodArray<z.ZodString>;
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Test a single field in the creation form before the device has
+         * been persisted. Typical use: probing an RTSP URL entered by the
+         * user. Providers that don't support field probing return
+         * `{ success: true, message: 'Field test not supported' }`.
+         *
+         * `formValues` is the live snapshot of every field in the form at
+         * the moment the user clicked Test — useful for probes that depend
+         * on multiple fields together (e.g. Reolink autodetect needs host
+         * + credentials + UID + transport mode in a single call). Optional
+         * for backwards compatibility; providers free to ignore it.
+         */
+        readonly testCreationField: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            type: z.ZodEnum<typeof DeviceType>;
+            key: z.ZodString;
+            value: z.ZodUnknown;
+            formValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodEnum<{
+                error: "error";
+                ok: "ok";
+            }>;
+            labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IDeviceProvider = InferProvider<typeof deviceProviderCapability>;
+export { ProviderStatusSchema, DiscoveredDeviceSchema, DiscoveryCandidateSchema, DeviceSummarySchema, FieldProbeResultSchema, };
+//# sourceMappingURL=device-provider.cap.d.ts.map

package/dist/capabilities/device-provider.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-provider.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-provider.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,oBAAoB;;;;iBAIxB,CAAA;AAEF,QAAA,MAAM,sBAAsB;;;;;iBAK1B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,wBAAwB;;;;;iBAK5B,CAAA;AAEF;;;;GAIG;AACH,QAAA,MAAM,mBAAmB;;;;;;;;;;iBAUvB,CAAA;AAEF;;;;;GAKG;AACH,QAAA,MAAM,sBAAsB;;;;;;;iBAI1B,CAAA;AAYF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BjC;;;;;WAKG;;;;;;;;;;;;;;;;;;QAaH;;;;;;;;;;;WAWG;;;;;;;;;;;;;;;CAYkC,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAE5E,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,GACvB,CAAA"}

package/dist/capabilities/device-state.cap.d.ts

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+/**
+ * `deviceState` — generic, cap-agnostic surface for cross-process
+ * access to per-device runtime state. Read pendant for every cap's
+ * runtime-state slice + the canonical write entrypoint. Mirrors the
+ * in-process `BaseDevice.runtimeState` API:
+ *
+ *   - `getSnapshot({deviceId})` → full `Record<capName, slice>`.
+ *   - `getCapSlice({deviceId, capName})` → one slice.
+ *   - `setCapSlice({deviceId, capName, slice})` → unified single-slice
+ *     write. Hub validates (when a cap schema is registered),
+ *     persists to disk (debounced), updates the mirror, and emits
+ *     `onChanged` for that cap.
+ *   - `onChanged` event → fires on every slice change.
+ *
+ * Drivers don't implement this cap directly — the kernel auto-mounts
+ * a singleton provider against `device-manager`'s in-hub mirror.
+ * Every `setCapState` call on a `BaseDevice.runtimeState` ultimately
+ * routes through `setCapSlice` (single cross-layer entrypoint) so
+ * UIs / addons subscribe to a single event channel for every
+ * cap-state change; per-cap events (`battery.onStatusChanged`, …)
+ * remain available for typed consumers but no longer have to be
+ * defined on every new cap with runtime state.
+ */
+export declare const deviceStateCapability: {
+    readonly name: "device-state";
+    readonly scope: "system";
+    readonly mode: "singleton";
+    readonly methods: {
+        /** Full state snapshot for one device. Empty object if no
+         *  cap-keyed slice has been written yet. */
+        readonly getSnapshot: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Single cap slice. Returns null when the slice hasn't been
+         *  written or the device isn't registered. */
+        readonly getCapSlice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            capName: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Whole-system snapshot — every device's full state in one
+         * payload. Used by `SystemManager` for warm-boot: a single
+         * round-trip populates the client mirror so every subsequent
+         * `sm.getDeviceById(id).state.<cap>.value` is sync. Empty inner
+         * record for devices that haven't emitted any slice yet.
+         */
+        readonly getAllSnapshots: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Canonical cross-layer WRITE for one cap-keyed slice. Used by
+         * everyone who needs to publish runtime state for a device:
+         * device providers (via `BaseDevice.runtimeState.setCapState`
+         * which delegates here), system-scope addons (e.g. the pipeline
+         * runner writing the `motion` slice on phase transitions), and
+         * direct cap-router callers in tests.
+         *
+         * Behavior on the hub:
+         *   1. Resolve the device — throws if unknown.
+         *   2. Diff the slice against the current mirror (no-op on
+         *      identical writes — saves disk and event churn).
+         *   3. Update the mirror in place.
+         *   4. Persist the full per-device blob to disk (debounced).
+         *   5. Emit `onChanged` for this cap so subscribers (UI mirror,
+         *      SystemManager, per-cap typed listeners) refresh.
+         *
+         * Schema validation is the caller's responsibility — callers
+         * going through `BaseDevice.runtimeState.setCapState` get the
+         * cap's `runtimeState` schema enforced in-process before the
+         * write reaches here. Direct callers should validate against
+         * the cap's schema themselves.
+         *
+         * No `patch` variant — for shallow merges read the slice via
+         * `getCapSlice` first, merge, and write. The single-writer
+         * conventions on each cap make atomic-merge semantics
+         * unnecessary in practice.
+         */
+        readonly setCapSlice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            capName: z.ZodString;
+            slice: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
+    };
+    readonly events: {
+        /**
+         * Fires whenever a cap-keyed slice changes. Per-event payload
+         * carries the slice that changed — subscribers can render off
+         * the payload alone without re-querying. Filterable by `deviceId`
+         * via the standard `EventFilter` helpers.
+         */
+        readonly onChanged: import("./capability-definition.js").CapabilityEventSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            capName: z.ZodString;
+            slice: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>>;
+    };
+};
+//# sourceMappingURL=device-state.cap.d.ts.map

package/dist/capabilities/device-state.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-state.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-state.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,qBAAqB;;;;;QAK9B;oDAC4C;;;;QAK5C;sDAC8C;;;;;QAK9C;;;;;;WAMG;;QAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;WA2BG;;;;;;;;QAYH;;;;;WAKG;;;;;;;CAOkC,CAAA"}

package/dist/capabilities/device-status.cap.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Generic device-level status snapshot. Auto-registered by `BaseDevice`
+ * for every device, regardless of provider — the kernel needs a uniform
+ * cap-keyed slice for the basic device flags every consumer expects to
+ * read across processes (the `online` flag in particular). Driver-specific
+ * caps (`battery`, `doorbell`, …) carry their domain-specific state on
+ * their own slices.
+ *
+ * Pattern is identical to `battery`: schema-bearing `runtimeState`,
+ * empty `methods`, single change event. Reads land at
+ * `runtimeState.getCapState('device-status')`; writes at
+ * `runtimeState.setCapState('device-status', …)`. Cross-process
+ * consumers reach the same data via the `device-state` cap router
+ * (`getCapSlice({deviceId, capName: 'device-status'})`).
+ */
+export declare const DeviceStatusSchema: z.ZodObject<{
+    online: z.ZodBoolean;
+    lastChangedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type DeviceStatus = z.infer<typeof DeviceStatusSchema>;
+export declare const deviceStatusCapability: {
+    readonly name: "device-status";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly methods: {};
+    readonly events: {
+        /** Emitted when `online` transitions. Mirrors the semantics of
+         *  `battery.onStatusChanged`. */
+        readonly onStatusChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                status: z.ZodObject<{
+                    online: z.ZodBoolean;
+                    lastChangedAt: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            online: z.ZodBoolean;
+            lastChangedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        online: z.ZodBoolean;
+        lastChangedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IDeviceStatusProvider = InferProvider<typeof deviceStatusCapability>;
+//# sourceMappingURL=device-status.cap.d.ts.map

package/dist/capabilities/device-status.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-status.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/device-status.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAE1F;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB;;;iBAY7B,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,eAAO,MAAM,sBAAsB;;;;;;QAM/B;yCACiC;;;;;;;;;;;;;;;;;;;;;;CAWI,CAAA;AAEzC,MAAM,MAAM,qBAAqB,GAAG,aAAa,CAAC,OAAO,sBAAsB,CAAC,CAAA"}

package/dist/capabilities/doorbell.cap.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+/**
+ * Doorbell button cap. Installed on a `DeviceType.Button` accessory
+ * with `role: DeviceRole.Doorbell`. Emits an `onPressed` event every
+ * time the firmware pushes a ring; status tracks the last press and
+ * a pressCount since start (diagnostic).
+ *
+ * The DeviceEventPropagator re-emits `onPressed` on the camera parent
+ * — subscribers listening at the camera level receive ring events
+ * with `via[]` populated. No code on the parent needed.
+ */
+export declare const DoorbellStatusSchema: z.ZodObject<{
+    lastPressedAt: z.ZodNullable<z.ZodNumber>;
+    pressCountSinceStart: z.ZodNumber;
+}, z.core.$strip>;
+export type DoorbellStatus = z.infer<typeof DoorbellStatusSchema>;
+export declare const DoorbellPressEventSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type DoorbellPressEvent = z.infer<typeof DoorbellPressEventSchema>;
+export declare const doorbellCapability: {
+    readonly name: "doorbell";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Button];
+    readonly methods: {};
+    readonly events: {
+        /**
+         * Fires once per physical press. Reolink delivers via Baichuan
+         * push (`ReolinkSimpleEvent.type === 'doorbell'`). There is no
+         * release/duration — it's a pulse.
+         */
+        readonly onPressed: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                timestamp: z.ZodNumber;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            lastPressedAt: z.ZodNullable<z.ZodNumber>;
+            pressCountSinceStart: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    /**
+     * Runtime-state slice — last press timestamp + lifetime press count.
+     * Mirrored by the kernel and readable via
+     * `device.state.doorbell.value`. UIs can show "last ring 5m ago"
+     * without subscribing.
+     */
+    readonly runtimeState: z.ZodObject<{
+        lastPressedAt: z.ZodNullable<z.ZodNumber>;
+        pressCountSinceStart: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IDoorbellProvider = InferProvider<typeof doorbellCapability>;
+//# sourceMappingURL=doorbell.cap.d.ts.map

package/dist/capabilities/doorbell.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doorbell.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/doorbell.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAA6B,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAC1F,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB;;;iBAK/B,CAAA;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEjE,eAAO,MAAM,wBAAwB;;;iBAGnC,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,kBAAkB;;;;;;;QAO3B;;;;WAIG;;;;;;;;;;;;;;;IAOL;;;;;OAKG;;;;;CAEoC,CAAA;AAEzC,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/capabilities/embedding-encoder.cap.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+declare const EmbeddingResultSchema: z.ZodObject<{
+    embedding: z.ZodArray<z.ZodNumber>;
+    dimensions: z.ZodNumber;
+}, z.core.$strip>;
+declare const EmbeddingInfoSchema: z.ZodObject<{
+    modelId: z.ZodString;
+    dimensions: z.ZodNumber;
+    inputSize: z.ZodNumber;
+}, z.core.$strip>;
+export declare const embeddingEncoderCapability: {
+    readonly name: "embedding-encoder";
+    readonly scope: "system";
+    readonly mode: "collection";
+    readonly internal: true;
+    readonly methods: {
+        readonly encode: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            crop: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            embedding: z.ZodArray<z.ZodNumber>;
+            dimensions: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly encodeText: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            embedding: z.ZodArray<z.ZodNumber>;
+            dimensions: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getInfo: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
+            modelId: z.ZodString;
+            dimensions: z.ZodNumber;
+            inputSize: z.ZodNumber;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IEmbeddingEncoderProvider = InferProvider<typeof embeddingEncoderCapability>;
+export { EmbeddingResultSchema, EmbeddingInfoSchema };
+//# sourceMappingURL=embedding-encoder.cap.d.ts.map

package/dist/capabilities/embedding-encoder.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-encoder.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/embedding-encoder.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAElG,QAAA,MAAM,qBAAqB;;;iBAGzB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;CAaE,CAAA;AAEzC,MAAM,MAAM,yBAAyB,GAAG,aAAa,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAExF,OAAO,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,CAAA"}

package/dist/capabilities/events.cap.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+import { DeviceType } from '../device/device-type.js';
+declare const EventItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    timestamp: z.ZodNumber;
+    label: z.ZodOptional<z.ZodString>;
+    thumbnailUrl: z.ZodOptional<z.ZodString>;
+    clipUrl: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export declare const eventsCapability: {
+    readonly name: "events";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly deviceTypes: readonly [DeviceType.Camera];
+    readonly methods: {
+        readonly getEvents: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            from: z.ZodOptional<z.ZodNumber>;
+            to: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            timestamp: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            thumbnailUrl: z.ZodOptional<z.ZodString>;
+            clipUrl: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getEventThumbnail: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            eventId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            contentType: z.ZodString;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly getEventClipUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            eventId: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodString>, import("./capability-definition.js").CapabilityMethodKind>;
+    };
+};
+export type IEventsProvider = InferProvider<typeof eventsCapability>;
+export { EventItemSchema };
+//# sourceMappingURL=events.cap.d.ts.map

package/dist/capabilities/events.cap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.cap.d.ts","sourceRoot":"","sources":["../../src/capabilities/events.cap.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAqC,KAAK,aAAa,EAAE,MAAM,4BAA4B,CAAA;AAClG,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAA;AAErD,QAAA,MAAM,eAAe;;;;;;;;iBAQnB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBY,CAAA;AAEzC,MAAM,MAAM,eAAe,GAAG,aAAa,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACpE,OAAO,EAAE,eAAe,EAAE,CAAA"}

package/dist/capabilities/feature-probe.cap.d.ts

@@ -0,0 +1,79 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+/**
+ * Per-device feature/identity probe slice. Holds the runtime-resolved
+ * truth about what a device CAN do — which the kernel uses to:
+ *   1. Reconcile accessory children (hub-children spawn siren/floodlight/PIR
+ *      based on what the firmware actually advertises).
+ *   2. Compute the public `features: DeviceFeature[]` array surfaced via
+ *      `device-manager.listAll`.
+ *   3. Decide which optional caps (PTZ, intercom, doorbell, battery, …)
+ *      to register on the device's capability surface.
+ *
+ * Auto-registered by `BaseDevice` for every device. Drivers populate the
+ * slice from `onProbe()` (kernel calls it once after register, before
+ * accessory reconciliation). Consumers read via:
+ *   `runtimeState.getCapState<FeatureProbeStatus>('feature-probe')`
+ *
+ * `flags` is an open record so each driver carries its own keys without
+ * a centralized schema bottleneck — Reolink writes `hasPtz/hasIntercom`,
+ * Hikvision writes `hasSupplementalLight/hasAlarmIo`, etc.
+ *
+ * Replaces the older driver-local `deviceCache.has*` blob: the per-device
+ * config is for operator-edited overrides + UI snapshots; runtime probe
+ * results belong in runtime-state where the kernel handles persistence,
+ * cross-process mirroring, and reactive updates.
+ */
+export declare const FeatureProbeStatusSchema: z.ZodObject<{
+    flags: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    deviceType: z.ZodNullable<z.ZodString>;
+    model: z.ZodNullable<z.ZodString>;
+    channelCount: z.ZodNullable<z.ZodNumber>;
+    lastProbedAt: z.ZodNumber;
+    lastFetchedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type FeatureProbeStatus = z.infer<typeof FeatureProbeStatusSchema>;
+export declare const featureProbeCapability: {
+    readonly name: "feature-probe";
+    readonly scope: "device";
+    readonly mode: "singleton";
+    readonly methods: {};
+    readonly events: {
+        /** Fires whenever a fresh probe completes (kernel-driven `reprobe()`
+         *  or driver-initiated re-detect after a state change). */
+        readonly onProbeChanged: {
+            readonly data: z.ZodObject<{
+                deviceId: z.ZodNumber;
+                status: z.ZodObject<{
+                    flags: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                    deviceType: z.ZodNullable<z.ZodString>;
+                    model: z.ZodNullable<z.ZodString>;
+                    channelCount: z.ZodNullable<z.ZodNumber>;
+                    lastProbedAt: z.ZodNumber;
+                    lastFetchedAt: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        };
+    };
+    readonly status: {
+        readonly schema: z.ZodObject<{
+            flags: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            deviceType: z.ZodNullable<z.ZodString>;
+            model: z.ZodNullable<z.ZodString>;
+            channelCount: z.ZodNullable<z.ZodNumber>;
+            lastProbedAt: z.ZodNumber;
+            lastFetchedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        readonly kind: "push";
+    };
+    readonly runtimeState: z.ZodObject<{
+        flags: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        deviceType: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        channelCount: z.ZodNullable<z.ZodNumber>;
+        lastProbedAt: z.ZodNumber;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export type IFeatureProbeProvider = InferProvider<typeof featureProbeCapability>;
+//# sourceMappingURL=feature-probe.cap.d.ts.map