@camstack/types 1.2.128 → 1.2.130

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BaEgqJNv.js");
-const require_sleep = require("./sleep-C3AniWy-.js");
+const require_sleep = require("./sleep-DIg3xuEw.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts
 /**
@@ -16,7 +16,7 @@ const require_err_msg = require("./err-msg-COpsHMw2.js");
 * Plain data, zero Zod: a forked runner must not import the schema barrel
 * (~144MB RSS per runner — D28).
 *
-* Coverage: 24 caps, 54 methods with defaults.
+* Coverage: 24 caps, 55 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
@@ -126,6 +126,7 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 	"pipeline-analytics": {
 		"getAudioEvents": { "limit": 1e3 },
 		"getKeyEvents": { "limit": 50 },
+		"getKeyEventsBatch": { "limit": 50 },
 		"getMotionEvents": { "limit": 1e3 },
 		"getObjectEvents": { "limit": 1e3 },
 		"getSensorEvents": { "limit": 1e3 },

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-BZL-fdNj.mjs";
-import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-ot6dTHCA.mjs";
+import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-DcA-CgqX.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**
@@ -15,7 +15,7 @@ import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 * Plain data, zero Zod: a forked runner must not import the schema barrel
 * (~144MB RSS per runner — D28).
 *
-* Coverage: 24 caps, 54 methods with defaults.
+* Coverage: 24 caps, 55 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
@@ -125,6 +125,7 @@ var CAP_INPUT_DEFAULTS = Object.freeze({
 	"pipeline-analytics": {
 		"getAudioEvents": { "limit": 1e3 },
 		"getKeyEvents": { "limit": 50 },
+		"getKeyEventsBatch": { "limit": 50 },
 		"getMotionEvents": { "limit": 1e3 },
 		"getObjectEvents": { "limit": 1e3 },
 		"getSensorEvents": { "limit": 1e3 },

package/dist/capabilities/index.d.ts

@@ -82,7 +82,7 @@ export { NetworkAccessStatusSchema, NetworkEndpointSchema, networkAccessCapabili
 export { type Attachment, type AttachmentMediaType, AttachmentMediaTypeSchema, AttachmentSchema, type DiscoveredTarget, DiscoveredTargetSchema, type INotificationOutputProvider, type NotificationAction, type NotificationActionIcon, NotificationActionIconSchema, NotificationActionSchema, type NotificationFormat, NotificationFormatSchema, NotificationSchema, notificationOutputCapability, type RenderedAs, RenderedAsSchema, type SendResult, SendResultSchema, type Target, type TargetKind, type TargetKindCaps, TargetKindCapsSchema, type TargetKindLevel, TargetKindLevelSchema, TargetKindSchema, TargetSchema, type TestResult, TestResultSchema, } from './notification-output.cap.js';
 export { type INotificationRulesProvider, NC_ALARM_SYSTEM_EVENT_KINDS, NC_AUDIO_DBFS_FLOOR, NC_AUTHORABLE_SYSTEM_EVENT_KINDS, NC_CONDITION_CATALOG, NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, NC_CONFIRM_DEFAULT_TIMEOUT_MS, NC_CONFIRM_MAX_TIMEOUT_MS, NC_CONFIRM_MIN_TIMEOUT_MS, NC_DEFAULT_SNOOZE_MINUTES, NC_HISTORY_LIMIT_DEFAULT, NC_HISTORY_LIMIT_MAX, NC_MAX_PER_TRACK_IMMEDIATE, NC_SNOOZE_MAX_MINUTES, type NcAlarmConfig, NcAlarmConfigSchema, type NcAlarmModeCoverage, NcAlarmModeCoverageSchema, type NcAlarmSettings, type NcAlarmSettingsPatch, NcAlarmSettingsPatchSchema, NcAlarmSettingsSchema, type NcAlarmSkippedDevice, NcAlarmSkippedDeviceSchema, type NcAlarmSkipReason, NcAlarmSkipReasonSchema, type NcAudioCondition, NcAudioConditionSchema, type NcConditionDescriptor, NcConditionDescriptorSchema, type NcConditions, NcConditionsSchema, type NcConfirm, type NcConfirmExpect, NcConfirmExpectSchema, NcConfirmSchema, type NcCrossing, NcCrossingSchema, type NcDelivery, NcDeliverySchema, type NcDeviceStateCondition, NcDeviceStateConditionSchema, type NcHistoryEntry, NcHistoryEntrySchema, type NcHistoryFilter, NcHistoryFilterSchema, type NcHistoryRecordKind, NcHistoryRecordKindSchema, type NcHistoryStatus, NcHistoryStatusSchema, type NcHistorySubject, NcHistorySubjectSchema, type NcMediaFrame, NcMediaFrameSchema, type NcMediaPolicy, NcMediaPolicySchema, type NcOccupancyCondition, NcOccupancyConditionSchema, type NcPlateMatcher, NcPlateMatcherSchema, type NcRule, type NcRuleAction, NcRuleActionSchema, type NcRuleActionSequence, NcRuleActionSequenceSchema, type NcRuleActions, NcRuleActionsSchema, type NcRuleInput, NcRuleInputSchema, type NcRuleNotificationButton, NcRuleNotificationButtonSchema, type NcRulePatch, NcRulePatchSchema, NcRuleSchema, type NcRuleTarget, NcRuleTargetSchema, type NcSceneCondition, NcSceneConditionSchema, type NcSchedule, NcScheduleSchema, type NcScheduleWindow, NcScheduleWindowSchema, type NcSnooze, type NcSnoozeInput, NcSnoozeInputSchema, NcSnoozeSchema, type NcSnoozeScope, NcSnoozeScopeSchema, type NcSnoozeSuppressed, NcSnoozeSuppressedSchema, type NcSystemEventCondition, NcSystemEventConditionSchema, type NcSystemEventKind, NcSystemEventKindSchema, type NcTestResult, NcTestResultSchema, type NcThrottle, type NcThrottleGranularity, NcThrottleGranularitySchema, NcThrottleSchema, type NcZoneCondition, NcZoneConditionSchema, notificationRulesCapability, } from './notification-rules.cap.js';
 export { type IOauthIntegrationProvider, type OauthIntegrationDescriptor, OauthIntegrationDescriptorSchema, oauthIntegrationCapability, } from './oauth-integration.cap.js';
-export { type AnalyticsGroupDetail, AnalyticsGroupDetailSchema, type AnalyticsGroupMember, AnalyticsGroupMemberSchema, type AnalyticsGroupRecord, AnalyticsGroupRecordSchema, type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type LabelAttribution, LabelAttributionSchema, type LabelTier, LabelTierSchema, type ListGroupsPage, ListGroupsPageSchema, type ListGroupsQuery, ListGroupsQueryInput, type MediaFile, type MediaFileBytes, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, type MediaFileRef, MediaFileRefSchema, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type RetrainAnnotation, type RetrainAnnotationDraft, RetrainAnnotationDraftSchema, RetrainAnnotationKindSchema, RetrainAnnotationSchema, RetrainAnnotationSourceSchema, type RetrainAssistResult, RetrainAssistResultSchema, RetrainAssistSubjectSchema, RetrainCopyRefusalSchema, type RetrainFrame, type RetrainFrameCandidate, RetrainFrameCandidateSchema, type RetrainFrameList, RetrainFrameListSchema, RetrainFrameSchema, type RetrainFrameSelection, RetrainFrameSelectionSchema, type RetrainMacroClass, RetrainMacroClassSchema, type RetrainStatus, RetrainStatusSchema, type RetrainTrack, RetrainTrackSchema, type RetrainTransitionResult, RetrainTransitionResultSchema, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackFlags, type TrackFlagsPatch, TrackFlagsPatchSchema, TrackFlagsSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackSource, TrackSourceSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type TrainingExportDeviceTotals, TrainingExportDeviceTotalsSchema, type TrainingExportSummary, TrainingExportSummarySchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
+export { type AnalyticsGroupDetail, AnalyticsGroupDetailSchema, type AnalyticsGroupMember, AnalyticsGroupMemberSchema, type AnalyticsGroupRecord, AnalyticsGroupRecordSchema, type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventMediaKindBreakdown, type EventMediaKindFootprint, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type KeyEventsForDevice, type LabelAttribution, LabelAttributionSchema, type LabelTier, LabelTierSchema, type ListGroupsPage, ListGroupsPageSchema, type ListGroupsQuery, ListGroupsQueryInput, type MediaFile, type MediaFileBytes, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, MediaFileKindEnum, type MediaFileRef, MediaFileRefSchema, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type RetrainAnnotation, type RetrainAnnotationDraft, RetrainAnnotationDraftSchema, RetrainAnnotationKindSchema, RetrainAnnotationSchema, RetrainAnnotationSourceSchema, type RetrainAssistResult, RetrainAssistResultSchema, RetrainAssistSubjectSchema, RetrainCopyRefusalSchema, type RetrainFrame, type RetrainFrameCandidate, RetrainFrameCandidateSchema, type RetrainFrameList, RetrainFrameListSchema, RetrainFrameSchema, type RetrainFrameSelection, RetrainFrameSelectionSchema, type RetrainMacroClass, RetrainMacroClassSchema, type RetrainStatus, RetrainStatusSchema, type RetrainTrack, RetrainTrackSchema, type RetrainTransitionResult, RetrainTransitionResultSchema, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackFlags, type TrackFlagsPatch, TrackFlagsPatchSchema, TrackFlagsSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackSource, TrackSourceSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type TrainingExportDeviceTotals, TrainingExportDeviceTotalsSchema, type TrainingExportSummary, TrainingExportSummarySchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
 export type { NativeCropRef, PipelineStepInputOutput, PipelineValidationIssue, PipelineValidationResult, } from './pipeline-executor.cap.js';
 export { ModelSubstitutionSchema, NativeCropRefSchema, 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, CameraStatusDegradation, CameraStatusDegradationReason, CameraStatusStage, DiskReconcileJob, InferenceDeviceExclusionReason, IngestOwner, NodeInferenceDevice, NodeInferenceDevices, } from './pipeline-orchestrator.cap.js';
@@ -187,7 +187,7 @@ export { type IPtzAutotrackProvider, type PtzAutotrackRuntimeState, PtzAutotrack
 export { type IRebootProvider, rebootCapability } from './reboot.cap.js';
 export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadGopBytesResult, ReadGopBytesResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, type ReadWindowBytesResult, ReadWindowBytesResultSchema, type RecordingAvailability, RecordingAvailabilitySchema, type RecordingDays, RecordingDaysSchema, type RecordingDeviceUsage, RecordingDeviceUsageSchema, type RecordingLocationUsage, RecordingLocationUsageSchema, type RecordingManifest, RecordingManifestSchema, RecordingRangeSchema, type RecordingRebalanceInput, RecordingRebalanceInputSchema, type RecordingRebalanceMove, RecordingRebalanceMoveSchema, type RecordingRebalancePlan, RecordingRebalancePlanSchema, type RecordingRebalanceSkip, type RecordingRebalanceSkipReason, RecordingRebalanceSkipReasonSchema, RecordingRebalanceSkipSchema, type RecordingStatus, RecordingStatusSchema, type RecordingStorageUsage, RecordingStorageUsageSchema, recordingCapability, } from './recording.cap.js';
 export { EXPORT_DENSE_MAX_RANGES, type ExportBytes, ExportBytesSchema, type ExportDense, type ExportDenseRange, ExportDenseRangeSchema, ExportDenseSchema, type ExportDownload, ExportDownloadSchema, type ExportOptions, ExportOptionsSchema, type ExportRecord, ExportRecordSchema, ExportSpeedSchema, type ExportState, ExportStateSchema, ExportTimelapseSchema, type IRecordingExportProvider, RECORDING_EXPORT_MAX_READ_BYTES, recordingExportCapability, } from './recording-export.cap.js';
-export { type ISceneMonitorProvider, SCENE_CONDITIONS, SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, SCENE_DEFAULT_ANCHOR_THRESHOLD, SCENE_DEFAULT_CHECK_INTERVAL_SEC, SCENE_DEFAULT_OBSERVATION_SPACING_SEC, SCENE_DEFAULT_QUIET_SECONDS, SCENE_DEFAULT_UNCOVERED_POLICY, SCENE_DIVERGED, SCENE_RESET_RECAPTURES, type SceneCheck, SceneCheckSchema, type SceneCondition, SceneConditionSchema, type SceneConfirm, SceneConfirmSchema, type SceneMonitor, SceneMonitorSchema, type SceneMonitorState, SceneMonitorStateSchema, type SceneMonitorStatus, SceneMonitorStatusSchema, type SceneReference, SceneReferenceSchema, type SceneUnavailable, SceneUnavailableSchema, type SceneUncoveredPolicy, SceneUncoveredPolicySchema, type SceneVerdict, SceneVerdictSchema, sceneMonitorCapability, } from './scene-monitor.cap.js';
+export { type ISceneMonitorProvider, SCENE_CONDITIONS, SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, SCENE_DEFAULT_ANCHOR_THRESHOLD, SCENE_DEFAULT_CHECK_INTERVAL_SEC, SCENE_DEFAULT_OBSERVATION_SPACING_SEC, SCENE_DEFAULT_QUIET_SECONDS, SCENE_DEFAULT_UNCOVERED_POLICY, SCENE_DIVERGED, SCENE_RESET_RECAPTURES, type SceneCheck, SceneCheckSchema, type SceneCondition, SceneConditionSchema, type SceneConfirm, SceneConfirmSchema, type SceneMonitor, SceneMonitorSchema, type SceneMonitorState, SceneMonitorStateSchema, type SceneMonitorStatus, type SceneMonitorStatusForDevice, SceneMonitorStatusForDeviceSchema, SceneMonitorStatusSchema, type SceneReference, SceneReferenceSchema, type SceneUnavailable, SceneUnavailableSchema, type SceneUncoveredPolicy, SceneUncoveredPolicySchema, type SceneVerdict, SceneVerdictSchema, sceneMonitorCapability, } from './scene-monitor.cap.js';
 export { type ZoneRule, type ZoneRuleMode, ZoneRuleModeEnum, ZoneRuleSchema, type ZoneRules, ZoneRulesArraySchema, } from './schemas/zone-rule.js';
 export { type IScriptRunnerProvider, type ScriptRunnerStatus, ScriptRunnerStatusSchema, scriptRunnerCapability, } from './script-runner.cap.js';
 export { type ISmokeProvider, type SmokeStatus, SmokeStatusSchema, smokeCapability, } from './smoke.cap.js';
@@ -206,7 +206,7 @@ export { type IValveProvider, type ValveState, ValveStateSchema, type ValveStatu
 export { type IVibrationProvider, type VibrationStatus, VibrationStatusSchema, vibrationCapability, } from './vibration.cap.js';
 export { type IWaterHeaterProvider, type WaterHeaterStatus, WaterHeaterStatusSchema, waterHeaterCapability, } from './water-heater.cap.js';
 export { type IWeatherProvider, type WeatherStatus, WeatherStatusSchema, weatherCapability, } from './weather.cap.js';
-export { type CameraOccupancySnapshot, type HistoryPoint, HistoryPointSchema, type HistoryResolution, HistoryResolutionEnum, type IZoneAnalyticsProvider, type PerScopeBreakdown, PerScopeBreakdownSchema, type StationaryObject, StationaryObjectSchema, type ZoneScopeBreakdown, ZoneScopeBreakdownSchema, zoneAnalyticsCapability, } from './zone-analytics.cap.js';
+export { type CameraOccupancySnapshot, type CameraOccupancySnapshotForDevice, CameraOccupancySnapshotForDeviceSchema, type HistoryPoint, HistoryPointSchema, type HistoryResolution, HistoryResolutionEnum, type IZoneAnalyticsProvider, type PerScopeBreakdown, PerScopeBreakdownSchema, type StationaryObject, StationaryObjectSchema, type ZoneScopeBreakdown, ZoneScopeBreakdownSchema, zoneAnalyticsCapability, } from './zone-analytics.cap.js';
 export { type IZoneRulesProvider, type ZoneRuleStage, ZoneRuleStageEnum, zoneRulesCapability, } from './zone-rules.cap.js';
 export { type IZonesProvider, type PolygonPoint, PolygonPointSchema, type Zone, type ZoneKind, ZoneKindEnum, ZoneSchema, zonesCapability, } from './zones.cap.js';
 import type { IReadinessRegistry } from '../interfaces/readiness.js';

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

@@ -1302,6 +1302,53 @@ declare const KeyEventSchema: z.ZodObject<{
     className: z.ZodString;
 }, z.core.$strip>;
 export type KeyEvent = z.infer<typeof KeyEventSchema>;
+/**
+ * One camera's key events in a batch answer.
+ *
+ * The row exists for every requested id. `getKeyEvents` degrades to `[]` on
+ * error rather than throwing, so a camera whose store read failed and one with
+ * no events in the window were ALREADY indistinguishable per camera — the
+ * batch does not make that worse, and the row keeps the deviceId the single
+ * method's output never carried (the caller used to stamp it from the fan-out
+ * key, which only worked because there was one query per camera).
+ */
+declare const KeyEventsForDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    events: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        retrainStatus: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            staging: "staging";
+            trained: "trained";
+        }>>;
+        markForTrain: z.ZodOptional<z.ZodBoolean>;
+        debug: z.ZodOptional<z.ZodBoolean>;
+        favourited: z.ZodOptional<z.ZodBoolean>;
+        importance: z.ZodNumber;
+        bestEventId: z.ZodString;
+        windowMs: z.ZodOptional<z.ZodNumber>;
+        label: z.ZodOptional<z.ZodString>;
+        labelScore: z.ZodOptional<z.ZodNumber>;
+        labelMeta: z.ZodOptional<z.ZodObject<{
+            stepId: z.ZodString;
+            modelId: z.ZodOptional<z.ZodString>;
+            decidedAt: z.ZodNumber;
+            identityId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        subLabel: z.ZodOptional<z.ZodString>;
+        subLabelScore: z.ZodOptional<z.ZodNumber>;
+        subLabelMeta: z.ZodOptional<z.ZodObject<{
+            stepId: z.ZodString;
+            modelId: z.ZodOptional<z.ZodString>;
+            decidedAt: z.ZodNumber;
+            identityId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        id: z.ZodString;
+        trackId: z.ZodString;
+        timestamp: z.ZodNumber;
+        className: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type KeyEventsForDevice = z.infer<typeof KeyEventsForDeviceSchema>;
 declare const TrackedDetectionSchema: z.ZodObject<{
     trackId: z.ZodString;
     className: z.ZodString;
@@ -1416,6 +1463,75 @@ declare const EventStoreFootprintSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type EventStoreFootprint = z.infer<typeof EventStoreFootprintSchema>;
+/** Event-media footprint for one {@link MediaFileKind}. */
+declare const EventMediaKindFootprintSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        crop: "crop";
+        snapshot: "snapshot";
+        keyFrame: "keyFrame";
+        thumbnail: "thumbnail";
+        firstFrame: "firstFrame";
+        lastFrame: "lastFrame";
+        fullFrame: "fullFrame";
+        fullFrameBoxed: "fullFrameBoxed";
+        faceCrop: "faceCrop";
+        plateCrop: "plateCrop";
+        keyFrameSmall: "keyFrameSmall";
+        thumbnailSmall: "thumbnailSmall";
+    }>;
+    rows: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaKindFootprint = z.infer<typeof EventMediaKindFootprintSchema>;
+/**
+ * The media footprint broken down by KIND — the axis a deletion decision
+ * actually turns on.
+ *
+ * A byte total says how much there is; it cannot say what is safe to remove.
+ * The deletable set (the periodic `snapshot` filmstrip, the surplus per-edge
+ * motion stills) and the keep set (`firstFrame`, rolling `lastFrame`,
+ * `thumbnail`/`thumbnailSmall`, `keyFrame`/`keyFrameSmall`, the face/plate
+ * buffers, gallery media, the CLIP `crop`) are distinguished by `kind` and by
+ * nothing else, so sizing a deletion means summing per kind.
+ *
+ * ## Why `unaccounted*` exists
+ *
+ * `kinds` is enumerated from {@link MediaFileKindEnum} — the closed set the
+ * writers use — and summed one kind at a time. `totalRows` / `totalBytes` come
+ * from a SEPARATE unfiltered aggregate over the same rows, never from adding
+ * `kinds` up. A row whose stored `kind` is not in the enum (written by a
+ * retired code path, or by a version that knew a kind this one does not) would
+ * otherwise vanish from the total silently, and an operator would delete
+ * against a denominator smaller than the disk.
+ *
+ * `unaccountedRows` / `unaccountedBytes` are the difference. They are normally
+ * zero; a non-zero value is a real finding and must be shown, not rounded away.
+ */
+declare const EventMediaKindBreakdownSchema: z.ZodObject<{
+    totalRows: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    kinds: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            crop: "crop";
+            snapshot: "snapshot";
+            keyFrame: "keyFrame";
+            thumbnail: "thumbnail";
+            firstFrame: "firstFrame";
+            lastFrame: "lastFrame";
+            fullFrame: "fullFrame";
+            fullFrameBoxed: "fullFrameBoxed";
+            faceCrop: "faceCrop";
+            plateCrop: "plateCrop";
+            keyFrameSmall: "keyFrameSmall";
+            thumbnailSmall: "thumbnailSmall";
+        }>;
+        rows: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+    unaccountedRows: z.ZodNumber;
+    unaccountedBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaKindBreakdown = z.infer<typeof EventMediaKindBreakdownSchema>;
 /** Per-kind counts returned by the event-prune / device-delete mutations. */
 declare const EventPruneCountsSchema: z.ZodObject<{
     motion: z.ZodNumber;
@@ -2246,6 +2362,63 @@ export declare const pipelineAnalyticsCapability: {
             timestamp: z.ZodNumber;
             className: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The same ranking, for a SET of cameras, in one round trip.
+         *
+         * The Detection Intelligence events feed asks this of every selected
+         * camera and re-asks on a 30s timer. Fanned out client-side that is N
+         * round trips — browser → hub → post-analysis — for N independent,
+         * already-indexed store queries. Batched, the queries are unchanged and
+         * run concurrently INSIDE the owner; only the transport collapses.
+         *
+         * Deliberately per-device rather than pre-merged: `limit` stays per
+         * camera (a total would let a busy camera starve a quiet one), and a
+         * caller that renders one camera's lane needs to know which camera a row
+         * came from. `getKeyEvents` stays for single-device callers.
+         */
+        readonly getKeyEventsBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodArray<z.ZodNumber>;
+            since: z.ZodNumber;
+            until: z.ZodNumber;
+            limit: z.ZodDefault<z.ZodNumber>;
+            minImportance: z.ZodOptional<z.ZodNumber>;
+            classFilter: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            events: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                retrainStatus: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    staging: "staging";
+                    trained: "trained";
+                }>>;
+                markForTrain: z.ZodOptional<z.ZodBoolean>;
+                debug: z.ZodOptional<z.ZodBoolean>;
+                favourited: z.ZodOptional<z.ZodBoolean>;
+                importance: z.ZodNumber;
+                bestEventId: z.ZodString;
+                windowMs: z.ZodOptional<z.ZodNumber>;
+                label: z.ZodOptional<z.ZodString>;
+                labelScore: z.ZodOptional<z.ZodNumber>;
+                labelMeta: z.ZodOptional<z.ZodObject<{
+                    stepId: z.ZodString;
+                    modelId: z.ZodOptional<z.ZodString>;
+                    decidedAt: z.ZodNumber;
+                    identityId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                subLabel: z.ZodOptional<z.ZodString>;
+                subLabelScore: z.ZodOptional<z.ZodNumber>;
+                subLabelMeta: z.ZodOptional<z.ZodObject<{
+                    stepId: z.ZodString;
+                    modelId: z.ZodOptional<z.ZodString>;
+                    decidedAt: z.ZodNumber;
+                    identityId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                id: z.ZodString;
+                trackId: z.ZodString;
+                timestamp: z.ZodNumber;
+                className: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Server-side bucketed event counts for the 24-hour timeline.
          *  Returns one entry per non-empty bucket; empty buckets are omitted. */
         readonly getEventDensity: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -2420,6 +2593,44 @@ export declare const pipelineAnalyticsCapability: {
                 bytes: z.ZodNumber;
             }, z.core.$strip>>>;
         }, z.core.$strip>, "query">;
+        /**
+         * The same media footprint, broken down by {@link MediaFileKind} instead of
+         * by camera — fleet-wide, or for one camera with `deviceId`.
+         *
+         * Separate from {@link getEventStoreFootprint} rather than a field on it:
+         * the two answer different questions on different axes, the per-camera one
+         * is what the management table renders on every open, and nothing should
+         * pay for a per-kind pass to draw it. See
+         * {@link EventMediaKindBreakdownSchema} for why `unaccounted*` exists —
+         * `kinds` is enumerated, `totalBytes` is not, and the gap must be visible
+         * to anyone sizing a deletion against it.
+         */
+        readonly getEventMediaFootprintByKind: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            totalRows: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+            kinds: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    crop: "crop";
+                    snapshot: "snapshot";
+                    keyFrame: "keyFrame";
+                    thumbnail: "thumbnail";
+                    firstFrame: "firstFrame";
+                    lastFrame: "lastFrame";
+                    fullFrame: "fullFrame";
+                    fullFrameBoxed: "fullFrameBoxed";
+                    faceCrop: "faceCrop";
+                    plateCrop: "plateCrop";
+                    keyFrameSmall: "keyFrameSmall";
+                    thumbnailSmall: "thumbnailSmall";
+                }>;
+                rows: z.ZodNumber;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>>;
+            unaccountedRows: z.ZodNumber;
+            unaccountedBytes: z.ZodNumber;
+        }, z.core.$strip>, "query">;
         /**
          * Cluster-wide prune of events older than `olderThanMs` (exclusive) across
          * every camera, deleting each event's media in lockstep. Logged to the
@@ -2505,6 +2716,7 @@ export declare const pipelineAnalyticsCapability: {
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
             rowsReconciled: z.ZodOptional<z.ZodNumber>;
+            rowsForgotten: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -2606,6 +2818,7 @@ export declare const pipelineAnalyticsCapability: {
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
             rowsReconciled: z.ZodOptional<z.ZodNumber>;
+            rowsForgotten: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;

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

@@ -666,6 +666,7 @@ export declare const recordingCapability: {
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
             rowsReconciled: z.ZodOptional<z.ZodNumber>;
+            rowsForgotten: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -716,6 +717,7 @@ export declare const recordingCapability: {
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
             rowsReconciled: z.ZodOptional<z.ZodNumber>;
+            rowsForgotten: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -740,6 +742,68 @@ export declare const recordingCapability: {
             segments: z.ZodNumber;
             bytes: z.ZodNumber;
         }, z.core.$strip>>, "query">;
+        /**
+         * Does this location's LEDGER tell the truth about its disk? (D319)
+         *
+         * One `readdir` per claimed hour, diffed both ways: durable rows whose file
+         * is not there, and files no durable row names. `apply` defaults to FALSE —
+         * the report is the product, and the dry run is how an operator
+         * sanity-checks the destructive run before authorising it.
+         *
+         * REFUSES a source that is still a write target: a listing of a live
+         * location is a lower bound, which is not the strong evidence that lets
+         * this pass forget without a budget. A live location is reconciled by the
+         * mover, under D318's bound.
+         */
+        readonly reconcileLedgerAgainstDisk: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            locationId: z.ZodString;
+            apply: z.ZodOptional<z.ZodBoolean>;
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            profiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>, z.ZodObject<{
+            locationId: z.ZodString;
+            applied: z.ZodBoolean;
+            refused: z.ZodNullable<z.ZodEnum<{
+                "location-unknown": "location-unknown";
+                "source-writable": "source-writable";
+                "no-ledger": "no-ledger";
+                "archive-unreadable": "archive-unreadable";
+                "anchor-absent": "anchor-absent";
+                "anchor-unreadable": "anchor-unreadable";
+                "anchor-moved": "anchor-moved";
+            }>>;
+            archiveSegments: z.ZodNullable<z.ZodNumber>;
+            archiveBytes: z.ZodNullable<z.ZodNumber>;
+            hoursClaimed: z.ZodNumber;
+            hoursWalked: z.ZodNumber;
+            hoursMissing: z.ZodNumber;
+            listings: z.ZodNumber;
+            segmentsClaimed: z.ZodNumber;
+            ghostSegments: z.ZodNumber;
+            ghostBytes: z.ZodNumber;
+            ghostHoursWhole: z.ZodNumber;
+            forgottenSegments: z.ZodNumber;
+            forgottenBytes: z.ZodNumber;
+            orphanFiles: z.ZodNumber;
+            orphanSample: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            hoursSkipped: z.ZodNumber;
+            skippedByReason: z.ZodObject<{
+                'live-tail': z.ZodNumber;
+                'listing-error': z.ZodNumber;
+                'path-mismatch': z.ZodNumber;
+                'durable-refused': z.ZodNumber;
+            }, z.core.$strip>;
+            bounded: z.ZodBoolean;
+            byDevice: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                hoursWalked: z.ZodNumber;
+                hoursMissing: z.ZodNumber;
+                ghostSegments: z.ZodNumber;
+                ghostBytes: z.ZodNumber;
+                forgottenSegments: z.ZodNumber;
+                orphanFiles: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation">;
         /** Cancel a running or queued relocate job. A queued job never runs. */
         readonly cancelRelocateJob: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             jobId: z.ZodString;