@camstack/types 1.1.46 → 1.1.47

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-Vh_bux78.js");
-const require_event_category = require("./event-category-BXd6yeJi.js");
+const require_sleep = require("./sleep-BkhAiFKX.js");
+const require_event_category = require("./event-category-AkBNxg_X.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 exports.BaseAddon = require_sleep.BaseAddon;
 exports.DATAPLANE_SECRET_HEADER = require_sleep.DATAPLANE_SECRET_HEADER;

package/dist/addon.mjs

@@ -1,4 +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 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 { 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-CK899CTS.mjs";
+import { t as EventCategory } from "./event-category-H4AVePnn.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/device-manager.cap.d.ts

@@ -202,6 +202,19 @@ export declare const ConfigEntrySchema: z.ZodObject<{
     value: z.ZodUnknown;
     description: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+export declare const DeviceLinkModeSchema: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+}>;
+export type DeviceLinkMode = z.infer<typeof DeviceLinkModeSchema>;
+/** One resolved linked device — the compact projection consumers need. */
+export declare const LinkedDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    name: z.ZodString;
+    location: z.ZodNullable<z.ZodString>;
+    features: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type LinkedDevice = z.infer<typeof LinkedDeviceSchema>;
 export { StreamSourceEntrySchema };
 export declare const SavedDeviceRowSchema: z.ZodObject<{
     id: z.ZodNumber;
@@ -331,6 +344,7 @@ export declare const deviceManagerCapability: {
     readonly name: "device-manager";
     readonly scope: "system";
     readonly mode: "singleton";
+    readonly exposesDeviceSettings: true;
     readonly methods: {
         /** Reserve (or re-resolve) a progressive numeric id for `(addonId, stableId)`.
          *  Idempotent: returns the existing id if one is already persisted for the
@@ -1024,6 +1038,29 @@ export declare const deviceManagerCapability: {
                 }, z.core.$strip>>>;
             }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Resolve the devices LINKED to a camera — the single policy authority
+         * both consumers call (viewer devices panel + pipeline-analytics event
+         * kinds/ingest). Device-tree children are ALWAYS included; mode 'auto'
+         * (default) adds every device sharing the camera's non-null `location`,
+         * mode 'manual' adds the persisted manual list instead. Excludes the
+         * camera itself; deduped. Configuration is standard per-device settings
+         * (see the module docblock) — there are no bespoke link mutations.
+         */
+        readonly getLinkedDevices: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            mode: z.ZodEnum<{
+                manual: "manual";
+                auto: "auto";
+            }>;
+            devices: z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                name: z.ZodString;
+                location: z.ZodNullable<z.ZodString>;
+                features: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Get stream sources for a camera device. */
         readonly getStreamSources: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;

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

@@ -2,10 +2,23 @@ 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).
+ * Doorbell button cap. Two kinds of providers coexist behind this cap
+ * name (same pattern as `snapshot`):
+ *
+ *   - **Native** providers: registered per-device by device-driver
+ *     addons via `ctx.registerNativeCap` — either on a
+ *     `DeviceType.Button` accessory with `role: DeviceRole.Doorbell`,
+ *     or directly on the camera (Reolink registers at camera level).
+ *     Emits an `onPressed` event every time the firmware pushes a
+ *     ring; status tracks the last press and a pressCount since start
+ *     (diagnostic).
+ *
+ *   - **Wrapper** provider: the `virtual-doorbell` system builtin
+ *     (`@camstack/system/builtins/doorbell`). Turns ANY binary-ish
+ *     device (contact / switch / event-emitter …) into a doorbell for
+ *     a camera. `defaultActive: false` — the operator explicitly binds
+ *     it per camera in the device-bindings UI, then picks the source
+ *     device + trigger in the per-device settings.
  *
  * The DeviceEventPropagator re-emits `onPressed` on the camera parent
  * — subscribers listening at the camera level receive ring events
@@ -26,7 +39,10 @@ export declare const doorbellCapability: {
     readonly scope: "device";
     readonly deviceNative: true;
     readonly mode: "singleton";
-    readonly deviceTypes: readonly [DeviceType.Button];
+    readonly kind: "wrapper";
+    readonly defaultActive: false;
+    readonly deviceTypes: readonly [DeviceType.Button, DeviceType.Camera];
+    readonly exposesDeviceSettings: true;
     readonly methods: {};
     readonly events: {
         /**

package/dist/capabilities/index.d.ts

@@ -54,7 +54,7 @@ export { AdoptInputSchema as AdoptionAdoptInputSchema, type AdoptionFilter, Adop
 export type { IDeviceExportProvider } from './device-export.cap.js';
 export { DeviceExportStatusSchema, deviceExportCapability, ExportSetupFieldSchema, ExportSetupSchema, ExposedDeviceSchema, ExposeInputSchema as DeviceExportExposeInputSchema, UnexposeInputSchema as DeviceExportUnexposeInputSchema, } from './device-export.cap.js';
 export type { DeviceInfo, DeviceManagerApplyInitialMetaInput } from './device-manager.cap.js';
-export { ConfigEntrySchema, DeviceInfoSchema, deviceManagerCapability, type IDeviceManagerProvider, } from './device-manager.cap.js';
+export { ConfigEntrySchema, DeviceInfoSchema, type DeviceLinkMode, DeviceLinkModeSchema, deviceManagerCapability, type IDeviceManagerProvider, type LinkedDevice, LinkedDeviceSchema, } from './device-manager.cap.js';
 export { DiscoveredDeviceSchema, deviceProviderCapability, ProviderStatusSchema, } from './device-provider.cap.js';
 export { deviceStateCapability } from './device-state.cap.js';
 export type { IEmbeddingEncoderProvider } from './embedding-encoder.cap.js';
@@ -77,7 +77,8 @@ export { type ILlmProvider, type LlmDefault, type LlmDefaultSelector, LlmDefault
 export { type ILlmRuntimeProvider, llmRuntimeCapability, type LlmNodeModel, LlmNodeModelSchema, type LlmRuntimeCompleteInput, LlmRuntimeCompleteInputSchema, type LlmRuntimeDiskUsage, LlmRuntimeDiskUsageSchema, type LlmRuntimeStatus, LlmRuntimeStatusSchema, type ManagedModelRef, ManagedModelRefSchema, type ManagedRuntimeConfig, ManagedRuntimeConfigSchema, } from './llm-runtime.cap.js';
 export { type LlmErrorCode, LlmErrorCodeSchema, type LlmGenerateBaseInput, LlmGenerateBaseInputSchema, type LlmGenerateErr, LlmGenerateErrSchema, type LlmGenerateOk, LlmGenerateOkSchema, type LlmGenerateResult, LlmGenerateResultSchema, type LlmImage, LlmImageSchema, type LlmUsage, LlmUsageSchema, } from './llm-shared.js';
 export { type IOauthIntegrationProvider, type OauthIntegrationDescriptor, OauthIntegrationDescriptorSchema, oauthIntegrationCapability, } from './oauth-integration.cap.js';
-export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, EventKindSchema, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type ScoredObjectEvent, ScoredObjectEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, TrackedDetectionSchema, TrackSchema, type TrackState, TrackStateSchema, } from './pipeline-analytics.cap.js';
+export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type MediaFile, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, TrackedDetectionSchema, type TrackEnvelope, TrackEnvelopeSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, } from './pipeline-analytics.cap.js';
+export { EVENT_KIND_BY_CAP, type SensorEventKindDescriptor } from './sensor-event-kinds.js';
 export type { PipelineStepInputOutput, PipelineValidationIssue, PipelineValidationResult, } from './pipeline-executor.cap.js';
 export { ModelSubstitutionSchema, PipelineDefaultStepSchema, PipelineEngineChoiceSchema, PipelineRunResultBridge, PipelineStepInputSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, pipelineExecutorCapability, } from './pipeline-executor.cap.js';
 export type { CameraAssignmentStatus, CameraAudioStatus, CameraBrokerProfile, CameraBrokerStatus, CameraDecoderShm, CameraDecoderStatus, CameraDetectionPhase, CameraDetectionProvisioning, CameraDetectionProvisioningState, CameraDetectionStatus, CameraMotionStatus, CameraRecordingMode, CameraRecordingStatus, CameraSourceStatus, CameraSourceStream, CameraStatus, IngestOwner, } from './pipeline-orchestrator.cap.js';

package/dist/capabilities/pipeline-analytics.cap.d.ts

@@ -39,6 +39,116 @@ declare const EventKindSchema: z.ZodEnum<{
     motion: "motion";
 }>;
 export type EventKind = z.infer<typeof EventKindSchema>;
+/**
+ * Spatial filter for `listTracks` — the rect + polygon variants of the shared
+ * MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
+ * of the camera frame (top-left origin), matching the drawing-plane editor.
+ */
+declare const TrackZoneFilterSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"rect">;
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"polygon">;
+    points: z.ZodArray<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export type TrackZoneFilter = z.infer<typeof TrackZoneFilterSchema>;
+/** Closed icon vocabulary so clients render a known glyph per kind. */
+export declare const EventKindIconSchema: z.ZodEnum<{
+    button: "button";
+    generic: "generic";
+    audio: "audio";
+    person: "person";
+    vehicle: "vehicle";
+    animal: "animal";
+    motion: "motion";
+    door: "door";
+    pir: "pir";
+    smoke: "smoke";
+    water: "water";
+}>;
+export type EventKindIcon = z.infer<typeof EventKindIconSchema>;
+export declare const EventKindCategorySchema: z.ZodEnum<{
+    sensor: "sensor";
+    audio: "audio";
+    custom: "custom";
+    motion: "motion";
+    detection: "detection";
+}>;
+export type EventKindCategory = z.infer<typeof EventKindCategorySchema>;
+declare const EventKindDescriptorSchema: z.ZodObject<{
+    kind: z.ZodString;
+    label: z.ZodString;
+    color: z.ZodString;
+    icon: z.ZodEnum<{
+        button: "button";
+        generic: "generic";
+        audio: "audio";
+        person: "person";
+        vehicle: "vehicle";
+        animal: "animal";
+        motion: "motion";
+        door: "door";
+        pir: "pir";
+        smoke: "smoke";
+        water: "water";
+    }>;
+    category: z.ZodEnum<{
+        sensor: "sensor";
+        audio: "audio";
+        custom: "custom";
+        motion: "motion";
+        detection: "detection";
+    }>;
+    source: z.ZodObject<{
+        capName: z.ZodString;
+        deviceId: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EventKindDescriptor = z.infer<typeof EventKindDescriptorSchema>;
+declare const SensorEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    deviceId: z.ZodNumber;
+    sourceDeviceId: z.ZodNumber;
+    kind: z.ZodString;
+    value: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type SensorEvent = z.infer<typeof SensorEventSchema>;
+/**
+ * Normalized 0..1 trajectory envelope (min/max over every position bbox,
+ * divided by the track's detection-frame dims), computed at persist time.
+ * Absent when the frame dims were unknown when the track was persisted
+ * (legacy rows / dims-less sources) and on active (in-RAM) tracks.
+ */
+declare const TrackEnvelopeSchema: z.ZodObject<{
+    minX: z.ZodNumber;
+    minY: z.ZodNumber;
+    maxX: z.ZodNumber;
+    maxY: z.ZodNumber;
+}, z.core.$strip>;
+export type TrackEnvelope = z.infer<typeof TrackEnvelopeSchema>;
+/**
+ * Row projection for track list queries. `full` (default) returns the
+ * complete Track including the frame-rate `positions[]` history and the
+ * `snapshots[]` references — megabytes across a page of tracks. `slim`
+ * keeps every scalar the list surfaces actually render (ids, class(es),
+ * label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
+ * zonesVisited, bestEventId, envelope) and returns `positions` /
+ * `snapshots` as EMPTY arrays — detail views re-fetch the full row via
+ * `getTrack`. Mirrors the event-store `projection` convention
+ * (`getObjectEvents` et al.).
+ */
+declare const TrackProjectionSchema: z.ZodEnum<{
+    full: "full";
+    slim: "slim";
+}>;
+export type TrackProjection = z.infer<typeof TrackProjectionSchema>;
 /**
  * One audio-classification label heard on the track's camera while the
  * track was alive, aggregated per label. An "episode" is one persisted
@@ -108,6 +218,12 @@ declare const TrackSchema: z.ZodObject<{
         firstAt: z.ZodNumber;
         lastAt: z.ZodNumber;
     }, z.core.$strip>>>>;
+    envelope: z.ZodOptional<z.ZodObject<{
+        minX: z.ZodNumber;
+        minY: z.ZodNumber;
+        maxX: z.ZodNumber;
+        maxY: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Track = z.infer<typeof TrackSchema>;
 declare const MotionEventSchema: z.ZodObject<{
@@ -227,6 +343,83 @@ declare const MediaFileSchema: z.ZodObject<{
     timestamp: z.ZodNumber;
 }, z.core.$strip>;
 export type MediaFile = z.infer<typeof MediaFileSchema>;
+declare const RecentTracksQueryInput: z.ZodObject<{
+    deviceIds: z.ZodArray<z.ZodNumber>;
+    since: z.ZodOptional<z.ZodNumber>;
+    until: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    projection: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        slim: "slim";
+    }>>;
+}, z.core.$strip>;
+export type RecentTracksQuery = z.infer<typeof RecentTracksQueryInput>;
+declare const RecentTracksPageSchema: z.ZodObject<{
+    tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        trackId: z.ZodString;
+        deviceId: z.ZodNumber;
+        className: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        firstSeen: z.ZodNumber;
+        lastSeen: z.ZodNumber;
+        positions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            timestamp: z.ZodNumber;
+            bbox: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>;
+        snapshots: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            timestamp: z.ZodNumber;
+            position: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                timestamp: z.ZodNumber;
+                bbox: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            mediaKey: z.ZodString;
+        }, z.core.$strip>>>;
+        zonesVisited: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        classes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        totalDistance: z.ZodNumber;
+        state: z.ZodEnum<{
+            moving: "moving";
+            left: "left";
+            idle: "idle";
+            new: "new";
+            entered: "entered";
+        }>;
+        active: z.ZodBoolean;
+        importance: z.ZodOptional<z.ZodNumber>;
+        bestEventId: z.ZodOptional<z.ZodString>;
+        importanceReason: z.ZodOptional<z.ZodString>;
+        audioLabels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            peakScore: z.ZodNumber;
+            count: z.ZodNumber;
+            firstAt: z.ZodNumber;
+            lastAt: z.ZodNumber;
+        }, z.core.$strip>>>>;
+        envelope: z.ZodOptional<z.ZodObject<{
+            minX: z.ZodNumber;
+            minY: z.ZodNumber;
+            maxX: z.ZodNumber;
+            maxY: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RecentTracksPage = z.infer<typeof RecentTracksPageSchema>;
 declare const KeyEventSchema: z.ZodObject<{
     id: z.ZodString;
     trackId: z.ZodString;
@@ -368,6 +561,12 @@ export declare const pipelineAnalyticsCapability: {
                 firstAt: z.ZodNumber;
                 lastAt: z.ZodNumber;
             }, z.core.$strip>>>>;
+            envelope: z.ZodOptional<z.ZodObject<{
+                minX: z.ZodNumber;
+                minY: z.ZodNumber;
+                maxX: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly getTrack: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -426,6 +625,12 @@ export declare const pipelineAnalyticsCapability: {
                 firstAt: z.ZodNumber;
                 lastAt: z.ZodNumber;
             }, z.core.$strip>>>>;
+            envelope: z.ZodOptional<z.ZodObject<{
+                minX: z.ZodNumber;
+                minY: z.ZodNumber;
+                maxX: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Historical completed tracks for a device. Queried from the
          *  persisted `pipeline-analytics:tracks` collection; active tracks
@@ -435,6 +640,23 @@ export declare const pipelineAnalyticsCapability: {
             since: z.ZodOptional<z.ZodNumber>;
             until: z.ZodOptional<z.ZodNumber>;
             limit: z.ZodOptional<z.ZodNumber>;
+            zone: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"rect">;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"polygon">;
+                points: z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "kind">>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                slim: "slim";
+            }>>;
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             trackId: z.ZodString;
             deviceId: z.ZodNumber;
@@ -489,7 +711,97 @@ export declare const pipelineAnalyticsCapability: {
                 firstAt: z.ZodNumber;
                 lastAt: z.ZodNumber;
             }, z.core.$strip>>>>;
+            envelope: z.ZodOptional<z.ZodObject<{
+                minX: z.ZodNumber;
+                minY: z.ZodNumber;
+                maxX: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Batched cluster-wide track listing — ONE call for the events page /
+         * reel first paint instead of a per-camera `listTracks` fan-out. Merges
+         * the persisted completed tracks of every requested device, sorted by
+         * `lastSeen` DESC with a stable (lastSeen, trackId) cursor. Per-device
+         * indexed pages (`idx_tracks_device_lastSeen`) are k-way merged
+         * provider-side; `projection: 'slim'` drops the heavy `positions[]` /
+         * `snapshots[]` JSON (returned as empty arrays). Active in-RAM tracks
+         * are not included (same contract as `listTracks`).
+         */
+        readonly listRecentTracks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodArray<z.ZodNumber>;
+            since: z.ZodOptional<z.ZodNumber>;
+            until: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodDefault<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            projection: z.ZodOptional<z.ZodEnum<{
+                full: "full";
+                slim: "slim";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                trackId: z.ZodString;
+                deviceId: z.ZodNumber;
+                className: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                firstSeen: z.ZodNumber;
+                lastSeen: z.ZodNumber;
+                positions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    timestamp: z.ZodNumber;
+                    bbox: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        w: z.ZodNumber;
+                        h: z.ZodNumber;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>>;
+                snapshots: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    timestamp: z.ZodNumber;
+                    position: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        timestamp: z.ZodNumber;
+                        bbox: z.ZodObject<{
+                            x: z.ZodNumber;
+                            y: z.ZodNumber;
+                            w: z.ZodNumber;
+                            h: z.ZodNumber;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    mediaKey: z.ZodString;
+                }, z.core.$strip>>>;
+                zonesVisited: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                classes: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                totalDistance: z.ZodNumber;
+                state: z.ZodEnum<{
+                    moving: "moving";
+                    left: "left";
+                    idle: "idle";
+                    new: "new";
+                    entered: "entered";
+                }>;
+                active: z.ZodBoolean;
+                importance: z.ZodOptional<z.ZodNumber>;
+                bestEventId: z.ZodOptional<z.ZodString>;
+                importanceReason: z.ZodOptional<z.ZodString>;
+                audioLabels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    peakScore: z.ZodNumber;
+                    count: z.ZodNumber;
+                    firstAt: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                }, z.core.$strip>>>>;
+                envelope: z.ZodOptional<z.ZodObject<{
+                    minX: z.ZodNumber;
+                    minY: z.ZodNumber;
+                    maxX: z.ZodNumber;
+                    maxY: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            nextCursor: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly clearTracks: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
@@ -590,6 +902,63 @@ export declare const pipelineAnalyticsCapability: {
             deviceId: z.ZodNumber;
             timestamp: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Every event kind the device can produce: built-ins (motion + audio),
+         * detection classes actually observed for the device (from the track
+         * history), and sensor kinds contributed by LINKED devices (resolved via
+         * `device-manager.getLinkedDevices`, mapped through `EVENT_KIND_BY_CAP`).
+         */
+        readonly listEventKinds: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            label: z.ZodString;
+            color: z.ZodString;
+            icon: z.ZodEnum<{
+                button: "button";
+                generic: "generic";
+                audio: "audio";
+                person: "person";
+                vehicle: "vehicle";
+                animal: "animal";
+                motion: "motion";
+                door: "door";
+                pir: "pir";
+                smoke: "smoke";
+                water: "water";
+            }>;
+            category: z.ZodEnum<{
+                sensor: "sensor";
+                audio: "audio";
+                custom: "custom";
+                motion: "motion";
+                detection: "detection";
+            }>;
+            source: z.ZodObject<{
+                capName: z.ZodString;
+                deviceId: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Sensor-event history for a camera: state changes of LINKED sensor
+         * devices, attributed to the camera at ingest time (one row per linked
+         * camera). Mirrors `getAudioEvents` query semantics; `kinds` narrows to
+         * a kind subset.
+         */
+        readonly getSensorEvents: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            since: z.ZodOptional<z.ZodNumber>;
+            until: z.ZodOptional<z.ZodNumber>;
+            kinds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            limit: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            deviceId: z.ZodNumber;
+            sourceDeviceId: z.ZodNumber;
+            kind: z.ZodString;
+            value: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            timestamp: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Importance-ranked highlights for a device+window. Queries completed
          * tracks by (deviceId, firstSeen ∈ [since,until]), scores each (or reuses
@@ -877,6 +1246,6 @@ export declare const pipelineAnalyticsCapability: {
     };
 };
 export type IPipelineAnalyticsProvider = InferProvider<typeof pipelineAnalyticsCapability>;
-export { TrackStateSchema, EventKindSchema, TrackSchema, TrackAudioLabelSchema, TrackCascadeCountsSchema, KeyEventSchema, MotionEventSchema, ObjectEventSchema, AudioEventSchema, MediaFileKindEnum, MediaFileSchema, 
+export { TrackStateSchema, EventKindSchema, TrackSchema, TrackEnvelopeSchema, TrackProjectionSchema, RecentTracksQueryInput, RecentTracksPageSchema, TrackAudioLabelSchema, TrackCascadeCountsSchema, TrackZoneFilterSchema, EventKindDescriptorSchema, SensorEventSchema, KeyEventSchema, MotionEventSchema, ObjectEventSchema, AudioEventSchema, MediaFileKindEnum, MediaFileSchema, 
 /** No longer carried on onFrameTracked (two-plane re-injection) — kept for compat. */
 TrackedDetectionSchema, };

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

@@ -84,7 +84,12 @@ export type RecordingStorageUsage = z.infer<typeof RecordingStorageUsageSchema>;
 /**
  * Result of locating footage at a wall-clock instant for one device/profile.
  * `segment` carries the covering segment's window; `gap` reports the forward
- * nearest covered edge (`null` past the end of footage / when none exists).
+ * nearest covered edge (`null` past the end of footage / when none exists)
+ * and the backward covered edge `prevEndMs` (exclusive end of the nearest
+ * footage behind the epoch; `null` when none — optional so older providers
+ * that omit it stay valid). `prevEndMs` lets a backward frame-step hop the
+ * small inter-segment cracks (durMs under-covers the span to the next
+ * startMs by ~11-17 ms) instead of no-opping at a segment head.
  */
 export declare const LocateSegmentResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"segment">;
@@ -94,6 +99,7 @@ export declare const LocateSegmentResultSchema: z.ZodDiscriminatedUnion<[z.ZodOb
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"gap">;
     nearestEdgeMs: z.ZodNullable<z.ZodNumber>;
+    prevEndMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
 }, z.core.$strip>], "kind">;
 export type LocateSegmentResult = z.infer<typeof LocateSegmentResultSchema>;
 /** Raw bytes of one finalized footage segment (read off disk on the recording node). */
@@ -260,6 +266,7 @@ export declare const recordingCapability: {
         }, z.core.$strip>, z.ZodObject<{
             kind: z.ZodLiteral<"gap">;
             nearestEdgeMs: z.ZodNullable<z.ZodNumber>;
+            prevEndMs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
         }, z.core.$strip>], "kind">, "query">;
         /** Read one finalized segment's raw bytes by its exact `startMs`. Used by a
          *  feeder running in another addon process to pull recorded footage over tRPC. */

package/dist/capabilities/sensor-event-kinds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Static event-kind descriptors for the SENSOR cap family — the mapping
+ * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
+ * sensor caps (contact / flood / gas / carbon-monoxide / enum-sensor /
+ * event-emitter) into per-camera event-kind entries.
+ *
+ * Lives beside the sensor cap definitions so adding a new sensor cap and its
+ * event-kind descriptor happens in one place. The `source` field of the full
+ * `EventKindDescriptor` is stamped at compose time (per linked device) — this
+ * map carries only the static half.
+ */
+import type { EventKindCategory, EventKindIcon } from './pipeline-analytics.cap.js';
+/** The static half of an `EventKindDescriptor` (no per-device `source`). */
+export interface SensorEventKindDescriptor {
+    readonly kind: string;
+    readonly label: string;
+    readonly color: string;
+    readonly icon: EventKindIcon;
+    readonly category: EventKindCategory;
+}
+/**
+ * Sensor cap name → static event-kind descriptor. A linked device
+ * contributes one entry per bound cap present in this map.
+ */
+export declare const EVENT_KIND_BY_CAP: Readonly<Record<string, SensorEventKindDescriptor>>;

package/dist/enums/event-category.d.ts

@@ -147,6 +147,9 @@ export declare enum EventCategory {
     RecordingSegmentWritten = "recording.segment.written",
     RecordingPolicyFallback = "recording.policy.fallback",
     RecordingRetentionCompleted = "recording.retention.completed",
+    /** Runner-sampled scrub thumbnail (~1/5 s/camera). Telemetry (D8): a lost
+     *  thumb is a scrub gap the recorder's keyframe backfill covers. */
+    RecordingThumbSampled = "recording.thumb-sampled",
     DetectionEvent = "detection.event",
     SessionTrackNew = "session.track.new",
     SessionTrackExpired = "session.track.expired",

package/dist/enums.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-BXd6yeJi.js");
+const require_event_category = require("./event-category-AkBNxg_X.js");
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/enums.mjs

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-CFZs3jI4.mjs";
+import { t as EventCategory } from "./event-category-H4AVePnn.mjs";
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";