@camstack/types 1.2.70 → 1.2.72

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { type InferNativeProvider } from './capability-definition.js';
 import { DeviceType } from '../device/device-type.js';
+import { type InferNativeProvider } from './capability-definition.js';
 /**
  * scene-monitor — device-scoped reference-region state cap. An operator marks
  * a rect ROI on a camera frame and names one or more states; the engine
@@ -14,9 +14,41 @@ import { DeviceType } from '../device/device-type.js';
  * settings-contribution methods. `status.kind:'push'` — the engine pushes on
  * every hysteresis flip / availability change; consumers never poll.
  */
-/** Extensible condition tag. Seeded 'day' | 'night'; open by design so more can
- *  be added without a wire break (matching falls back to any-condition refs). */
+/** Extensible condition tag. Seeded 'day' | 'ir' (the two variants the operator
+ *  captures) plus 'night' | 'dawn' | 'dusk' from the resolver's sun-times band.
+ *  Open by design so more can be added without a wire break.
+ *
+ *  Matching does NOT fall back across conditions: cross-condition cosines are
+ *  not comparable, so "I have never seen this scene in this light" is reported
+ *  as `unknown`, never guessed. A day reference scored against an IR frame
+ *  collapses the cosine and would latch a false alarm every single night. */
 export declare const SceneConditionSchema: z.ZodString;
+/** The conditions the resolver can produce. Seeds for the UI's coverage line;
+ *  the wire type stays an open string. */
+export declare const SCENE_CONDITIONS: readonly ["day", "ir", "night", "dawn", "dusk"];
+/** Reserved, engine-owned state id standing for "the region no longer looks
+ *  like ANY captured reference". Never authored by an operator, never stored in
+ *  `states[]` — it is the synthetic candidate that makes divergence a
+ *  first-class hysteresis input rather than a bare `return`. */
+export declare const SCENE_DIVERGED = "__diverged__";
+/** `matched` = the baseline is what we see; `diverged` = it demonstrably is not;
+ *  `unknown` = we cannot judge (no reference for this condition, encoder model
+ *  changed, view shifted, no snapshot). `unknown` is a real value, not a null,
+ *  and never counts toward hysteresis in either direction. */
+export declare const SceneVerdictSchema: z.ZodEnum<{
+    unknown: "unknown";
+    matched: "matched";
+    diverged: "diverged";
+}>;
+/** Why a scene cannot judge. Named, because this feature's failure mode is
+ *  silence that reads as "nothing has happened". */
+export declare const SceneUnavailableSchema: z.ZodEnum<{
+    "no-reference-for-condition": "no-reference-for-condition";
+    "view-shifted": "view-shifted";
+    "no-vision-profile": "no-vision-profile";
+    "encoder-model-changed": "encoder-model-changed";
+    "no-snapshot": "no-snapshot";
+}>;
 /** One captured reference — condition-tagged, model-version-gated. `embedding`
  *  is `number[]` (Float32Array does NOT survive MsgPack/UDS). */
 export declare const SceneReferenceSchema: z.ZodObject<{
@@ -25,6 +57,7 @@ export declare const SceneReferenceSchema: z.ZodObject<{
     condition: z.ZodString;
     capturedAt: z.ZodNumber;
     thumbnailMediaId: z.ZodOptional<z.ZodString>;
+    anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
 }, z.core.$strip>;
 export declare const SceneMonitorStateSchema: z.ZodObject<{
     id: z.ZodString;
@@ -35,6 +68,7 @@ export declare const SceneMonitorStateSchema: z.ZodObject<{
         condition: z.ZodString;
         capturedAt: z.ZodNumber;
         thumbnailMediaId: z.ZodOptional<z.ZodString>;
+        anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
     }, z.core.$strip>>;
     textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     referenceCount: z.ZodNumber;
@@ -52,6 +86,40 @@ export declare const SceneCheckSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     profileId: z.ZodOptional<z.ZodString>;
     hysteresisCount: z.ZodNumber;
 }, z.core.$strip>], "mode">;
