@camstack/types 1.2.128 → 1.2.130

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>;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
 import { StorageLocationTypeSchema } from '../interfaces/storage-location.js';
+import { type InferProvider } from './capability-definition.js';
 /**
  * `storage` — singleton consumer-facing capability owned by the
  * `storage-orchestrator` builtin (Task 4 of the storage-unification
@@ -214,6 +214,7 @@ export declare const storageCapability: {
         }, z.core.$strip>], "shouldSaveDiskSpace">>>, import("./capability-definition.js").CapabilityMethodKind>;
         readonly testConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             providerId: z.ZodString;
+            locationId: z.ZodOptional<z.ZodString>;
             config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strip>, z.ZodObject<{
             ok: z.ZodBoolean;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+import { type InferProvider } from './capability-definition.js';
 /**
  * Per-zone occupancy aggregation produced by the analytics frame
  * processor on every inference result. Covers the full combinatorial
@@ -93,6 +93,67 @@ export declare const CameraOccupancySnapshotSchema: z.ZodObject<{
     }, z.core.$strip>>>>;
 }, z.core.$strip>;
 export type CameraOccupancySnapshot = z.infer<typeof CameraOccupancySnapshotSchema>;
+/**
+ * One camera's row in a `getCurrentSnapshotBatch` answer.
+ *
+ * THREE outcomes, and the single-camera method could only express two of them
+ * because `snapshot: null` was already spoken for:
+ *
+ *  - `read: 'read'`, `snapshot` present — the live occupancy reading.
+ *  - `read: 'read'`, `snapshot: null`   — read, and this camera has no reading
+ *    yet: no frame since boot, and no parked-object registry to hydrate from.
+ *  - `read: 'unreadable'`               — the owner could not answer for this
+ *    camera. `snapshot` is null, and it does NOT mean "nothing parked here".
+ *
+ * Collapsing the last two is the failure this field exists to prevent: a
+ * hydration that threw would otherwise render as an empty Stationary section,
+ * which is a definite claim about a camera nobody could read.
+ */
+export declare const CameraOccupancySnapshotForDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodNumber;
+    read: z.ZodEnum<{
+        read: "read";
+        unreadable: "unreadable";
+    }>;
+    snapshot: z.ZodNullable<z.ZodObject<{
+        ts: z.ZodNumber;
+        frameWidth: z.ZodNumber;
+        frameHeight: z.ZodNumber;
+        zones: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+            zoneId: z.ZodString;
+            zoneName: z.ZodString;
+            trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        frame: z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        unzoned: z.ZodObject<{
+            totalObjects: z.ZodNumber;
+            byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        stationaryObjects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            className: z.ZodString;
+            bbox: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                w: z.ZodNumber;
+                h: z.ZodNumber;
+            }, z.core.$strip>;
+            frameWidth: z.ZodNumber;
+            frameHeight: z.ZodNumber;
+            firstSeenAt: z.ZodNumber;
+            becameStationaryAt: z.ZodNumber;
+            lastConfirmedAt: z.ZodNumber;
+            label: z.ZodOptional<z.ZodString>;
+            keyFrameMediaKey: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CameraOccupancySnapshotForDevice = z.infer<typeof CameraOccupancySnapshotForDeviceSchema>;
 export type ZoneScopeBreakdown = z.infer<typeof ZoneScopeBreakdownSchema>;
 export type PerScopeBreakdown = z.infer<typeof PerScopeBreakdownSchema>;
 /**
@@ -192,6 +253,65 @@ export declare const zoneAnalyticsCapability: {
                 keyFrameMediaKey: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>>>;
         }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * The same snapshot, for a SET of cameras, in one round trip.
+         *
+         * The Events page's Stationary section polls this every 15s for every
+         * selected camera. Fanned out client-side that is one query per camera to
+         * read a `Map.get` at the owner — the answer costs nothing, the round trip
+         * costs everything. Batched, N transports become one and the per-device
+         * work is unchanged.
+         *
+         * Every requested deviceId gets a row, tagged `read` — see
+         * {@link CameraOccupancySnapshotForDeviceSchema}. A camera the owner could
+         * not answer for is `'unreadable'`, never an empty reading.
+         */
+        readonly getCurrentSnapshotBatch: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceIds: z.ZodArray<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            read: z.ZodEnum<{
+                read: "read";
+                unreadable: "unreadable";
+            }>;
+            snapshot: z.ZodNullable<z.ZodObject<{
+                ts: z.ZodNumber;
+                frameWidth: z.ZodNumber;
+                frameHeight: z.ZodNumber;
+                zones: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    totalObjects: z.ZodNumber;
+                    byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                    zoneId: z.ZodString;
+                    zoneName: z.ZodString;
+                    trackIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                frame: z.ZodObject<{
+                    totalObjects: z.ZodNumber;
+                    byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                }, z.core.$strip>;
+                unzoned: z.ZodObject<{
+                    totalObjects: z.ZodNumber;
+                    byClass: z.ZodRecord<z.ZodString, z.ZodNumber>;
+                }, z.core.$strip>;
+                stationaryObjects: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    className: z.ZodString;
+                    bbox: z.ZodObject<{
+                        x: z.ZodNumber;
+                        y: z.ZodNumber;
+                        w: z.ZodNumber;
+                        h: z.ZodNumber;
+                    }, z.core.$strip>;
+                    frameWidth: z.ZodNumber;
+                    frameHeight: z.ZodNumber;
+                    firstSeenAt: z.ZodNumber;
+                    becameStationaryAt: z.ZodNumber;
+                    lastConfirmedAt: z.ZodNumber;
+                    label: z.ZodOptional<z.ZodString>;
+                    keyFrameMediaKey: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** Time-series object count inside one zone. `className` optional —
          *  omit to count every class in the zone. */
         readonly getZoneHistory: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -293,4 +413,4 @@ export declare const zoneAnalyticsCapability: {
     readonly durability: "session";
 };
 export type IZoneAnalyticsProvider = InferProvider<typeof zoneAnalyticsCapability>;
-export { CameraOccupancySnapshotSchema as _CameraOccupancySnapshotSchema, StationaryObjectSchema, HistoryResolutionEnum, HistoryPointSchema, HistoryRangeSchema, ZoneScopeBreakdownSchema, PerScopeBreakdownSchema, };
+export { CameraOccupancySnapshotSchema as _CameraOccupancySnapshotSchema, HistoryPointSchema, HistoryRangeSchema, HistoryResolutionEnum, PerScopeBreakdownSchema, StationaryObjectSchema, ZoneScopeBreakdownSchema, };

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

@@ -5002,6 +5002,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.getKeyEvents.output>;
             meta: object;
         }>;
+        getKeyEventsBatch: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.getKeyEventsBatch.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.getKeyEventsBatch.output>;
+            meta: object;
+        }>;
         getEventDensity: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -5058,6 +5065,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.getEventStoreFootprint.output>;
             meta: object;
         }>;
+        getEventMediaFootprintByKind: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.getEventMediaFootprintByKind.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.getEventMediaFootprintByKind.output>;
+            meta: object;
+        }>;
         pruneEvents: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -6599,6 +6613,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof recordingCapability.methods.getRelocateResidue.output>;
             meta: object;
         }>;
+        reconcileLedgerAgainstDisk: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.reconcileLedgerAgainstDisk.input>;
+            output: z.infer<typeof recordingCapability.methods.reconcileLedgerAgainstDisk.output>;
+            meta: object;
+        }>;
         cancelRelocateJob: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -6697,6 +6718,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof sceneMonitorCapability.methods.listScenes.output>;
             meta: object;
         }>;
+        listScenesBatch: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof sceneMonitorCapability.methods.listScenesBatch.input>;
+            output: z.infer<typeof sceneMonitorCapability.methods.listScenesBatch.output>;
+            meta: object;
+        }>;
         createScene: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -8669,6 +8697,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof zoneAnalyticsCapability.methods.getCurrentSnapshot.output>;
             meta: object;
         }>;
+        getCurrentSnapshotBatch: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof zoneAnalyticsCapability.methods.getCurrentSnapshotBatch.input>;
+            output: z.infer<typeof zoneAnalyticsCapability.methods.getCurrentSnapshotBatch.output>;
+            meta: object;
+        }>;
         getZoneHistory: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;

package/dist/generated/cap-input-defaults.d.ts

@@ -11,7 +11,7 @@
  * 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.
  */
 export declare const CAP_INPUT_DEFAULTS: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
 /**

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: 987 method paths across 126 capabilities.
+ * Coverage: 992 method paths across 126 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/method-device-selectors.d.ts

@@ -6,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 346 methods carry a device reference, of which
- * 129 are on SYSTEM-scope caps.
+ * Coverage: 351 methods carry a device reference, of which
+ * 130 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher

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

@@ -87,7 +87,7 @@ export interface SystemProxy {
     readonly pipelineOrchestrator: Pick<InferProvider<typeof pipelineOrchestratorCapability>, 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'rebalance' | 'getPipelineAssignments' | 'getAgentLoad' | 'getGlobalMetrics' | 'getCapabilityBindings' | 'setCapabilityBinding' | 'getIngestOwner' | 'getAudioNodeLoad' | 'getAgentSettings' | 'listAgentSettings' | 'removeAgentSettings' | 'setAgentMaxCameras' | 'setAgentDetectWeight' | 'setAgentCapabilities' | 'setAgentReachableHost' | 'setAgentInferenceDevices' | 'getNodeInferenceDevices' | 'resetNodePipelineDefaults' | 'getCameraStatuses' | 'reconcileFromDisk' | 'getReconcileFromDiskStatus' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate'>;
     readonly pipelineRunner: Pick<InferProvider<typeof pipelineRunnerCapability>, 'attachCamera' | 'reportMotion' | 'getLocalLoad' | 'getLocalMetrics' | 'getAllCameraMetrics' | 'getLocalCameras' | 'getNativeCrop' | 'runStatelessStep'>;
     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' | 'listOpsLog' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'refreshStorageLocationsForMigration' | 'startStorageMigrationMove' | 'getStorageMigrationMoveStatus' | 'cancelStorageMigrationMove' | 'relocateFootage' | 'listRelocateJobs' | 'getRelocateResidue' | 'cancelRelocateJob' | 'planStorageRebalance' | 'startStorageRebalance'>;
+    readonly recording: Pick<InferProvider<typeof recordingCapability>, 'getStorageUsage' | 'listOpsLog' | 'pauseForStorageMigration' | 'resumeForStorageMigration' | 'refreshStorageLocationsForMigration' | 'startStorageMigrationMove' | 'getStorageMigrationMoveStatus' | 'cancelStorageMigrationMove' | 'relocateFootage' | 'listRelocateJobs' | 'getRelocateResidue' | 'reconcileLedgerAgainstDisk' | 'cancelRelocateJob' | 'planStorageRebalance' | 'startStorageRebalance'>;
     readonly recordingExport: Pick<InferProvider<typeof recordingExportCapability>, 'createExport' | 'getExport' | 'cancelExport' | 'deleteExport' | 'getDownloadUrl' | 'readExportBytes'>;
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
     readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'insert' | 'insertMany' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'aggregate' | 'histogram' | 'isEmpty' | 'declareCollection'>;