@camstack/types 1.2.110 → 1.2.112

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-EY0GNjV9.js");
-const require_sleep = require("./sleep-DnbNfEhn.js");
+const require_sleep = require("./sleep-CSodb2vQ.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/addon.mjs

@@ -1,5 +1,5 @@
 import { t as EventCategory } from "./event-category-CIa_iT6b.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-swxwnJmL.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-CdbM8ge4.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/capabilities/index.d.ts

@@ -179,7 +179,7 @@ export { type IPrivacyMaskProvider, type PrivacyMaskOptions, PrivacyMaskOptionsS
 export { type IPtzProvider, PtzMoveCommandSchema, type PtzOptions, PtzOptionsSchema, PtzPositionSchema, PtzPresetSchema, type PtzStatus, PtzStatusSchema, ptzCapability, } from './ptz.cap.js';
 export { type IPtzAutotrackProvider, type PtzAutotrackRuntimeState, PtzAutotrackRuntimeStateSchema, type PtzAutotrackSettings, PtzAutotrackSettingsSchema, type PtzAutotrackStatus, PtzAutotrackStatusSchema, type PtzAutotrackTargetOption, PtzAutotrackTargetOptionSchema, ptzAutotrackCapability, } from './ptz-autotrack.cap.js';
 export { type IRebootProvider, rebootCapability } from './reboot.cap.js';
-export { type IRecordingProvider, type LocateSegmentResult, LocateSegmentResultSchema, type ReadGopBytesResult, ReadGopBytesResultSchema, type ReadSegmentBytesResult, ReadSegmentBytesResultSchema, 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 { 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 ZoneRule, type ZoneRuleMode, ZoneRuleModeEnum, ZoneRuleSchema, type ZoneRules, ZoneRulesArraySchema, } from './schemas/zone-rule.js';

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

@@ -1812,6 +1812,7 @@ export declare const NcHistoryEntrySchema: z.ZodObject<{
             data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    artifactIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type NcHistoryEntry = z.infer<typeof NcHistoryEntrySchema>;
 /** `getHistory` default page size + hard ceiling (bounded output). */
@@ -4047,8 +4048,27 @@ export declare const notificationRulesCapability: {
                         data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
                     }, z.core.$strip>>;
                 }, z.core.$strip>;
+                artifactIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Mint a fresh, externally-reachable URL for one artefact a history row
+         * named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
+         * signed-link mechanism the dispatcher uses to attach media to an
+         * outgoing notification (one derivation; this never re-implements it).
+         *
+         * `url: null` on THREE causes a caller must treat identically ("no image
+         * right now", never a broken link): the id is unknown, its artefact has
+         * expired past the retained shelf's own age bound, or this install has no
+         * externally-reachable base URL. A caller that received a URL on a
+         * previous call and now gets `null` must stop showing it — a link that
+         * worked five minutes ago is not proof it works now.
+         */
+        readonly resolveArtifactUrl: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            artifactId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            url: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * Snooze windows currently in effect, plus any whose digest has not yet
          * gone out. `caller: 'required'`: a user sees their OWN windows and the

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

@@ -1338,6 +1338,34 @@ declare const EventPruneCountsSchema: z.ZodObject<{
     audio: z.ZodNumber;
 }, z.core.$strip>;
 export type EventPruneCounts = z.infer<typeof EventPruneCountsSchema>;
+declare const ReplayTrackSchema: z.ZodObject<{
+    className: z.ZodString;
+    firstSeenMs: z.ZodNumber;
+    lastSeenMs: z.ZodNumber;
+    bbox: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        w: z.ZodNumber;
+        h: z.ZodNumber;
+    }, z.core.$strip>;
+    framesMatched: z.ZodNumber;
+}, z.core.$strip>;
+declare const RunReplayFrameProcessorResultSchema: z.ZodObject<{
+    tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        className: z.ZodString;
+        firstSeenMs: z.ZodNumber;
+        lastSeenMs: z.ZodNumber;
+        bbox: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>;
+        framesMatched: z.ZodNumber;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ReplayTrack = z.infer<typeof ReplayTrackSchema>;
+export type RunReplayFrameProcessorResult = z.infer<typeof RunReplayFrameProcessorResultSchema>;
 export declare const pipelineAnalyticsCapability: {
     readonly name: "pipeline-analytics";
     readonly scope: "device";
@@ -2751,6 +2779,73 @@ export declare const pipelineAnalyticsCapability: {
             reason: z.ZodString;
             detail: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>], "kind">, "mutation">;
+        /**
+         * The FrameProcessor pass of a replay run — see the `Replay` section
+         * above this capability's definition for why this is not the
+         * `processFrame` method this file's header says pipeline-analytics does
+         * not have.
+         *
+         * Constructs a FRESH `FrameProcessor` for `(deviceId, source)`, feeds it
+         * `frames` IN THE ORDER GIVEN (the caller is responsible for time
+         * ordering — this method does not sort), and returns the tracks it
+         * produced. Zero persistence: no `TrackStore`, no event bus, no media
+         * capture. `zones` / `detectionRules` are the run's OWN zone set —
+         * typically the camera's real zones plus an ephemeral overlay
+         * (`addon-benchmark`'s `replay-plan.ts`), never read from or written to
+         * the `zones` capability by this method itself.
+         */
+        readonly runReplayFrameProcessor: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            source: z.ZodEnum<{
+                pipeline: "pipeline";
+                onboard: "onboard";
+            }>;
+            zones: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                kind: z.ZodDefault<z.ZodEnum<{
+                    polygon: "polygon";
+                    tripwire: "tripwire";
+                }>>;
+                polygon: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                }, z.core.$strip>>>;
+                color: z.ZodDefault<z.ZodString>;
+            }, z.core.$strip>>>>;
+            detectionRules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                zoneIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+                mode: z.ZodEnum<{
+                    include: "include";
+                    exclude: "exclude";
+                }>;
+                classFilter: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+                overlapThreshold: z.ZodOptional<z.ZodNumber>;
+                bboxInclusionPct: z.ZodOptional<z.ZodNumber>;
+                preferMask: z.ZodOptional<z.ZodBoolean>;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>>>;
+            zoneMembershipMinOverlap: z.ZodOptional<z.ZodNumber>;
+            frames: z.ZodArray<z.ZodObject<{
+                timestamp: z.ZodNumber;
+                frame: z.ZodCustom<import("../index.js").FrameResult, import("../index.js").FrameResult>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                className: z.ZodString;
+                firstSeenMs: z.ZodNumber;
+                lastSeenMs: z.ZodNumber;
+                bbox: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    w: z.ZodNumber;
+                    h: z.ZodNumber;
+                }, z.core.$strip>;
+                framesMatched: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation">;
         /** Every annotation on a track, oldest first. */
         readonly listRetrainAnnotations: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             trackId: z.ZodString;

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

@@ -638,6 +638,56 @@ export declare const pipelineExecutorCapability: {
             success: z.ZodLiteral<true>;
             clearedDevices: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * Which of THIS node's inference devices the executor currently refuses,
+         * and why. `nodeId` is the ROUTING key (stripped by the generated router).
+         *
+         * The channel that did not exist. Pool health was known only inside the
+         * detection addon and was an input to no routing decision anywhere: the
+         * per-dispatch capability gate is keyed on model FORMAT and so can never
+         * separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
+         * eligibility probe (`platformProbe.getCapabilities`) answers about
+         * HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
+         * Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
+         * balancer went on handing that dead pool cameras by rotation for 31 hours:
+         * ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
+         *
+         * Read semantics the caller depends on, and which the provider guarantees:
+         * this is a synchronous read of in-memory state. It never probes hardware,
+         * never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
+         * nothing is refused", which is what re-admits a device. A read that FAILS
+         * (node offline, version skew) must therefore be distinguishable from an
+         * empty answer, and it is: it rejects.
+         */
+        readonly getInferenceDeviceHealth: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            unhealthy: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                deviceKey: z.ZodString;
+                state: z.ZodEnum<{
+                    failed: "failed";
+                    backoff: "backoff";
+                }>;
+                since: z.ZodNumber;
+                deaths: z.ZodNumber;
+                lastError: z.ZodString;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Re-arm a terminally `failed` inference device on `nodeId`: forget its
+         * restart budget so the next dispatch builds a fresh pool.
+         *
+         * The terminal state is deliberate (the abort it bounds is deterministic —
+         * an automatic probation would just respawn Python forever, more slowly),
+         * and a terminal state an operator cannot leave is a silent fault. This is
+         * the way out. `rearmed:false` means there was nothing to forget.
+         */
+        readonly rearmInferenceDevice: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            nodeId: z.ZodString;
+            deviceKey: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            rearmed: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         readonly getSchema: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodObject<{
             availableEngines: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 engine: z.ZodObject<{

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

@@ -203,6 +203,33 @@ export declare const ReadGopBytesResultSchema: z.ZodObject<{
     gopDurMs: z.ZodNumber;
 }, z.core.$strip>;
 export type ReadGopBytesResult = z.infer<typeof ReadGopBytesResultSchema>;
+/**
+ * A time WINDOW of one finalized segment, cut by byte range — the multi-GOP
+ * twin of {@link ReadGopBytesResultSchema}'s single instant. Built for the
+ * replay clip's `recording` source (`docs/design/plans/2026-08-26-replay-clip-su-pipeline.md`):
+ * a replay needs several seconds of native pixels, not one frame.
+ *
+ * `ok.data` is standalone-demuxable, same as a GOP read. `ok.reachesRequestedEnd`
+ * is `false` when the returned bytes were cut short by the read's own safety
+ * byte cap before covering `[fromMs, toMs)` — a truncation, reported, not a
+ * silently shorter answer. `spans-multiple-segments` is a REFUSAL, not a
+ * degradation: a window whose end falls past the covering segment would need
+ * bytes stitched from a second segment file (its own `ftyp`+`moov`), which is
+ * not one standalone-demuxable stream — the caller's answer is to request a
+ * shorter window or one aligned to a single segment, not to receive spliced
+ * bytes nothing has proven decodable.
+ */
+export declare const ReadWindowBytesResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"ok">;
+    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    gopStartMs: z.ZodNumber;
+    gopDurMs: z.ZodNumber;
+    reachesRequestedEnd: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"spans-multiple-segments">;
+    segmentEndMs: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export type ReadWindowBytesResult = z.infer<typeof ReadWindowBytesResultSchema>;
 export declare const recordingCapability: {
     readonly name: "recording";
     readonly scope: "system";
@@ -348,6 +375,27 @@ export declare const recordingCapability: {
             gopStartMs: z.ZodNumber;
             gopDurMs: z.ZodNumber;
         }, z.core.$strip>, "query">;
+        /** Read a WINDOW `[fromMs, toMs)` of segment `startMs`, by mfra byte
+         *  range — the multi-GOP twin of `readGopBytes`. Refuses (does not
+         *  degrade) when the window runs past the covering segment. Used by the
+         *  replay clip's `recording` source to fetch several seconds of native
+         *  footage for its single ffmpeg decode pass. */
+        readonly readWindowBytes: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            profile: z.ZodString;
+            startMs: z.ZodNumber;
+            fromMs: z.ZodNumber;
+            toMs: z.ZodNumber;
+        }, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"ok">;
+            data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+            gopStartMs: z.ZodNumber;
+            gopDurMs: z.ZodNumber;
+            reachesRequestedEnd: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"spans-multiple-segments">;
+            segmentEndMs: z.ZodNumber;
+        }, z.core.$strip>], "kind">, "query">;
         readonly setDeviceConfig: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
             config: z.ZodObject<{

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

@@ -4526,6 +4526,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof notificationRulesCapability.methods.getHistory.output>;
             meta: object;
         }>;
+        resolveArtifactUrl: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof notificationRulesCapability.methods.resolveArtifactUrl.input>;
+            output: z.infer<typeof notificationRulesCapability.methods.resolveArtifactUrl.output>;
+            meta: object;
+        }>;
         listSnoozes: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -5108,6 +5115,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.proposeRetrainAnnotations.output>;
             meta: object;
         }>;
+        runReplayFrameProcessor: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.runReplayFrameProcessor.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.runReplayFrameProcessor.output>;
+            meta: object;
+        }>;
         listRetrainAnnotations: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -5248,6 +5262,20 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineExecutorCapability.methods.clearDeviceOverrides.output>;
             meta: object;
         }>;