+/** Defaults, as CONSTANTS rather than only as Zod `.default()`. A Zod default
+ *  does NOT run on the addon→addon cap path, so every runtime seam reads these
+ *  as absent-with-a-constant (the `NcConfirmSchema` lesson, three production
+ *  failures in one day). The schema defaults and these values are the same
+ *  numbers on purpose. */
+export declare const SCENE_DEFAULT_QUIET_SECONDS = 60;
+export declare const SCENE_DEFAULT_OBSERVATION_SPACING_SEC = 120;
+export declare const SCENE_DEFAULT_CHECK_INTERVAL_SEC = 60;
+export declare const SCENE_DEFAULT_ANCHOR_THRESHOLD = 0.85;
+export declare const SCENE_CONFIRM_DEFAULT_TIMEOUT_MS = 8000;
+export declare const SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX = 448;
+/** `resetScene({ recapture })` absent means TRUE — the operator decision. Read
+ *  at the seam, because a Zod `.optional()` carries no default at all. */
+export declare const SCENE_RESET_RECAPTURES = true;
+/**
+ * Vision-model adjudication of a candidate flip. Field names deliberately
+ * mirror `NcConfirmSchema` so an operator meets one vocabulary, not two.
+ *
+ * `onTimeout` defaults to **'hold'**, the OPPOSITE of `NcConfirmGate`'s
+ * fail-open: a notification suppressed is the worse error there, but a vision
+ * model that timed out has not told us the bin is gone, and a latch is a
+ * stateful claim that costs the operator a trip to reset.
+ */
+export declare const SceneConfirmSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    prompt: z.ZodString;
+    profileId: z.ZodOptional<z.ZodString>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    maxImagePx: z.ZodDefault<z.ZodNumber>;
+    onTimeout: z.ZodDefault<z.ZodEnum<{
+        flip: "flip";
+        hold: "hold";
+    }>>;
+}, z.core.$strip>;
 export declare const SceneMonitorSchema: z.ZodObject<{
     id: z.ZodString;
     label: z.ZodString;
@@ -88,6 +156,7 @@ export declare const SceneMonitorSchema: z.ZodObject<{
             condition: z.ZodString;
             capturedAt: z.ZodNumber;
             thumbnailMediaId: z.ZodOptional<z.ZodString>;
+            anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
         }, z.core.$strip>>;
         textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
         referenceCount: z.ZodNumber;
@@ -102,6 +171,43 @@ export declare const SceneMonitorSchema: z.ZodObject<{
         unavailable: "unavailable";
     }>;
     unavailableReason: z.ZodNullable<z.ZodString>;
+    baselineStateId: z.ZodNullable<z.ZodString>;
+    emit: z.ZodDefault<z.ZodEnum<{
+        live: "live";
+        latched: "latched";
+    }>>;
+    verdict: z.ZodEnum<{
+        unknown: "unknown";
+        matched: "matched";
+        diverged: "diverged";
+    }>;
+    latched: z.ZodBoolean;
+    armedAt: z.ZodNumber;
+    divergedAt: z.ZodNullable<z.ZodNumber>;
+    restoredAt: z.ZodNullable<z.ZodNumber>;
+    quietSeconds: z.ZodDefault<z.ZodNumber>;
+    minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+    confirm: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        prompt: z.ZodString;
+        profileId: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxImagePx: z.ZodDefault<z.ZodNumber>;
+        onTimeout: z.ZodDefault<z.ZodEnum<{
+            flip: "flip";
+            hold: "hold";
+        }>>;
+    }, z.core.$strip>>;
+    anchorThreshold: z.ZodDefault<z.ZodNumber>;
+    autoRestore: z.ZodDefault<z.ZodBoolean>;
+    unavailable: z.ZodNullable<z.ZodEnum<{
+        "no-reference-for-condition": "no-reference-for-condition";
+        "view-shifted": "view-shifted";
+        "no-vision-profile": "no-vision-profile";
+        "encoder-model-changed": "encoder-model-changed";
+        "no-snapshot": "no-snapshot";
+    }>>;
+    coveredConditions: z.ZodArray<z.ZodString>;
 }, z.core.$strip>;
 export declare const SceneMonitorStatusSchema: z.ZodObject<{
     monitors: z.ZodArray<z.ZodObject<{
@@ -140,6 +246,7 @@ export declare const SceneMonitorStatusSchema: z.ZodObject<{
                 condition: z.ZodString;
                 capturedAt: z.ZodNumber;
                 thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
             }, z.core.$strip>>;
             textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
             referenceCount: z.ZodNumber;
@@ -154,10 +261,50 @@ export declare const SceneMonitorStatusSchema: z.ZodObject<{
             unavailable: "unavailable";
         }>;
         unavailableReason: z.ZodNullable<z.ZodString>;
+        baselineStateId: z.ZodNullable<z.ZodString>;
+        emit: z.ZodDefault<z.ZodEnum<{
+            live: "live";
+            latched: "latched";
+        }>>;
+        verdict: z.ZodEnum<{
+            unknown: "unknown";
+            matched: "matched";
+            diverged: "diverged";
+        }>;
+        latched: z.ZodBoolean;
+        armedAt: z.ZodNumber;
+        divergedAt: z.ZodNullable<z.ZodNumber>;
+        restoredAt: z.ZodNullable<z.ZodNumber>;
+        quietSeconds: z.ZodDefault<z.ZodNumber>;
+        minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+        confirm: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            prompt: z.ZodString;
+            profileId: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodDefault<z.ZodNumber>;
+            maxImagePx: z.ZodDefault<z.ZodNumber>;
+            onTimeout: z.ZodDefault<z.ZodEnum<{
+                flip: "flip";
+                hold: "hold";
+            }>>;
+        }, z.core.$strip>>;
+        anchorThreshold: z.ZodDefault<z.ZodNumber>;
+        autoRestore: z.ZodDefault<z.ZodBoolean>;
+        unavailable: z.ZodNullable<z.ZodEnum<{
+            "no-reference-for-condition": "no-reference-for-condition";
+            "view-shifted": "view-shifted";
+            "no-vision-profile": "no-vision-profile";
+            "encoder-model-changed": "encoder-model-changed";
+            "no-snapshot": "no-snapshot";
+        }>>;
+        coveredConditions: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
     lastFetchedAt: z.ZodNumber;
 }, z.core.$strip>;
 export type SceneCondition = z.infer<typeof SceneConditionSchema>;
