@camstack/types 1.2.126 → 1.2.128

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-C3AniWy-.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-ot6dTHCA.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

package/dist/capabilities/device-manager.cap.d.ts

@@ -982,6 +982,15 @@ export declare const deviceManagerCapability: {
          * calls are sync. Bindings change rarely (only on wrapper toggle or
          * device add/remove) — clients invalidate via the
          * `capability.binding-changed` event.
+         *
+         * "A single round-trip" describes the CLIENT's side and used not to
+         * describe the server's: until 2026-08-30 the resolver read the persisted
+         * wrapper activations once per device, so answering this cost one
+         * settings-door RPC per device — 1 020 on the live 1 019-device hub, and
+         * it did not return in 240 s against `SystemMirror.init`'s 15 s budget.
+         * The server side is now two reads for the whole fleet. Anything PERIODIC
+         * still belongs on `getBindings` / `getBindingsBatch` (D12); this remains
+         * a warm seed.
          */
         readonly getAllBindings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodArray<z.ZodObject<{
             deviceId: z.ZodNumber;

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 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, 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>;
@@ -2421,6 +2504,7 @@ export declare const pipelineAnalyticsCapability: {
             filesMoved: z.ZodNumber;
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
+            rowsReconciled: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -2458,12 +2542,30 @@ export declare const pipelineAnalyticsCapability: {
          * happens to stamp it. This count is what the migration planner's
          * non-blocking gate reads; `relocateMedia({ mode: 'seal' })` is what drives
          * it to zero.
+         *
+         * TWO indexed statements per collection, not a walk. It used to page the
+         * whole collection at 200 rows per RPC ordered by an unindexed column, so
+         * on the live hub — 1 254 576 rows — it hit the 60 s RPC deadline every
+         * time it was called, and the migration it gates could never start. The
+         * cheap question (`present`: is there at least one) is asked first and
+         * separately from the expensive one (`rows`), because only the first has
+         * to be answerable for the gate to do its job.
+         *
+         * **`null` is "not measurable", never zero** — at either level. An
+         * unreadable collection must not read as a sealed one.
          */
-        readonly countUnstampedEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
-            media: z.ZodNumber;
-            retrainFrames: z.ZodNumber;
-            total: z.ZodNumber;
-        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly countUnstampedEventMedia: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodNullable<z.ZodObject<{
+            media: z.ZodObject<{
+                present: z.ZodBoolean;
+                rows: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            retrainFrames: z.ZodObject<{
+                present: z.ZodBoolean;
+                rows: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>;
+            anyPresent: z.ZodBoolean;
+            total: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>, import("./capability-definition.js").CapabilityMethodKind>;
         /**
          * How many rows a pass would STILL act on against `toLocationId`.
          *
@@ -2503,6 +2605,7 @@ export declare const pipelineAnalyticsCapability: {
             filesMoved: z.ZodNumber;
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
+            rowsReconciled: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -3121,9 +3224,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
@@ -3162,9 +3266,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.
@@ -3201,6 +3306,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>;
         /**
@@ -3377,6 +3522,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/recording.cap.d.ts

@@ -665,6 +665,7 @@ export declare const recordingCapability: {
             filesMoved: z.ZodNumber;
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
+            rowsReconciled: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;
@@ -714,6 +715,7 @@ export declare const recordingCapability: {
             filesMoved: z.ZodNumber;
             bytesMoved: z.ZodNumber;
             filesTotal: z.ZodNullable<z.ZodNumber>;
+            rowsReconciled: z.ZodOptional<z.ZodNumber>;
             startedAt: z.ZodNumber;
             finishedAt: z.ZodNullable<z.ZodNumber>;
             error: z.ZodNullable<z.ZodString>;

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

@@ -133,6 +133,7 @@ export declare const storageMigrationCapability: {
                     filesMoved: z.ZodNumber;
                     filesTotal: z.ZodNullable<z.ZodNumber>;
                     bytesMoved: z.ZodNumber;
+                    rowsReconciled: z.ZodOptional<z.ZodNumber>;
                     startedAt: z.ZodNumber;
                     observedAt: z.ZodNumber;
                 }, z.core.$strip>>;
@@ -185,6 +186,7 @@ export declare const storageMigrationCapability: {
                 filesMoved: z.ZodNumber;
                 bytesMoved: z.ZodNumber;
                 filesTotal: z.ZodNullable<z.ZodNumber>;
+                rowsReconciled: z.ZodOptional<z.ZodNumber>;
                 startedAt: z.ZodNumber;
                 finishedAt: z.ZodNullable<z.ZodNumber>;
                 error: z.ZodNullable<z.ZodString>;

package/dist/device/system-mirror.d.ts

@@ -57,6 +57,13 @@ export interface SystemMirrorApi extends SliceHandleApi {
         /**
          * Whole-fleet binding dump. WARM BOOT ONLY — 903 ms and 373 KB on a
          * 524-device hub. Anything on the event path uses `getBindings`.
+         *
+         * `init` gives this 15 s, and on 2026-08-30 it took longer than 240 s on a
+         * 1 019-device hub: the server-side resolver read the wrapper-activation
+         * blob once PER DEVICE, so answering cost 1 020 settings-door RPCs. Fixed
+         * in `device-bindings-store.ts` (two reads for the whole fleet). Worth
+         * knowing here because the symptom is always this timeout, and the cause
+         * is never in this file.
          */
         readonly getAllBindings: {
             query(input: Record<string, never>): Promise<ReadonlyArray<DeviceBinding>>;

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

@@ -5275,6 +5275,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: 987 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: 346 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