@camstack/types 1.2.404 → 1.2.406

package/dist/pipeline/second-pass/motion-crop-plan.d.ts

@@ -0,0 +1,183 @@
+/**
+ * The MEASURED motion-crop recipe (D396) — per camera, default off.
+ *
+ * ## What this adds to the pass that already exists
+ *
+ * `small-subject-recovery.ts` ships a second detector pass gated on an
+ * UNCOVERED motion region: a region is worth a crop when it is small AND
+ * mostly NOT accounted for by a full-frame box. That rule was built to find a
+ * subject standing NEXT TO one the detector already sees, and it works.
+ *
+ * The measurement says the cheaper question is the better one. On camera 615,
+ * against the production detector (`yolov9m-320-int8`, python+openvino) on the
+ * node that runs that camera, over 38 visually confirmed positive frames from
+ * six real animal pass-bys: full-frame recall at our animal floor **24%**,
+ * detecting on motion-derived crops **42%**, the same crops with the motion
+ * area bar lowered **74%**. Per pass-by 4/6 → 6/6 at our floor, 3/6 → 6/6 at
+ * a 0.70 floor. The score distribution moves with it — full frame median
+ * 0.780 / p25 0.526, crops 0.840 / p25 0.652.
+ *
+ * So this rule keeps every moving region, and treats a tracked box that
+ * intersects one as a SEED rather than as an exclusion.
+ *
+ * ## Additive, never substitutive
+ *
+ * On frames where motion is silent the crop arm scores 0% and the full-frame
+ * arm still scores 5% — and the full frame is the only arm that can see a
+ * STATIONARY subject at all. Both recipes only ever ADD boxes to the
+ * full-frame result; nothing here can remove one.
+ *
+ * ## Cost
+ *
+ * Mean 0.25 extra detector invocations per frame at the shipped motion
+ * sensitivity and 0.88 at the lowered bar, on the node that would run it. A
+ * crop costs about the same as a full frame (45.2 ms vs 40.8 ms p50) — it is
+ * not cheaper, it is better aimed — and the whole thing is bounded by the
+ * motion duty cycle. The runner's own per-camera rate limit
+ * (`RECOVERY_MIN_INTERVAL_MS`) is the ceiling above that.
+ *
+ * ## What this is NOT (D52)
+ *
+ * Not a detail/CLIP crop, for the same reason `small-subject-recovery.ts` is
+ * not one: `deriveDetailCropRect` derives the rectangle an enrichment step is
+ * fed from a KNOWN subject box, and `object-clip` is one vector index that
+ * tolerates exactly one such derivation. This module derives a square from a
+ * MOTION region, before any subject exists, for the FIRST-LEVEL detector; its
+ * output is a detection, never a vector. Nothing here calls the detail
+ * derivation and nothing here may be reused for one.
+ *
+ * Pure: no runner state, no IPC, no pixels.
+ *
+ * Lives in `@camstack/types` so the live runner (`addon-pipeline`) and the
+ * offline accuracy evaluation (`addon-benchmark`) plan the SAME crops: one
+ * module, two callers, no copy to drift.
+ */
+import type { ObjectDetection } from '../../types/detection.js';
+import type { PipelineStepInputOutput } from '../../capabilities/pipeline-executor.cap.js';
+import { type NormalizedRect, type RecoveryCrop, type RecoveryPlanInput } from './small-subject-recovery.js';
+/**
+ * Which region rule this camera's second pass runs.
+ *
+ * The selector is per camera and defaults to the shipped rule, exactly like
+ * the motion area bar's own `minArea: 0` opt-in (D394): a deploy changes
+ * nothing until an operator moves a camera.
+ */
+export type RecoveryRecipe = 'uncovered-region' | 'motion-crop';
+/**
+ * Step-settings key of the opt-in, on the `object-detection` step — so it is
+ * per camera through `pipelineOrchestrator.setCameraStepSettings` (a
+ * camera-semantic key, D927), and it rides the same
+ * `PipelineStepInputOutput.settings` the per-macro confidence floors ride.
+ */
+export declare const MOTION_CROP_DISPATCH_KEY = "motionCropDispatch";
+/**
+ * Read the opt-in. Anything that is not the boolean `true` is the shipped
+ * rule: a stored string or a number is a mis-write (this repo has shipped a
+ * setting written into the wrong sqlite table before), and a mis-write must
+ * not silently change what a camera detects on.
+ */
+export declare function readRecoveryRecipe(settings: Readonly<Record<string, unknown>> | undefined): RecoveryRecipe;
+/**
+ * The recipe this camera's resolved step tree selects.
+ *
+ * Reads the ENABLED first-level detector's own settings, which is where
+ * `pipelineOrchestrator.setCameraStepSettings` writes a per-camera value. A
+ * tree with no enabled detector runs no second pass at all, so the answer
+ * there is the shipped rule and it is never used.
+ */
+export declare function readRecoveryRecipeForSteps(steps: readonly PipelineStepInputOutput[]): RecoveryRecipe;
+/**
+ * A motion box is grown ×1.5 about its centre before anything else.
+ *
+ * The motion step's box is the CHANGED pixels, which on a moving animal is the
+ * leading edge plus its shadow, not the animal. The detector needs the subject
+ * and the context it was trained on.
+ */
+export declare const MOTION_CROP_MOTION_PAD = 1.5;
+/**
+ * An intersecting tracked box is grown ×1.25 — less, because it is already a
+ * subject rectangle rather than a change mask.
+ */
+export declare const MOTION_CROP_TRACKED_PAD = 1.25;
+/**
+ * Regions per frame, largest area first.
+ *
+ * Measured as NON-BINDING: over the 156 frames of the recall harness the cap
+ * bound on 0 of them. It is the bound on a storm, not a tuning knob, and the
+ * runner reports when it binds so a camera on which it starts to is visible.
+ */
+export declare const MOTION_CROP_MAX_REGIONS = 3;
+/**
+ * The floor a `person` or `vehicle` box must clear when it came out of a CROP
+ * rather than out of the full frame.
+ *
+ * Collected, not assumed: 3 085 quiet frames produced 27 motion-positive
+ * frames and 28 crop invocations. The full-frame arm produced 0 boxes above
+ * any gate; the crop arm produced 3, of which two are genuine false positives,
+ * and both are night-IR corners upscaled into a 320 model — `vehicle 0.749`
+ * and `person 0.701`. Zero false `animal` at any gate, which is why `animal`
+ * is deliberately absent from this table: the class the pass exists to recover
+ * is the class that never produced a false positive, and gating it would cost
+ * the whole measured gain.
+ *
+ * This is a CROP-ONLY floor, applied on top of the per-macro floors the
+ * executor already enforced. A full-frame `person` at 0.70 is untouched — the
+ * full-frame arm is the one arm with ground truth behind its floor
+ * (`minConfidencePerson` 0.65, raised on 2026-07-30 from a measured
+ * distribution).
+ *
+ * The cost of this floor is stated rather than assumed away: it can also
+ * remove a real distant person or vehicle recovered from a crop at 0.70–0.80.
+ * Nothing in the quiet-footage sample measures that, so the floor is a
+ * constant here rather than a slider, and the runner reports every drop it
+ * makes per camera.
+ */
+export declare const CROP_CLASS_FLOORS: Readonly<Record<string, number>>;
+/** One box the crop floor removed, with the numbers that removed it. */
+export interface CropFloorDrop {
+    readonly macroClass: string;
+    readonly score: number;
+    readonly floor: number;
+}
+/** What {@link applyCropClassFloors} kept, and everything it did not. */
+export interface CropFloorVerdict {
+    readonly kept: readonly ObjectDetection[];
+    readonly dropped: readonly CropFloorDrop[];
+}
+/**
+ * Apply the crop-only class floors, REPORTING every drop.
+ *
+ * A class with no entry in {@link CROP_CLASS_FLOORS} is kept: a floor this
+ * table cannot express is not a floor of zero, and silently dropping a class
+ * nobody measured is the exact shape of silent drop this repo has paid for
+ * three separate times.
+ */
+export declare function applyCropClassFloors(detections: readonly ObjectDetection[]): CropFloorVerdict;
+/**
+ * The regions the measured recipe judges this frame on.
+ *
+ * Motion boxes padded {@link MOTION_CROP_MOTION_PAD}; every full-frame box
+ * that intersects a RAW motion box padded {@link MOTION_CROP_TRACKED_PAD} and
+ * added as a seed of its own; everything that overlaps merged; the result
+ * clamped to the frame, ordered largest first and capped at
+ * {@link MOTION_CROP_MAX_REGIONS}.
+ *
+ * There is deliberately no coverage gate and no size gate here. Those belong
+ * to the shipped rule, and they are what makes it a rule about a subject
+ * BESIDE a detected one; the measurement says the pass is worth running on the
+ * detected subject's own region too.
+ */
+export declare function planMotionCropRegions(input: RecoveryPlanInput): readonly NormalizedRect[];
+/**
+ * The crops the measured recipe runs on this frame.
+ *
+ * Dedupe is by CONTAINMENT only. Two squares that merely overlap both run: the
+ * pixels the second adds are pixels no other crop shows the detector, and the
+ * fusion step downstream already refuses a duplicate BOX. Dropping a crop
+ * because it overlapped would drop the subject sitting at its edge, which is
+ * the whole population this pass exists for.
+ *
+ * A frame that cannot hold the smallest crop yields nothing: it is already
+ * seen at scale.
+ */
+export declare function planMotionCrops(input: RecoveryPlanInput): readonly RecoveryCrop[];

