@camstack/types 1.2.44 → 1.2.46

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

@@ -55,6 +55,8 @@ declare const DetailResultSchema: z.ZodObject<{
     }, z.core.$strip>>;
     embedding: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
+    labelTier: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    labelModelId: z.ZodOptional<z.ZodString>;
     alignedCropJpeg: z.ZodOptional<z.ZodString>;
     nativeFaceShortSidePx: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
@@ -623,6 +625,8 @@ export declare const pipelineRunnerCapability: {
                 }, z.core.$strip>>;
                 embedding: z.ZodOptional<z.ZodString>;
                 label: z.ZodOptional<z.ZodString>;
+                labelTier: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+                labelModelId: z.ZodOptional<z.ZodString>;
                 alignedCropJpeg: z.ZodOptional<z.ZodString>;
                 nativeFaceShortSidePx: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
@@ -699,6 +703,8 @@ export declare const pipelineRunnerCapability: {
                 }, z.core.$strip>>;
                 embedding: z.ZodOptional<z.ZodString>;
                 label: z.ZodOptional<z.ZodString>;
+                labelTier: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+                labelModelId: z.ZodOptional<z.ZodString>;
                 alignedCropJpeg: z.ZodOptional<z.ZodString>;
                 nativeFaceShortSidePx: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;

package/dist/capabilities/stream-broker.cap.d.ts

@@ -8,6 +8,87 @@ export declare const StreamFormatSchema: z.ZodEnum<{
     mjpeg: "mjpeg";
 }>;
 export type StreamFormat = z.infer<typeof StreamFormatSchema>;
+/** A container `produceEventMedia` can emit. */
+export declare const EventMediaKindSchema: z.ZodEnum<{
+    mp4: "mp4";
+    gif: "gif";
+}>;
+export type EventMediaKind = z.infer<typeof EventMediaKindSchema>;
+/**
+ * One produced artifact, referenced by HANDLE.
+ *
+ * Never inline bytes: a produced clip is 200 KB–5 MB and every consumer of this
+ * method is in another runner ([D9](../../../../docs/decisions/adr-0009.md),
+ * [D18](../../../../docs/decisions/adr-0018.md) — cross-process media is fetched
+ * on demand, compressed, by handle). `bytes` is here so a caller can decide
+ * whether it wants the fetch at all.
+ */
+export declare const EventMediaArtifactSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        mp4: "mp4";
+        gif: "gif";
+    }>;
+    handle: z.ZodString;
+    nodeId: z.ZodString;
+    mime: z.ZodString;
+    bytes: z.ZodNumber;
+    width: z.ZodNumber;
+    height: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaArtifact = z.infer<typeof EventMediaArtifactSchema>;
+/**
+ * What a production actually covered — the answer to the only question an
+ * operator asks about a notification clip.
+ *
+ * `fromTs`/`toTs` are WALL CLOCK, derived from the ring's own packet timeline,
+ * so a caller can state "this clip starts 4.1 s before the event" instead of
+ * inferring it from a duration. A production whose `fromTs` is later than the
+ * event is a production with no pre-roll, and that is exactly the defect this
+ * method exists to make visible rather than plausible.
+ */
+export declare const EventMediaCoverageSchema: z.ZodObject<{
+    fromTs: z.ZodNumber;
+    toTs: z.ZodNumber;
+    packets: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaCoverage = z.infer<typeof EventMediaCoverageSchema>;
+/**
+ * The result of ONE cut, in every container the caller asked for.
+ *
+ * Every artifact in `media` came out of the SAME window of the SAME rendition —
+ * that is the whole reason this is one method rather than one call per format.
+ * A consumer attaching a gif and a video can no longer show two different
+ * moments, because it never chose two sources.
+ */
+export declare const EventMediaProductionSchema: z.ZodObject<{
+    media: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            mp4: "mp4";
+            gif: "gif";
+        }>;
+        handle: z.ZodString;
+        nodeId: z.ZodString;
+        mime: z.ZodString;
+        bytes: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>>>;
+    coverage: z.ZodObject<{
+        fromTs: z.ZodNumber;
+        toTs: z.ZodNumber;
+        packets: z.ZodNumber;
+    }, z.core.$strip>;
+    profile: z.ZodEnum<{
+        high: "high";
+        mid: "mid";
+        low: "low";
+    }>;
+    video: z.ZodEnum<{
+        encode: "encode";
+        copy: "copy";
+    }>;
+}, z.core.$strip>;
+export type EventMediaProduction = z.infer<typeof EventMediaProductionSchema>;
 declare const RtspRestreamEntrySchema: z.ZodObject<{
     brokerId: z.ZodString;
     url: z.ZodString;
@@ -592,8 +673,8 @@ export declare const streamBrokerCapability: {
             preRollSec: z.ZodDefault<z.ZodNumber>;
             postRollSec: z.ZodDefault<z.ZodNumber>;
             format: z.ZodDefault<z.ZodEnum<{
-                gif: "gif";
                 mp4: "mp4";
+                gif: "gif";
             }>>;
             maxWidth: z.ZodDefault<z.ZodNumber>;
             fps: z.ZodDefault<z.ZodNumber>;
@@ -609,6 +690,88 @@ export declare const streamBrokerCapability: {
             }>;
             durationMs: z.ZodNumber;
         }, z.core.$strip>, "mutation">;
+        /**
+         * THE production point for event media — one window, every container.
+         *
+         * `renderPreBufferClip` renders ONE format per call, so a consumer wanting a
+         * gif and a video made two calls and got two windows. On 2026-08-08 the
+         * operator received exactly that: a gif around a doorbell press and an mp4
+         * of the six seconds after it. This method cuts once and derives the rest,
+         * so "the attachments agree" is a property of the service instead of a
+         * discipline every consumer has to keep.
+         *
+         * It is also the only place that owns the packets. The broker already
+         * retains an AnnexB ring per camera (`setClipRetention`, D32) — the
+         * prebuffer — so a production reaches BACKWARDS from the event with no
+         * process to spawn and nothing kept warm. It waits out `postSeconds`, muxes
+         * the window once (COPYING the camera's own H.264 whenever nothing is being
+         * changed), derives any gif from that same mux, and returns HANDLES.
+         *
+         * Intended for every future consumer, not just notifications: a clips API, a
+         * retrain export and an event export all want the same window of the same
+         * camera and must not each grow their own renderer.
+         */
+        readonly produceEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            profile: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>>;
+            aroundMs: z.ZodNumber;
+            preSeconds: z.ZodDefault<z.ZodNumber>;
+            postSeconds: z.ZodDefault<z.ZodNumber>;
+            kinds: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                mp4: "mp4";
+                gif: "gif";
+            }>>>;
+            gifMaxWidth: z.ZodDefault<z.ZodNumber>;
+            gifFps: z.ZodDefault<z.ZodNumber>;
+            speed: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            media: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    mp4: "mp4";
+                    gif: "gif";
+                }>;
+                handle: z.ZodString;
+                nodeId: z.ZodString;
+                mime: z.ZodString;
+                bytes: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>>;
+            coverage: z.ZodObject<{
+                fromTs: z.ZodNumber;
+                toTs: z.ZodNumber;
+                packets: z.ZodNumber;
+            }, z.core.$strip>;
+            profile: z.ZodEnum<{
+                high: "high";
+                mid: "mid";
+                low: "low";
+            }>;
+            video: z.ZodEnum<{
+                encode: "encode";
+                copy: "copy";
+            }>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Redeem a {@link EventMediaArtifactSchema} handle for its bytes.
+         *
+         * Separate from the production on purpose (D18): the producing runner keeps
+         * the artifact for a few minutes, and a consumer that only wanted the
+         * coverage never moves a megabyte. `null` once it has expired — a handle is
+         * short-lived by design and a caller that waited too long must see that
+         * rather than a zero-length file.
+         */
+        readonly fetchEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            handle: z.ZodString;
+        }, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            base64: z.ZodString;
+            mime: z.ZodString;
+            bytes: z.ZodNumber;
+        }, z.core.$strip>>, "mutation">;
         readonly listAllCameraStreams: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             camStreamId: z.ZodString;
             deviceId: z.ZodNumber;

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

