@camstack/types 1.2.127 → 1.2.129

package/dist/addon.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_event_category = require("./event-category-BaEgqJNv.js");
-const require_sleep = require("./sleep-CWWLTM6W.js");
+const require_sleep = require("./sleep-D5821NGq.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-BZL-fdNj.mjs";
-import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-bm0x6zZF.mjs";
+import { B as ReadinessRegistry, E as adminUiCapability, L as nodePin, R as readNodePin, St as emitReadiness, T as DeviceType, V as ReadinessTimeoutError, W as scopeKey, _t as DisposerChain, a as asJsonObject, b as deviceOpsCapability, d as BOOT_RECOVERY_BACKOFF_MS, f as DEVICE_SCOPED_CAPS, gt as DATAPLANE_SECRET_HEADER, h as createEventBusSliceSource, j as expandCapMethods, m as createDeviceProxy, p as isDeviceScopedCap, s as asString, t as sleep, u as parseJsonUnknown, vt as BaseAddon, x as viewerUiCapability, yt as normalizeAddonInitResult } from "./sleep-BS40IUZZ.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/capabilities/face-gallery.cap.d.ts

@@ -199,7 +199,7 @@ export declare const faceGalleryCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             kind: z.ZodString;
-            base64: z.ZodString;
+            url: z.ZodString;
             sizeBytes: z.ZodNumber;
             timestamp: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

package/dist/capabilities/index.d.ts

@@ -55,17 +55,17 @@ export { DiscoveredDeviceSchema, deviceProviderCapability, ProviderStatusSchema,
 export { deviceStateCapability } from './device-state.cap.js';
 export type { IEmbeddingEncoderProvider } from './embedding-encoder.cap.js';
 export { EmbeddingInfoSchema, EmbeddingResultSchema, embeddingEncoderCapability, } from './embedding-encoder.cap.js';
+export type { FailureContribution, IFailureContributionProvider, } from './failure-contribution.cap.js';
+export { FailureContributionSchema, FailureReasonCountSchema, failureContributionCapability, } from './failure-contribution.cap.js';
 export { filesystemBrowseCapability, type IFilesystemBrowseProvider, } from './filesystem-browse.cap.js';
 export { type HfModelResolution, HfModelResolutionSchema, type ILlmProvider, type LlmDefault, LlmDefaultSchema, type LlmDefaultSelector, LlmDefaultSelectorSchema, type LlmProfile, type LlmProfileKind, type LlmProfileKindDescriptor, LlmProfileKindDescriptorSchema, LlmProfileKindSchema, LlmProfileSchema, type LlmRuntimeNode, LlmRuntimeNodeSchema, type LlmUsageRollup, LlmUsageRollupSchema, llmCapability, type ManagedModelCatalogEntry, ManagedModelCatalogEntrySchema, } from './llm.cap.js';
 export { type ILlmRuntimeProvider, type LlmDownloadProgress, LlmDownloadProgressSchema, type LlmNodeModel, LlmNodeModelSchema, type LlmRuntimeCompleteInput, LlmRuntimeCompleteInputSchema, type LlmRuntimeDiskUsage, LlmRuntimeDiskUsageSchema, type LlmRuntimeStatus, LlmRuntimeStatusSchema, llmRuntimeCapability, type ManagedModelExtraFile, ManagedModelExtraFileSchema, 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 LlmRetryPolicy, LlmRetryPolicySchema, LlmTimeoutDefaults, type LlmUsage, LlmUsageSchema, } from './llm-shared.js';
+export type { ILoadContributionProvider, LoadContribution, LoadContributionAttribution, LoadContributionRole, } from './load-contribution.cap.js';
+export { LOAD_CONTRIBUTION_ATTRIBUTIONS, LOAD_CONTRIBUTION_ROLES, LoadContributionSchema, loadContributionCapability, } from './load-contribution.cap.js';
 export type { ILogChannelsProvider, LogChannelApplyResult } from './log-channels.cap.js';
 export { LogChannelApplyResultSchema, logChannelsCapability } from './log-channels.cap.js';
 export { LogEntrySchema, LogLevelSchema, logDestinationCapability } from './log-destination.cap.js';
-export type { FailureContribution, IFailureContributionProvider, } from './failure-contribution.cap.js';
-export { FailureContributionSchema, FailureReasonCountSchema, failureContributionCapability, } from './failure-contribution.cap.js';
-export type { ILoadContributionProvider, LoadContribution, LoadContributionAttribution, LoadContributionRole, } from './load-contribution.cap.js';
-export { LOAD_CONTRIBUTION_ATTRIBUTIONS, LOAD_CONTRIBUTION_ROLES, LoadContributionSchema, loadContributionCapability, } from './load-contribution.cap.js';
 export type { ILoginMethodProvider, LoginMethodContribution, LoginStage, PasskeyLoginMethod, RedirectLoginMethod, WidgetLoginMethod, } from './login-method.cap.js';
 export { LoginMethodContributionSchema, LoginStageEnum, loginMethodCapability, PasskeyLoginMethodSchema, RedirectLoginMethodSchema, WidgetLoginMethodSchema, } from './login-method.cap.js';
 export { type IMetricsProvider, metricsProviderCapability, SystemMetricsSchema, } from './metrics-provider.cap.js';
@@ -82,13 +82,13 @@ export { NetworkAccessStatusSchema, NetworkEndpointSchema, networkAccessCapabili
 export { type Attachment, type AttachmentMediaType, AttachmentMediaTypeSchema, AttachmentSchema, type DiscoveredTarget, DiscoveredTargetSchema, type INotificationOutputProvider, type NotificationAction, type NotificationActionIcon, NotificationActionIconSchema, NotificationActionSchema, type NotificationFormat, NotificationFormatSchema, NotificationSchema, notificationOutputCapability, type RenderedAs, RenderedAsSchema, type SendResult, SendResultSchema, type Target, type TargetKind, type TargetKindCaps, TargetKindCapsSchema, type TargetKindLevel, TargetKindLevelSchema, TargetKindSchema, TargetSchema, type TestResult, TestResultSchema, } from './notification-output.cap.js';
 export { type INotificationRulesProvider, NC_ALARM_SYSTEM_EVENT_KINDS, NC_AUDIO_DBFS_FLOOR, NC_AUTHORABLE_SYSTEM_EVENT_KINDS, NC_CONDITION_CATALOG, NC_CONFIRM_DEFAULT_MAX_IMAGE_PX, NC_CONFIRM_DEFAULT_TIMEOUT_MS, NC_CONFIRM_MAX_TIMEOUT_MS, NC_CONFIRM_MIN_TIMEOUT_MS, NC_DEFAULT_SNOOZE_MINUTES, NC_HISTORY_LIMIT_DEFAULT, NC_HISTORY_LIMIT_MAX, NC_MAX_PER_TRACK_IMMEDIATE, NC_SNOOZE_MAX_MINUTES, type NcAlarmConfig, NcAlarmConfigSchema, type NcAlarmModeCoverage, NcAlarmModeCoverageSchema, type NcAlarmSettings, type NcAlarmSettingsPatch, NcAlarmSettingsPatchSchema, NcAlarmSettingsSchema, type NcAlarmSkippedDevice, NcAlarmSkippedDeviceSchema, type NcAlarmSkipReason, NcAlarmSkipReasonSchema, type NcAudioCondition, NcAudioConditionSchema, type NcConditionDescriptor, NcConditionDescriptorSchema, type NcConditions, NcConditionsSchema, type NcConfirm, type NcConfirmExpect, NcConfirmExpectSchema, NcConfirmSchema, type NcCrossing, NcCrossingSchema, type NcDelivery, NcDeliverySchema, type NcDeviceStateCondition, NcDeviceStateConditionSchema, type NcHistoryEntry, NcHistoryEntrySchema, type NcHistoryFilter, NcHistoryFilterSchema, type NcHistoryRecordKind, NcHistoryRecordKindSchema, type NcHistoryStatus, NcHistoryStatusSchema, type NcHistorySubject, NcHistorySubjectSchema, type NcMediaFrame, NcMediaFrameSchema, type NcMediaPolicy, NcMediaPolicySchema, type NcOccupancyCondition, NcOccupancyConditionSchema, type NcPlateMatcher, NcPlateMatcherSchema, type NcRule, type NcRuleAction, NcRuleActionSchema, type NcRuleActionSequence, NcRuleActionSequenceSchema, type NcRuleActions, NcRuleActionsSchema, type NcRuleInput, NcRuleInputSchema, type NcRuleNotificationButton, NcRuleNotificationButtonSchema, type NcRulePatch, NcRulePatchSchema, NcRuleSchema, type NcRuleTarget, NcRuleTargetSchema, type NcSceneCondition, NcSceneConditionSchema, type NcSchedule, NcScheduleSchema, type NcScheduleWindow, NcScheduleWindowSchema, type NcSnooze, type NcSnoozeInput, NcSnoozeInputSchema, NcSnoozeSchema, type NcSnoozeScope, NcSnoozeScopeSchema, type NcSnoozeSuppressed, NcSnoozeSuppressedSchema, type NcSystemEventCondition, NcSystemEventConditionSchema, type NcSystemEventKind, NcSystemEventKindSchema, type NcTestResult, NcTestResultSchema, type NcThrottle, type NcThrottleGranularity, NcThrottleGranularitySchema, NcThrottleSchema, type NcZoneCondition, NcZoneConditionSchema, notificationRulesCapability, } from './notification-rules.cap.js';
 export { type IOauthIntegrationProvider, type OauthIntegrationDescriptor, OauthIntegrationDescriptorSchema, oauthIntegrationCapability, } from './oauth-integration.cap.js';
-export { type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type LabelAttribution, LabelAttributionSchema, type LabelTier, LabelTierSchema, type MediaFile, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type AnalyticsGroupDetail, AnalyticsGroupDetailSchema, type AnalyticsGroupMember, AnalyticsGroupMemberSchema, type AnalyticsGroupRecord, AnalyticsGroupRecordSchema, type ListGroupsPage, ListGroupsPageSchema, type ListGroupsQuery, ListGroupsQueryInput, type RetrainAnnotation, type RetrainAnnotationDraft, RetrainAnnotationDraftSchema, RetrainAnnotationKindSchema, RetrainAnnotationSchema, RetrainAnnotationSourceSchema, type RetrainAssistResult, RetrainAssistResultSchema, RetrainAssistSubjectSchema, RetrainCopyRefusalSchema, type RetrainFrame, type RetrainFrameCandidate, RetrainFrameCandidateSchema, type RetrainFrameList, RetrainFrameListSchema, RetrainFrameSchema, type RetrainFrameSelection, RetrainFrameSelectionSchema, type RetrainMacroClass, RetrainMacroClassSchema, type RetrainStatus, RetrainStatusSchema, type RetrainTrack, RetrainTrackSchema, type RetrainTransitionResult, RetrainTransitionResultSchema, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackFlags, type TrackFlagsPatch, TrackFlagsPatchSchema, TrackFlagsSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackSource, TrackSourceSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type TrainingExportDeviceTotals, TrainingExportDeviceTotalsSchema, type TrainingExportSummary, TrainingExportSummarySchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
+export { type AnalyticsGroupDetail, AnalyticsGroupDetailSchema, type AnalyticsGroupMember, AnalyticsGroupMemberSchema, type AnalyticsGroupRecord, AnalyticsGroupRecordSchema, type AudioEvent, AudioEventSchema, type DetectionSource, DetectionSourceSchema, type EventKind, type EventKindCategory, EventKindCategorySchema, type EventKindDescriptor, EventKindDescriptorSchema, type EventKindIcon, EventKindIconSchema, EventKindSchema, type EventKindsForDevice, EventKindsForDeviceSchema, type EventMediaKindBreakdown, type EventMediaKindFootprint, type EventPruneCounts, type EventStoreDeviceFootprint, type EventStoreFootprint, type IPipelineAnalyticsProvider, type KeyEvent, KeyEventSchema, type LabelAttribution, LabelAttributionSchema, type LabelTier, LabelTierSchema, type ListGroupsPage, ListGroupsPageSchema, type ListGroupsQuery, ListGroupsQueryInput, type MediaFile, type MediaFileBytes, type MediaFileInfo, MediaFileInfoSchema, type MediaFileKind, MediaFileKindEnum, type MediaFileRef, MediaFileRefSchema, MediaFileSchema, type MotionEvent, MotionEventSchema, type ObjectEvent, ObjectEventSchema, pipelineAnalyticsCapability, type RecentTracksPage, RecentTracksPageSchema, type RecentTracksQuery, RecentTracksQueryInput, type RetrainAnnotation, type RetrainAnnotationDraft, RetrainAnnotationDraftSchema, RetrainAnnotationKindSchema, RetrainAnnotationSchema, RetrainAnnotationSourceSchema, type RetrainAssistResult, RetrainAssistResultSchema, RetrainAssistSubjectSchema, RetrainCopyRefusalSchema, type RetrainFrame, type RetrainFrameCandidate, RetrainFrameCandidateSchema, type RetrainFrameList, RetrainFrameListSchema, RetrainFrameSchema, type RetrainFrameSelection, RetrainFrameSelectionSchema, type RetrainMacroClass, RetrainMacroClassSchema, type RetrainStatus, RetrainStatusSchema, type RetrainTrack, RetrainTrackSchema, type RetrainTransitionResult, RetrainTransitionResultSchema, type ScoredObjectEvent, ScoredObjectEventSchema, type SensorEvent, SensorEventSchema, type Track, type TrackCascadeCounts, TrackCascadeCountsSchema, type TrackEnvelope, TrackEnvelopeSchema, TrackedDetectionSchema, type TrackFlags, type TrackFlagsPatch, TrackFlagsPatchSchema, TrackFlagsSchema, type TrackProjection, TrackProjectionSchema, TrackSchema, type TrackSource, TrackSourceSchema, type TrackState, TrackStateSchema, type TrackZoneFilter, TrackZoneFilterSchema, type TrainingExportDeviceTotals, TrainingExportDeviceTotalsSchema, type TrainingExportSummary, TrainingExportSummarySchema, type ZoneCrossing, type ZoneCrossingDirection, ZoneCrossingDirectionSchema, ZoneCrossingSchema, } from './pipeline-analytics.cap.js';
 export type { NativeCropRef, PipelineStepInputOutput, PipelineValidationIssue, PipelineValidationResult, } from './pipeline-executor.cap.js';
 export { ModelSubstitutionSchema, NativeCropRefSchema, PipelineDefaultStepSchema, PipelineEngineChoiceSchema, PipelineRunResultBridge, PipelineStepInputSchema, PipelineValidationIssueSchema, PipelineValidationResultSchema, pipelineExecutorCapability, } from './pipeline-executor.cap.js';
 export type { CameraAssignmentStatus, CameraAudioStatus, CameraBrokerProfile, CameraBrokerStatus, CameraDecoderShm, CameraDecoderStatus, CameraDetectionPhase, CameraDetectionProvisioning, CameraDetectionProvisioningState, CameraDetectionStatus, CameraMotionStatus, CameraRecordingMode, CameraRecordingStatus, CameraSourceStatus, CameraSourceStream, CameraStatus, CameraStatusDegradation, CameraStatusDegradationReason, CameraStatusStage, DiskReconcileJob, InferenceDeviceExclusionReason, IngestOwner, NodeInferenceDevice, NodeInferenceDevices, } from './pipeline-orchestrator.cap.js';
 export { AgentLoadSummarySchema, CameraAssignmentStatusSchema, CameraAudioStatusSchema, CameraBrokerProfileSchema, CameraBrokerStatusSchema, CameraDecoderShmSchema, CameraDecoderStatusSchema, CameraDetectionPhaseSchema, CameraDetectionProvisioningSchema, CameraDetectionProvisioningStateSchema, CameraDetectionStatusSchema, CameraMotionStatusSchema, CameraRecordingModeSchema, CameraRecordingStatusSchema, CameraSourceStatusSchema, CameraSourceStreamSchema, CameraStatusDegradationReasonSchema, CameraStatusDegradationSchema, CameraStatusSchema, CameraStatusStageSchema, CapabilityBindingsSchema, DiskReconcileJobSchema, GlobalMetricsSchema, INFERENCE_DEVICE_EXCLUSION_REASONS, InferenceDeviceExclusionReasonSchema, IngestOwnerSchema, PipelineAssignmentSchema, pipelineOrchestratorCapability, } from './pipeline-orchestrator.cap.js';
 export type { DetailParent, DetailResult, MotionSource, MotionSources, ReportMotionInput, RunDetailSubtreeInput, RunDetailSubtreeResult, RunnerFrameSource, RunnerInferenceDevice, RunStatelessStepInput, RunStatelessStepResult, StatelessStepRefusal, } from './pipeline-runner.cap.js';
-export { MotionSourceEnum, MotionSourcesSchema, type NativeCropBbox, NativeCropBboxSchema, NativeCropResultSchema, pipelineRunnerCapability, ReportMotionInputSchema, RunnerCameraConfigSchema, RunnerCameraDeviceUIFields, RunnerFrameSourceSchema, RunnerInferenceDeviceSchema, FrameLazyCountersSchema, FrameLazyMetricsSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema, } from './pipeline-runner.cap.js';
+export { FrameLazyCountersSchema, FrameLazyMetricsSchema, MotionSourceEnum, MotionSourcesSchema, type NativeCropBbox, NativeCropBboxSchema, NativeCropResultSchema, pipelineRunnerCapability, ReportMotionInputSchema, RunnerCameraConfigSchema, RunnerCameraDeviceUIFields, RunnerFrameSourceSchema, RunnerInferenceDeviceSchema, RunnerLocalLoadSchema, RunnerLocalMetricsSchema, } from './pipeline-runner.cap.js';
 export { AudioChunkInputSchema, AudioClassificationLabelSchema, AudioLevelSchema, BoundingBoxSchema, FrameInputSchema, SpatialDetectionSchema, } from './schemas/detection-shared.js';
 export { CameraMetricsSchema, CameraMetricsWithDeviceIdSchema, OrchestratorMetricsSchema, } from './schemas/orchestrator-metrics.js';
 export type { CameraStream, CamProfile, CamStreamKind, DecodedAudioChunkWire, FrameHandleFormat, ProfileRtspEntry, ProfileSlot, ProfileSlotStatus, SubscribeAudioChunksInput, SubscribeAudioChunksResult, SubscribeFramesInput, SubscribeFramesResult, } from './schemas/streaming-shared.js';
@@ -267,6 +267,7 @@ import type { enumSensorCapability } from './enum-sensor.cap.js';
 import type { eventEmitterCapability } from './event-emitter.cap.js';
 import type { eventsCapability } from './events.cap.js';
 import type { faceGalleryCapability } from './face-gallery.cap.js';
+import type { failureContributionCapability } from './failure-contribution.cap.js';
 import type { fanControlCapability } from './fan-control.cap.js';
 import type { featureProbeCapability } from './feature-probe.cap.js';
 import type { filesystemBrowseCapability } from './filesystem-browse.cap.js';
@@ -281,11 +282,10 @@ import type { intercomCapability } from './intercom.cap.js';
 import type { lawnMowerControlCapability } from './lawn-mower-control.cap.js';
 import type { llmCapability } from './llm.cap.js';
 import type { llmRuntimeCapability } from './llm-runtime.cap.js';
+import type { loadContributionCapability } from './load-contribution.cap.js';
 import type { localNetworkCapability } from './local-network.cap.js';
 import type { lockControlCapability } from './lock-control.cap.js';
 import type { logChannelsCapability } from './log-channels.cap.js';
-import type { failureContributionCapability } from './failure-contribution.cap.js';
-import type { loadContributionCapability } from './load-contribution.cap.js';
 import type { logDestinationCapability } from './log-destination.cap.js';
 import type { loginMethodCapability } from './login-method.cap.js';
 import type { mediaPlayerCapability } from './media-player.cap.js';

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

@@ -619,6 +619,85 @@ declare const MediaFileKindEnum: z.ZodEnum<{
     thumbnailSmall: "thumbnailSmall";
 }>;
 export type MediaFileKind = z.infer<typeof MediaFileKindEnum>;
+/**
+ * One media row's IDENTITY and shape, with no representation of its bytes.
+ *
+ * This is the half of a media row that is cheap: it comes out of the index
+ * without opening a blob, and it is everything a client needs to decide what
+ * to render before it renders anything. Both wire shapes below are this plus
+ * an address; the STORE's own read-back shape ({@link MediaFileBytes}) is this
+ * plus the bytes.
+ */
+declare const MediaFileRefSchema: z.ZodObject<{
+    key: z.ZodString;
+    kind: z.ZodEnum<{
+        crop: "crop";
+        snapshot: "snapshot";
+        keyFrame: "keyFrame";
+        thumbnail: "thumbnail";
+        firstFrame: "firstFrame";
+        lastFrame: "lastFrame";
+        fullFrame: "fullFrame";
+        fullFrameBoxed: "fullFrameBoxed";
+        faceCrop: "faceCrop";
+        plateCrop: "plateCrop";
+        keyFrameSmall: "keyFrameSmall";
+        thumbnailSmall: "thumbnailSmall";
+    }>;
+    sizeBytes: z.ZodNumber;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type MediaFileRef = z.infer<typeof MediaFileRefSchema>;
+/**
+ * A media row AS STORED — its ref plus its bytes, base64.
+ *
+ * **This is not a wire shape and must never become one.** It is what
+ * `MediaStore` reads back and what every server-side picker
+ * (`pickCleanMedia`, `pickTrackFallbackMedia`, the last-frame promotion, the
+ * track-close ladder) works over, because those decide BETWEEN blobs and then
+ * hand exactly one of them to something that needs the pixels. A client never
+ * gets this: it gets {@link MediaFile}, and fetches the bytes by URL.
+ */
+export interface MediaFileBytes extends MediaFileRef {
+    readonly base64: string;
+}
+/**
+ * One media row ON THE WIRE: what it is, how big it is, and WHERE ITS BYTES
+ * ARE — never the bytes themselves.
+ *
+ * ## Why `url` and not `base64`
+ *
+ * Measured on the live hub 2026-08-30: `getTrackMedia {trackId, deviceId}`
+ * with no `kinds` returned 6 rows / **3 597 219 B**, of which `keyFrame` alone
+ * was **2 824 077 B** — one full-resolution frame, base64, so +33 % on the
+ * wire. Forty events is ~144 MB. Every byte of it was read off disk,
+ * base64-encoded, held whole in a unary tRPC envelope, and materialised in
+ * hub-main's heap on the way past — for an `<img>` that would have cached it.
+ *
+ * `url` points at the `event-media` data plane
+ * (`/addon/<addonId>/event-media/<storedKey>`), which serves the same blob
+ * with an ETag and `Cache-Control: immutable`, honours conditional GETs, can
+ * render a `?variant=thumb`, and streams. The hub gate in front of it requires
+ * a bearer or the session cookie (`access: 'authenticated'`), so the bytes are
+ * no less protected than they were inside a `view`-level cap response — see
+ * `data-plane-access.ts` for the rule and the one gap it does not close
+ * (per-device scoping).
+ *
+ * The URL is built from the row's **stored** key, which is not always its
+ * published `kind`: a track's face/plate crop is stored as `crop` under
+ * `('face'|'plate', '<prefix>-<trackId>')` and published as
+ * `faceCrop`/`plateCrop`. `MediaStore.getByKey` knows only the stored key.
+ *
+ * ## `base64` is TRANSITIONAL and is going away
+ *
+ * It is still populated for one reason: the deployed viewer's track-detail
+ * HERO tile reads it (`use-track-media-entry.ts` → `parseMediaFiles`, which
+ * REQUIRES the field), and a row without it parses as a FAILED read — the red
+ * triangle — not as absence. Removing the field before that viewer ships is an
+ * outage, not a cleanup. Once the viewer takes its hero bytes from `url`,
+ * delete this line and the `withBytes` pass-through in
+ * `analytics-query-facade.ts`; nothing else reads it.
+ */
 declare const MediaFileSchema: z.ZodObject<{
     key: z.ZodString;
     kind: z.ZodEnum<{
@@ -635,9 +714,10 @@ declare const MediaFileSchema: z.ZodObject<{
         keyFrameSmall: "keyFrameSmall";
         thumbnailSmall: "thumbnailSmall";
     }>;
-    base64: z.ZodString;
     sizeBytes: z.ZodNumber;
     timestamp: z.ZodNumber;
+    url: z.ZodString;
+    base64: z.ZodString;
 }, z.core.$strip>;
 export type MediaFile = z.infer<typeof MediaFileSchema>;
 /**
@@ -650,7 +730,9 @@ export type MediaFile = z.infer<typeof MediaFileSchema>;
  * blocks the whole view.
  *
  * `sizeBytes` is carried because it is what lets a client decide between the
- * stored blob and a `?variant=thumb` rendering without fetching either.
+ * stored blob and a `?variant=thumb` rendering without fetching either, and
+ * `url` because a client that had to build the plane path itself is a second
+ * copy of a route — the embed, the viewer and the admin UI each grew one.
  */
 declare const MediaFileInfoSchema: z.ZodObject<{
     key: z.ZodString;
@@ -669,6 +751,7 @@ declare const MediaFileInfoSchema: z.ZodObject<{
         keyFrameSmall: "keyFrameSmall";
         thumbnailSmall: "thumbnailSmall";
     }>;
+    url: z.ZodString;
     sizeBytes: z.ZodNumber;
 }, z.core.$strip>;
 export type MediaFileInfo = z.infer<typeof MediaFileInfoSchema>;
@@ -1333,6 +1416,75 @@ declare const EventStoreFootprintSchema: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type EventStoreFootprint = z.infer<typeof EventStoreFootprintSchema>;
+/** Event-media footprint for one {@link MediaFileKind}. */
+declare const EventMediaKindFootprintSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        crop: "crop";
+        snapshot: "snapshot";
+        keyFrame: "keyFrame";
+        thumbnail: "thumbnail";
+        firstFrame: "firstFrame";
+        lastFrame: "lastFrame";
+        fullFrame: "fullFrame";
+        fullFrameBoxed: "fullFrameBoxed";
+        faceCrop: "faceCrop";
+        plateCrop: "plateCrop";
+        keyFrameSmall: "keyFrameSmall";
+        thumbnailSmall: "thumbnailSmall";
+    }>;
+    rows: z.ZodNumber;
+    bytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaKindFootprint = z.infer<typeof EventMediaKindFootprintSchema>;
+/**
+ * The media footprint broken down by KIND — the axis a deletion decision
+ * actually turns on.
+ *
+ * A byte total says how much there is; it cannot say what is safe to remove.
+ * The deletable set (the periodic `snapshot` filmstrip, the surplus per-edge
+ * motion stills) and the keep set (`firstFrame`, rolling `lastFrame`,
+ * `thumbnail`/`thumbnailSmall`, `keyFrame`/`keyFrameSmall`, the face/plate
+ * buffers, gallery media, the CLIP `crop`) are distinguished by `kind` and by
+ * nothing else, so sizing a deletion means summing per kind.
+ *
+ * ## Why `unaccounted*` exists
+ *
+ * `kinds` is enumerated from {@link MediaFileKindEnum} — the closed set the
+ * writers use — and summed one kind at a time. `totalRows` / `totalBytes` come
+ * from a SEPARATE unfiltered aggregate over the same rows, never from adding
+ * `kinds` up. A row whose stored `kind` is not in the enum (written by a
+ * retired code path, or by a version that knew a kind this one does not) would
+ * otherwise vanish from the total silently, and an operator would delete
+ * against a denominator smaller than the disk.
+ *
+ * `unaccountedRows` / `unaccountedBytes` are the difference. They are normally
+ * zero; a non-zero value is a real finding and must be shown, not rounded away.
+ */
+declare const EventMediaKindBreakdownSchema: z.ZodObject<{
+    totalRows: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    kinds: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            crop: "crop";
+            snapshot: "snapshot";
+            keyFrame: "keyFrame";
+            thumbnail: "thumbnail";
+            firstFrame: "firstFrame";
+            lastFrame: "lastFrame";
+            fullFrame: "fullFrame";
+            fullFrameBoxed: "fullFrameBoxed";
+            faceCrop: "faceCrop";
+            plateCrop: "plateCrop";
+            keyFrameSmall: "keyFrameSmall";
+            thumbnailSmall: "thumbnailSmall";
+        }>;
+        rows: z.ZodNumber;
+        bytes: z.ZodNumber;
+    }, z.core.$strip>>>;
+    unaccountedRows: z.ZodNumber;
+    unaccountedBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type EventMediaKindBreakdown = z.infer<typeof EventMediaKindBreakdownSchema>;
 /** Per-kind counts returned by the event-prune / device-delete mutations. */
 declare const EventPruneCountsSchema: z.ZodObject<{
     motion: z.ZodNumber;
@@ -2337,6 +2489,44 @@ export declare const pipelineAnalyticsCapability: {
                 bytes: z.ZodNumber;
             }, z.core.$strip>>>;
         }, z.core.$strip>, "query">;
+        /**
+         * The same media footprint, broken down by {@link MediaFileKind} instead of
+         * by camera — fleet-wide, or for one camera with `deviceId`.
+         *
+         * Separate from {@link getEventStoreFootprint} rather than a field on it:
+         * the two answer different questions on different axes, the per-camera one
+         * is what the management table renders on every open, and nothing should
+         * pay for a per-kind pass to draw it. See
+         * {@link EventMediaKindBreakdownSchema} for why `unaccounted*` exists —
+         * `kinds` is enumerated, `totalBytes` is not, and the gap must be visible
+         * to anyone sizing a deletion against it.
+         */
+        readonly getEventMediaFootprintByKind: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            totalRows: z.ZodNumber;
+            totalBytes: z.ZodNumber;
+            kinds: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    crop: "crop";
+                    snapshot: "snapshot";
+                    keyFrame: "keyFrame";
+                    thumbnail: "thumbnail";
+                    firstFrame: "firstFrame";
+                    lastFrame: "lastFrame";
+                    fullFrame: "fullFrame";
+                    fullFrameBoxed: "fullFrameBoxed";
+                    faceCrop: "faceCrop";
+                    plateCrop: "plateCrop";
+                    keyFrameSmall: "keyFrameSmall";
+                    thumbnailSmall: "thumbnailSmall";
+                }>;
+                rows: z.ZodNumber;
+                bytes: z.ZodNumber;
+            }, z.core.$strip>>>;
+            unaccountedRows: z.ZodNumber;
+            unaccountedBytes: z.ZodNumber;
+        }, 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
@@ -3141,9 +3331,10 @@ export declare const pipelineAnalyticsCapability: {
                 keyFrameSmall: "keyFrameSmall";
                 thumbnailSmall: "thumbnailSmall";
             }>;
-            base64: z.ZodString;
             sizeBytes: z.ZodNumber;
             timestamp: z.ZodNumber;
+            url: z.ZodString;
+            base64: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /** All media rows owned by a track. `kinds` narrows to a kind subset so a
          *  client can fetch the SMALL display variants on open and pull the
@@ -3182,9 +3373,10 @@ export declare const pipelineAnalyticsCapability: {
                 keyFrameSmall: "keyFrameSmall";
                 thumbnailSmall: "thumbnailSmall";
             }>;
-            base64: z.ZodString;
             sizeBytes: z.ZodNumber;
             timestamp: z.ZodNumber;
+            url: z.ZodString;
+            base64: z.ZodString;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * What media a track HAS, without any of it.
@@ -3221,6 +3413,46 @@ export declare const pipelineAnalyticsCapability: {
                 keyFrameSmall: "keyFrameSmall";
                 thumbnailSmall: "thumbnailSmall";
             }>;
+            url: z.ZodString;
+            sizeBytes: z.ZodNumber;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * What media an EVENT has, without any of it — the twin `getEventMedia`
+         * never had.
+         *
+         * `listTrackMedia` above got this treatment because a track's media is
+         * 5-8 MB. An event's is worse per row, not better: an old-style event owns
+         * a `crop` AND a native-resolution `fullFrameBoxed`, and the track DETAIL
+         * modal — the one surface that legitimately shows the big kinds — unions
+         * both listings to build its filmstrip. It then renders every tile from
+         * the `event-media` plane by key and throws the bytes away. Measured on
+         * the live hub: one event's `fullFrameBoxed` is 2 824 077 B, base64'd to
+         * ~3.8 MB, allocated whole in hub-main's heap, for a list of keys.
+         *
+         * Same `deviceId` authorization subject as `getEventMedia`, and the same
+         * rows — this is a projection of that method, never a different question.
+         */
+        readonly listEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            eventId: z.ZodString;
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            timestamp: z.ZodNumber;
+            kind: z.ZodEnum<{
+                crop: "crop";
+                snapshot: "snapshot";
+                keyFrame: "keyFrame";
+                thumbnail: "thumbnail";
+                firstFrame: "firstFrame";
+                lastFrame: "lastFrame";
+                fullFrame: "fullFrame";
+                fullFrameBoxed: "fullFrameBoxed";
+                faceCrop: "faceCrop";
+                plateCrop: "plateCrop";
+                keyFrameSmall: "keyFrameSmall";
+                thumbnailSmall: "thumbnailSmall";
+            }>;
+            url: z.ZodString;
             sizeBytes: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
@@ -3397,6 +3629,6 @@ export declare const pipelineAnalyticsCapability: {
     };
 };
 export type IPipelineAnalyticsProvider = InferProvider<typeof pipelineAnalyticsCapability>;