package/dist/pipeline/second-pass/small-subject-recovery.d.ts

@@ -0,0 +1,216 @@
+/**
+ * Small-subject recovery — a second detector pass at NATIVE resolution on
+ * the moving regions the full-frame pass did not account for.
+ *
+ * ## Why
+ *
+ * The first-level detector sees the frame at its input size (320 px on every
+ * hardware-aware default). A 4K frame is reduced 12×: a dog measured at
+ * 89–277 px in the source is 7–38 px for the model and is not emitted. Camera 615, six
+ * instants with a dog in the scene, five with no `animal` detection at all —
+ * nothing downstream (tracker, gate, notifications) ever saw a subject. The
+ * confirmation gate, which re-runs the same detector on a 320 px native crop
+ * of the PERSON, found the dog at 0.74–0.91 as `bestIncompatibleClass`. The
+ * measurement that decided the constants below is
+ * `docs/benchmarks/pipeline-frame-model-eval.md`, case `miss-dog-615`: a
+ * 640–800 px native square around the moving region brings the dog to
+ * 0.82–0.91 with the SAME 320 model; a 1280 px square loses it again.
+ *
+ * ## What this is NOT (D52)
+ *
+ * Not a detail/CLIP crop. `deriveDetailCropRect` derives the rectangle a
+ * detail or embedding step is fed from a KNOWN subject box, and one vector
+ * index tolerates exactly one such derivation. This module derives a square
+ * from a MOTION region, before any subject exists, for the FIRST-LEVEL
+ * detector; its output is a detection, never a vector. Nothing here may be
+ * reused for a detail crop, and nothing here calls the detail derivation.
+ *
+ * ## When it runs — NOT only when the frame is empty
+ *
+ * The trigger is an UNCOVERED MOTION REGION, deliberately broader than "the
+ * full-frame pass found nothing". Camera 615, 2026-09-06 19:54:33 local: the
+ * gate DID confirm an `animal` birth (bestScore 0.8983) — and the track held
+ * 9 positions over 1 666 ms, then coasted out its `maxMissedMs` (4 000 ms) and
+ * died at 19:54:39, before the dog reached the Aiuola zone. Both of its object
+ * events carry `zones: []`, while in the same seconds the animal was in fact
+ * at x≈3200, inside the zone. So the defect is not only "the subject is never
+ * born" — it is "the subject is born and then the full-frame pass stops seeing
+ * it", and a pass gated on "no detections at all" would not have run on a
+ * single one of those frames, because the PERSON was still detected.
+ *
+ * Gating on the motion region instead makes the pass fire in both cases with
+ * one rule: a moving thing the full-frame boxes do not account for. A live
+ * track feeding on recovered boxes needs one hit per `maxMissedMs` to survive
+ * and `minHits` (3) to be born; at {@link RECOVERY_MIN_INTERVAL_MS} the pass
+ * supplies 2/s, which is 8× the coasting budget and births a subject in 1.5 s.
+ *
+ * ## Where
+ *
+ * In the runner, in-process, on the frame the full pass just ran on. The
+ * pixels come from the same process-local `frameRef` lease the full pass
+ * used; the crop is resolved as one compressed ≤640 px view. Frames never
+ * cross a process boundary at frame rate (D9/D18) — a second crop of the
+ * same frame on the same channel does not change that.
+ *
+ * Pure: no runner state, no IPC, no pixels. The runner wires the lease, the
+ * executor call and the rate limit around it.
+ *
+ * Lives in `@camstack/types` so the live runner (`addon-pipeline`) and the
+ * offline accuracy evaluation (`addon-benchmark`) plan the SAME crops: one
+ * module, two callers, no copy to drift.
+ */
+import type { ObjectDetection } from '../../types/detection.js';
+import type { PipelineStepInputOutput } from '../../capabilities/pipeline-executor.cap.js';
+/** The object-detection step id — the first-level detector both recipes run. */
+export declare const OBJECT_DETECTION_STEP_ID = "object-detection";
+/** Fraction of a frame, `[0, 1]` on both axes. */
+export interface NormalizedRect {
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+export interface FrameDims {
+    readonly width: number;
+    readonly height: number;
+}
+/** A square of the NATIVE frame, in native pixels. */
+export interface RecoveryCrop {
+    readonly left: number;
+    readonly top: number;
+    readonly side: number;
+}
+/**
+ * Smallest crop side, native pixels. Below this the model no longer
+ * magnifies enough to matter on a 4K frame, and on a 1080p frame 640 is
+ * already a third of the picture. Measured: 480–800 px all recover the dog.
+ */
+export declare const RECOVERY_CROP_MIN_SIDE_PX = 640;
+/**
+ * Largest crop side. A 320 model on a 1024 px square is a 3.2× reduction and
+ * scored the dog at 0.52–0.76; at 1280 px it was absent again. A region wider
+ * than this is tiled, never zoomed out.
+ */
+export declare const RECOVERY_CROP_MAX_SIDE_PX = 800;
+/** Context around the region before squaring, as a fraction of its larger side. */
+export declare const RECOVERY_CROP_PADDING_RATIO = 0.25;
+/**
+ * The view the crop is resolved at, compressed. Never larger than the crop
+ * (the floor is {@link RECOVERY_CROP_MIN_SIDE_PX}), so it never upscales, and
+ * the model letterboxes it to its own input from here as it does the frame.
+ */
+export declare const RECOVERY_VIEW_PX = 640;
+/**
+ * Crops per frame. Each is one more inference on the same pool (15–25 ms on
+ * CoreML for a 640 view); two cover a person-and-dog blob and a second mover.
+ */
+export declare const RECOVERY_MAX_CROPS_PER_FRAME = 2;
+/**
+ * The pass runs at most this often per camera — at 10 fps that is one frame
+ * in five. A subject the full pass misses is missed for seconds, not for one
+ * frame, so the recovery does not need every frame to find it.
+ *
+ * The floor under this number is the tracker: a track coasts for
+ * `maxMissedMs` (4 000 ms by default) before it is dropped, so 2 recoveries a
+ * second keep a subject the full-frame pass has lost ALIVE with 8× margin,
+ * and reach `minHits` (3) in 1.5 s. Raising it past ~1 300 ms would start to
+ * lose tracks between passes.
+ */
+export declare const RECOVERY_MIN_INTERVAL_MS = 500;
+/**
+ * A region larger than this share of the frame is not a small subject: a
+ * lighting change, a car filling the picture, a person at the lens. The
+ * full-frame pass already sees those at scale.
+ */
+export declare const RECOVERY_MAX_REGION_FRAME_FRACTION = 0.25;
+/**
+ * How much of a region must lie OUTSIDE every full-frame detection for the
+ * pass to run on it. A person's own blob (dilated, with shadow) is covered
+ * 70–90% by the person box; a person-and-dog blob is covered ~55% by it.
+ */
+export declare const RECOVERY_MIN_UNCOVERED_FRACTION = 0.35;
+/** Motion regions older than this describe a different frame. */
+export declare const RECOVERY_MOTION_MAX_AGE_MS = 2000;
+/** A recovered box overlapping a same-class full-frame box this much is the same subject. */
+export declare const RECOVERY_FUSE_IOU = 0.5;
+/**
+ * A recovered box CONTAINED this much in a same-class full-frame box is a part
+ * of it — a torso the crop cut out of a person the full pass already has.
+ */
+export declare const RECOVERY_FUSE_CONTAINMENT = 0.7;
+/** A box within this many crop-view pixels of the crop edge was clipped by it. */
+export declare const RECOVERY_EDGE_MARGIN_PX = 2;
+/** Area of a normalised rectangle, never negative. Shared with the D396 recipe. */
+export declare function normalizedArea(r: NormalizedRect): number;
+/**
+ * THE square-placement rule of this pass — one owner, shared by both recipes.
+ *
+ * A crop is a square of `side` native pixels centred where it can be and slid
+ * inside the frame where it cannot. Both region rules place their squares
+ * through this function so a crop means the same rectangle whichever rule
+ * chose the region.
+ */
+export declare function squareAround(centreX: number, centreY: number, side: number, native: FrameDims): RecoveryCrop;
+export interface RecoveryPlanInput {
+    /** Motion regions of this frame, normalised. */
+    readonly regions: readonly NormalizedRect[];
+    /** The full-frame pass's boxes, normalised. */
+    readonly detections: readonly NormalizedRect[];
+    /** The NATIVE frame the crops are cut from. */
+    readonly native: FrameDims;
+}
+/**
+ * The crops the second pass runs on this frame — possibly none.
+ *
+ * A region qualifies when it is small (`RECOVERY_MAX_REGION_FRAME_FRACTION`)
+ * and mostly uncovered by the full-frame boxes
+ * (`RECOVERY_MIN_UNCOVERED_FRACTION`). Qualifying regions are served largest
+ * uncovered area first under `RECOVERY_MAX_CROPS_PER_FRAME`; a crop whose
+ * centre already lies inside a planned crop is folded into it. A frame that
+ * cannot hold the smallest crop yields nothing: it is already seen at scale.
+ */
+/** Why a motion region is, or is not, worth a native crop. */
+export type RecoveryRegionVerdict = 'eligible' | 'too-large' | 'covered';
+/** How the regions of one frame fell against the two gates. */
+export interface RecoverySkipCounts {
+    readonly tooLarge: number;
+    readonly covered: number;
+    readonly eligible: number;
+}
+/**
+ * WHY A FRAME PLANNED NO CROP, AS A NUMBER (D378).
+ *
+ * The pass report counts the passes that RAN, so "the second pass stops running
+ * when a person is beside the dog" — a plausible reading of
+ * {@link RECOVERY_MAX_REGION_FRAME_FRACTION} and
+ * {@link RECOVERY_MIN_UNCOVERED_FRACTION}, and a live hypothesis on camera 615
+ * — could not be confirmed or killed from the logs at all. This classifies the
+ * regions a frame offered, against the same predicate the planner filters on.
+ */
+export declare function countRecoverySkips(input: RecoveryPlanInput): RecoverySkipCounts;
+export declare function planRecoveryCrops(input: RecoveryPlanInput): readonly RecoveryCrop[];
+/**
+ * Boxes the executor produced on the crop VIEW → the result's own space.
+ *
+ * Three spaces meet here: the view the model saw (`view`, ≤640 px), the native
+ * square it was cut from (`crop`, native px) and the space the full-frame
+ * result reports in (`result`, native px on the `frameRef` path, the inline
+ * ≤640 view otherwise). A box touching the view edge was clipped by the crop
+ * and is dropped: half a person is not a person, and the tracker would take
+ * the half as the whole.
+ */
+export declare function remapCropDetections(detections: readonly ObjectDetection[], crop: RecoveryCrop, view: FrameDims, result: FrameDims, native: FrameDims): readonly ObjectDetection[];
+/**
+ * Class-aware NMS of the recovered boxes against the full-frame ones. Every
+ * full-frame box is kept as it is — the second pass only ADDS. A recovered box
+ * is added when no full-frame box of the same macro class is the same subject
+ * (`RECOVERY_FUSE_IOU`) or contains it (`RECOVERY_FUSE_CONTAINMENT`). Ids are
+ * re-minted so a crop's `d0` cannot collide with the frame's.
+ */
+export declare function fuseRecoveredDetections(full: readonly ObjectDetection[], recovered: readonly ObjectDetection[]): readonly ObjectDetection[];
+/**
+ * The step the second pass runs: the enabled first-level object detector of
+ * the camera's own tree, with its own model and no children. Same model as
+ * the full pass so a recovered box is comparable to a full-frame one.
+ */
+export declare function selectRecoveryStep(steps: readonly PipelineStepInputOutput[]): PipelineStepInputOutput | null;

package/dist/running-state/assignment.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure builder for Customize → Running assignment (D933). Same contract as
+ * admin-ui battery presets: returns null when the source cannot be expressed.
+ */
+import type { CompositionFieldsFeature, CompositionSourceRef } from '../composition/composition.js';
+import type { CompositionFieldKind } from '../composition/composition-report.js';
+export type PresetMode = 'add' | 'replace';
+export interface RunningAssignmentSource {
+    readonly source: CompositionSourceRef;
+    readonly cap: string;
+    readonly fieldPath: string;
+    readonly kind: CompositionFieldKind;
+}
+export interface RunningAssignmentInput {
+    readonly mode: PresetMode;
+    readonly target: CompositionSourceRef;
+    readonly source: RunningAssignmentSource;
+    readonly changedAtField: string | null;
+    readonly invert: boolean;
+    readonly thresholdWatts: number;
+    readonly startDelayMs: number;
+    readonly stopDelayMs: number;
+}
+export declare function runningAssignmentFeature(input: RunningAssignmentInput): CompositionFieldsFeature | null;
+export interface RunningAssignmentRecovered {
+    readonly source: RunningAssignmentSource;
+    readonly invert: boolean;
+    readonly thresholdWatts: number;
+    readonly startDelayMs: number;
+    readonly stopDelayMs: number;
+}
+/** Recover what {@link runningAssignmentFeature} wrote, else null. */
+export declare function runningAssignmentRecovered(stored: CompositionFieldsFeature, target: CompositionSourceRef): RunningAssignmentRecovered | null;
+export declare function isRunningAssignmentFeature(stored: CompositionFieldsFeature, mode: PresetMode, target: CompositionSourceRef): boolean;

package/dist/running-state/defaults.d.ts

@@ -0,0 +1,3 @@
+export declare const RUNNING_POWER_THRESHOLD_WATTS = 5;
+export declare const RUNNING_POWER_START_DELAY_MS = 30000;
+export declare const RUNNING_POWER_STOP_DELAY_MS = 180000;

package/dist/running-state/from-operation.d.ts

@@ -0,0 +1,14 @@
+import type { DishwasherOperationState } from '../capabilities/dishwasher.cap.js';
+import type { LawnMowerActivity } from '../capabilities/lawn-mower-control.cap.js';
+import type { MediaPlayerState } from '../capabilities/media-player.cap.js';
+import type { VacuumState } from '../capabilities/vacuum-control.cap.js';
+import type { RunningStateStatus } from '../capabilities/running-state.cap.js';
+/** Prior boolean clock used when republishing without moving `since`. */
+export interface RunningStatePrevious {
+    readonly running: boolean | null;
+    readonly since: number | null;
+}
+export declare function runningFromDishwasherOperation(operation: DishwasherOperationState | null, program: string | null, previous: RunningStatePrevious | undefined, now: number): RunningStateStatus;
+export declare function runningFromVacuumState(state: VacuumState | null, previous: RunningStatePrevious | undefined, now: number): RunningStateStatus;
+export declare function runningFromLawnMower(activity: LawnMowerActivity | null, previous: RunningStatePrevious | undefined, now: number): RunningStateStatus;
+export declare function runningFromMediaPlayer(state: MediaPlayerState | null, previous: RunningStatePrevious | undefined, now: number): RunningStateStatus;

package/dist/{sleep-CHIEEJkY.mjs → sleep-CYfIZzGv.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-fDPduoeC.mjs";
+import { t as EventCategory } from "./event-category-Ceif8n-v.mjs";
 import { z } from "zod";
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -504,7 +504,7 @@ var WELL_KNOWN_TAB_MAP = Object.fromEntries(WELL_KNOWN_TABS.map((t) => [t.id, t]
 * `hydrateSchema` to skip the `value` injection for structural-only fields.
 */
 function isValuelessField(field) {
-	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
+	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button" || field.type === "account-sign-in" || field.type === "secret-presence";
 }
 /**
 * Base collector: flatten a hydrated `ConfigUISchemaWithValues` into
@@ -7327,6 +7327,7 @@ function createDeviceProxy(api, binding, opts) {
 		getStatus: (input) => dispatch("recording-onboard", "recordingOnboard", "getStatus", "query", input)
 	};
 	const recordingSignalInterface = { getStatus: (input) => dispatch("recording-signal", "recordingSignal", "getStatus", "query", input) };
+	const runningStateInterface = { getStatus: (input) => dispatch("running-state", "runningState", "getStatus", "query", input) };
 	const sceneMonitorInterface = {
 		listScenes: (input) => dispatch("scene-monitor", "sceneMonitor", "listScenes", "query", input),
 		listScenesBatch: (input) => dispatch("scene-monitor", "sceneMonitor", "listScenesBatch", "query", input),
@@ -7653,6 +7654,7 @@ function createDeviceProxy(api, binding, opts) {
 			ptzAutotrack: createSliceHandle(stateSource, binding.deviceId, "ptz-autotrack"),
 			recordingOnboard: createSliceHandle(stateSource, binding.deviceId, "recording-onboard"),
 			recordingSignal: createSliceHandle(stateSource, binding.deviceId, "recording-signal"),
+			runningState: createSliceHandle(stateSource, binding.deviceId, "running-state"),
 			sceneMonitor: createSliceHandle(stateSource, binding.deviceId, "scene-monitor"),
 			scriptRunner: createSliceHandle(stateSource, binding.deviceId, "script-runner"),
 			smoke: createSliceHandle(stateSource, binding.deviceId, "smoke"),
@@ -7741,6 +7743,7 @@ function createDeviceProxy(api, binding, opts) {
 		...bound("recording") ? { recording: recordingInterface } : {},
 		...bound("recording-onboard") ? { recordingOnboard: recordingOnboardInterface } : {},
 		...bound("recording-signal") ? { recordingSignal: recordingSignalInterface } : {},
+		...bound("running-state") ? { runningState: runningStateInterface } : {},
 		...bound("scene-monitor") ? { sceneMonitor: sceneMonitorInterface } : {},
 		...bound("script-runner") ? { scriptRunner: scriptRunnerInterface } : {},
 		...bound("smoke") ? { smoke: smokeInterface } : {},
@@ -7791,7 +7794,7 @@ function createDeviceProxy(api, binding, opts) {
 * can answer "may a rule actuate this?" without importing the schema barrel
 * (~144MB RSS per runner, D28).
 *
-* Coverage: 90 device-scoped capabilities.
+* Coverage: 91 device-scoped capabilities.
 */
 var DEVICE_SCOPED_CAPS = new Set([
 	"accessories",
@@ -7863,6 +7866,7 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"recording",
 	"recording-onboard",
 	"recording-signal",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"smoke",

package/dist/{sleep-BKS4OPMo.js → sleep-UP964hNP.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-CXrwjC3e.js");
+const require_event_category = require("./event-category-DG6Vir8Z.js");
 let zod = require("zod");
 //#region src/audio/audio-chunk-format.ts
 /**
@@ -504,7 +504,7 @@ var WELL_KNOWN_TAB_MAP = Object.fromEntries(WELL_KNOWN_TABS.map((t) => [t.id, t]
 * `hydrateSchema` to skip the `value` injection for structural-only fields.
 */
 function isValuelessField(field) {
-	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button";
+	return field.type === "separator" || field.type === "info" || field.type === "qr-code" || field.type === "button" || field.type === "object-array" || field.type === "widget" || field.type === "addon-action-button" || field.type === "device-action-button" || field.type === "account-sign-in" || field.type === "secret-presence";
 }
 /**
 * Base collector: flatten a hydrated `ConfigUISchemaWithValues` into
@@ -7327,6 +7327,7 @@ function createDeviceProxy(api, binding, opts) {
 		getStatus: (input) => dispatch("recording-onboard", "recordingOnboard", "getStatus", "query", input)
 	};
 	const recordingSignalInterface = { getStatus: (input) => dispatch("recording-signal", "recordingSignal", "getStatus", "query", input) };
+	const runningStateInterface = { getStatus: (input) => dispatch("running-state", "runningState", "getStatus", "query", input) };
 	const sceneMonitorInterface = {
 		listScenes: (input) => dispatch("scene-monitor", "sceneMonitor", "listScenes", "query", input),
 		listScenesBatch: (input) => dispatch("scene-monitor", "sceneMonitor", "listScenesBatch", "query", input),
@@ -7653,6 +7654,7 @@ function createDeviceProxy(api, binding, opts) {
 			ptzAutotrack: createSliceHandle(stateSource, binding.deviceId, "ptz-autotrack"),
 			recordingOnboard: createSliceHandle(stateSource, binding.deviceId, "recording-onboard"),
 			recordingSignal: createSliceHandle(stateSource, binding.deviceId, "recording-signal"),
+			runningState: createSliceHandle(stateSource, binding.deviceId, "running-state"),
 			sceneMonitor: createSliceHandle(stateSource, binding.deviceId, "scene-monitor"),
 			scriptRunner: createSliceHandle(stateSource, binding.deviceId, "script-runner"),
 			smoke: createSliceHandle(stateSource, binding.deviceId, "smoke"),
@@ -7741,6 +7743,7 @@ function createDeviceProxy(api, binding, opts) {
 		...bound("recording") ? { recording: recordingInterface } : {},
 		...bound("recording-onboard") ? { recordingOnboard: recordingOnboardInterface } : {},
 		...bound("recording-signal") ? { recordingSignal: recordingSignalInterface } : {},
+		...bound("running-state") ? { runningState: runningStateInterface } : {},
 		...bound("scene-monitor") ? { sceneMonitor: sceneMonitorInterface } : {},
 		...bound("script-runner") ? { scriptRunner: scriptRunnerInterface } : {},
 		...bound("smoke") ? { smoke: smokeInterface } : {},
@@ -7791,7 +7794,7 @@ function createDeviceProxy(api, binding, opts) {
 * can answer "may a rule actuate this?" without importing the schema barrel
 * (~144MB RSS per runner, D28).
 *
-* Coverage: 90 device-scoped capabilities.
+* Coverage: 91 device-scoped capabilities.
 */
 var DEVICE_SCOPED_CAPS = new Set([
 	"accessories",
@@ -7863,6 +7866,7 @@ var DEVICE_SCOPED_CAPS = new Set([
 	"recording",
 	"recording-onboard",
 	"recording-signal",
+	"running-state",
 	"scene-monitor",
 	"script-runner",
 	"smoke",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/types",
-  "version": "1.2.404",
+  "version": "1.2.406",
   "description": "Shared types, interfaces, and model catalogs for the CamStack detection ecosystem",
   "keywords": [
     "camstack",