@@ -4876,6 +4876,83 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.getTrainingExportUrl.output>;
             meta: object;
         }>;
+        listRetrainStaging: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.listRetrainStaging.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.listRetrainStaging.output>;
+            meta: object;
+        }>;
+        listRetrainFrames: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.listRetrainFrames.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.listRetrainFrames.output>;
+            meta: object;
+        }>;
+        selectRetrainFrames: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.selectRetrainFrames.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.selectRetrainFrames.output>;
+            meta: object;
+        }>;
+        deselectRetrainFrame: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.deselectRetrainFrame.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.deselectRetrainFrame.output>;
+            meta: object;
+        }>;
+        getRetrainFrameImage: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.getRetrainFrameImage.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.getRetrainFrameImage.output>;
+            meta: object;
+        }>;
+        proposeRetrainAnnotations: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.proposeRetrainAnnotations.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.proposeRetrainAnnotations.output>;
+            meta: object;
+        }>;
+        listRetrainAnnotations: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.listRetrainAnnotations.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.listRetrainAnnotations.output>;
+            meta: object;
+        }>;
+        saveRetrainAnnotations: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.saveRetrainAnnotations.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.saveRetrainAnnotations.output>;
+            meta: object;
+        }>;
+        completeRetrainTrack: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.completeRetrainTrack.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.completeRetrainTrack.output>;
+            meta: object;
+        }>;
+        restageRetrainTrack: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.restageRetrainTrack.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.restageRetrainTrack.output>;
+            meta: object;
+        }>;
+        getRetrainExportUrl: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.getRetrainExportUrl.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.getRetrainExportUrl.output>;
+            meta: object;
+        }>;
         getEventMedia: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -6884,6 +6961,20 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof streamBrokerCapability.methods.renderPreBufferClip.output>;
             meta: object;
         }>;