+export type SceneVerdict = z.infer<typeof SceneVerdictSchema>;
+export type SceneUnavailable = z.infer<typeof SceneUnavailableSchema>;
+export type SceneConfirm = z.infer<typeof SceneConfirmSchema>;
 export type SceneReference = z.infer<typeof SceneReferenceSchema>;
 export type SceneMonitorState = z.infer<typeof SceneMonitorStateSchema>;
 export type SceneCheck = z.infer<typeof SceneCheckSchema>;
@@ -218,6 +365,7 @@ export declare const sceneMonitorCapability: {
                         condition: z.ZodString;
                         capturedAt: z.ZodNumber;
                         thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                        anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                     }, z.core.$strip>>;
                     textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     referenceCount: z.ZodNumber;
@@ -232,6 +380,43 @@ export declare const sceneMonitorCapability: {
                     unavailable: "unavailable";
                 }>;
                 unavailableReason: z.ZodNullable<z.ZodString>;
+                baselineStateId: z.ZodNullable<z.ZodString>;
+                emit: z.ZodDefault<z.ZodEnum<{
+                    live: "live";
+                    latched: "latched";
+                }>>;
+                verdict: z.ZodEnum<{
+                    unknown: "unknown";
+                    matched: "matched";
+                    diverged: "diverged";
+                }>;
+                latched: z.ZodBoolean;
+                armedAt: z.ZodNumber;
+                divergedAt: z.ZodNullable<z.ZodNumber>;
+                restoredAt: z.ZodNullable<z.ZodNumber>;
+                quietSeconds: z.ZodDefault<z.ZodNumber>;
+                minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+                confirm: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    prompt: z.ZodString;
+                    profileId: z.ZodOptional<z.ZodString>;
+                    timeoutMs: z.ZodDefault<z.ZodNumber>;
+                    maxImagePx: z.ZodDefault<z.ZodNumber>;
+                    onTimeout: z.ZodDefault<z.ZodEnum<{
+                        flip: "flip";
+                        hold: "hold";
+                    }>>;
+                }, z.core.$strip>>;
+                anchorThreshold: z.ZodDefault<z.ZodNumber>;
+                autoRestore: z.ZodDefault<z.ZodBoolean>;
+                unavailable: z.ZodNullable<z.ZodEnum<{
+                    "no-reference-for-condition": "no-reference-for-condition";
+                    "view-shifted": "view-shifted";
+                    "no-vision-profile": "no-vision-profile";
+                    "encoder-model-changed": "encoder-model-changed";
+                    "no-snapshot": "no-snapshot";
+                }>>;
+                coveredConditions: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>, import("./capability-definition.js").CapabilityMethodKind>;
@@ -297,6 +482,7 @@ export declare const sceneMonitorCapability: {
                     condition: z.ZodString;
                     capturedAt: z.ZodNumber;
                     thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                    anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 }, z.core.$strip>>;
                 textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 referenceCount: z.ZodNumber;
