@camstack/types 1.2.129 → 1.2.131

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-D5821NGq.js");
+const require_sleep = require("./sleep-CqVyhcl-.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, 56 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
@@ -126,11 +126,13 @@ 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 },
 		"listGroups": { "limit": 40 },
 		"listRecentTracks": { "limit": 200 },
+		"reclaimDebugMedia": { "mode": "report" },
 		"searchObjectEvents": {
 			"limit": 50,
 			"minScore": .2

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-BS40IUZZ.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-BBI0PDUc.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, 56 methods with defaults.
 */
 var CAP_INPUT_DEFAULTS = Object.freeze({
 	"addons": { "getLogs": { "limit": 100 } },
@@ -125,11 +125,13 @@ 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 },
 		"listGroups": { "limit": 40 },
 		"listRecentTracks": { "limit": 200 },
+		"reclaimDebugMedia": { "mode": "report" },
 		"searchObjectEvents": {
 			"limit": 50,
 			"minScore": .2

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 EventMediaKindBreakdown, type EventMediaKindFootprint, 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, 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 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;
@@ -2315,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<{
@@ -2612,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>;
@@ -2713,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>;
@@ -2755,6 +2861,51 @@ export declare const pipelineAnalyticsCapability: {
             detail: z.ZodNullable<z.ZodString>;
             actor: z.ZodString;
         }, z.core.$strip>>>, "query">;
+        /**
+         * Reclaim the standing debug-media backlog (motion-visit stills + track
+         * filmstrips). DETACHED: returns `{ started }` immediately. The pass is
+         * tens of minutes; awaiting it is a timeout, not a verdict. Dry-run unless
+         * `mode: 'reclaim'`. Poll `getMediaReclaimStatus`.
+         */
+        readonly reclaimDebugMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            mode: z.ZodDefault<z.ZodEnum<{
+                report: "report";
+                reclaim: "reclaim";
+            }>>;
+            scopes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                "motion-still": "motion-still";
+                "track-filmstrip": "track-filmstrip";
+            }>>>;
+            deviceIds: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            restart: z.ZodOptional<z.ZodBoolean>;
+            pageSize: z.ZodOptional<z.ZodNumber>;
+            maxRowsPerDevice: z.ZodOptional<z.ZodNumber>;
+            maxReclaimPerDevice: z.ZodOptional<z.ZodNumber>;
+            maxBytesPerRun: z.ZodOptional<z.ZodNumber>;
+            budgetMinutes: z.ZodOptional<z.ZodNumber>;
+            throttleBytesPerSec: z.ZodOptional<z.ZodNumber>;
+            graceMinutes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            started: z.ZodBoolean;
+            alreadyRunning: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+        readonly getMediaReclaimStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            running: z.ZodBoolean;
+            mode: z.ZodNullable<z.ZodEnum<{
+                report: "report";
+                reclaim: "reclaim";
+            }>>;
+            totalExamined: z.ZodNumber;
+            totalEligible: z.ZodNumber;
+            totalReclaimed: z.ZodNumber;
+            totalBytesReclaimed: z.ZodNumber;
+            totalRefused: z.ZodNumber;
+            devicesDone: z.ZodNumber;
+            complete: z.ZodNullable<z.ZodBoolean>;
+            startedAtMs: z.ZodNullable<z.ZodNumber>;
+            finishedAtMs: z.ZodNullable<z.ZodNumber>;
+            error: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, "query">;
         /**
          * The CHEAP QUESTION, asked before any media moves: how big is the dataset
          * the marked (`markForTrain`) tracks would produce?

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;

package/dist/capabilities/scene-monitor.cap.d.ts

@@ -366,6 +366,122 @@ export type SceneMonitorState = z.infer<typeof SceneMonitorStateSchema>;
 export type SceneCheck = z.infer<typeof SceneCheckSchema>;
 export type SceneMonitor = z.infer<typeof SceneMonitorSchema>;
 export type SceneMonitorStatus = z.infer<typeof SceneMonitorStatusSchema>;
+/**
+ * One camera's row in a `listScenesBatch` answer.
+ *
+ * `status` is NULLABLE and the nullability is the whole point. `scene-monitor`
+ * is a `defaultActive` wrapper, so every camera is asked; a camera whose
+ * provider is absent (pipeline-analytics not deployed, the post-processing node
+ * down) cannot answer, and that is not the same fact as a camera with no scenes
+ * configured. Fanned out per camera the difference was visible — one query
+ * errored while the others resolved — and a batch that returned only the rows
+ * it managed would have destroyed it, silently, by making an unreachable camera
+ * indistinguishable from one that answered `monitors: []`.
+ *
+ * So: EVERY requested deviceId gets a row. `status: null` means "this camera
+ * could not be read"; `status.monitors: []` means "read, and it has none".
+ */
+export declare const SceneMonitorStatusForDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    status: z.ZodNullable<z.ZodObject<{
+        monitors: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            roi: z.ZodObject<{
+                kind: z.ZodLiteral<"rect">;
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+            enabled: z.ZodBoolean;
+            triggerMode: z.ZodEnum<{
+                periodic: "periodic";
+                both: "both";
+                "on-motion": "on-motion";
+            }>;
+            checkIntervalSec: z.ZodOptional<z.ZodNumber>;
+            check: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                mode: z.ZodLiteral<"similarity">;
+                threshold: z.ZodNumber;
+                hysteresisCount: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                mode: z.ZodLiteral<"llm">;
+                prompt: z.ZodString;
+                profileId: z.ZodOptional<z.ZodString>;
+                hysteresisCount: z.ZodNumber;
+            }, z.core.$strip>], "mode">;
+            states: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+                references: z.ZodArray<z.ZodObject<{
+                    embedding: z.ZodArray<z.ZodNumber>;
+                    modelId: z.ZodString;
+                    condition: z.ZodString;
+                    capturedAt: z.ZodNumber;
+                    thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                    anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                }, z.core.$strip>>;
+                textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceCount: z.ZodNumber;
+                currentlyMatched: z.ZodBoolean;
+            }, z.core.$strip>>;
+            currentStateId: z.ZodNullable<z.ZodString>;
+            lastCheckedAt: z.ZodNullable<z.ZodNumber>;
+            lastConfidence: z.ZodNullable<z.ZodNumber>;
+            currentCondition: z.ZodNullable<z.ZodString>;
+            availability: z.ZodEnum<{
+                ok: "ok";
+                unavailable: "unavailable";
+            }>;
+            unavailableReason: z.ZodNullable<z.ZodString>;
+            baselineStateId: z.ZodNullable<z.ZodString>;
+            emit: z.ZodDefault<z.ZodEnum<{
+                live: "live";
+                latched: "latched";
+            }>>;
+            verdict: z.ZodEnum<{
+                unknown: "unknown";
+                matched: "matched";
+                diverged: "diverged";
+            }>;
+            latched: z.ZodBoolean;
+            armedAt: z.ZodNumber;
+            divergedAt: z.ZodNullable<z.ZodNumber>;
+            restoredAt: z.ZodNullable<z.ZodNumber>;
+            quietSeconds: z.ZodDefault<z.ZodNumber>;
+            minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+            confirm: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                prompt: z.ZodString;
+                profileId: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxImagePx: z.ZodDefault<z.ZodNumber>;
+                onTimeout: z.ZodDefault<z.ZodEnum<{
+                    flip: "flip";
+                    hold: "hold";
+                }>>;
+            }, z.core.$strip>>;
+            anchorThreshold: z.ZodDefault<z.ZodNumber>;
+            autoRestore: z.ZodDefault<z.ZodBoolean>;
+            onUncoveredCondition: z.ZodDefault<z.ZodEnum<{
+                skip: "skip";
+                "judge-anyway": "judge-anyway";
+            }>>;
+            suspendedCondition: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+            unavailable: z.ZodNullable<z.ZodEnum<{
+                "no-reference-for-condition": "no-reference-for-condition";
+                "view-shifted": "view-shifted";
+                "no-vision-profile": "no-vision-profile";
+                "encoder-model-changed": "encoder-model-changed";
+                "no-snapshot": "no-snapshot";
+            }>>;
+            coveredConditions: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        lastFetchedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SceneMonitorStatusForDevice = z.infer<typeof SceneMonitorStatusForDeviceSchema>;
 export declare const sceneMonitorCapability: {
     readonly name: "scene-monitor";
     readonly scope: "device";
@@ -473,6 +589,123 @@ export declare const sceneMonitorCapability: {
             }, z.core.$strip>>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The same answer, for a SET of cameras, in one round trip.
+         *
+         * `/scenes` renders every camera and re-reads them on a 30s safety-net
+         * poll behind the push slice. Fanned out client-side that was one query
+         * per camera — 29 round trips through the browser, the hub and the
+         * post-analysis runner every 30 seconds to read an in-memory map the
+         * owner had already merged. The work is unchanged (`statusFor` per
+         * device, all in-process at the owner); what collapses is the transport.
+         *
+         * A camera that cannot answer still gets a row, with `status: null` —
+         * see {@link SceneMonitorStatusForDeviceSchema}. Never fewer rows than
+         * ids: a caller that asked for twenty-nine and got twenty-seven cannot
+         * tell which two are missing, or that any are.
+         */
+        readonly listScenesBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            status: z.ZodNullable<z.ZodObject<{
+                monitors: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    roi: z.ZodObject<{
+                        kind: z.ZodLiteral<"rect">;
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        width: z.ZodNumber;
+                        height: z.ZodNumber;
+                    }, z.core.$strip>;
+                    enabled: z.ZodBoolean;
+                    triggerMode: z.ZodEnum<{
+                        periodic: "periodic";
+                        both: "both";
+                        "on-motion": "on-motion";
+                    }>;
+                    checkIntervalSec: z.ZodOptional<z.ZodNumber>;
+                    check: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                        mode: z.ZodLiteral<"similarity">;
+                        threshold: z.ZodNumber;
+                        hysteresisCount: z.ZodNumber;
+                    }, z.core.$strip>, z.ZodObject<{
+                        mode: z.ZodLiteral<"llm">;
+                        prompt: z.ZodString;
+                        profileId: z.ZodOptional<z.ZodString>;
+                        hysteresisCount: z.ZodNumber;
+                    }, z.core.$strip>], "mode">;
+                    states: z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        references: z.ZodArray<z.ZodObject<{
+                            embedding: z.ZodArray<z.ZodNumber>;
+                            modelId: z.ZodString;
+                            condition: z.ZodString;
+                            capturedAt: z.ZodNumber;
+                            thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                            anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                        }, z.core.$strip>>;
+                        textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        referenceCount: z.ZodNumber;
+                        currentlyMatched: z.ZodBoolean;
+                    }, z.core.$strip>>;
+                    currentStateId: z.ZodNullable<z.ZodString>;
+                    lastCheckedAt: z.ZodNullable<z.ZodNumber>;
+                    lastConfidence: z.ZodNullable<z.ZodNumber>;
+                    currentCondition: z.ZodNullable<z.ZodString>;
+                    availability: z.ZodEnum<{
+                        ok: "ok";
+                        unavailable: "unavailable";
+                    }>;
+                    unavailableReason: z.ZodNullable<z.ZodString>;
+                    baselineStateId: z.ZodNullable<z.ZodString>;
+                    emit: z.ZodDefault<z.ZodEnum<{
+                        live: "live";
+                        latched: "latched";
+                    }>>;
+                    verdict: z.ZodEnum<{
+                        unknown: "unknown";
+                        matched: "matched";
+                        diverged: "diverged";
+                    }>;
+                    latched: z.ZodBoolean;
+                    armedAt: z.ZodNumber;
+                    divergedAt: z.ZodNullable<z.ZodNumber>;
+                    restoredAt: z.ZodNullable<z.ZodNumber>;
+                    quietSeconds: z.ZodDefault<z.ZodNumber>;
+                    minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+                    confirm: z.ZodOptional<z.ZodObject<{
+                        enabled: z.ZodDefault<z.ZodBoolean>;
+                        prompt: z.ZodString;
+                        profileId: z.ZodOptional<z.ZodString>;
+                        timeoutMs: z.ZodDefault<z.ZodNumber>;
+                        maxImagePx: z.ZodDefault<z.ZodNumber>;
+                        onTimeout: z.ZodDefault<z.ZodEnum<{
+                            flip: "flip";
+                            hold: "hold";
+                        }>>;
+                    }, z.core.$strip>>;
+                    anchorThreshold: z.ZodDefault<z.ZodNumber>;
+                    autoRestore: z.ZodDefault<z.ZodBoolean>;
+                    onUncoveredCondition: z.ZodDefault<z.ZodEnum<{
+                        skip: "skip";
+                        "judge-anyway": "judge-anyway";
+                    }>>;
+                    suspendedCondition: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    unavailable: z.ZodNullable<z.ZodEnum<{
+                        "no-reference-for-condition": "no-reference-for-condition";
+                        "view-shifted": "view-shifted";
+                        "no-vision-profile": "no-vision-profile";
+                        "encoder-model-changed": "encoder-model-changed";
+                        "no-snapshot": "no-snapshot";
+                    }>>;
+                    coveredConditions: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>>;
+                lastFetchedAt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly createScene: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             label: z.ZodString;

package/dist/capabilities/storage-migration.cap.d.ts

@@ -187,6 +187,7 @@ export declare const storageMigrationCapability: {
                 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>;