+        produceEventMedia: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof streamBrokerCapability.methods.produceEventMedia.input>;
+            output: z.infer<typeof streamBrokerCapability.methods.produceEventMedia.output>;
+            meta: object;
+        }>;
+        fetchEventMedia: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof streamBrokerCapability.methods.fetchEventMedia.input>;
+            output: z.infer<typeof streamBrokerCapability.methods.fetchEventMedia.output>;
+            meta: object;
+        }>;
         listAllCameraStreams: TRPCQueryProcedure<{
             input: {
                 nodeId?: string | undefined;

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: 23 caps, 50 methods with defaults.
+ * Coverage: 23 caps, 51 methods with defaults.
  */
 export declare const CAP_INPUT_DEFAULTS: Readonly<Record<string, Readonly<Record<string, Readonly<Record<string, unknown>>>>>>;
 /**

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

@@ -280,7 +280,7 @@ export interface DeviceProxy {
     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 recordingExport: Pick<InferDeviceProxyCap<typeof recordingExportCapability>, 'createExport' | 'listExports'>;
-    readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'renderPreBufferClip' | 'restartProfile' | 'getDeviceAudioMute' | 'setDeviceAudioMute' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'renderPreBufferClip' | 'produceEventMedia' | 'restartProfile' | 'getDeviceAudioMute' | 'setDeviceAudioMute' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
 }
 /**
  * Build a DeviceProxy that pre-binds deviceId + nodeId on every method call

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

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

@@ -89,7 +89,7 @@ export interface SystemProxy {
     readonly serverManagement: Pick<InferProvider<typeof serverManagementCapability>, 'getServerPackageStatus' | 'checkServerUpdate' | 'applyServerUpdate' | 'rollbackServerUpdate' | 'restartServer'>;
     readonly settingsStore: Pick<InferProvider<typeof settingsStoreCapability>, 'get' | 'set' | 'query' | 'insert' | 'update' | 'delete' | 'deleteWhere' | 'updateWhere' | 'count' | 'histogram' | 'isEmpty' | 'declareCollection'>;
     readonly storage: Pick<InferProvider<typeof storageCapability>, 'resolve' | 'write' | 'read' | 'exists' | 'list' | 'delete' | 'getAvailableSpace' | 'beginUpload' | 'writeChunk' | 'finalizeUpload' | 'abortUpload' | 'beginDownload' | 'readChunk' | 'endDownload' | 'listLocations' | 'getDefaultLocation' | 'listLocationDeclarations' | 'upsertLocation' | 'deleteLocation' | 'testLocation' | 'listProviders' | 'testConfig'>;
-    readonly streamBroker: Pick<InferProvider<typeof streamBrokerCapability>, 'listAllCameraStreams' | 'listAllProfileSlots' | 'getBrokerStats' | 'probeStream' | 'listClients' | 'killClient' | 'getStreamUrl' | 'getStreamWithCodec' | 'releaseStreamWithCodec' | 'acquireEgressTranscode' | 'releaseEgressTranscode' | 'subscribeAudioChunks' | 'pullAudioChunks' | 'unsubscribeAudioChunks' | 'subscribeFrames' | 'pullFrameHandles' | 'unsubscribeFrames' | 'setPreBufferDuration' | 'getPreBufferInfo' | 'getRtspPort' | 'getAllRtspEntries' | 'getRtspEntry' | 'regenerateRtspToken' | 'setRtspEnabled' | 'isRtspEnabled'>;
+    readonly streamBroker: Pick<InferProvider<typeof streamBrokerCapability>, 'fetchEventMedia' | 'listAllCameraStreams' | 'listAllProfileSlots' | 'getBrokerStats' | 'probeStream' | 'listClients' | 'killClient' | 'getStreamUrl' | 'getStreamWithCodec' | 'releaseStreamWithCodec' | 'acquireEgressTranscode' | 'releaseEgressTranscode' | 'subscribeAudioChunks' | 'pullAudioChunks' | 'unsubscribeAudioChunks' | 'subscribeFrames' | 'pullFrameHandles' | 'unsubscribeFrames' | 'setPreBufferDuration' | 'getPreBufferInfo' | 'getRtspPort' | 'getAllRtspEntries' | 'getRtspEntry' | 'regenerateRtspToken' | 'setRtspEnabled' | 'isRtspEnabled'>;
     readonly system: Pick<InferProvider<typeof systemCapability>, 'info' | 'health' | 'featureFlags' | 'networkAddresses' | 'getRetentionConfig' | 'setRetentionConfig' | 'forceRetentionCleanup'>;
     readonly terminalSession: Pick<InferProvider<typeof terminalSessionCapability>, 'listProfiles' | 'listSessions' | 'openSession' | 'resize' | 'close'>;
     readonly toast: Pick<InferProvider<typeof toastCapability>, 'onToast'>;