+        getInferenceDeviceHealth: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineExecutorCapability.methods.getInferenceDeviceHealth.input>;
+            output: z.infer<typeof pipelineExecutorCapability.methods.getInferenceDeviceHealth.output>;
+            meta: object;
+        }>;
+        rearmInferenceDevice: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineExecutorCapability.methods.rearmInferenceDevice.input>;
+            output: z.infer<typeof pipelineExecutorCapability.methods.rearmInferenceDevice.output>;
+            meta: object;
+        }>;
         getSchema: TRPCQueryProcedure<{
             input: {
                 nodeId?: string | undefined;
@@ -6348,6 +6376,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof recordingCapability.methods.readGopBytes.output>;
             meta: object;
         }>;
+        readWindowBytes: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.readWindowBytes.input>;
+            output: z.infer<typeof recordingCapability.methods.readWindowBytes.output>;
+            meta: object;
+        }>;
         setDeviceConfig: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;

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

@@ -280,7 +280,7 @@ export interface DeviceProxy {
     readonly pipelineOrchestrator: Pick<InferDeviceProxyCap<typeof pipelineOrchestratorCapability>, 'assignPipeline' | 'unassignPipeline' | 'setPipelineDevicePin' | 'getPipelineDevicePin' | 'getPipelineAssignment' | 'getCameraMetrics' | 'assignAudio' | 'unassignAudio' | 'getAudioAssignment' | 'getAudioAssignments' | 'getCameraSettings' | 'setCameraStepToggle' | 'getCameraStepOverrides' | 'setCameraStepOverride' | 'setCameraPipelineForAgent' | 'resolvePipeline' | 'getCameraSwitches' | 'setCameraSwitch' | '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' | 'readGopBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'deleteFootprint' | 'renderGif' | 'renderClip' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly recording: Pick<InferDeviceProxyCap<typeof recordingCapability>, 'getAvailability' | 'getDaysWithRecordings' | 'getPlaybackManifest' | 'getDeviceConfig' | 'locateSegment' | 'readSegmentBytes' | 'readGopBytes' | 'readWindowBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'deleteFootprint' | 'renderGif' | 'renderClip' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly recordingExport: Pick<InferDeviceProxyCap<typeof recordingExportCapability>, 'listExports'>;
     readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'renderPreBufferClip' | 'produceEventMedia' | 'restartProfile' | 'getDeviceAudioMute' | 'setDeviceAudioMute' | '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: 958 method paths across 123 capabilities.
+ * Coverage: 963 method paths across 123 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: 342 methods carry a device reference, of which
- * 127 are on SYSTEM-scope caps.
+ * Coverage: 344 methods carry a device reference, of which
+ * 128 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

@@ -83,7 +83,7 @@ export interface SystemProxy {
     readonly nodes: Pick<InferProvider<typeof nodesCapability>, 'topology' | 'deployAddon' | 'undeployAddon' | 'restartAddon' | 'restartProcess' | 'restartNode' | 'shutdownNode' | 'renameNode' | 'clusterAddonStatus' | 'getCapUsageGraph' | 'getNodeAddons' | 'setProcessLogLevel' | 'executeQuery'>;
     readonly notificationOutput: Pick<InferProvider<typeof notificationOutputCapability>, 'listTargetKinds' | 'listTargets' | 'discoverTargets' | 'send' | 'testTarget' | 'upsertTarget' | 'deleteTarget' | 'setTargetEnabled'>;
     readonly osdManager: Pick<InferProvider<typeof osdManagerCapability>, 'getConditionSupport' | 'copyDeviceConfiguration'>;
-    readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'clearDeviceOverrides' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'validatePipeline' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
+    readonly pipelineExecutor: Pick<InferProvider<typeof pipelineExecutorCapability>, 'getAvailableEngines' | 'getSelectedEngine' | 'getDefaultSteps' | 'getEngineProvisioning' | 'getVideoPipelineSteps' | 'setVideoPipelineSteps' | 'clearDeviceOverrides' | 'getInferenceDeviceHealth' | 'rearmInferenceDevice' | 'getSchema' | 'getGlobalSteps' | 'getGlobalPipelineConfig' | 'getOrchestratorConfigSchema' | 'validatePipeline' | 'listTemplates' | 'saveTemplate' | 'updateTemplate' | 'deleteTemplate' | 'getCapabilities' | 'getAddonModels' | 'downloadModel' | 'deleteModel' | 'cacheFrameInPool' | 'inferCached' | 'uncacheFrame' | 'getEffectiveTuning' | 'listLoadedEngines' | 'spinEngine' | 'killEngine' | 'listReferenceImages' | 'getReferenceImage' | 'getReferenceAudioFiles' | 'getReferenceAudio' | 'getAudioCapabilities' | 'runAudioTest' | 'getDetectionConfigSchema'>;
     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'>;