@camstack/types 1.2.270 → 1.2.272

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

@@ -31,9 +31,9 @@ declare const BeginUploadInputSchema: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         mode: z.ZodOptional<z.ZodEnum<{
             readonly: "readonly";
+            disabled: "disabled";
             active: "active";
             drain: "drain";
-            disabled: "disabled";
         }>>;
         capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             totalBytes: z.ZodNumber;
@@ -75,9 +75,9 @@ declare const BeginDownloadInputSchema: z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         mode: z.ZodOptional<z.ZodEnum<{
             readonly: "readonly";
+            disabled: "disabled";
             active: "active";
             drain: "drain";
-            disabled: "disabled";
         }>>;
         capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             totalBytes: z.ZodNumber;
@@ -180,9 +180,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -209,9 +209,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -239,9 +239,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -268,9 +268,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -297,9 +297,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -326,9 +326,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -355,9 +355,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -383,9 +383,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;
@@ -426,9 +426,9 @@ export declare const storageProviderCapability: {
                 enabled: z.ZodOptional<z.ZodBoolean>;
                 mode: z.ZodOptional<z.ZodEnum<{
                     readonly: "readonly";
+                    disabled: "disabled";
                     active: "active";
                     drain: "drain";
-                    disabled: "disabled";
                 }>>;
                 capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                     totalBytes: z.ZodNumber;

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

@@ -98,9 +98,9 @@ export declare const storageCapability: {
             enabled: z.ZodOptional<z.ZodBoolean>;
             mode: z.ZodOptional<z.ZodEnum<{
                 readonly: "readonly";
+                disabled: "disabled";
                 active: "active";
                 drain: "drain";
-                disabled: "disabled";
             }>>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 totalBytes: z.ZodNumber;
@@ -138,9 +138,9 @@ export declare const storageCapability: {
             nodeId: z.ZodOptional<z.ZodString>;
             mode: z.ZodOptional<z.ZodEnum<{
                 readonly: "readonly";
+                disabled: "disabled";
                 active: "active";
                 drain: "drain";
-                disabled: "disabled";
             }>>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             displayName: z.ZodString;
@@ -166,9 +166,9 @@ export declare const storageCapability: {
             enabled: z.ZodOptional<z.ZodBoolean>;
             mode: z.ZodOptional<z.ZodEnum<{
                 readonly: "readonly";
+                disabled: "disabled";
                 active: "active";
                 drain: "drain";
-                disabled: "disabled";
             }>>;
             capacity: z.ZodOptional<z.ZodNullable<z.ZodObject<{
                 totalBytes: z.ZodNumber;

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

@@ -294,10 +294,10 @@ export type BrokerDecodedClient = z.infer<typeof BrokerDecodedClientSchema>;
 export type BrokerAudioClient = z.infer<typeof BrokerAudioClientSchema>;
 export type BrokerClients = z.infer<typeof BrokerClientsSchema>;
 export declare const PlaceholderReasonSchema: z.ZodEnum<{
+    offline: "offline";
     disabled: "disabled";
     sleeping: "sleeping";
     reconnecting: "reconnecting";
-    offline: "offline";
     waking: "waking";
 }>;
 export type PlaceholderReason = z.infer<typeof PlaceholderReasonSchema>;

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

@@ -61,9 +61,9 @@ export declare const MAX_CLIP_LABELS = 3;
  * rendered as `Refused: <prose>`.
  */
 export declare const ClipStillRefusalCodeSchema: z.ZodEnum<{
+    unsupported: "unsupported";
     "unknown-device": "unknown-device";
     sleeping: "sleeping";
-    unsupported: "unsupported";
     "camera-refused": "camera-refused";
     "no-keyframe": "no-keyframe";
     "queue-full": "queue-full";
@@ -155,8 +155,8 @@ export declare const ClipSchema: z.ZodObject<{
     thumbnailMint: z.ZodOptional<z.ZodString>;
     thumbnailUnavailable: z.ZodOptional<z.ZodObject<{
         reason: z.ZodEnum<{
-            sleeping: "sleeping";
             unsupported: "unsupported";
+            sleeping: "sleeping";
             "camera-refused": "camera-refused";
             "no-keyframe": "no-keyframe";
         }>;
@@ -627,8 +627,8 @@ export declare const videoclipsCapability: {
             thumbnailMint: z.ZodOptional<z.ZodString>;
             thumbnailUnavailable: z.ZodOptional<z.ZodObject<{
                 reason: z.ZodEnum<{
-                    sleeping: "sleeping";
                     unsupported: "unsupported";
+                    sleeping: "sleeping";
                     "camera-refused": "camera-refused";
                     "no-keyframe": "no-keyframe";
                 }>;

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

@@ -122,8 +122,8 @@ export type CameraOccupancySnapshot = z.infer<typeof CameraOccupancySnapshotSche
 export declare const CameraOccupancySnapshotForDeviceSchema: z.ZodObject<{
     deviceId: z.ZodNumber;
     read: z.ZodEnum<{
-        read: "read";
         unreadable: "unreadable";
+        read: "read";
     }>;
     snapshot: z.ZodNullable<z.ZodObject<{
         ts: z.ZodNumber;
@@ -310,8 +310,8 @@ export declare const zoneAnalyticsCapability: {
         }, z.core.$strip>, z.ZodReadonly<z.ZodArray<z.ZodObject<{
             deviceId: z.ZodNumber;
             read: z.ZodEnum<{
-                read: "read";
                 unreadable: "unreadable";
+                read: "read";
             }>;
             snapshot: z.ZodNullable<z.ZodObject<{
                 ts: z.ZodNumber;

package/dist/composition/composition-report.d.ts

@@ -171,8 +171,8 @@ export declare function compositionFieldKey(plan: Pick<CompositionFieldPlan, 'ca
  * `replace`s named fields of one it has natively.
  */
 export declare const CompositionFeatureModeSchema: z.ZodEnum<{
-    new: "new";
     replace: "replace";
+    new: "new";
     add: "add";
 }>;
 export type CompositionFeatureMode = z.infer<typeof CompositionFeatureModeSchema>;
@@ -180,8 +180,8 @@ export declare const CompositionFeaturePlanSchema: z.ZodObject<{
     featureIndex: z.ZodNumber;
     cap: z.ZodString;
     mode: z.ZodEnum<{
-        new: "new";
         replace: "replace";
+        new: "new";
         add: "add";
     }>;
 }, z.core.$strip>;
@@ -285,8 +285,8 @@ export declare const CompositionValidationSchema: z.ZodObject<{
         featureIndex: z.ZodNumber;
         cap: z.ZodString;
         mode: z.ZodEnum<{
-            new: "new";
             replace: "replace";
+            new: "new";
             add: "add";
         }>;
     }, z.core.$strip>>;

package/dist/{composition-D5BQywfe.mjs → composition-BK-GTFYb.mjs}

@@ -989,14 +989,37 @@ function evaluateRose(level, changedAt, debounceMs, call, field, env) {
 	field.acceptedEdgeAt = verdict.timestamp;
 	return verdict.timestamp;
 }
+/**
+* `count(x)`: how many times `x` strictly advanced (D670). It starts on the
+* first ANSWERED read of `x`:
+*  - an answered `null` ("never happened") primes it with no high-water, so the
+*    next finite value is a real advance and counts 1;
+*  - an answered finite value primes it with that value as the high-water and
+*    no increment — it is history, not an event;
+*  - anything else (a read that did not answer reaches here as neither) does
+*    NOT prime it (D393: unknown is not null).
+* An unavailable binding never reaches this function at all: the field is
+* judged unavailable before the expression runs.
+*
+* Edge case, accepted: an input that answers `null` and LATER reports a
+* historical value (a sensor's `lastChangedAt` that was null until its first
+* report) counts that value once. For the doorbell it cannot happen — its
+* input is its own `lastPressedAt`, which only advances on a `rose` edge that
+* also emits the press — but an external input can overcount by one.
+*/
 function evaluateCount(input, call, currentOutput) {
 	const currentCount = typeof currentOutput === "number" && Number.isFinite(currentOutput) && currentOutput >= 0 ? currentOutput : 0;
+	if (input === null) {
+		call.primed = true;
+		return currentCount;
+	}
 	if (typeof input !== "number" || !Number.isFinite(input)) return currentCount;
-	if (call.highWater === null) {
+	if (!call.primed) {
+		call.primed = true;
 		call.highWater = input;
 		return currentCount;
 	}
-	if (input <= call.highWater) return currentCount;
+	if (call.highWater !== null && input <= call.highWater) return currentCount;
 	call.highWater = input;
 	return currentCount + 1;
 }
@@ -1744,7 +1767,8 @@ function evaluateStatefulExpressionCall(invocation, memory, env) {
 		case "count": {
 			const call = existing?.kind === "count" ? existing : {
 				kind: "count",
-				highWater: null
+				highWater: null,
+				primed: false
 			};
 			memory.calls.set(invocation.path, call);
 			return evaluateCount(invocation.args[0], call, env.currentOutput);

package/dist/{composition-BAH3n-zq.js → composition-BRxAnxtU.js}

@@ -989,14 +989,37 @@ function evaluateRose(level, changedAt, debounceMs, call, field, env) {
 	field.acceptedEdgeAt = verdict.timestamp;
 	return verdict.timestamp;
 }
+/**
+* `count(x)`: how many times `x` strictly advanced (D670). It starts on the
+* first ANSWERED read of `x`:
+*  - an answered `null` ("never happened") primes it with no high-water, so the
+*    next finite value is a real advance and counts 1;
+*  - an answered finite value primes it with that value as the high-water and
+*    no increment — it is history, not an event;
+*  - anything else (a read that did not answer reaches here as neither) does
+*    NOT prime it (D393: unknown is not null).
+* An unavailable binding never reaches this function at all: the field is
+* judged unavailable before the expression runs.
+*
+* Edge case, accepted: an input that answers `null` and LATER reports a
+* historical value (a sensor's `lastChangedAt` that was null until its first
+* report) counts that value once. For the doorbell it cannot happen — its
+* input is its own `lastPressedAt`, which only advances on a `rose` edge that
+* also emits the press — but an external input can overcount by one.
+*/
 function evaluateCount(input, call, currentOutput) {
 	const currentCount = typeof currentOutput === "number" && Number.isFinite(currentOutput) && currentOutput >= 0 ? currentOutput : 0;
+	if (input === null) {
+		call.primed = true;
+		return currentCount;
+	}
 	if (typeof input !== "number" || !Number.isFinite(input)) return currentCount;
-	if (call.highWater === null) {
+	if (!call.primed) {
+		call.primed = true;
 		call.highWater = input;
 		return currentCount;
 	}
-	if (input <= call.highWater) return currentCount;
+	if (call.highWater !== null && input <= call.highWater) return currentCount;
 	call.highWater = input;
 	return currentCount + 1;
 }
@@ -1744,7 +1767,8 @@ function evaluateStatefulExpressionCall(invocation, memory, env) {
 		case "count": {
 			const call = existing?.kind === "count" ? existing : {
 				kind: "count",
-				highWater: null
+				highWater: null,
+				primed: false
 			};
 			memory.calls.set(invocation.path, call);
 			return evaluateCount(invocation.args[0], call, env.currentOutput);

package/dist/device/base-device-provider.d.ts

@@ -176,8 +176,13 @@ export declare abstract class BaseDeviceProvider<TConfig extends object = Record
     /** Retry lane width. See `device-restore-retry.ts` for why retries
      *  never re-stampede full-width while the initial pass does (D167). */
     protected readonly restoreRetryConcurrency: number;
-    private _restoreRetryScheduler;
+    /** Every bounded retry this process started — the default pass's, and each
+     *  `restoreWithBoundedRetry` of a provider's own rows. Cancelled together. */
+    private _restoreRetrySchedulers;
     private _restoreRetryCompletion;
+    /** Set by `onShutdown` BEFORE the retries are cancelled: a restore pass still
+     *  in flight must not start a scheduler after the cancel ran. */
+    private _restoreShuttingDown;
     private readonly _permanentRestoreFailures;
     /** Settles when the background retry rounds finish (or `null` when
      *  nothing failed). Exposed for tests and subclass diagnostics —
@@ -215,6 +220,19 @@ export declare abstract class BaseDeviceProvider<TConfig extends object = Record
     private cancelRestoreRetries;
     private recordPermanentRestoreFailure;
     private scheduleRestoreRetries;
+    /**
+     * Restore rows the default pass does not handle (a provider's own restore
+     * loop) under the SAME bounded retry (D347): one attempt each, in order; a
+     * row that throws is logged with `tags.deviceId` and retried in the
+     * background rounds, then marked permanently failed like any other.
+     *
+     * A restore is a device build, and a build whose runtime-state load did not
+     * answer is REFUSED rather than started on cold defaults (D677) — so a
+     * transient hub read must cost a retry, never the device until the next
+     * runner restart. An ANSWERED `{}` is the device's true state and never
+     * refuses.
+     */
+    protected restoreWithBoundedRetry(rows: readonly SavedDevice[], attempt: (saved: SavedDevice) => Promise<void>): Promise<void>;
     /**
      * Tear down and reconstruct ONE device from its persisted rows — the
      * `deviceProvider.reloadDevice` cap method. Persistence is never touched,

package/dist/device/device-context.d.ts

@@ -162,6 +162,18 @@ export interface DeviceManagerApi {
      *  don't need to think about this — the standard `create()` shortcut
      *  loads it automatically. */
     createContext(stableId: string, id: number, parentDeviceId?: number | null, persistedConfig?: Record<string, unknown>): DeviceContext;
+    /** `createContext` for a device the context will BUILD, hydrated like
+     *  `create()`: the device's stored runtime state is loaded first. A load
+     *  that did not answer REJECTS — a device built on an empty state writes
+     *  its cold-start defaults over the restored values (D677). A brand-new
+     *  device's `{}` is an answer, never a refusal.
+     *
+     *  `createContext` stays synchronous and EMPTY-state for callers that build
+     *  no device from it (a composer graft registers method-serving natives
+     *  only) and for addons compiled before this method existed. Optional: an
+     *  older kernel does not provide it — a caller falls back to
+     *  `createContext` there. */
+    loadContext?(stableId: string, id: number, parentDeviceId?: number | null, persistedConfig?: Record<string, unknown>): Promise<DeviceContext>;
     /** Read the per-device persisted config blob from the DB. Returns
      *  `{}` for devices that have no persisted row yet (newly allocated
      *  but not registered). Used by callers going through the manual

package/dist/expression/builtins.d.ts

@@ -48,6 +48,24 @@ export declare function evaluateRose(level: unknown, changedAt: unknown, debounc
     readonly startedAtMs: number;
     readonly nowMs: number;
 }): number | null;
+/**
+ * `count(x)`: how many times `x` strictly advanced (D670). It starts on the
+ * first ANSWERED read of `x`:
+ *  - an answered `null` ("never happened") primes it with no high-water, so the
+ *    next finite value is a real advance and counts 1;
+ *  - an answered finite value primes it with that value as the high-water and
+ *    no increment — it is history, not an event;
+ *  - anything else (a read that did not answer reaches here as neither) does
+ *    NOT prime it (D393: unknown is not null).
+ * An unavailable binding never reaches this function at all: the field is
+ * judged unavailable before the expression runs.
+ *
+ * Edge case, accepted: an input that answers `null` and LATER reports a
+ * historical value (a sensor's `lastChangedAt` that was null until its first
+ * report) counts that value once. For the doorbell it cannot happen — its
+ * input is its own `lastPressedAt`, which only advances on a `rose` edge that
+ * also emits the press — but an external input can overcount by one.
+ */
 export declare function evaluateCount(input: unknown, call: CountCallState, currentOutput: unknown): number;
 /** Frozen, null-prototype builtin table. */
 export declare const EXPRESSION_BUILTINS: Readonly<Record<string, ExpressionBuiltin>>;

package/dist/expression/expression-source.d.ts

@@ -17,6 +17,8 @@ export interface RoseCallState {
 export interface CountCallState {
     readonly kind: 'count';
     highWater: number | null;
+    /** Whether a read has ANSWERED yet (a finite value or `null`); `highWater` means nothing before. */
+    primed: boolean;
 }
 export type StatefulCallState = RoseCallState | CountCallState;
 export interface StatefulExpressionMemory {

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

@@ -2623,6 +2623,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof deviceManagerCapability.methods.setWrapperActive.output>;
             meta: object;
         }>;
+        getWrapperActivation: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceManagerCapability.methods.getWrapperActivation.input>;
+            output: z.infer<typeof deviceManagerCapability.methods.getWrapperActivation.output>;
+            meta: object;
+        }>;
         listWrappersForCap: TRPCQueryProcedure<{
             input: {
                 [x: string]: unknown;
@@ -9621,39 +9628,6 @@ export type AppRouter = TrpcCoreRouter<{
             output: Record<string, unknown>;
             meta: object;
         }>;
-        updateGlobal: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                field: string;
-                value: unknown;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
-        updateDevice: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                deviceId: string;
-                field: string;
-                value: unknown;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
-        replaceGlobal: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                config: Record<string, unknown>;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
     }>> & import("@trpc/server").TRPCDecorateCreateRouterOptions<{
         getGlobal: import("@trpc/server").TRPCQueryProcedure<{
             input: {
@@ -9670,39 +9644,6 @@ export type AppRouter = TrpcCoreRouter<{
             output: Record<string, unknown>;
             meta: object;
         }>;
-        updateGlobal: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                field: string;
-                value: unknown;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
-        updateDevice: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                deviceId: string;
-                field: string;
-                value: unknown;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
-        replaceGlobal: import("@trpc/server").TRPCMutationProcedure<{
-            input: {
-                addonId: string;
-                config: Record<string, unknown>;
-            };
-            output: {
-                success: true;
-            };
-            meta: object;
-        }>;
     }>;
     eventBusProxy: import("@trpc/server/unstable-core-do-not-import").Router<{
         ctx: any;

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

@@ -293,7 +293,7 @@ export interface DeviceProxy {
     readonly audioAnalyzer: Pick<InferDeviceProxyCap<typeof audioAnalyzerCapability>, 'detachDevice'>;
     readonly deviceAdoption: Pick<InferDeviceProxyCap<typeof deviceAdoptionCapability>, 'getStatus'>;
     readonly deviceExport: Pick<InferDeviceProxyCap<typeof deviceExportCapability>, 'getDeviceSettingsContribution' | 'getDeviceLiveContribution' | 'applyDeviceSettingsPatch'>;
-    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDisplay' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getLinkedDevices' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'setWrapperActive' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate'>;
+    readonly deviceManager: Pick<InferDeviceProxyCap<typeof deviceManagerCapability>, 'loadConfig' | 'loadRuntimeState' | 'loadMeta' | 'setName' | 'setLocation' | 'setType' | 'setIntegrationId' | 'setLinkDeviceId' | 'setPrimaryChildEntityId' | 'setChildLayout' | 'setDisplay' | 'getWireableFields' | 'setRole' | 'applyInitialMeta' | 'setMetadata' | 'setDisabled' | 'getDevice' | 'getLinkedDevices' | 'getStreamSources' | 'getConfigSchema' | 'getSettingsSchema' | 'updateConfig' | 'enable' | 'disable' | 'remove' | 'getStreamProfileMap' | 'setStreamProfileMap' | 'probeStreams' | 'getBindings' | 'setWrapperActive' | 'getWrapperActivation' | 'getDeviceSettingsAggregate' | 'getDeviceLiveInfoAggregate' | 'getDeviceAggregate' | 'runDeviceAction' | 'updateDeviceField' | 'updateDeviceFieldsBatch' | 'testField' | 'getDeviceStatusAggregate'>;
     readonly deviceState: Pick<InferDeviceProxyCap<typeof deviceStateCapability>, 'getSnapshot' | 'getCapSlice' | 'setCapSlice' | 'claimFields' | 'patchOwnedFields' | 'releaseClaim' | 'getNativeCapSlice'>;
     readonly faceGallery: Pick<InferDeviceProxyCap<typeof faceGalleryCapability>, 'listRecentFaces' | 'getFaceByTrack'>;
     readonly networkQuality: Pick<InferDeviceProxyCap<typeof networkQualityCapability>, 'getDeviceStats' | 'reportClientStats'>;

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: 1191 method paths across 162 capabilities.
+ * Coverage: 1192 method paths across 162 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: 403 methods carry a device reference, of which
- * 142 are on SYSTEM-scope caps.
+ * Coverage: 404 methods carry a device reference, of which
+ * 143 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/index.d.ts

@@ -243,6 +243,7 @@ export { NC_SERVER_PACKAGE_NAME, NC_UPDATE_EVENT_PACKAGE_NAMES, type NcInstalled
 export type { TimelapseCadencePair, TimelapsePreviewMode, TimelapseRule, TimelapseRuleInput, TimelapseRulePatch, TimelapseTemplate, } from './notification/timelapse-rule.js';
 export { assertTimelapseCadences, DEFAULT_TIMELAPSE_PREVIEW_TEXT, readTimelapseGeneratedAt, TIMELAPSE_DENSE_FLOOR_SEC, TimelapseRuleInputSchema, TimelapseRulePatchSchema, TimelapseRuleSchema, TimelapseTemplateSchema, } from './notification/timelapse-rule.js';
 export { CLUSTER_MODEL_SCOPED_STEPS, CLUSTER_MODEL_SECTION_ID, CLUSTER_STEP_SETTING_FIELDS, type ClusterModelScopedStep, type ClusterStepModels, type ClusterStepSettingField, type ClusterStepSettings, clusterModelSettingKey, clusterStepSettingFieldsFor, clusterStepSettingKey, DEFAULT_CLUSTER_STEP_MODELS, DEFAULT_CLUSTER_STEP_SETTINGS, DEFAULT_MIN_LANDMARK_FACE_SIZE_PX, type HydratedClusterSection, type HydratedClusterView, interpretStoredClusterModel, type InvalidClusterStepModelEntry, invalidClusterStepModelEntries, isClusterScopedStep, overlayClusterStepSettings, pickClusterStepModels, pickClusterStepSettings, pickInvalidClusterStepModels, readClusterStepModels, readClusterStepSettings, resolveClusterStepModelId, type StepModelScope, type StoredClusterModelInterpretation, } from './pipeline/cluster-model-scope.js';
+export { CAMERA_SENSORS_NOT_LOADED, CAMERA_SENSORS_SETTINGS_KEY, CAMERA_TRIGGER, type CameraSensorAttachment, CameraSensorAttachmentSchema, type CameraSensorRef, CameraSensorRefSchema, cameraSensorRefKey, type CameraSensorsConfig, CameraSensorsConfigSchema, type CameraSensorsMode, CameraSensorsModeSchema, type CameraSensorsNotForwarded, CameraSensorsNotForwardedSchema, type CameraSensorsStatus, CameraSensorsStatusSchema, MAX_CAMERA_SENSORS, type MotionTriggeredBy, type MotionTriggeredByReading, MotionTriggeredBySchema, readMotionTriggeredBy, } from './pipeline/camera-sensors.js';
 export { type FormatRunnableModel, stepModelRunsOnFormat, } from './pipeline/step-format-runnable.js';
 export { DEFAULT_DETAIL_CROP_CONVENTION, DETAIL_CROP_PADDING_FIELD, DETAIL_CROP_PADDING_KEY, DETAIL_CROP_SECTION_ID, DETAIL_CROP_SQUARE_KEY, type DetailCropConvention, DetailCropConventionSchema, type DetailCropRect, deriveDetailCropRect, FULL_IMAGE_BBOX, type HydratedSettingsSection, type HydratedSettingsView, pickDetailCropConvention, readDetailCropConvention, } from './pipeline/detail-crop.js';
 export { DEFAULT_NATIVE_LEASE_SETTINGS, NATIVE_LEASE_ACTIVITY_FIELD, NATIVE_LEASE_ACTIVITY_KEY, NATIVE_LEASE_ADMISSION_FIELD, NATIVE_LEASE_ADMISSION_KEY, NATIVE_LEASE_BUDGET_FIELD, NATIVE_LEASE_BUDGET_KEY, NATIVE_LEASE_HOLD_FIELD, NATIVE_LEASE_HOLD_KEY, NATIVE_LEASE_SCENE_BUDGET_FIELD, NATIVE_LEASE_SCENE_BUDGET_KEY, NATIVE_LEASE_SECTION_ID, NATIVE_LEASE_TILE_BUDGET_FIELD, NATIVE_LEASE_TILE_BUDGET_KEY, type NativeLeaseAdmission, NativeLeaseAdmissionSchema, type NativeLeaseKnob, type NativeLeaseNumberKnob, type NativeLeaseSettings, type NativeLeaseSettingsOverride, NativeLeaseSettingsSchema, pickNativeLeaseOverride, readNativeLeaseOverride, } from './pipeline/native-lease.js';