@@ -311,6 +497,43 @@ export declare const sceneMonitorCapability: {
                 unavailable: "unavailable";
             }>;
             unavailableReason: z.ZodNullable<z.ZodString>;
+            baselineStateId: z.ZodNullable<z.ZodString>;
+            emit: z.ZodDefault<z.ZodEnum<{
+                live: "live";
+                latched: "latched";
+            }>>;
+            verdict: z.ZodEnum<{
+                unknown: "unknown";
+                matched: "matched";
+                diverged: "diverged";
+            }>;
+            latched: z.ZodBoolean;
+            armedAt: z.ZodNumber;
+            divergedAt: z.ZodNullable<z.ZodNumber>;
+            restoredAt: z.ZodNullable<z.ZodNumber>;
+            quietSeconds: z.ZodDefault<z.ZodNumber>;
+            minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+            confirm: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                prompt: z.ZodString;
+                profileId: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxImagePx: z.ZodDefault<z.ZodNumber>;
+                onTimeout: z.ZodDefault<z.ZodEnum<{
+                    flip: "flip";
+                    hold: "hold";
+                }>>;
+            }, z.core.$strip>>;
+            anchorThreshold: z.ZodDefault<z.ZodNumber>;
+            autoRestore: z.ZodDefault<z.ZodBoolean>;
+            unavailable: z.ZodNullable<z.ZodEnum<{
+                "no-reference-for-condition": "no-reference-for-condition";
+                "view-shifted": "view-shifted";
+                "no-vision-profile": "no-vision-profile";
+                "encoder-model-changed": "encoder-model-changed";
+                "no-snapshot": "no-snapshot";
+            }>>;
+            coveredConditions: z.ZodArray<z.ZodString>;
         }, z.core.$strip>, "mutation">;
         readonly updateScene: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
             deviceId: z.ZodNumber;
@@ -341,6 +564,25 @@ export declare const sceneMonitorCapability: {
                     profileId: z.ZodOptional<z.ZodString>;
                     hysteresisCount: z.ZodNumber;
                 }, z.core.$strip>], "mode">>;
+                emit: z.ZodOptional<z.ZodEnum<{
+                    live: "live";
+                    latched: "latched";
+                }>>;
+                quietSeconds: z.ZodOptional<z.ZodNumber>;
+                minObservationSpacingSec: z.ZodOptional<z.ZodNumber>;
+                anchorThreshold: z.ZodOptional<z.ZodNumber>;
+                autoRestore: z.ZodOptional<z.ZodBoolean>;
+                confirm: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    prompt: z.ZodString;
+                    profileId: z.ZodOptional<z.ZodString>;
+                    timeoutMs: z.ZodDefault<z.ZodNumber>;
+                    maxImagePx: z.ZodDefault<z.ZodNumber>;
+                    onTimeout: z.ZodDefault<z.ZodEnum<{
+                        flip: "flip";
+                        hold: "hold";
+                    }>>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
         readonly deleteScene: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
@@ -367,6 +609,22 @@ export declare const sceneMonitorCapability: {
             deviceId: z.ZodNumber;
             monitorId: z.ZodString;
         }, z.core.$strip>, z.ZodVoid, "mutation">;
+        /**
+         * Clear the latch, re-arm, and — by default — RE-CAPTURE the baseline for
+         * the CURRENT condition. The bin never goes back in exactly the same spot;
+         * "reset" in the operator's head means *this is the new normal*, and
+         * re-capture is what makes the feature self-healing against slow drift
+         * instead of failing silently weeks later.
+         *
+         * Reachable from three surfaces on this one mutation: the scene card, a
+         * notification button (an `onTrigger` sequence with a `kind:'cap'` step —
+         * no new Notification-Center code at all), and tRPC for scripts.
+         */
+        readonly resetScene: import("./capability-definition.js").CapabilityMethodSchema<z.ZodObject<{
+            deviceId: z.ZodNumber;
+            monitorId: z.ZodString;
+            recapture: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>, z.ZodVoid, "mutation">;
     };
     readonly status: {
         readonly schema: z.ZodObject<{
@@ -406,6 +664,7 @@ export declare const sceneMonitorCapability: {
                         condition: z.ZodString;
                         capturedAt: z.ZodNumber;
                         thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                        anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                     }, z.core.$strip>>;
                     textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
                     referenceCount: z.ZodNumber;
@@ -420,6 +679,43 @@ export declare const sceneMonitorCapability: {
                     unavailable: "unavailable";
                 }>;
                 unavailableReason: z.ZodNullable<z.ZodString>;
+                baselineStateId: z.ZodNullable<z.ZodString>;
+                emit: z.ZodDefault<z.ZodEnum<{
+                    live: "live";
+                    latched: "latched";
+                }>>;
+                verdict: z.ZodEnum<{
+                    unknown: "unknown";
+                    matched: "matched";
+                    diverged: "diverged";
+                }>;
+                latched: z.ZodBoolean;
+                armedAt: z.ZodNumber;
+                divergedAt: z.ZodNullable<z.ZodNumber>;
+                restoredAt: z.ZodNullable<z.ZodNumber>;
+                quietSeconds: z.ZodDefault<z.ZodNumber>;
+                minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+                confirm: z.ZodOptional<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    prompt: z.ZodString;
+                    profileId: z.ZodOptional<z.ZodString>;
+                    timeoutMs: z.ZodDefault<z.ZodNumber>;
+                    maxImagePx: z.ZodDefault<z.ZodNumber>;
+                    onTimeout: z.ZodDefault<z.ZodEnum<{
+                        flip: "flip";
+                        hold: "hold";
+                    }>>;
+                }, z.core.$strip>>;
+                anchorThreshold: z.ZodDefault<z.ZodNumber>;
+                autoRestore: z.ZodDefault<z.ZodBoolean>;
+                unavailable: z.ZodNullable<z.ZodEnum<{
+                    "no-reference-for-condition": "no-reference-for-condition";
+                    "view-shifted": "view-shifted";
+                    "no-vision-profile": "no-vision-profile";
+                    "encoder-model-changed": "encoder-model-changed";
+                    "no-snapshot": "no-snapshot";
+                }>>;
+                coveredConditions: z.ZodArray<z.ZodString>;
             }, z.core.$strip>>;
             lastFetchedAt: z.ZodNumber;
         }, z.core.$strip>;
@@ -462,6 +758,7 @@ export declare const sceneMonitorCapability: {
                     condition: z.ZodString;
                     capturedAt: z.ZodNumber;
                     thumbnailMediaId: z.ZodOptional<z.ZodString>;
+                    anchorEmbedding: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
                 }, z.core.$strip>>;
                 textPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 referenceCount: z.ZodNumber;
@@ -476,6 +773,43 @@ export declare const sceneMonitorCapability: {
                 unavailable: "unavailable";
             }>;
             unavailableReason: z.ZodNullable<z.ZodString>;
+            baselineStateId: z.ZodNullable<z.ZodString>;
+            emit: z.ZodDefault<z.ZodEnum<{
+                live: "live";
+                latched: "latched";
+            }>>;
+            verdict: z.ZodEnum<{
+                unknown: "unknown";
+                matched: "matched";
+                diverged: "diverged";
+            }>;
+            latched: z.ZodBoolean;
+            armedAt: z.ZodNumber;
+            divergedAt: z.ZodNullable<z.ZodNumber>;
+            restoredAt: z.ZodNullable<z.ZodNumber>;
+            quietSeconds: z.ZodDefault<z.ZodNumber>;
+            minObservationSpacingSec: z.ZodDefault<z.ZodNumber>;
+            confirm: z.ZodOptional<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                prompt: z.ZodString;
+                profileId: z.ZodOptional<z.ZodString>;
+                timeoutMs: z.ZodDefault<z.ZodNumber>;
+                maxImagePx: z.ZodDefault<z.ZodNumber>;
+                onTimeout: z.ZodDefault<z.ZodEnum<{
+                    flip: "flip";
+                    hold: "hold";
+                }>>;
+            }, z.core.$strip>>;
+            anchorThreshold: z.ZodDefault<z.ZodNumber>;
+            autoRestore: z.ZodDefault<z.ZodBoolean>;
+            unavailable: z.ZodNullable<z.ZodEnum<{
+                "no-reference-for-condition": "no-reference-for-condition";
+                "view-shifted": "view-shifted";
+                "no-vision-profile": "no-vision-profile";
+                "encoder-model-changed": "encoder-model-changed";
+                "no-snapshot": "no-snapshot";
+            }>>;
+            coveredConditions: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
         lastFetchedAt: z.ZodNumber;
     }, z.core.$strip>;

package/dist/enums/event-category.d.ts

@@ -203,6 +203,33 @@ export declare enum EventCategory {
      */
     PipelineCameraAssigned = "pipeline.camera-assigned",
     PipelineCameraUnassigned = "pipeline.camera-unassigned",
+    /**
+     * A node the orchestrator would otherwise place cameras on has NO usable
+     * inference device: the operator enabled one or more accelerators there and
+     * the live probe reports every one of them unavailable. Emitted once per
+     * TRANSITION into that state (never per dispatch), and the node is dropped
+     * from the placement candidate set for as long as it holds.
+     *
+     * This exists because the state was previously invisible: little-unraid
+     * absorbed 283k inference errors in a day while still being handed cameras,
+     * and nothing in the system said so.
+     *
+     * A node with no accelerators configured at all is NOT this — its devices
+     * are `disabled`, not `unavailable`, and the runner's default CPU pool
+     * serves it exactly as before.
+     */
+    PipelineNodeInferenceUnavailable = "pipeline.node-inference-unavailable",
+    /**
+     * A camera has an OPEN detection session and has produced no detection at
+     * all for longer than the blind threshold — the camera is being decoded and
+     * inferred and is returning nothing. Emitted once per transition into blind,
+     * per camera.
+     *
+     * The failure it reports: a 1h43 detection blackout on the entrance camera
+     * that nobody noticed, because "a camera that detects nothing" and "a quiet
+     * camera" produce byte-identical silence.
+     */
+    PipelineDetectionBlind = "pipeline.detection-blind",
     /**
      * Per-camera pipeline config was mutated by the orchestrator
      * (3-level settings change via `setAgentAddonDefaults` /

package/dist/enums.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-DxZbWydC.js");
+const require_event_category = require("./event-category-D3gG7oil.js");
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/enums.mjs

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-Cv9dO26A.mjs";
+import { t as EventCategory } from "./event-category-Bxo5yJjt.mjs";
 //#region src/enums/event-source-type.ts
 var EventSourceType = /* @__PURE__ */ function(EventSourceType) {
 	EventSourceType["Addon"] = "addon";

package/dist/{event-category-Cv9dO26A.mjs → event-category-Bxo5yJjt.mjs}

@@ -205,6 +205,33 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["PipelineCameraAssigned"] = "pipeline.camera-assigned";
 	EventCategory["PipelineCameraUnassigned"] = "pipeline.camera-unassigned";
 	/**
+	* A node the orchestrator would otherwise place cameras on has NO usable
+	* inference device: the operator enabled one or more accelerators there and
+	* the live probe reports every one of them unavailable. Emitted once per
+	* TRANSITION into that state (never per dispatch), and the node is dropped
+	* from the placement candidate set for as long as it holds.
+	*
+	* This exists because the state was previously invisible: little-unraid
+	* absorbed 283k inference errors in a day while still being handed cameras,
+	* and nothing in the system said so.
+	*
+	* A node with no accelerators configured at all is NOT this — its devices
+	* are `disabled`, not `unavailable`, and the runner's default CPU pool
+	* serves it exactly as before.
+	*/
+	EventCategory["PipelineNodeInferenceUnavailable"] = "pipeline.node-inference-unavailable";
+	/**
+	* A camera has an OPEN detection session and has produced no detection at
+	* all for longer than the blind threshold — the camera is being decoded and
+	* inferred and is returning nothing. Emitted once per transition into blind,
+	* per camera.
+	*
+	* The failure it reports: a 1h43 detection blackout on the entrance camera
+	* that nobody noticed, because "a camera that detects nothing" and "a quiet
+	* camera" produce byte-identical silence.
+	*/
+	EventCategory["PipelineDetectionBlind"] = "pipeline.detection-blind";
+	/**
 	* Per-camera pipeline config was mutated by the orchestrator
 	* (3-level settings change via `setAgentAddonDefaults` /
 	* `setCameraStepToggle` / `setCameraPipelineForAgent` or a

package/dist/{event-category-DxZbWydC.js → event-category-D3gG7oil.js}

@@ -205,6 +205,33 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["PipelineCameraAssigned"] = "pipeline.camera-assigned";
 	EventCategory["PipelineCameraUnassigned"] = "pipeline.camera-unassigned";
 	/**
+	* A node the orchestrator would otherwise place cameras on has NO usable
+	* inference device: the operator enabled one or more accelerators there and
+	* the live probe reports every one of them unavailable. Emitted once per
+	* TRANSITION into that state (never per dispatch), and the node is dropped
+	* from the placement candidate set for as long as it holds.
+	*
+	* This exists because the state was previously invisible: little-unraid
+	* absorbed 283k inference errors in a day while still being handed cameras,
+	* and nothing in the system said so.
+	*
+	* A node with no accelerators configured at all is NOT this — its devices
+	* are `disabled`, not `unavailable`, and the runner's default CPU pool
+	* serves it exactly as before.
+	*/
+	EventCategory["PipelineNodeInferenceUnavailable"] = "pipeline.node-inference-unavailable";
+	/**
+	* A camera has an OPEN detection session and has produced no detection at
+	* all for longer than the blind threshold — the camera is being decoded and
+	* inferred and is returning nothing. Emitted once per transition into blind,
+	* per camera.
+	*
+	* The failure it reports: a 1h43 detection blackout on the entrance camera
+	* that nobody noticed, because "a camera that detects nothing" and "a quiet
+	* camera" produce byte-identical silence.
+	*/
+	EventCategory["PipelineDetectionBlind"] = "pipeline.detection-blind";
+	/**
 	* Per-camera pipeline config was mutated by the orchestrator
 	* (3-level settings change via `setAgentAddonDefaults` /
 	* `setCameraStepToggle` / `setCameraPipelineForAgent` or a

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

@@ -6464,6 +6464,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof sceneMonitorCapability.methods.recheckNow.output>;
             meta: object;
         }>;
+        resetScene: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof sceneMonitorCapability.methods.resetScene.input>;
+            output: z.infer<typeof sceneMonitorCapability.methods.resetScene.output>;
+            meta: object;
+        }>;
     }>>;
     scriptRunner: TRPCBuiltRouter<{
         ctx: TrpcContext;

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: 933 method paths across 123 capabilities.
+ * Coverage: 934 method paths across 123 capabilities.
  */
 import type { CapabilityMethodAccess } from '../capabilities/capability-definition.js';
 export interface MethodAccessRecord {

package/dist/generated/method-device-selectors.d.ts

@@ -6,7 +6,7 @@
  * system-scope cap that takes a deviceId was previously never device-filtered
  * — see the generator header).
  *
- * Coverage: 330 methods carry a device reference, of which
+ * Coverage: 331 methods carry a device reference, of which
  * 124 are on SYSTEM-scope caps.
  *
  * Only TOP-LEVEL input fields appear here; a nested device id is not