@camstack/types 1.1.49 → 1.1.50

package/dist/addon.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BfvNtyu8.js");
+const require_sleep = require("./sleep-CF-UWPp0.js");
 const require_event_category = require("./event-category-CGj9fI4L.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 exports.BaseAddon = require_sleep.BaseAddon;

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-DOq2moJx.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-D8ZkNoYz.mjs";
 import { t as EventCategory } from "./event-category-D4HJq7Mw.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/index.d.ts

@@ -77,7 +77,7 @@ 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, 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 { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, 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';

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

@@ -500,6 +500,31 @@ declare const TrackCascadeCountsSchema: z.ZodObject<{
     embeddings: z.ZodNumber;
 }, z.core.$strip>;
 export type TrackCascadeCounts = z.infer<typeof TrackCascadeCountsSchema>;
+/** Event-store footprint for one camera. */
+declare const EventStoreDeviceFootprintSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    rows: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EventStoreDeviceFootprint = z.infer<typeof EventStoreDeviceFootprintSchema>;
+/** Aggregate event-store footprint: global totals + per-camera breakdown. */
+declare const EventStoreFootprintSchema: z.ZodObject<{
+    totalRows: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        deviceId: z.ZodNumber;
+        rows: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type EventStoreFootprint = z.infer<typeof EventStoreFootprintSchema>;
+/** Per-kind counts returned by the event-prune / device-delete mutations. */
+declare const EventPruneCountsSchema: z.ZodObject<{
+    motion: z.ZodNumber;
+    object: z.ZodNumber;
+    audio: z.ZodNumber;
+}, z.core.$strip>;
+export type EventPruneCounts = z.infer<typeof EventPruneCountsSchema>;
 export declare const pipelineAnalyticsCapability: {
     readonly name: "pipeline-analytics";
     readonly scope: "device";
@@ -1077,6 +1102,84 @@ export declare const pipelineAnalyticsCapability: {
             deleted: z.ZodNumber;
             failed: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Durable event-store footprint for the management UI: event rows
+         * (motion + object + audio) counted per camera + total, plus the
+         * event-owned media bytes on disk per camera + total. Stat/count-based,
+         * computed on demand.
+         */
+        readonly getEventStoreFootprint: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            totalRows: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+            devices: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceId: z.ZodNumber;
+                rows: z.ZodNumber;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, 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
+         * events ops-log with `reason` (default `'retention'`). Returns the summed
+         * per-kind deleted counts.
+         */
+        readonly pruneEvents: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            olderThanMs: z.ZodNumber;
+            reason: z.ZodOptional<z.ZodEnum<{
+                manual: "manual";
+                retention: "retention";
+                quota: "quota";
+                operator: "operator";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            motion: z.ZodNumber;
+            object: z.ZodNumber;
+            audio: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Manually delete EVERY event (motion + object + audio) for one camera and
+         * its event-owned media in lockstep. Logged to the events ops-log as
+         * `op:'manual-delete', reason:'manual'`. Destructive — the admin UI guards
+         * it behind a confirm.
+         */
+        readonly deleteDeviceEvents: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            motion: z.ZodNumber;
+            object: z.ZodNumber;
+            audio: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** The events ops-log rows (newest-first), optionally scoped to one camera.
+         *  Backed by a declared pipeline-analytics SQLite collection. */
+        readonly listOpsLog: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            at: z.ZodNumber;
+            domain: z.ZodEnum<{
+                events: "events";
+                recording: "recording";
+            }>;
+            op: z.ZodEnum<{
+                prune: "prune";
+                "manual-delete": "manual-delete";
+                rescan: "rescan";
+                "retention-run": "retention-run";
+            }>;
+            reason: z.ZodEnum<{
+                manual: "manual";
+                retention: "retention";
+                quota: "quota";
+                operator: "operator";
+            }>;
+            deviceId: z.ZodNullable<z.ZodNumber>;
+            nodeId: z.ZodString;
+            itemsAffected: z.ZodNumber;
+            bytesReclaimed: z.ZodNumber;
+            detail: z.ZodNullable<z.ZodString>;
+            actor: z.ZodString;
+        }, z.core.$strip>>>, "query">;
         readonly getEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             eventId: z.ZodString;
             kind: z.ZodOptional<z.ZodEnum<{

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

@@ -464,14 +464,68 @@ export declare const recordingCapability: {
             storageBytes: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
         /** Apply this device's retention policy to footage now; returns the oldest
-         *  surviving footage start (the retention floor) or null if no footage. */
+         *  surviving footage start (the retention floor) or null if no footage. The
+         *  prune is logged to the recordings ops-log with `reason` (default
+         *  `'retention'` — the policy-driven prune; `'quota'` when disk-pressure
+         *  triggered). */
         readonly pruneFootage: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
+            reason: z.ZodOptional<z.ZodEnum<{
+                manual: "manual";
+                retention: "retention";
+                quota: "quota";
+                operator: "operator";
+            }>>;
         }, z.core.$strip>, z.ZodObject<{
             floorMs: z.ZodNullable<z.ZodNumber>;
             deletedBuckets: z.ZodNumber;
             reclaimedBytes: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Manually delete a camera's footage — the whole footprint, or a
+         * `[fromMs, toMs)` window when either bound is given. Logged to the
+         * recordings ops-log as `op:'manual-delete', reason:'manual'`. Destructive:
+         * the admin UI guards it behind a confirm.
+         */
+        readonly deleteFootprint: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            fromMs: z.ZodOptional<z.ZodNumber>;
+            toMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            deletedBuckets: z.ZodNumber;
+            reclaimedBytes: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
+        /** The recordings ops-log rows (newest-first), optionally scoped to one
+         *  camera. Backed by the recorder's bounded DurableState ring. */
+        readonly listOpsLog: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            at: z.ZodNumber;
+            domain: z.ZodEnum<{
+                events: "events";
+                recording: "recording";
+            }>;
+            op: z.ZodEnum<{
+                prune: "prune";
+                "manual-delete": "manual-delete";
+                rescan: "rescan";
+                "retention-run": "retention-run";
+            }>;
+            reason: z.ZodEnum<{
+                manual: "manual";
+                retention: "retention";
+                quota: "quota";
+                operator: "operator";
+            }>;
+            deviceId: z.ZodNullable<z.ZodNumber>;
+            nodeId: z.ZodString;
+            itemsAffected: z.ZodNumber;
+            bytesReclaimed: z.ZodNumber;
+            detail: z.ZodNullable<z.ZodString>;
+            actor: z.ZodString;
+        }, z.core.$strip>>>, "query">;
     };
 };
 export type IRecordingProvider = InferProvider<typeof recordingCapability>;

package/dist/capabilities/zone-rules.cap.d.ts

@@ -100,9 +100,10 @@ export declare const zoneRulesCapability: {
      * `package` backs the package-drop detector — a package zone is a
      * `ZoneRule` on the `'package'` stage referencing drawn polygons
      * (see docs/superpowers/specs/2026-07-17-package-zones-design.md §3.1).
-     * The orchestrator provider that writes this stage lands in a later
-     * slice; until then the mirror carries only `{motion, detection}` and
-     * consumers read `package` as absent (treat as `[]`).
+     * The orchestrator provider writes this stage as a first-class slice
+     * (Phase 4): every mutation mirrors the full `{motion, detection,
+     * package}` shape, so consumers read the current package rules directly
+     * off `device.state.zoneRules.value.package`.
      */
     readonly runtimeState: z.ZodObject<{
         motion: z.ZodReadonly<z.ZodArray<z.ZodObject<{

package/dist/generated/addon-api.d.ts

@@ -10136,6 +10136,67 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        getEventStoreFootprint: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            };
+            output: {
+                totalRows: number;
+                totalBytes: number;
+                devices: readonly {
+                    deviceId: number;
+                    rows: number;
+                    bytes: number;
+                }[];
+            };
+            meta: object;
+        }>;
+        pruneEvents: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                olderThanMs: number;
+                reason?: "manual" | "retention" | "quota" | "operator" | undefined;
+            };
+            output: {
+                motion: number;
+                object: number;
+                audio: number;
+            };
+            meta: object;
+        }>;
+        deleteDeviceEvents: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+            };
+            output: {
+                motion: number;
+                object: number;
+                audio: number;
+            };
+            meta: object;
+        }>;
+        listOpsLog: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId?: number | undefined;
+                limit?: number | undefined;
+            };
+            output: readonly {
+                id: string;
+                at: number;
+                domain: "recording" | "events";
+                op: "prune" | "manual-delete" | "rescan" | "retention-run";
+                reason: "manual" | "retention" | "quota" | "operator";
+                deviceId: number | null;
+                nodeId: string;
+                itemsAffected: number;
+                bytesReclaimed: number;
+                detail: string | null;
+                actor: string;
+            }[];
+            meta: object;
+        }>;
         getEventMedia: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -12895,6 +12956,7 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             input: {
                 [x: string]: unknown;
                 deviceId: number;
+                reason?: "manual" | "retention" | "quota" | "operator" | undefined;
             };
             output: {
                 floorMs: number | null;
@@ -12903,6 +12965,40 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        deleteFootprint: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+                fromMs?: number | undefined;
+                toMs?: number | undefined;
+            };
+            output: {
+                deletedBuckets: number;
+                reclaimedBytes: number;
+            };
+            meta: object;
+        }>;
+        listOpsLog: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId?: number | undefined;
+                limit?: number | undefined;
+            };
+            output: readonly {
+                id: string;
+                at: number;
+                domain: "recording" | "events";
+                op: "prune" | "manual-delete" | "rescan" | "retention-run";
+                reason: "manual" | "retention" | "quota" | "operator";
+                deviceId: number | null;
+                nodeId: string;
+                itemsAffected: number;
+                bytesReclaimed: number;
+                detail: string | null;
+                actor: string;
+            }[];
+            meta: object;
+        }>;
     }>>;
     recordingExport: import("@trpc/server").TRPCBuiltRouter<{
         ctx: TrpcContext;
@@ -26778,6 +26874,67 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        getEventStoreFootprint: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            };
+            output: {
+                totalRows: number;
+                totalBytes: number;
+                devices: readonly {
+                    deviceId: number;
+                    rows: number;
+                    bytes: number;
+                }[];
+            };
+            meta: object;
+        }>;
+        pruneEvents: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                olderThanMs: number;
+                reason?: "manual" | "retention" | "quota" | "operator" | undefined;
+            };
+            output: {
+                motion: number;
+                object: number;
+                audio: number;
+            };
+            meta: object;
+        }>;
+        deleteDeviceEvents: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+            };
+            output: {
+                motion: number;
+                object: number;
+                audio: number;
+            };
+            meta: object;
+        }>;
+        listOpsLog: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId?: number | undefined;
+                limit?: number | undefined;
+            };
+            output: readonly {
+                id: string;
+                at: number;
+                domain: "recording" | "events";
+                op: "prune" | "manual-delete" | "rescan" | "retention-run";
+                reason: "manual" | "retention" | "quota" | "operator";
+                deviceId: number | null;
+                nodeId: string;
+                itemsAffected: number;
+                bytesReclaimed: number;
+                detail: string | null;
+                actor: string;
+            }[];
+            meta: object;
+        }>;
         getEventMedia: import("@trpc/server").TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -29537,6 +29694,7 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             input: {
                 [x: string]: unknown;
                 deviceId: number;
+                reason?: "manual" | "retention" | "quota" | "operator" | undefined;
             };
             output: {
                 floorMs: number | null;
@@ -29545,6 +29703,40 @@ export type AppRouter = import("@trpc/server/unstable-core-do-not-import").Route
             };
             meta: object;
         }>;
