@camstack/types 1.2.64 → 1.2.66

package/dist/capabilities/lock-control.cap.d.ts

@@ -87,5 +87,15 @@ export declare const lockControlCapability: {
         }>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — a lock left locked must still read locked.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type ILockControlProvider = InferProvider<typeof lockControlCapability>;

package/dist/capabilities/media-player.cap.d.ts

@@ -195,6 +195,13 @@ export declare const mediaPlayerCapability: {
         }>>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a restored transport position describes a playback that stopped when the hub did.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IMediaPlayerProvider = InferProvider<typeof mediaPlayerCapability>;
 export {};

package/dist/capabilities/motion-trigger.cap.d.ts

@@ -74,5 +74,12 @@ export declare const motionTriggerCapability: {
         lastChangedAt: z.ZodNumber;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — the authority for motion-trigger enablement is the provider's own config; the slice is a mirror of it, re-published on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IMotionTriggerProvider = InferProvider<typeof motionTriggerCapability>;

package/dist/capabilities/motion-zones.cap.d.ts

@@ -160,5 +160,15 @@ export declare const motionZonesCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — the 14 KB polygon list is the single largest slice on the fleet and has not changed since the operator drew it. Highest value per byte in the table.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IMotionZonesProvider = InferNativeProvider<typeof motionZonesCapability>;

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

@@ -129,5 +129,12 @@ export declare const motionCapability: {
         lastDetectedAt: z.ZodNullable<z.ZodNumber>;
         autoClearAfterMs: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — self-clearing by construction (`autoClearAfterMs`); a restored `detected: true` is a frozen event, and the next frame re-publishes the real one.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IMotionProvider = InferProvider<typeof motionCapability>;

package/dist/capabilities/native-object-detection.cap.d.ts

@@ -193,5 +193,15 @@ export declare const nativeObjectDetectionCapability: {
         enabled: z.ZodBoolean;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — `enabled` is an operator toggle on a camera whose refresh is a no-op and whose staleMs is Infinity. There is no hardware value to re-read — losing it loses the setting.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type INativeObjectDetectionProvider = InferProvider<typeof nativeObjectDetectionCapability>;

package/dist/capabilities/notification-output.cap.d.ts

@@ -120,6 +120,10 @@ export declare const NotificationActionSchema: z.ZodObject<{
         alert: "alert";
     }>>;
     destructive: z.ZodOptional<z.ZodBoolean>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        navigate: "navigate";
+        background: "background";
+    }>>;
 }, z.core.$strip>;
 export type NotificationAction = z.infer<typeof NotificationActionSchema>;
 /**
@@ -174,6 +178,10 @@ export declare const NotificationSchema: z.ZodObject<{
             alert: "alert";
         }>>;
         destructive: z.ZodOptional<z.ZodBoolean>;
+        mode: z.ZodOptional<z.ZodEnum<{
+            navigate: "navigate";
+            background: "background";
+        }>>;
     }, z.core.$strip>>>;
     sound: z.ZodOptional<z.ZodString>;
     ttl: z.ZodOptional<z.ZodNumber>;
@@ -499,6 +507,10 @@ export declare const notificationOutputCapability: {
                         alert: "alert";
                     }>>;
                     destructive: z.ZodOptional<z.ZodBoolean>;
+                    mode: z.ZodOptional<z.ZodEnum<{
+                        navigate: "navigate";
+                        background: "background";
+                    }>>;
                 }, z.core.$strip>>>;
                 sound: z.ZodOptional<z.ZodString>;
                 ttl: z.ZodOptional<z.ZodNumber>;
@@ -569,6 +581,10 @@ export declare const notificationOutputCapability: {
                         alert: "alert";
                     }>>;
                     destructive: z.ZodOptional<z.ZodBoolean>;
+                    mode: z.ZodOptional<z.ZodEnum<{
+                        navigate: "navigate";
+                        background: "background";
+                    }>>;
                 }, z.core.$strip>>>;
                 sound: z.ZodOptional<z.ZodString>;
                 ttl: z.ZodOptional<z.ZodNumber>;

package/dist/capabilities/notification-rules.cap.d.ts

@@ -137,6 +137,22 @@ export type NcSystemEventCondition = z.infer<typeof NcSystemEventConditionSchema
  * unique key `(ruleId, trackId, targetId)`. Not a rule field in P1.
  */
 export declare const NC_MAX_PER_TRACK_IMMEDIATE = 1;
+/** Hard ceiling on a window (24h). A snooze that could not expire would be an
+ *  outage the operator asked for once and forgot. */
+export declare const NC_SNOOZE_MAX_MINUTES = 1440;
+/**
+ * The durations a notification offers when its rule does not say otherwise.
+ *
+ * MINUTES, and short ones: a snooze button is answered on a lock screen, and
+ * the three choices that fit there are "the next few minutes", "the next half
+ * hour" and "the next hour". Anything longer is a decision somebody sits down
+ * to make, which is what the app's own snooze surface is for.
+ *
+ * Resolved in CODE (`snoozeChoices`), never as a Zod default — see
+ * {@link NcRuleInputSchema.shape.snoozeOptions} for why the distinction is
+ * load-bearing.
+ */
+export declare const NC_DEFAULT_SNOOZE_MINUTES: readonly number[];
 /** One weekly activation window. `startMinute > endMinute` crosses midnight. */
 export declare const NcScheduleWindowSchema: z.ZodObject<{
     days: z.ZodArray<z.ZodNumber>;
@@ -848,6 +864,7 @@ export declare const NcRuleInputSchema: z.ZodObject<{
     priority: z.ZodDefault<z.ZodNumber>;
     ownerUserId: z.ZodOptional<z.ZodString>;
     snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+    snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     actions: z.ZodOptional<z.ZodObject<{
         onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -947,6 +964,7 @@ export declare const NcRulePatchSchema: z.ZodObject<{
     }, z.core.$strip>>>;
     ownerUserId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
     snoozeAllowGlobal: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    snoozeOptions: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
     actions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
         onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -1307,6 +1325,7 @@ export declare const NcRuleSchema: z.ZodObject<{
     priority: z.ZodDefault<z.ZodNumber>;
     ownerUserId: z.ZodOptional<z.ZodString>;
     snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+    snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     actions: z.ZodOptional<z.ZodObject<{
         onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
@@ -1393,6 +1412,7 @@ export type NcTestResult = z.infer<typeof NcTestResultSchema>;
 export declare const NcConditionDescriptorSchema: z.ZodObject<{
     id: z.ZodString;
     group: z.ZodEnum<{
+        audio: "audio";
         system: "system";
         device: "device";
         label: "label";
@@ -1407,6 +1427,7 @@ export declare const NcConditionDescriptorSchema: z.ZodObject<{
     label: z.ZodString;
     valueType: z.ZodEnum<{
         number: "number";
+        audio: "audio";
         deviceState: "deviceState";
         schedule: "schedule";
         packagePhase: "packagePhase";
@@ -1622,9 +1643,6 @@ export declare const NcSnoozeScopeSchema: z.ZodEnum<{
     rule: "rule";
 }>;
 export type NcSnoozeScope = z.infer<typeof NcSnoozeScopeSchema>;
-/** Hard ceiling on a window (24h). A snooze that could not expire would be an
- *  outage the operator asked for once and forgot. */
-export declare const NC_SNOOZE_MAX_MINUTES = 1440;
 /**
  * Client-authored snooze. The server stamps `userId`, `startedAt` and
  * `expiresAt` — a DURATION is sent rather than an instant so a client with a
@@ -1638,6 +1656,7 @@ export declare const NcSnoozeInputSchema: z.ZodObject<{
     }>;
     ruleId: z.ZodOptional<z.ZodString>;
     deviceId: z.ZodOptional<z.ZodNumber>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     durationMinutes: z.ZodNumber;
     global: z.ZodOptional<z.ZodBoolean>;
     summary: z.ZodOptional<z.ZodBoolean>;
@@ -1654,6 +1673,7 @@ export declare const NcSnoozeSchema: z.ZodObject<{
     }>;
     ruleId: z.ZodOptional<z.ZodString>;
     deviceId: z.ZodOptional<z.ZodNumber>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     startedAt: z.ZodNumber;
     expiresAt: z.ZodNumber;
     global: z.ZodBoolean;
@@ -1951,6 +1971,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -2183,6 +2204,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -2413,6 +2435,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -2637,6 +2660,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -2736,6 +2760,7 @@ export declare const notificationRulesCapability: {
                 }, z.core.$strip>>>;
                 ownerUserId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                snoozeOptions: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodNumber>>>;
                 actions: z.ZodOptional<z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -3095,6 +3120,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -3373,6 +3399,7 @@ export declare const notificationRulesCapability: {
                 priority: z.ZodDefault<z.ZodNumber>;
                 ownerUserId: z.ZodOptional<z.ZodString>;
                 snoozeAllowGlobal: z.ZodOptional<z.ZodBoolean>;
+                snoozeOptions: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 actions: z.ZodOptional<z.ZodObject<{
                     onTrigger: z.ZodOptional<z.ZodArray<z.ZodObject<{
                         name: z.ZodString;
@@ -3466,6 +3493,7 @@ export declare const notificationRulesCapability: {
             catalog: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 group: z.ZodEnum<{
+                    audio: "audio";
                     system: "system";
                     device: "device";
                     label: "label";
@@ -3480,6 +3508,7 @@ export declare const notificationRulesCapability: {
                 label: z.ZodString;
                 valueType: z.ZodEnum<{
                     number: "number";
+                    audio: "audio";
                     deviceState: "deviceState";
                     schedule: "schedule";
                     packagePhase: "packagePhase";
@@ -3643,6 +3672,7 @@ export declare const notificationRulesCapability: {
                 }>;
                 ruleId: z.ZodOptional<z.ZodString>;
                 deviceId: z.ZodOptional<z.ZodNumber>;
+                classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 startedAt: z.ZodNumber;
                 expiresAt: z.ZodNumber;
                 global: z.ZodBoolean;
@@ -3669,6 +3699,7 @@ export declare const notificationRulesCapability: {
                 }>;
                 ruleId: z.ZodOptional<z.ZodString>;
                 deviceId: z.ZodOptional<z.ZodNumber>;
+                classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 durationMinutes: z.ZodNumber;
                 global: z.ZodOptional<z.ZodBoolean>;
                 summary: z.ZodOptional<z.ZodBoolean>;
@@ -3684,6 +3715,7 @@ export declare const notificationRulesCapability: {
                 }>;
                 ruleId: z.ZodOptional<z.ZodString>;
                 deviceId: z.ZodOptional<z.ZodNumber>;
+                classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 startedAt: z.ZodNumber;
                 expiresAt: z.ZodNumber;
                 global: z.ZodBoolean;

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

@@ -167,6 +167,13 @@ export declare const notifierCapability: {
             recipients: z.ZodBoolean;
         }, z.core.$strip>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — live queue depth and last-send state; a restored queue depth describes a queue that no longer exists.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type INotifierProvider = InferProvider<typeof notifierCapability>;
 export {};

package/dist/capabilities/numeric-sensor.cap.d.ts

@@ -47,5 +47,15 @@ export declare const numericSensorCapability: {
         precision: z.ZodOptional<z.ZodNumber>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — polled value, low churn once the clock is excluded (251 of 669 writes were the clock alone); restoring it removes the cold window before the first poll.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type INumericSensorProvider = InferProvider<typeof numericSensorCapability>;

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

@@ -587,6 +587,7 @@ export declare const osdManagerCapability: {
             catalog: z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
                 group: z.ZodEnum<{
+                    audio: "audio";
                     system: "system";
                     device: "device";
                     label: "label";
@@ -601,6 +602,7 @@ export declare const osdManagerCapability: {
                 label: z.ZodString;
                 valueType: z.ZodEnum<{
                     number: "number";
+                    audio: "audio";
                     deviceState: "deviceState";
                     schedule: "schedule";
                     packagePhase: "packagePhase";

package/dist/capabilities/pet-feeder.cap.d.ts

@@ -181,5 +181,12 @@ export declare const petFeederCapability: {
         volume: z.ZodNumber;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — live appliance state re-published on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IPetFeederProvider = InferProvider<typeof petFeederCapability>;

package/dist/capabilities/power-meter.cap.d.ts

@@ -60,5 +60,15 @@ export declare const powerMeterCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor`; `kwhTotal` is an accumulator whose restored value is the baseline.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPowerMeterProvider = InferProvider<typeof powerMeterCapability>;

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

@@ -73,6 +73,16 @@ export declare const presenceCapability: {
         batteryPercent: z.ZodNullable<z.ZodNumber>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — occupancy-relevant: the restored state is what an occupancy rule compares the first post-restart observation against.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type IPresenceProvider = InferProvider<typeof presenceCapability>;
 export {};

package/dist/capabilities/pressure-sensor.cap.d.ts

@@ -38,5 +38,15 @@ export declare const pressureSensorCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPressureSensorProvider = InferProvider<typeof pressureSensorCapability>;

package/dist/capabilities/privacy-mask.cap.d.ts

@@ -243,6 +243,16 @@ export declare const privacyMaskCapability: {
         audioEnabled: z.ZodNullable<z.ZodBoolean>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator-drawn regions, zero real churn — 22 writes in 25 minutes, every one of them the clock.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IPrivacyMaskProvider = InferNativeProvider<typeof privacyMaskCapability>;
 /**

package/dist/capabilities/ptz-autotrack.cap.d.ts

@@ -194,5 +194,12 @@ export declare const ptzAutotrackCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — mirrors the camera's own autotrack config, re-read on connect.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IPtzAutotrackProvider = InferProvider<typeof ptzAutotrackCapability>;

package/dist/capabilities/recording-export.cap.d.ts

@@ -17,13 +17,24 @@ import { type InferProvider } from './capability-definition.js';
 /** Playback-speed multiplier for the render (1 = realtime). */
 export declare const ExportSpeedSchema: z.ZodNumber;
 /**
- * One dense interval, in SECONDS FROM THE EXPORT'S OWN `fromMs`.
+ * One dense interval, in WALL-CLOCK SECONDS FROM THE EXPORT'S OWN `fromMs`.
  *
- * Relative and not absolute epoch on purpose: the renderer's frame-select
- * expression sees ffmpeg's `t`, which starts at 0 for the export's source
- * playlist. Handing it absolute epochs would make every call site responsible
- * for the same subtraction, and the one that forgot would emit a filter that
- * selects nothing — silently, as a uniform timelapse.
+ * **Wall clock, not ffmpeg's `t`** — and the recorder translates. A caller
+ * derives these bounds from things that happened at a TIME (a track's
+ * `firstSeen`), while `t` runs over the source playlist: the concatenation of
+ * every segment present for the range, with each recording GAP removed. The
+ * two agree only on a window that recorded without one interruption, and only
+ * the render side knows the segments, so the translation lives there
+ * (`export-dense-map.ts`, addon-pipeline).
+ *
+ * It was not always so. These seconds were fed to `between(t,…)` verbatim, and
+ * on a 10 h window holding 29,393 s of footage every range landed late by the
+ * gap accumulated before it — up to 6,607 s, well past EOF. Nothing matched,
+ * the video was a uniform timelapse, and the log line reported the five ranges
+ * that had been ASKED for (2026-08-13, export `57d14363`, camera 615).
+ *
+ * Relative and not absolute epoch, because an absolute epoch would make every
+ * call site responsible for the same subtraction.
  */
 export declare const ExportDenseRangeSchema: z.ZodObject<{
     fromSec: z.ZodNumber;

package/dist/capabilities/scene-monitor.cap.d.ts

@@ -479,5 +479,12 @@ export declare const sceneMonitorCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — re-derived from the current scene on the next evaluation.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type ISceneMonitorProvider = InferNativeProvider<typeof sceneMonitorCapability>;

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

@@ -57,5 +57,12 @@ export declare const scriptRunnerCapability: {
         lastError: z.ZodNullable<z.ZodString>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a restored `isRunning: true` describes a process that died with the previous hub.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IScriptRunnerProvider = InferProvider<typeof scriptRunnerCapability>;

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

@@ -33,5 +33,15 @@ export declare const smokeCapability: {
         detected: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — a safety sensor must not read "clear" merely because the hub restarted.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type ISmokeProvider = InferProvider<typeof smokeCapability>;

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

@@ -481,6 +481,16 @@ export declare const streamParamsCapability: {
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — operator-set encoder profile; mutation-driven.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type IStreamParamsProvider = InferNativeProvider<typeof streamParamsCapability>;
 export { StreamProfileConfigSchema, StreamProfileOptionsSchema };

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

@@ -50,6 +50,16 @@ export declare const switchCapability: {
         on: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — device state an operator reads as authoritative; 55 devices, transition-driven.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
     readonly settings: {
         readonly bindings: readonly [{
             readonly kind: "scalar";

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

@@ -28,5 +28,15 @@ export declare const tamperCapability: {
         tampered: z.ZodBoolean;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `smoke`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastChangedAt"];
 };
 export type ITamperProvider = InferProvider<typeof tamperCapability>;

package/dist/capabilities/temperature-sensor.cap.d.ts

@@ -46,5 +46,15 @@ export declare const temperatureSensorCapability: {
         unit: z.ZodOptional<z.ZodString>;
         precision: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **restored** — as `numeric-sensor` (69 of 125 writes were the clock alone).
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "restored";
+    /** Clock fields: written, but excluded from the compare that decides
+     *  whether persisting is worth a SQLite commit. */
+    readonly volatileStateFields: readonly ["lastFetchedAt"];
 };
 export type ITemperatureSensorProvider = InferProvider<typeof temperatureSensorCapability>;

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

@@ -44,5 +44,12 @@ export declare const updateCapability: {
         state: z.ZodNullable<z.ZodString>;
         inProgress: z.ZodBoolean;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — a restored `inProgress: true` describes an update that is no longer running; versions are re-probed at boot.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IUpdateProvider = InferProvider<typeof updateCapability>;

package/dist/capabilities/vacuum-control.cap.d.ts

@@ -237,5 +237,12 @@ export declare const vacuumControlCapability: {
         errorLabel: z.ZodNullable<z.ZodString>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — as `media-player` — a restored `state: cleaning` is a robot that is not cleaning.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IVacuumControlProvider = InferProvider<typeof vacuumControlCapability>;

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

@@ -88,5 +88,12 @@ export declare const valveCapability: {
         position: z.ZodNullable<z.ZodNumber>;
         lastChangedAt: z.ZodNumber;
     }, z.core.$strip>;
+    /**
+     * Runtime-state durability: **session** — as `brightness`.
+     *
+     * See `RuntimeStateDurability`. Enforced by
+     * `scripts/check-runtime-state-durability.ts`.
+     */
+    readonly durability: "session";
 };
 export type IValveProvider = InferProvider<typeof valveCapability>;