@camstack/types 1.2.246 → 1.2.248

package/dist/capabilities/reserved-collection-sources.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Source ids of a device COLLECTION that exactly one addon may mint (D625).
+ *
+ * A collection cap's picker treats its rows as peers, and that is right almost
+ * everywhere. It is wrong for exactly one thing: a DEFAULT that must be
+ * impossible to express otherwise.
+ *
+ * `recording`'s default is ours, always (the operator's ruling, 2026-09-24).
+ * The way that is made structural rather than a sort order is a RESERVED id:
+ * the absence of an operator choice MEANS `camstack`, so a surface never needs
+ * a "first row" fallback and there is nowhere to put one. `clip-sources.ts`
+ * ends with `?? sources[0]`, and `videoclips.listSources` on 592 answers the
+ * ONBOARD row first — for clips that fallback was argued for, for a timeline it
+ * would silently swap an 85 362 s bar for a 21 388 s one.
+ *
+ * A reserved id is only worth anything if nothing else can spell it, so it is
+ * enforced twice and neither is a paragraph:
+ *
+ *  1. `device-collection-dispatch.ts` DROPS a `listSources` row carrying a
+ *     reserved id from any addon but its owner, naming the impostor in a log
+ *     line with `tags: { deviceId }`. It drops the row rather than throwing:
+ *     one lying provider must not empty a camera's picker.
+ *  2. `scripts/check-reserved-collection-sources.ts` fails CI on any package
+ *     but the owner's that spells the id at all. It reads THIS table, so a new
+ *     reservation is guarded the moment it is added here.
+ */
+/** One reservation: `sourceId` on `capName` may be served only by `addonId`. */
+export interface ReservedCollectionSource {
+    readonly capName: string;
+    readonly sourceId: string;
+    readonly addonId: string;
+}
+/**
+ * Every reserved (cap, source) pair in the system.
+ *
+ * KEEP THE LITERALS INLINE. The CI guard parses this array textually — it
+ * cannot execute TypeScript — so an entry built from an imported constant
+ * would be invisible to it, and a guard that reads the wrong surface is worse
+ * than none.
+ */
+export declare const RESERVED_COLLECTION_SOURCES: readonly ReservedCollectionSource[];
+/**
+ * The addon allowed to serve `sourceId` on `capName`, or `null` when the id is
+ * not reserved at all (which is the common case — most sources are peers).
+ */
+export declare function reservedSourceOwner(capName: string, sourceId: string): string | null;

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

@@ -393,27 +393,66 @@ export declare const ClipStreamDialSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type ClipStreamDial = z.infer<typeof ClipStreamDialSchema>;
 /**
- * The playback rates a clip can be DELIVERED at, ascending, always with `1`.
+ * The playback rates the broker can pace over media it HOLDS, ascending,
+ * always with `1` — and the WIDEST ladder there is. It is the domain the
+ * broker's `clampPlaybackRate` is derived from, at both ends.
  *
  * These are the BROKER's: it re-paces frames it has already demuxed — the
  * `MonotonicClock` divides source elapsed time by the factor and the pacer
- * pushes that much faster — so the domain is the recorded one, {0} ∪ [0.25, 4],
- * and this is the discrete ladder drawn from it. `1.5` is in it because a
- * re-pacer has no reason to refuse it.
- *
- * `8` and `16` are deliberately NOT here. They are the CAMERA's own
- * `<playSpeed>` (Reolink cmd-5 replay), a different mechanism, still unwired
- * (D597, D600) — a rate change there costs a new dial and a new stream, and
- * the camera's 8x would need a resample the clip audio path has no decoder
- * for. Offering them today accepts a rate and delivers 1x, which is the whole
- * defect this list exists to end (D612). When `playSpeed` IS wired its rates
- * join THIS array — a second list elsewhere is the second authority D62
- * forbids.
- *
- * Every entry must survive the broker's `clampPlaybackRate` unchanged: a set
- * that offers what the clamp then moves is the same lie one step later.
+ * pushes that much faster. `1.5` is in it because a re-pacer has no reason to
+ * refuse it.
+ *
+ * **`8` is here since D621, and it is the pacer's, not a camera's.** D620
+ * measured the thing that was assumed for a year and was never true: a
+ * Reolink `<playSpeed>` does not time-compress anything. At 1, 2, 4 and 8 the
+ * transfer is byte-identical — same 947 472 bytes, same 594 access units,
+ * same 39.855 s presentation span, same 624 AAC frames — and only the wall
+ * clock moves. It buys SUPPLY, never speed. So there was never a second
+ * mechanism to wire for 8×: there is one, this one, and what it needs is
+ * media in hand and a clamp that does not move the number.
+ *
+ * **`16` is deliberately NOT here, and will not join by widening this array.**
+ * The camera's `playSpeed 16` is not a rate at all but an I-frame-only MODE —
+ * measured on 592: 10 access units for a whole 36.3 s sub clip, 20 for the
+ * main twin at a 2 025 ms median spacing, and no audio track. That is
+ * different CONTENT, a stream of its own, and the honest broker-side twin of
+ * it would be a pacer that DROPS whole GOPs rather than one that pushes 16×
+ * the bitrate at a live WebRTC track. Neither exists. A `16` in this array
+ * today would be a rate accepted and delivered at 8 — D612's defect, which
+ * this list exists to end, one number further along.
+ *
+ * Every entry must survive the broker's `clampPlaybackRate` unchanged. Since
+ * D621 that is structural rather than a discipline: the clamp reads this
+ * array's own ends. What still has to be proved behaviourally — and is, in
+ * the broker's `clip-stream-feeder.spec` — is that the PACER really empties a
+ * clip `rate` times faster, because a clamp agreeing with a ladder is a
+ * constant compared against itself.
+ *
+ * Narrower ladders exist for transports whose SUPPLY is bounded; they are
+ * subsets of this one ({@link CLIP_STREAM_SOURCE_RATES},
+ * {@link CLIP_REALTIME_SOURCE_RATES}).
  */
 export declare const CLIP_BROKER_PACED_RATES: readonly number[];
+/**
+ * The rates a provider-STREAMED clip can be delivered at — a subset of
+ * {@link CLIP_BROKER_PACED_RATES}, and frozen below it on purpose (D621).
+ *
+ * A `stream` clip's media does not exist yet: it arrives on a socket from the
+ * camera while the pacer consumes it. The pacer takes `rate` seconds of media
+ * per second of wall clock, so the ceiling is whatever the SOURCE supplies,
+ * and that is a measurement per vendor rather than a preference.
+ *
+ * Reolink, the one provider on this envelope, was measured on 592
+ * (2026-09-23, D620): with the `<ReplaySeek>` that 0.11.1 sends before every
+ * replay, a sub clip arrives at **1.2×** and a main twin at **1.37×**. The
+ * ladder below is therefore ALREADY beyond this transport above 1 — the D612
+ * defect returned through a door nobody opened — and D620 fixed the repair
+ * order: the supply first, the ladder after. So this array does not move with
+ * the broker's, and it does not gain `8`; what it gains, when the library
+ * forwards a `<playSpeed>` large enough to feed the rate being paced over it,
+ * is the right to be widened on a measurement rather than shortened on one.
+ */
+export declare const CLIP_STREAM_SOURCE_RATES: readonly number[];
 /**
  * The rates a REALTIME-BOUND stream can be delivered at.
  *

package/dist/device/linked-device-resolve.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Which devices a camera's LINKED set resolves to — the pure rules, with no
+ * store and no provider context.
+ *
+ * They live in `@camstack/types` rather than in the device-manager builtin
+ * because two surfaces need the SAME answer and a second copy would be a
+ * second definition of what a room contains: the hub's boot backfill, and the
+ * admin UI's per-room rebuild. Moving them here also keeps that button a
+ * framework-free change — a new cap method would only reach a node through a
+ * published `@camstack/server` and a restart (D16), which is not what a
+ * convenience button is worth.
+ */
+import { DeviceType } from './device-type.js';
+/** The device fields the pure resolver consumes (subset of `DeviceInfo`). */
+export interface LinkCandidate {
+    readonly id: number;
+    readonly parentDeviceId: number | null;
+    readonly location: string | null;
+    readonly type: DeviceType;
+    /**
+     * The child identity a container's stored pick is matched against. A NOT
+     * NULL column, so `slim` carries it — which is the whole reason the pick is
+     * keyed on it (see `ContainerChildRef.stableId`).
+     */
+    readonly stableId: string;
+    /** The container's own operator pick, when one was made. */
+    readonly primaryChildEntityId?: string | null;
+    /**
+     * The child's `DeviceRole`. Ranked ABOVE `type` when a container picks the
+     * child it stands for, because `DeviceType` cannot tell a door contact from a
+     * battery reading — Home Assistant maps both to `Sensor`. A first-class meta
+     * column, so `slim` carries it.
+     */
+    readonly role?: string | null | undefined;
+    /** Operator-facing name — used for the namesake tiebreak. Also a column. */
+    readonly name?: string;
+}
+/**
+ * Resolve one candidate id to the ids it should actually contribute to a
+ * linked set: itself, unless it is a CONTAINER, in which case its own
+ * children (recursively expanded the same way — a container-of-containers
+ * is vanishingly unlikely per `DeviceType.Container`'s contract, but this
+ * costs nothing to handle). `visited` guards a pathological parent-cycle in
+ * persisted data from recursing forever; a candidate already on the current
+ * expansion path is dropped rather than re-expanded.
+ *
+ * This is the STRUCTURAL, location-independent way a container's child
+ * becomes reachable: the device-tree "children of the camera" rule and a
+ * persisted manual pick are parentDeviceId chains, never location-based —
+ * a container named there is excluded by expanding into whatever it
+ * actually contains, regardless of what its (or its children's) `location`
+ * column holds.
+ */
+export declare function expandContainer(id: number, byId: ReadonlyMap<number, LinkCandidate>, byParent: ReadonlyMap<number, readonly LinkCandidate[]>, visited: ReadonlySet<number>, out: Set<number>): void;
+/**
+ * What the retired `auto` mode (pre-D356) added beyond the device-tree
+ * children: every non-container candidate sharing the camera's location, a
+ * container child standing in for its container's PRIMARY child.
+ *
+ * Two callers, both WRITERS, never the read path: the one-shot boot backfill
+ * that materialises it into the manual list
+ * (`linked-devices-manual-backfill.ts`), and the admin UI's per-room rebuild.
+ * Both ask "what does this room contain", and a second copy of the answer is
+ * how two surfaces start disagreeing about a room.
+ *
+ * A camera with NO location answers `[]`. A caller that would WRITE that must
+ * refuse instead: emptying a list because nobody set the room is the silent
+ * drop D391 names.
+ */
+export declare function legacyAutoLinkIds(params: {
+    readonly selfId: number;
+    readonly selfLocation: string | null;
+    readonly candidates: readonly LinkCandidate[];
+}): readonly number[];

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

@@ -45,7 +45,6 @@ import type { deviceOpsCapability } from '../capabilities/device-ops.cap.js';
 import type { deviceProviderCapability } from '../capabilities/device-provider.cap.js';
 import type { deviceStateCapability } from '../capabilities/device-state.cap.js';
 import type { embeddingEncoderCapability } from '../capabilities/embedding-encoder.cap.js';
-import type { eventsCapability } from '../capabilities/events.cap.js';
 import type { faceGalleryCapability } from '../capabilities/face-gallery.cap.js';
 import type { failureContributionCapability } from '../capabilities/failure-contribution.cap.js';
 import type { fanControlCapability } from '../capabilities/fan-control.cap.js';
@@ -94,6 +93,7 @@ import type { privacyMaskCapability } from '../capabilities/privacy-mask.cap.js'
 import type { ptzAutotrackCapability } from '../capabilities/ptz-autotrack.cap.js';
 import type { ptzCapability } from '../capabilities/ptz.cap.js';
 import type { rebootCapability } from '../capabilities/reboot.cap.js';
+import type { recordingArchiveCapability } from '../capabilities/recording-archive.cap.js';
 import type { recordingExportCapability } from '../capabilities/recording-export.cap.js';
 import type { recordingOnboardCapability } from '../capabilities/recording-onboard.cap.js';
 import type { recordingSignalCapability } from '../capabilities/recording-signal.cap.js';
@@ -3054,34 +3054,6 @@ export type AppRouter = TrpcCoreRouter<{
             meta: object;
         }>;
     }>>;
-    events: TRPCBuiltRouter<{
-        ctx: TrpcContext;
-        meta: object;
-        errorShape: AugmentedErrorShape;
-        transformer: true;
-    }, TRPCDecorateCreateRouterOptions<{
-        getEvents: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof eventsCapability.methods.getEvents.input>;
-            output: z.infer<typeof eventsCapability.methods.getEvents.output>;
-            meta: object;
-        }>;
-        getEventThumbnail: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof eventsCapability.methods.getEventThumbnail.input>;
-            output: z.infer<typeof eventsCapability.methods.getEventThumbnail.output>;
-            meta: object;
-        }>;
-        getEventClipUrl: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof eventsCapability.methods.getEventClipUrl.input>;
-            output: z.infer<typeof eventsCapability.methods.getEventClipUrl.output>;
-            meta: object;
-        }>;
-    }>>;
     faceGallery: TRPCBuiltRouter<{
         ctx: TrpcContext;
         meta: object;
@@ -6836,6 +6808,48 @@ export type AppRouter = TrpcCoreRouter<{
         meta: object;
         errorShape: AugmentedErrorShape;
         transformer: true;
+    }, TRPCDecorateCreateRouterOptions<{
+        listSources: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.listSources.input>;
+            output: z.infer<typeof recordingCapability.methods.listSources.output>;
+            meta: object;
+        }>;
+        getAvailability: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.getAvailability.input>;
+            output: z.infer<typeof recordingCapability.methods.getAvailability.output>;
+            meta: object;
+        }>;
+        getDaysWithRecordings: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.getDaysWithRecordings.input>;
+            output: z.infer<typeof recordingCapability.methods.getDaysWithRecordings.output>;
+            meta: object;
+        }>;
+        getPlayback: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.getPlayback.input>;
+            output: z.infer<typeof recordingCapability.methods.getPlayback.output>;
+            meta: object;
+        }>;
+        getPlaybackOptions: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof recordingCapability.methods.getPlaybackOptions.input>;
+            output: z.infer<typeof recordingCapability.methods.getPlaybackOptions.output>;
+            meta: object;
+        }>;
+    }>>;
+    recordingArchive: TRPCBuiltRouter<{
+        ctx: TrpcContext;
+        meta: object;
+        errorShape: AugmentedErrorShape;
+        transformer: true;
     }, TRPCDecorateCreateRouterOptions<{
         getStatus: TRPCQueryProcedure<{
             input: {
@@ -6865,235 +6879,214 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof DEVICE_SETTINGS_CONTRIBUTION_METHODS.applyDeviceSettingsPatch.output>;
             meta: object;
         }>;
-        getAvailability: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getAvailability.input>;
-            output: z.infer<typeof recordingCapability.methods.getAvailability.output>;
-            meta: object;
-        }>;
         getAvailabilityBatch: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getAvailabilityBatch.input>;
-            output: z.infer<typeof recordingCapability.methods.getAvailabilityBatch.output>;
-            meta: object;
-        }>;
-        getDaysWithRecordings: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getDaysWithRecordings.input>;
-            output: z.infer<typeof recordingCapability.methods.getDaysWithRecordings.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getAvailabilityBatch.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getAvailabilityBatch.output>;
             meta: object;
         }>;
         getDaysWithRecordingsBatch: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getDaysWithRecordingsBatch.input>;
-            output: z.infer<typeof recordingCapability.methods.getDaysWithRecordingsBatch.output>;
-            meta: object;
-        }>;
-        getPlaybackManifest: TRPCQueryProcedure<{
-            input: {
-                [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getPlaybackManifest.input>;
-            output: z.infer<typeof recordingCapability.methods.getPlaybackManifest.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getDaysWithRecordingsBatch.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getDaysWithRecordingsBatch.output>;
             meta: object;
         }>;
         getStorageUsage: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getStorageUsage.input>;
-            output: z.infer<typeof recordingCapability.methods.getStorageUsage.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getStorageUsage.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getStorageUsage.output>;
             meta: object;
         }>;
         getDeviceConfig: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getDeviceConfig.input>;
-            output: z.infer<typeof recordingCapability.methods.getDeviceConfig.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getDeviceConfig.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getDeviceConfig.output>;
             meta: object;
         }>;
         locateSegment: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.locateSegment.input>;
-            output: z.infer<typeof recordingCapability.methods.locateSegment.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.locateSegment.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.locateSegment.output>;
             meta: object;
         }>;
         readSegmentBytes: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.readSegmentBytes.input>;
-            output: z.infer<typeof recordingCapability.methods.readSegmentBytes.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.readSegmentBytes.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.readSegmentBytes.output>;
             meta: object;
         }>;
         readGopBytes: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.readGopBytes.input>;
-            output: z.infer<typeof recordingCapability.methods.readGopBytes.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.readGopBytes.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.readGopBytes.output>;
             meta: object;
         }>;
         readWindowBytes: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.readWindowBytes.input>;
-            output: z.infer<typeof recordingCapability.methods.readWindowBytes.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.readWindowBytes.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.readWindowBytes.output>;
             meta: object;
         }>;
         setDeviceConfig: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.setDeviceConfig.input>;
-            output: z.infer<typeof recordingCapability.methods.setDeviceConfig.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.setDeviceConfig.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.setDeviceConfig.output>;
             meta: object;
         }>;
         rescanStorage: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.rescanStorage.input>;
-            output: z.infer<typeof recordingCapability.methods.rescanStorage.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.rescanStorage.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.rescanStorage.output>;
             meta: object;
         }>;
         pruneFootage: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.pruneFootage.input>;
-            output: z.infer<typeof recordingCapability.methods.pruneFootage.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.pruneFootage.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.pruneFootage.output>;
             meta: object;
         }>;
         deleteFootprint: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.deleteFootprint.input>;
-            output: z.infer<typeof recordingCapability.methods.deleteFootprint.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.deleteFootprint.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.deleteFootprint.output>;
             meta: object;
         }>;
         listOpsLog: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.listOpsLog.input>;
-            output: z.infer<typeof recordingCapability.methods.listOpsLog.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.listOpsLog.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.listOpsLog.output>;
             meta: object;
         }>;
         renderGif: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.renderGif.input>;
-            output: z.infer<typeof recordingCapability.methods.renderGif.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.renderGif.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.renderGif.output>;
             meta: object;
         }>;
         renderClip: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.renderClip.input>;
-            output: z.infer<typeof recordingCapability.methods.renderClip.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.renderClip.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.renderClip.output>;
             meta: object;
         }>;
         pauseForStorageMigration: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.pauseForStorageMigration.input>;
-            output: z.infer<typeof recordingCapability.methods.pauseForStorageMigration.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.pauseForStorageMigration.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.pauseForStorageMigration.output>;
             meta: object;
         }>;
         resumeForStorageMigration: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.resumeForStorageMigration.input>;
-            output: z.infer<typeof recordingCapability.methods.resumeForStorageMigration.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.resumeForStorageMigration.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.resumeForStorageMigration.output>;
             meta: object;
         }>;
         refreshStorageLocationsForMigration: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.refreshStorageLocationsForMigration.input>;