-export { AudioEventSchema, EventKindDescriptorSchema, EventKindSchema, EventKindsForDeviceSchema, KeyEventSchema, MediaFileInfoSchema, MediaFileKindEnum, MediaFileSchema, MotionEventSchema, ObjectEventSchema, RecentTracksPageSchema, RecentTracksQueryInput, SensorEventSchema, TrackAudioLabelSchema, TrackCascadeCountsSchema, TrackEnvelopeSchema, 
+export { AudioEventSchema, EventKindDescriptorSchema, EventKindSchema, EventKindsForDeviceSchema, KeyEventSchema, MediaFileInfoSchema, MediaFileKindEnum, MediaFileRefSchema, MediaFileSchema, MotionEventSchema, ObjectEventSchema, RecentTracksPageSchema, RecentTracksQueryInput, SensorEventSchema, TrackAudioLabelSchema, TrackCascadeCountsSchema, TrackEnvelopeSchema, 
 /** No longer carried on onFrameTracked (two-plane re-injection) — kept for compat. */
 TrackedDetectionSchema, TrackProjectionSchema, TrackSchema, TrackStateSchema, TrackZoneFilterSchema, };

package/dist/capabilities/plate-gallery.cap.d.ts

@@ -106,7 +106,7 @@ export declare const plateGalleryCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             key: z.ZodString;
             kind: z.ZodString;
-            base64: z.ZodString;
+            url: z.ZodString;
             sizeBytes: z.ZodNumber;
             timestamp: z.ZodNumber;
         }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;

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/generated/addon-api.d.ts

@@ -5058,6 +5058,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;
@@ -5275,6 +5282,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof pipelineAnalyticsCapability.methods.listTrackMedia.output>;
             meta: object;
         }>;
+        listEventMedia: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof pipelineAnalyticsCapability.methods.listEventMedia.input>;
+            output: z.infer<typeof pipelineAnalyticsCapability.methods.listEventMedia.output>;
+            meta: object;
+        }>;
         searchObjectEvents: TRPCQueryProcedure<{
             input: {
                 [x: 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: 986 method paths across 126 capabilities.
+ * Coverage: 988 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,7 +6,7 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 345 methods carry a device reference, of which
+ * Coverage: 347 methods carry a device reference, of which
  * 129 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying