@camstack/types 1.2.364 → 1.2.366

package/dist/capabilities/capability-definition.d.ts

@@ -378,6 +378,68 @@ export interface DeviceConfigSpec {
 export type RuntimeStateDurability = 'session' | 'restored';
 /** The default applied to a `runtimeState` cap that declares no `durability`. */
 export declare const DEFAULT_RUNTIME_STATE_DURABILITY: RuntimeStateDurability;
+/**
+ * Unit of a recorded history series. A closed set: the History tab formats by
+ * it. `'ug/m3'` is the ASCII-safe id of micrograms per cubic metre — render it
+ * through {@link HISTORY_UNIT_LABELS}. A series whose unit is a per-device fact
+ * names a sibling field with {@link CapabilityHistoryField.unitFrom} instead.
+ */
+export type HistoryUnit = '%' | 'dBFS' | 'dBm' | '°C' | 'W' | 'kWh' | 'V' | 'A' | 'VA' | 'lx' | 'ppm' | 'ppb' | 'ug/m3' | 'hPa' | 'count' | 'ratio' | 'ms' | 's' | 'days' | 'bytes';
+/** Display label per {@link HistoryUnit} (only `'ug/m3'` differs from its id). */
+export declare const HISTORY_UNIT_LABELS: Readonly<Record<HistoryUnit, string>>;
+/** One `runtimeState` field recorded as a history series. */
+export interface CapabilityHistoryField {
+    /**
+     * `gauge` — a level, averaged in a rollup. `counter` — a MONOTONIC hardware
+     * meter only (`kwhTotal`); a drop is a reset, never a negative reading. A
+     * counter that restarts with the addon (`pressCountSinceStart`) is not one.
+     * `boolean` — stored 0/1; a rollup gives the fraction of time true.
+     */
+    readonly kind: 'gauge' | 'counter' | 'boolean';
+    /** Fixed unit of the series. Mutually exclusive with {@link unitFrom}. */
+    readonly unit?: HistoryUnit;
+    /**
+     * Path of a SIBLING `runtimeState` field (a string or enum) that carries this
+     * device's unit — `weather.temperature` takes it from `temperatureUnit`. The
+     * catalog records the path; the reader resolves it per device. Mutually
+     * exclusive with {@link unit}.
+     */
+    readonly unitFrom?: string;
+    readonly displayName?: string;
+    /** Drop a change smaller than this (ABSOLUTE) — anti-jitter for noisy gauges. */
+    readonly deadband?: number;
+    /**
+     * Drop a change smaller than this percentage of the last recorded value
+     * (RELATIVE) — for a wide-range gauge such as lux. Applied together with
+     * {@link deadband} when both are set: a change must clear both.
+     */
+    readonly deadbandPct?: number;
+    /**
+     * At most one raw point per this many ms per series. Absent means the capture
+     * floor of the kind: 10 000 for `gauge` and `counter`, none for `boolean`
+     * (change-only). Set it ABOVE the floor to be sparser; the floor is not
+     * lowered by a smaller value except `0`, which a field may state to opt out
+     * of the floor (a flapping state that must not lose an edge).
+     */
+    readonly minIntervalMs?: number;
+    /**
+     * Device types for which this field is NOT captured. `motion.detected` is a
+     * series for a PIR sensor and not for a camera, whose motion is already an
+     * addon series and a ledger.
+     */
+    readonly excludeDeviceTypes?: readonly DeviceType[];
+}
+/**
+ * The `history` block of a cap with `runtimeState`: `'none'` is an explicit
+ * answer; otherwise `fields` maps TOP-LEVEL or fixed-object (`a.b`) paths of
+ * `runtimeState` to a series. A path never goes into an array or a record keyed
+ * by runtime ids. Enforced by `scripts/check-cap-history-declared.ts`.
+ */
+export type CapabilityHistory = 'none' | {
+    readonly fields: Readonly<Record<string, CapabilityHistoryField>>;
+};
+/** Capture floor (ms) applied to `gauge` / `counter` series when a field states none. */
+export declare const HISTORY_DEFAULT_MIN_INTERVAL_MS = 10000;
 /**
  * How a COMPOSED provider answers a method it cannot forward yet (D663). A
  * composition that ADDS a cap to a device serves this cap's methods from here
@@ -516,6 +578,14 @@ export interface CapabilityDefinition<TName extends string = string, TMethods ex
      * trick with `ts` for the two hot caps; this is the same idea, declared.
      */
     readonly volatileStateFields?: readonly string[];
+    /**
+     * Which `runtimeState` fields are recorded as long-term history series
+     * (D850), or `'none'`. Mandatory for every cap declaring `runtimeState` —
+     * `scripts/check-cap-history-declared.ts` fails the build otherwise. See
+     * {@link CapabilityHistory}; `npm run codegen` projects it into
+     * `generated/history-catalog.ts`.
+     */
+    readonly history?: CapabilityHistory;
     /**
      * Declarative settings spec. When present, the device-manager's
      * settings aggregator auto-derives the ConfigUISchema and routes

package/dist/capabilities/carbon-monoxide.cap.d.ts

@@ -35,6 +35,16 @@ export declare const carbonMonoxideCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly detected: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -206,5 +206,37 @@ export declare const climateControlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. Celsius by contract; setpoints keep every change (`minIntervalMs: 0`).
+     */
+    readonly history: {
+        readonly fields: {
+            readonly currentTemp: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly deadband: 0.1;
+            };
+            readonly currentHumidity: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 0.5;
+            };
+            readonly target: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly minIntervalMs: 0;
+            };
+            readonly targetHigh: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly minIntervalMs: 0;
+            };
+            readonly targetLow: {
+                readonly kind: 'gauge';
+                readonly unit: '°C';
+                readonly minIntervalMs: 0;
+            };
+        };
+    };
 };
 export type IClimateControlProvider = InferProvider<typeof climateControlCapability>;

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

@@ -187,6 +187,10 @@ export declare const colorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — nested and cosmetic.
+     */
+    readonly history: 'none';
 };
 export type IColorProvider = InferProvider<typeof colorCapability>;
 export {};

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

@@ -39,6 +39,10 @@ export declare const connectivityCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — duplicates device-status.online (one authority for availability).
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -227,6 +227,10 @@ export declare const consumablesCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — `items` is an array keyed by runtime ids; a history path never enters it.
+     */
+    readonly history: 'none';
     /** Clocks, not content: a re-read that changed no item costs no commit. */
     readonly volatileStateFields: readonly ["lastChangedAt", "lastFetchedAt"];
 };

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

@@ -43,6 +43,16 @@ export declare const contactCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly entryOpen: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -168,6 +168,10 @@ export declare const controlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — `value` is a number/string union; configuration entity.
+     */
+    readonly history: 'none';
 };
 export type IControlProvider = InferProvider<typeof controlCapability>;
 export {};

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

@@ -106,6 +106,18 @@ export declare const coverCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series. Actuator tier: position keeps every tick of a movement.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly position: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly minIntervalMs: 0;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

package/dist/capabilities/day-night.cap.d.ts

@@ -165,6 +165,10 @@ export declare const dayNightCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — firmware configuration, not a measurement.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -0,0 +1,174 @@
+import { z } from 'zod';
+import { type InferProvider } from './capability-definition.js';
+export declare const DeviceCaStatusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    state: z.ZodLiteral<"absent">;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"ready">;
+    subject: z.ZodString;
+    fingerprintSha256: z.ZodString;
+    validTo: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    state: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strip>], "state">;
+export type DeviceCaStatus = z.infer<typeof DeviceCaStatusSchema>;
+export declare const DeviceCertificateSettingsSchema: z.ZodObject<{
+    selfEnrollment: z.ZodEnum<{
+        allowed: "allowed";
+        disabled: "disabled";
+    }>;
+}, z.core.$strip>;
+export type DeviceCertificateSettings = z.infer<typeof DeviceCertificateSettingsSchema>;
+/**
+ * `device-credentials` — the admin surface of device certificates (D855).
+ *
+ * Everything a device does ITSELF — completing an enrollment, getting a
+ * challenge, signing in, renewing — is a PUBLIC procedure of the hub's `auth`
+ * router (`auth.completeEnrollment`, `getDeviceChallenge`,
+ * `loginWithDeviceCertificate`, `renewDeviceCertificate`): those legs are
+ * proofs of possession, not capability calls, and must not be reachable as
+ * cap methods. This cap holds only what an operator does about them.
+ *
+ * Provider: `local-auth`, which also owns the device CA and the registry.
+ * The hub is the only node that persists device credentials.
+ */
+export declare const deviceCredentialsCapability: {
+    readonly name: 'device-credentials';
+    readonly scope: 'system';
+    readonly mode: 'singleton';
+    readonly methods: {
+        /**
+         * Every enrolled device, newest first; `userId` narrows to one user.
+         * `status` is derived: revoked wins over expired.
+         */
+        readonly listDeviceCredentials: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            userId: z.ZodOptional<z.ZodString>;
+            includeRevoked: z.ZodDefault<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            userId: z.ZodString;
+            username: z.ZodNullable<z.ZodString>;
+            deviceName: z.ZodString;
+            platform: z.ZodEnum<{
+                android: "android";
+                ios: "ios";
+                other: "other";
+                web: "web";
+            }>;
+            enrolledVia: z.ZodEnum<{
+                qr: "qr";
+                self: "self";
+            }>;
+            fingerprint: z.ZodString;
+            issuedAt: z.ZodNumber;
+            expiresAt: z.ZodNumber;
+            lastUsedAt: z.ZodNullable<z.ZodNumber>;
+            lastUsedFrom: z.ZodNullable<z.ZodString>;
+            revokedAt: z.ZodNullable<z.ZodNumber>;
+            revokedBy: z.ZodNullable<z.ZodString>;
+            status: z.ZodEnum<{
+                active: "active";
+                expired: "expired";
+                revoked: "revoked";
+            }>;
+        }, z.core.$strip>>>, import("./capability-definition.js").CapabilityMethodKind>;
+        /**
+         * Mint a one-shot enrollment code for `userId` and a device name: 128-bit
+         * random, single use, 10 minutes, kept only as a hash. Returns the code
+         * once, with the `camstack://enroll?hub=…&code=…` link a QR carries.
+         * `caller` (the admin) is recorded in the audit trail.
+         */
+        readonly startEnrollment: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            userId: z.ZodString;
+            deviceName: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            code: z.ZodString;
+            expiresAt: z.ZodNumber;
+            enrollUrl: z.ZodString;
+            hubOrigin: z.ZodNullable<z.ZodString>;
+            hubOrigins: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: 'required';
+        };
+        /**
+         * Revoke a credential: its certificate stops logging in at once, and every
+         * session it opened ends (an open session also dies at its next refresh
+         * even if this call raced it). Idempotent.
+         */
+        readonly revokeDeviceCredential: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            revoked: z.ZodBoolean;
+            sessionsEnded: z.ZodNumber;
+            status: z.ZodEnum<{
+                active: "active";
+                expired: "expired";
+                revoked: "revoked";
+            }>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: 'required';
+        };
+        /**
+         * Hub-wide device-certificate settings. `selfEnrollment`: `allowed`
+         * (default) lets a signed-in user enroll their own device after a step-up
+         * sign-in; `disabled` makes `auth.enrollSelf` refuse. The admin QR path is
+         * unaffected. Hub-wide only (no per-role switch).
+         */
+        readonly getDeviceCertificateSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodObject<{
+            selfEnrollment: z.ZodEnum<{
+                allowed: "allowed";
+                disabled: "disabled";
+            }>;
+        }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
+        readonly setDeviceCertificateSettings: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            selfEnrollment: z.ZodEnum<{
+                allowed: "allowed";
+                disabled: "disabled";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            selfEnrollment: z.ZodEnum<{
+                allowed: "allowed";
+                disabled: "disabled";
+            }>;
+        }, z.core.$strip>, "mutation">;
+        /**
+         * Delete the registry row of a REVOKED credential (clean-up; the audit trail
+         * keeps the revocation). Refuses a live credential: revoke it first. After
+         * the row is gone the device's next call answers `unknown-credential`.
+         */
+        readonly deleteDeviceCredential: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            result: z.ZodEnum<{
+                deleted: "deleted";
+                live: "live";
+                unknown: "unknown";
+            }>;
+        }, z.core.$strip>, "mutation"> & {
+            readonly caller: 'required';
+        };
+        /**
+         * The device CA: `absent` until the first enrollment creates it (lazily,
+         * never rotated on boot), `unavailable` while the keychain cannot answer.
+         */
+        readonly getDeviceCaStatus: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"absent">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"ready">;
+            subject: z.ZodString;
+            fingerprintSha256: z.ZodString;
+            validTo: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "state">, import("./capability-definition.js").CapabilityMethodKind>;
+        /** Rename a credential (the label only; the certificate is unchanged). */
+        readonly renameDeviceCredential: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            id: z.ZodString;
+            deviceName: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            renamed: z.ZodBoolean;
+        }, z.core.$strip>, "mutation">;
+    };
+};
+export type IDeviceCredentialsProvider = InferProvider<typeof deviceCredentialsCapability>;

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

@@ -106,6 +106,10 @@ export declare const deviceDiscoveryCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — inventory.
+     */
+    readonly history: 'none';
     readonly methods: {
         /**
          * Snapshot of the current `discovered` list. Returns the

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

@@ -57,6 +57,16 @@ export declare const deviceStatusCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series. The ONE availability series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly online: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -74,5 +74,9 @@ export declare const doorbellCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — `pressCountSinceStart` resets with the addon, so it is not a monotonic meter; presses live in the events ledger.
+     */
+    readonly history: 'none';
 };
 export type IDoorbellProvider = InferProvider<typeof doorbellCapability>;

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

@@ -62,6 +62,10 @@ export declare const enumSensorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — text/enum state has no history (non-goal).
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/event-emitter.cap.d.ts

@@ -81,5 +81,9 @@ export declare const eventEmitterCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — `eventCountSinceStart` resets with the addon; events live in ledgers.
+     */
+    readonly history: 'none';
 };
 export type IEventEmitterProvider = InferProvider<typeof eventEmitterCapability>;

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

@@ -102,5 +102,20 @@ export declare const fanControlCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series. Actuator tier: speed keeps every change.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly percentage: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly minIntervalMs: 0;
+            };
+            readonly oscillating: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
 };
 export type IFanControlProvider = InferProvider<typeof fanControlCapability>;

package/dist/capabilities/feature-probe.cap.d.ts

@@ -82,5 +82,9 @@ export declare const featureProbeCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — static identity and capability probe.
+     */
+    readonly history: 'none';
 };
 export type IFeatureProbeProvider = InferProvider<typeof featureProbeCapability>;

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

@@ -39,6 +39,16 @@ export declare const floodCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly flooded: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -36,6 +36,16 @@ export declare const gasCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly detected: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastChangedAt"];

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

@@ -84,5 +84,20 @@ export declare const humidifierCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly currentHumidity: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 0.5;
+            };
+            readonly on: {
+                readonly kind: 'boolean';
+            };
+        };
+    };
 };
 export type IHumidifierProvider = InferProvider<typeof humidifierCapability>;

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

@@ -45,6 +45,18 @@ export declare const humiditySensorCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): recorded series.
+     */
+    readonly history: {
+        readonly fields: {
+            readonly percent: {
+                readonly kind: 'gauge';
+                readonly unit: '%';
+                readonly deadband: 0.5;
+            };
+        };
+    };
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

package/dist/capabilities/image-settings.cap.d.ts

@@ -360,6 +360,10 @@ export declare const imageSettingsCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'restored';
+    /**
+     * History (D850): none — camera image configuration (operator intent), not a trend.
+     */
+    readonly history: 'none';
     /** Clock fields: written, but excluded from the compare that decides
      *  whether persisting is worth a SQLite commit. */
     readonly volatileStateFields: readonly ["lastFetchedAt"];

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

@@ -49,5 +49,9 @@ export declare const imageCapability: {
      * `scripts/check-runtime-state-durability.ts`.
      */
     readonly durability: 'session';
+    /**
+     * History (D850): none — not numeric.
+     */
+    readonly history: 'none';
 };
 export type IImageProvider = InferProvider<typeof imageCapability>;