-            output: z.infer<typeof recordingCapability.methods.refreshStorageLocationsForMigration.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.refreshStorageLocationsForMigration.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.refreshStorageLocationsForMigration.output>;
             meta: object;
         }>;
         startStorageMigrationMove: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.startStorageMigrationMove.input>;
-            output: z.infer<typeof recordingCapability.methods.startStorageMigrationMove.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.startStorageMigrationMove.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.startStorageMigrationMove.output>;
             meta: object;
         }>;
         getStorageMigrationMoveStatus: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getStorageMigrationMoveStatus.input>;
-            output: z.infer<typeof recordingCapability.methods.getStorageMigrationMoveStatus.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getStorageMigrationMoveStatus.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getStorageMigrationMoveStatus.output>;
             meta: object;
         }>;
         cancelStorageMigrationMove: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.cancelStorageMigrationMove.input>;
-            output: z.infer<typeof recordingCapability.methods.cancelStorageMigrationMove.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.cancelStorageMigrationMove.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.cancelStorageMigrationMove.output>;
             meta: object;
         }>;
         relocateFootage: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.relocateFootage.input>;
-            output: z.infer<typeof recordingCapability.methods.relocateFootage.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.relocateFootage.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.relocateFootage.output>;
             meta: object;
         }>;
         listRelocateJobs: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.listRelocateJobs.input>;
-            output: z.infer<typeof recordingCapability.methods.listRelocateJobs.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.listRelocateJobs.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.listRelocateJobs.output>;
             meta: object;
         }>;
         getRelocateResidue: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getRelocateResidue.input>;
-            output: z.infer<typeof recordingCapability.methods.getRelocateResidue.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getRelocateResidue.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getRelocateResidue.output>;
             meta: object;
         }>;
         reconcileLedgerAgainstDisk: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.reconcileLedgerAgainstDisk.input>;
-            output: z.infer<typeof recordingCapability.methods.reconcileLedgerAgainstDisk.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.reconcileLedgerAgainstDisk.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.reconcileLedgerAgainstDisk.output>;
             meta: object;
         }>;
         cancelRelocateJob: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.cancelRelocateJob.input>;
-            output: z.infer<typeof recordingCapability.methods.cancelRelocateJob.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.cancelRelocateJob.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.cancelRelocateJob.output>;
             meta: object;
         }>;
         planStorageRebalance: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.planStorageRebalance.input>;
-            output: z.infer<typeof recordingCapability.methods.planStorageRebalance.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.planStorageRebalance.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.planStorageRebalance.output>;
             meta: object;
         }>;
         startStorageRebalance: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.startStorageRebalance.input>;
-            output: z.infer<typeof recordingCapability.methods.startStorageRebalance.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.startStorageRebalance.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.startStorageRebalance.output>;
             meta: object;
         }>;
         getPlacement: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.getPlacement.input>;
-            output: z.infer<typeof recordingCapability.methods.getPlacement.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.getPlacement.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.getPlacement.output>;
             meta: object;
         }>;
         setDevicePlacement: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
-            } & z.input<typeof recordingCapability.methods.setDevicePlacement.input>;
-            output: z.infer<typeof recordingCapability.methods.setDevicePlacement.output>;
+            } & z.input<typeof recordingArchiveCapability.methods.setDevicePlacement.input>;
+            output: z.infer<typeof recordingArchiveCapability.methods.setDevicePlacement.output>;
             meta: object;
         }>;
     }>>;

package/dist/generated/cap-status-types.d.ts

@@ -54,7 +54,7 @@ import type { PressureSensorStatusSchema } from '../capabilities/pressure-sensor
 import type { PrivacyMaskStatusSchema } from '../capabilities/privacy-mask.cap.js';
 import type { PtzStatusSchema } from '../capabilities/ptz.cap.js';
 import type { PtzAutotrackStatusSchema } from '../capabilities/ptz-autotrack.cap.js';
-import type { RecordingStatusSchema } from '../capabilities/recording.cap.js';
+import type { recordingArchiveCapability } from '../capabilities/recording-archive.cap.js';
 import type { RecordingOnboardStatusSchema } from '../capabilities/recording-onboard.cap.js';
 import type { RecordingSignalStatusSchema } from '../capabilities/recording-signal.cap.js';
 import type { SceneMonitorStatusSchema } from '../capabilities/scene-monitor.cap.js';
@@ -132,7 +132,7 @@ export type CapStatusTypeMap = {
     readonly 'privacy-mask': z.infer<typeof PrivacyMaskStatusSchema>;
     readonly 'ptz': z.infer<typeof PtzStatusSchema>;
     readonly 'ptz-autotrack': z.infer<typeof PtzAutotrackStatusSchema>;
-    readonly 'recording': z.infer<typeof RecordingStatusSchema>;
+    readonly 'recording-archive': z.infer<(typeof recordingArchiveCapability)['status']['schema']>;
     readonly 'recording-onboard': z.infer<typeof RecordingOnboardStatusSchema>;
     readonly 'recording-signal': z.infer<typeof RecordingSignalStatusSchema>;
     readonly 'scene-monitor': z.infer<typeof SceneMonitorStatusSchema>;
@@ -157,4 +157,4 @@ export type CapNameWithStatus = keyof CapStatusTypeMap;
  * aggregator to enumerate caps whose `status` should be polled +
  * streamed via `subscribeDeviceStatusAggregate`.
  */
-export declare const CAP_NAMES_WITH_STATUS: readonly ["accessories", "air-quality-sensor", "alarm-panel", "ambient-light-sensor", "automation-control", "battery", "binary", "brightness", "broker", "camera-credentials", "carbon-monoxide", "climate-control", "color", "connectivity", "consumables", "contact", "control", "cover", "day-night", "device-adoption", "device-discovery", "device-export", "device-status", "doorbell", "enum-sensor", "event-emitter", "fan-control", "feature-probe", "flood", "gas", "humidifier", "humidity-sensor", "image", "image-settings", "intercom", "lawn-mower-control", "lock-control", "media-player", "motion", "motion-trigger", "motion-zones", "mqtt-broker", "native-object-detection", "navigation", "network-link", "notifier", "numeric-sensor", "osd", "pet-feeder", "power-meter", "presence", "pressure-sensor", "privacy-mask", "ptz", "ptz-autotrack", "recording", "recording-onboard", "recording-signal", "scene-monitor", "script-runner", "smoke", "snapshot", "stream-params", "switch", "tamper", "temperature-sensor", "update", "vacuum-control", "valve", "vibration", "water-heater", "weather"];
+export declare const CAP_NAMES_WITH_STATUS: readonly ["accessories", "air-quality-sensor", "alarm-panel", "ambient-light-sensor", "automation-control", "battery", "binary", "brightness", "broker", "camera-credentials", "carbon-monoxide", "climate-control", "color", "connectivity", "consumables", "contact", "control", "cover", "day-night", "device-adoption", "device-discovery", "device-export", "device-status", "doorbell", "enum-sensor", "event-emitter", "fan-control", "feature-probe", "flood", "gas", "humidifier", "humidity-sensor", "image", "image-settings", "intercom", "lawn-mower-control", "lock-control", "media-player", "motion", "motion-trigger", "motion-zones", "mqtt-broker", "native-object-detection", "navigation", "network-link", "notifier", "numeric-sensor", "osd", "pet-feeder", "power-meter", "presence", "pressure-sensor", "privacy-mask", "ptz", "ptz-autotrack", "recording-archive", "recording-onboard", "recording-signal", "scene-monitor", "script-runner", "smoke", "snapshot", "stream-params", "switch", "tamper", "temperature-sensor", "update", "vacuum-control", "valve", "vibration", "water-heater", "weather"];