+        deleteFootprint: import("@trpc/server").TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId: number;
+                fromMs?: number | undefined;
+                toMs?: number | undefined;
+            };
+            output: {
+                deletedBuckets: number;
+                reclaimedBytes: number;
+            };
+            meta: object;
+        }>;
+        listOpsLog: import("@trpc/server").TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+                deviceId?: number | undefined;
+                limit?: number | undefined;
+            };
+            output: readonly {
+                id: string;
+                at: number;
+                domain: "recording" | "events";
+                op: "prune" | "manual-delete" | "rescan" | "retention-run";
+                reason: "manual" | "retention" | "quota" | "operator";
+                deviceId: number | null;
+                nodeId: string;
+                itemsAffected: number;
+                bytesReclaimed: number;
+                detail: string | null;
+                actor: string;
+            }[];
+            meta: object;
+        }>;
     }>>;
     recordingExport: import("@trpc/server").TRPCBuiltRouter<{
         ctx: TrpcContext;

package/dist/generated/device-proxy.d.ts

@@ -274,7 +274,7 @@ export interface DeviceProxy {
     readonly pipelineOrchestrator: Pick<InferDeviceProxyCap<typeof pipelineOrchestratorCapability>, 'assignPipeline' | 'unassignPipeline' | 'getPipelineAssignment' | 'getCameraMetrics' | 'assignAudio' | 'unassignAudio' | 'getAudioAssignment' | 'getAudioAssignments' | 'getCameraSettings' | 'setCameraStepToggle' | 'getCameraStepOverrides' | 'setCameraStepOverride' | 'setCameraPipelineForAgent' | 'resolvePipeline' | 'getCameraStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly pipelineRunner: Pick<InferDeviceProxyCap<typeof pipelineRunnerCapability>, 'detachCamera' | 'getCameraMetrics' | 'runDetailSubtree'>;
     readonly plateGallery: Pick<InferDeviceProxyCap<typeof plateGalleryCapability>, 'listPlates' | 'getPlateByTrack'>;
-    readonly recording: Pick<InferDeviceProxyCap<typeof recordingCapability>, 'getAvailability' | 'getDaysWithRecordings' | 'getPlaybackManifest' | 'getDeviceConfig' | 'locateSegment' | 'readSegmentBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly recording: Pick<InferDeviceProxyCap<typeof recordingCapability>, 'getAvailability' | 'getDaysWithRecordings' | 'getPlaybackManifest' | 'getDeviceConfig' | 'locateSegment' | 'readSegmentBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'deleteFootprint' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly recordingExport: Pick<InferDeviceProxyCap<typeof recordingExportCapability>, 'createExport' | 'listExports'>;
     readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'restartProfile' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
 }

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 795 method paths across 116 capabilities.
+ * Coverage: 801 method paths across 116 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/system-proxy.d.ts

@@ -79,7 +79,7 @@ export interface SystemProxy {
     readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAgentSettings' | 'listAgentSettings' | 'setAgentAddonDefaults' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentDetectWeight' | 'setAgentCapabilities' | 'setAgentReachableHost' | 'resetNodePipelineDefaults' | 'getCameraStatuses' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop'>;
     readonly plateGallery: Pick<InferProvider<typeof plateGalleryCapability>, 'getPlateMedia' | 'searchPlates' | 'suggestPlateClusters' | 'correctPlateText' | 'deletePlate' | 'listVehicles' | 'createVehicle' | 'renameVehicle' | 'deleteVehicle' | 'listVehicleSamples' | 'removeVehicleSample' | 'assignPlate' | 'unassignPlate' | 'assignPlates' | 'unassignPlates'>;
-    readonly recording: Pick<InferProvider<typeof recordingCapability>, 'getStorageUsage'>;
+    readonly recording: Pick<InferProvider<typeof recordingCapability>, 'getStorageUsage' | 'listOpsLog'>;
     readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl'>;
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
     readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'insert' | 'update' | 'delete' | 'count' | 'histogram' | 'isEmpty' | 'declareCollection'>;

package/dist/index.d.ts

@@ -44,6 +44,7 @@ export type * from './interfaces/analysis.js';
 export type * from './interfaces/advanced-notifier.js';
 export * from './interfaces/recording-config.js';
 export { migrateConfigToBands } from './interfaces/recording-config-migrate.js';
+export * from './interfaces/ops-log.js';
 export type * from './interfaces/python-env.js';
 export type * from './interfaces/network.js';
 export type * from './interfaces/router.js';