@camstack/types 1.2.140 → 1.2.142

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-BwGJ_wL_.js");
+const require_sleep = require("./sleep-BDmIj1HV.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-C1mz-ocE.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-Cwo3fRlv.mjs";
 import { t as errMsg } from "./err-msg-IQTHeDzc.mjs";
 //#region src/generated/cap-input-defaults.ts
 /**

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

@@ -111,6 +111,82 @@ declare const LocationStatSchema: z.ZodObject<{
     fileCount: z.ZodNumber;
     present: z.ZodBoolean;
 }, z.core.$strip>;
+/** Lifecycle of a backup run. Terminal states: succeeded / failed / cancelled. */
+declare const BackupRunStateSchema: z.ZodEnum<{
+    failed: "failed";
+    running: "running";
+    queued: "queued";
+    cancelled: "cancelled";
+    succeeded: "succeeded";
+}>;
+/**
+ * Where a running backup currently is. `queued` before it starts,
+ * `building` while the tar.gz is being staged, `uploading` during the
+ * per-destination fan-out, `done` once terminal.
+ */
+declare const BackupRunPhaseSchema: z.ZodEnum<{
+    queued: "queued";
+    done: "done";
+    building: "building";
+    uploading: "uploading";
+}>;
+/**
+ * Observable state of one backup run — readable WHILE it runs via
+ * `backup.listRuns`. This is what makes the execution queue and
+ * `backup.cancel` usable: the 2026-09-04 incident (two concurrent
+ * multi-GB builds, staging 5.1 GB → 18 GB, load 62) was only
+ * diagnosable with `du` because nothing reported that runs existed or
+ * how large the staged archive had grown.
+ */
+declare const BackupRunSchema: z.ZodObject<{
+    id: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        queued: "queued";
+        cancelled: "cancelled";
+        succeeded: "succeeded";
+    }>;
+    phase: z.ZodEnum<{
+        queued: "queued";
+        done: "done";
+        building: "building";
+        uploading: "uploading";
+    }>;
+    destinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    label: z.ZodOptional<z.ZodString>;
+    requestedAt: z.ZodNumber;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    finishedAt: z.ZodOptional<z.ZodNumber>;
+    stagedBytes: z.ZodNumber;
+    archiveSizeBytes: z.ZodOptional<z.ZodNumber>;
+    uploadedBytes: z.ZodNumber;
+    completedDestinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    failedDestinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+    queuePosition: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Result of `backup.trigger`. The call still resolves when the run
+ * terminates (compat with schedule-driven runs and the admin UI), but
+ * it now names the run and says whether it had to WAIT: a trigger that
+ * arrives while another run is in flight is enqueued (or joined onto
+ * an identical already-queued run), never started concurrently.
+ */
+declare const BackupTriggerResultSchema: z.ZodObject<{
+    runId: z.ZodString;
+    queued: z.ZodBoolean;
+    joined: z.ZodBoolean;
+    cancelled: z.ZodBoolean;
+    entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        destinationId: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodNumber;
+        sizeBytes: z.ZodNumber;
+        locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 /**
  * A backup schedule — the N:M "entry" that binds one cron cadence to a
  * SET of destination locations. Supersedes the per-location cron on
@@ -176,20 +252,82 @@ export declare const backupCapability: {
          * Trigger a backup. Without `destinations` the orchestrator fans
          * out to every destination flagged as enabled in the routing
          * config; with it, only the listed addons receive the archive.
+         *
+         * At most ONE backup run executes at a time — the source tree and
+         * the staging disk are shared by every run, so a second trigger
+         * while one is in flight is enqueued (or joined onto an identical
+         * queued run) and the result says so. See D342.
          */
         readonly trigger: import("./capability-definition.js").CapabilityMethodSchema<z.ZodOptional<z.ZodObject<{
             destinations: z.ZodOptional<z.ZodArray<z.ZodString>>;
             locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
             retentionCount: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        }, z.core.$strip>>, z.ZodObject<{
+            runId: z.ZodString;
+            queued: z.ZodBoolean;
+            joined: z.ZodBoolean;
+            cancelled: z.ZodBoolean;
+            entries: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                destinationId: z.ZodOptional<z.ZodString>;
+                label: z.ZodOptional<z.ZodString>;
+                createdAt: z.ZodNumber;
+                sizeBytes: z.ZodNumber;
+                locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Every run the orchestrator knows about, in EXECUTION order: the
+         * running run first, then queued runs in the exact order they will
+         * execute (each with `queuePosition`, 1 = next), then the bounded
+         * finished history newest-first. Only one run executes at a time
+         * (D342) — the queued section IS the line. Each run carries live
+         * phase + byte counters so a runaway build is visible in seconds,
+         * not via `du`.
+         */
+        readonly listRuns: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
-            destinationId: z.ZodOptional<z.ZodString>;
+            state: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                queued: "queued";
+                cancelled: "cancelled";
+                succeeded: "succeeded";
+            }>;
+            phase: z.ZodEnum<{
+                queued: "queued";
+                done: "done";
+                building: "building";
+                uploading: "uploading";
+            }>;
+            destinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
             label: z.ZodOptional<z.ZodString>;
-            createdAt: z.ZodNumber;
-            sizeBytes: z.ZodNumber;
-            locations: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>>, "mutation">;
+            requestedAt: z.ZodNumber;
+            startedAt: z.ZodOptional<z.ZodNumber>;
+            finishedAt: z.ZodOptional<z.ZodNumber>;
+            stagedBytes: z.ZodNumber;
+            archiveSizeBytes: z.ZodOptional<z.ZodNumber>;
+            uploadedBytes: z.ZodNumber;
+            completedDestinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            failedDestinationIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            error: z.ZodOptional<z.ZodString>;
+            queuePosition: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Stop a backup run. Mirrors `storage-migration.cancel` semantics:
+         * id in, `{ cancelled }` out — `false` when the run is unknown or
+         * already terminal. A QUEUED run is removed before it ever starts;
+         * the RUNNING run has its tar/upload stream actually aborted, the
+         * half-written staging archive is deleted, and the in-flight
+         * destination upload is aborted server-side (partial discarded).
+         * Destinations that already completed keep their archive.
+         */
+        readonly cancel: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            runId: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            cancelled: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
         /** Union of every destination's archives, each tagged with `destinationId`. */
         readonly list: import("./capability-definition.js").CapabilityMethodSchema<z.ZodVoid, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
@@ -337,4 +475,8 @@ export declare const backupCapability: {
     };
 };
 export type IBackupProvider = InferProvider<typeof backupCapability>;
-export { ArchiveEntrySchema, ArchiveManifestSchema, BackupArchiveEntrySchema, BackupDestinationInfoSchema, BackupEntrySchema, BackupScheduleSchema, BackupSubDestinationInfoSchema, LocationStatSchema, };
+export { ArchiveEntrySchema, ArchiveManifestSchema, BackupArchiveEntrySchema, BackupDestinationInfoSchema, BackupEntrySchema, BackupRunPhaseSchema, BackupRunSchema, BackupRunStateSchema, BackupScheduleSchema, BackupSubDestinationInfoSchema, BackupTriggerResultSchema, LocationStatSchema, };
+export type BackupRunState = z.infer<typeof BackupRunStateSchema>;
+export type BackupRunPhase = z.infer<typeof BackupRunPhaseSchema>;
+export type BackupRun = z.infer<typeof BackupRunSchema>;
+export type BackupTriggerResult = z.infer<typeof BackupTriggerResultSchema>;

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

@@ -9,7 +9,7 @@ import { DeviceType } from '../device/device-type.js';
  * threshold.
  */
 export declare const BatteryStatusSchema: z.ZodObject<{
-    percentage: z.ZodNumber;
+    percentage: z.ZodNullable<z.ZodNumber>;
     charging: z.ZodEnum<{
         none: "none";
         dc: "dc";
@@ -63,7 +63,7 @@ export declare const batteryCapability: {
             readonly data: z.ZodObject<{
                 deviceId: z.ZodNumber;
                 status: z.ZodObject<{
-                    percentage: z.ZodNumber;
+                    percentage: z.ZodNullable<z.ZodNumber>;
                     charging: z.ZodEnum<{
                         none: "none";
                         dc: "dc";
@@ -79,7 +79,7 @@ export declare const batteryCapability: {
     };
     readonly status: {
         readonly schema: z.ZodObject<{
-            percentage: z.ZodNumber;
+            percentage: z.ZodNullable<z.ZodNumber>;
             charging: z.ZodEnum<{
                 none: "none";
                 dc: "dc";
@@ -108,7 +108,7 @@ export declare const batteryCapability: {
      * the underlying driver.
      */
     readonly runtimeState: z.ZodObject<{
-        percentage: z.ZodNumber;
+        percentage: z.ZodNullable<z.ZodNumber>;
         charging: z.ZodEnum<{
             none: "none";
             dc: "dc";

package/dist/capabilities/index.d.ts

@@ -31,7 +31,7 @@ export type { AudioAnalyzerGlobalConfig, AudioBackendChoice, IAudioAnalyzerProvi
 export { AUDIO_BACKEND_CHOICES, AudioAnalysisResultSchema, AudioAnalysisSettingsSchema, AudioClassificationResultSchema, audioAnalyzerCapability, DEFAULT_AUDIO_ANALYZER_CONFIG, } from './audio-analyzer.cap.js';
 export { AudioCodecInfoSchema, AudioDecodeSessionConfigSchema, AudioEncodedChunkSchema, AudioEncodeSessionConfigSchema, AudioPcmChunkSchema, audioCodecCapability, type IAudioCodecCapProvider, PcmSampleFormatSchema, } from './audio-codec.cap.js';
 export { AuthResultSchema, authProviderCapability } from './auth-provider.cap.js';
-export { ArchiveEntrySchema, ArchiveManifestSchema, BackupDestinationInfoSchema, BackupEntrySchema, backupCapability, type IBackupProvider, LocationStatSchema, } from './backup.cap.js';
+export { ArchiveEntrySchema, ArchiveManifestSchema, BackupDestinationInfoSchema, BackupEntrySchema, type BackupRun, type BackupRunPhase, BackupRunPhaseSchema, BackupRunSchema, type BackupRunState, BackupRunStateSchema, type BackupTriggerResult, BackupTriggerResultSchema, backupCapability, type IBackupProvider, LocationStatSchema, } from './backup.cap.js';
 export { BrokerAddInputSchema, BrokerGetStateInputSchema, type BrokerInfo as UnifiedBrokerInfo, BrokerInfoSchema as UnifiedBrokerInfoSchema, type BrokerProviderInfo, BrokerProviderInfoSchema, BrokerPublishInputSchema, BrokerRegistryStatusSchema, type BrokerStatus as UnifiedBrokerStatus, BrokerStatusEnum, BrokerSubscribeInputSchema, BrokerSubscribeResultSchema, BrokerTestConnectionResultSchema, BrokerUnsubscribeInputSchema, brokerCapability, type IBrokerProvider, } from './broker.cap.js';
 export { cameraPipelineConfigCapability, type ICameraPipelineConfigProvider, } from './camera-pipeline-config.cap.js';
 export { cameraStreamsCapability, type ICameraStreamsProvider, type PickedCamStream, PickedCamStreamSchema, PickStreamPreferencesSchema, PickStreamRequirementsSchema, type StreamCodec, StreamCodecSchema, } from './camera-streams.cap.js';

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

@@ -1106,6 +1106,7 @@ declare const RecentTracksQueryInput: z.ZodObject<{
         slim: "slim";
     }>>;
     includeStationary: z.ZodOptional<z.ZodBoolean>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type RecentTracksQuery = z.infer<typeof RecentTracksQueryInput>;
 declare const RecentTracksPageSchema: z.ZodObject<{
@@ -1907,6 +1908,7 @@ export declare const pipelineAnalyticsCapability: {
                 slim: "slim";
             }>>;
             includeStationary: z.ZodOptional<z.ZodBoolean>;
+            classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>, z.ZodObject<{
             tracks: z.ZodReadonly<z.ZodArray<z.ZodObject<{
                 retrainStatus: z.ZodOptional<z.ZodEnum<{

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

@@ -643,6 +643,37 @@ export declare const streamBrokerCapability: {
         }, z.core.$strip>, z.ZodObject<{
             success: z.ZodLiteral<true>;
         }, z.core.$strip>, "mutation">;
+        /**
+         * The HARDWARE behind a device number was replaced
+         * (`deviceManager.migrateDevice`). Forget every piece of broker state that
+         * described the old box, so the next catalog pull derives everything from
+         * the camera that is actually there:
+         *
+         *  - every `derived:*` stream definition — a derived is authored against a
+         *    specific profile layout, and against the wrong hardware its feeder
+         *    respawns forever (observed at attempt 2732 on the live hub,
+         *    2026-09-01);
+         *  - the profile-slot assignment entry, PURGED (not unassigned — unassign
+         *    marks the slot manual, which would pin the stale choice instead of
+         *    letting `computeInitialAssignment` re-derive it);
+         *  - the probe snapshots (`<deviceId>/…` — probed codec/resolution of the
+         *    old hardware);
+         *  - the persisted RTSP token rows for the device's brokers (keyed
+         *    `<deviceId>/<camStreamId>`; the stream ids change with the hardware,
+         *    so the rows are dead URLs).
+         *
+         * An RPC, deliberately — an event is telemetry and may be dropped (D8),
+         * and a dropped forget leaves a feeder respawning against a stream that
+         * does not exist.
+         */
+        readonly forgetDeviceHardware: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            derivedStreamsDeleted: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+            assignmentsPurged: z.ZodBoolean;
+            probeSnapshotsDropped: z.ZodNumber;
+            rtspTokenRowsDeleted: z.ZodNumber;
+        }, z.core.$strip>, "mutation">;
         /**
          * Render a short GIF or MP4 from the broker's PRE-BUFFER around an instant.
          *

package/dist/device/container-primary-child.d.ts

@@ -14,6 +14,15 @@
  * Each carried the same list and a comment asking the others to stay in sync.
  * This is that list, in the one package all of them already depend on.
  *
+ * `ui-library` and the server's linked-devices expansion IMPORT it. Two
+ * consumers cannot, and keep a checked copy instead: the viewer resolves
+ * `@camstack/types` from its own `node_modules` (an installed release, where a
+ * newly added export simply is not there), and the Home Assistant provider
+ * expresses the same precedence over the `DeviceType` enum because it answers
+ * a different question from the same ordering. `scripts/check-container-
+ * priority-in-sync.ts` fails the build when either drifts — the comment that
+ * used to ask for this could not.
+ *
  * The rule has two halves and the ORDER matters: an operator's explicit pick
  * wins outright, and only in its absence does type priority decide. The pick is
  * keyed on the child's re-sync-stable `entityId`, not its numeric id, so it
@@ -34,8 +43,28 @@ export declare const CONTAINER_CHILD_PRIORITY: readonly string[];
 /** The slice of a child this resolution needs. */
 export interface ContainerChildRef {
     readonly id: number;
-    /** Re-sync-stable identity (`sourceInfo.id`, falling back to `stableId`). */
-    readonly entityId: string;
+    /**
+     * The CANONICAL key an operator's pick is matched on.
+     *
+     * `stableId` and not `sourceInfo.id`, because `sourceInfo` is rebuilt from
+     * the device's config blob and the projection that linked-devices must use
+     * (`slim`) does not read it — measured on the live hub, 677 of 925 container
+     * children have a `sourceInfo.id` that differs from their `stableId`, so a
+     * resolver keyed on it would have missed the operator's pick for three
+     * children in four and fallen back to priority WHILE LOOKING LIKE IT WORKED.
+     *
+     * `stableId` costs nothing to have: it is a NOT NULL column, and
+     * `(addonId, stableId)` is the very index the row store re-identifies a
+     * device by across a re-sync — which is exactly the durability the pick
+     * needs.
+     */
+    readonly stableId: string;
+    /**
+     * The integration's own entity id, when the caller has it. Accepted ONLY so
+     * a pick stored under the previous key still resolves; new picks are written
+     * as `stableId`. Absent is normal.
+     */
+    readonly entityId?: string;
     readonly type: string;
 }
 /**

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

@@ -870,6 +870,20 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof backupCapability.methods.trigger.output>;
             meta: object;
         }>;
+        listRuns: TRPCQueryProcedure<{
+            input: {
+                nodeId?: string | undefined;
+            } | undefined;
+            output: z.infer<typeof backupCapability.methods.listRuns.output>;
+            meta: object;
+        }>;
+        cancel: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof backupCapability.methods.cancel.input>;
+            output: z.infer<typeof backupCapability.methods.cancel.output>;
+            meta: object;
+        }>;
         list: TRPCQueryProcedure<{
             input: {
                 nodeId?: string | undefined;
@@ -7568,6 +7582,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof streamBrokerCapability.methods.unassignProfile.output>;
             meta: object;
         }>;
+        forgetDeviceHardware: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof streamBrokerCapability.methods.forgetDeviceHardware.input>;
+            output: z.infer<typeof streamBrokerCapability.methods.forgetDeviceHardware.output>;
+            meta: object;
+        }>;
         renderPreBufferClip: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;

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

@@ -282,7 +282,7 @@ export interface DeviceProxy {
     readonly plateGallery: Pick<InferDeviceProxyCap<typeof plateGalleryCapability>, 'listPlates' | 'getPlateByTrack'>;
     readonly recording: Pick<InferDeviceProxyCap<typeof recordingCapability>, 'getAvailability' | 'getDaysWithRecordings' | 'getPlaybackManifest' | 'getDeviceConfig' | 'locateSegment' | 'readSegmentBytes' | 'readGopBytes' | 'readWindowBytes' | 'setDeviceConfig' | 'rescanStorage' | 'pruneFootage' | 'deleteFootprint' | 'renderGif' | 'renderClip' | 'getStatus' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
     readonly recordingExport: Pick<InferDeviceProxyCap<typeof recordingExportCapability>, 'listExports'>;
-    readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'renderPreBufferClip' | 'produceEventMedia' | 'restartProfile' | 'getDeviceAudioMute' | 'setDeviceAudioMute' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
+    readonly streamBroker: Pick<InferDeviceProxyCap<typeof streamBrokerCapability>, 'publishCameraStream' | 'retractCameraStream' | 'assignProfile' | 'unassignProfile' | 'forgetDeviceHardware' | 'renderPreBufferClip' | 'produceEventMedia' | 'restartProfile' | 'getDeviceAudioMute' | 'setDeviceAudioMute' | 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
 }
 /**
  * Build a DeviceProxy that pre-binds deviceId + nodeId on every method call

package/dist/generated/method-access-map.d.ts

@@ -6,7 +6,7 @@
  * scope+access check inside `protectedProcedure` (see
  * `server/backend/src/api/trpc/trpc.middleware.ts`).
  *
- * Coverage: 1002 method paths across 126 capabilities.
+ * Coverage: 1005 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,8 +6,8 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 354 methods carry a device reference, of which
- * 133 are on SYSTEM-scope caps.
+ * Coverage: 355 methods carry a device reference, of which
+ * 134 are on SYSTEM-scope caps.
  *
  * Top-level fields, number arrays, and one-level arrays of objects carrying
  * a numeric device field (targets[].deviceId) are all mapped; the matcher

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

@@ -61,7 +61,7 @@ export interface SystemProxy {
     readonly alerts: Pick<InferProvider<typeof alertsCapability>, 'emit' | 'update' | 'list' | 'getUnreadCount' | 'markRead' | 'markAllRead' | 'dismiss'>;
     readonly audioAnalyzer: Pick<InferProvider<typeof audioAnalyzerCapability>, 'analyseChunk' | 'classify' | 'isReady' | 'dispose' | 'reprobeAudioEngine'>;
     readonly audioCodec: Pick<InferProvider<typeof audioCodecCapability>, 'listSupportedCodecs' | 'canHandle' | 'createDecodeSession' | 'createEncodeSession' | 'closeSession' | 'pushEncodedFrame' | 'pullPcm' | 'pushPcm' | 'pullEncoded' | 'flushEncode' | 'listActiveSessions'>;
-    readonly backup: Pick<InferProvider<typeof backupCapability>, 'listDestinations' | 'trigger' | 'list' | 'listLocations' | 'getEntries' | 'restore' | 'delete' | 'listArchives' | 'upsertDestinationPolicy' | 'previewSchedule' | 'listSchedules' | 'upsertSchedule' | 'deleteSchedule'>;
+    readonly backup: Pick<InferProvider<typeof backupCapability>, 'listDestinations' | 'trigger' | 'listRuns' | 'cancel' | 'list' | 'listLocations' | 'getEntries' | 'restore' | 'delete' | 'listArchives' | 'upsertDestinationPolicy' | 'previewSchedule' | 'listSchedules' | 'upsertSchedule' | 'deleteSchedule'>;
     readonly broker: Pick<InferProvider<typeof brokerCapability>, 'list' | 'get' | 'listProviders' | 'add' | 'remove' | 'testConnection' | 'getSettings' | 'setSettings' | 'getBrokerConfig' | 'getSettingsSchema' | 'testSettings' | 'publish' | 'subscribe' | 'unsubscribe' | 'getState' | 'getStatus'>;
     readonly connectionTest: Pick<InferProvider<typeof connectionTestCapability>, 'testSettings' | 'describeTest'>;
     readonly coreBlocks: Pick<InferProvider<typeof coreBlocksCapability>, 'list' | 'get' | 'create' | 'update' | 'delete' | 'setEnabled' | 'restart' | 'compile' | 'getTypeDefs'>;