@camstack/types 1.2.283 → 1.2.285

package/dist/interfaces/event-bus.d.ts

@@ -79,6 +79,10 @@ export interface MotionAnalysisPayload {
 export type MotionOnMotionChangedPayload = import('../capabilities/motion.cap.js').MotionOnMotionChangedData & {
     [key: string]: unknown;
 };
+/** A camera's RAW onboard push (D673) — see `pipeline/provider-motion.ts`. */
+export type ProviderMotionPayload = import('../pipeline/provider-motion.js').ProviderMotionData & {
+    [key: string]: unknown;
+};
 /** Raw motion zone from CCL (before minArea filter). */
 export interface MotionRawZone {
     readonly bbox: readonly [number, number, number, number];
@@ -1055,9 +1059,7 @@ export interface EventCatalog {
         deviceId: number;
         addonId?: string;
     };
-    'provider.motion': {
-        active: boolean;
-    };
+    'provider.motion': ProviderMotionPayload;
     'provider.detection': {
         detections: unknown;
     };

package/dist/interfaces/pipeline-runner-capability.d.ts

@@ -165,6 +165,8 @@ export interface RunnerLocalLoad {
      *  / pre-multi-device runners. */
     readonly devices: readonly RunnerDeviceLoad[];
     readonly hardware: RunnerHardwareCapabilities;
+    /** D696: `'orchestrator'` = this runner never writes a camera's `motion` slice. Absent = an older runner, which does. */
+    readonly motionSliceWriter?: 'orchestrator';
 }
 /**
  * Aggregate runtime metrics for a runner's whole local pool. Mirrors the

package/dist/node.js

@@ -21,7 +21,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-const require_composition = require("./composition-DG4jVTfB.js");
+const require_composition = require("./composition-w3gBWMer.js");
 const require_err_msg = require("./err-msg-Dx2Kor0g.js");
 let node_crypto = require("node:crypto");
 let node_fs = require("node:fs");

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { Ct as chooseFfmpegBinary, Dt as getFfmpegDownloadUrl, Et as getFfmpegArtifact, Lt as isSoftwareDecode, Nt as buildFfmpegArgs, Ot as canonicalHash, P as compositionSourceKey, St as FFMPEG_PATH_ENV, Tt as FFMPEG_RELEASE, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, kt as Fmp4BoxSplitter, wt as ffmpegBinaryName } from "./composition-Dq42XWp0.mjs";
+import { Ct as chooseFfmpegBinary, Dt as getFfmpegDownloadUrl, Et as getFfmpegArtifact, Lt as isSoftwareDecode, Nt as buildFfmpegArgs, Ot as canonicalHash, P as compositionSourceKey, St as FFMPEG_PATH_ENV, Tt as FFMPEG_RELEASE, a as CUSTOMIZATION_BLOCK_NAME_PREFIX, kt as Fmp4BoxSplitter, wt as ffmpegBinaryName } from "./composition-43aqsZQj.mjs";
 import { t as errMsg } from "./err-msg-DX6i_MY4.mjs";
 import { createHash, createHmac, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs";

package/dist/notification/alarm-settings.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Alarm settings, as pure functions (D697). Inheritance of per-mode delays, application of a
+ * patch's per-field edits and single-membership edit, and the "did my patch land" check.
+ *
+ * The engine and both clients call these; nobody re-implements them. No I/O, no clock.
+ */
+import type { AlarmArmMode } from '../capabilities/alarm-panel.cap.js';
+import { type NcAlarmModeDelays, type NcAlarmModeDelaysEdit, type NcAlarmNonBlocking, type NcAlarmNonBlockingEdit, type NcAlarmSettings, type NcAlarmSettingsPatch } from '../capabilities/notification-rules.cap.js';
+export type NcAlarmDelayField = 'exitDelaySec' | 'entryDelaySec' | 'triggeredDurationSec';
+export declare const NC_ALARM_DELAY_FIELDS: readonly NcAlarmDelayField[];
+export type NcAlarmDelaySource = 'mode' | 'default';
+export interface NcAlarmResolvedDelays {
+    readonly exitDelaySec: number;
+    readonly entryDelaySec: number;
+    readonly triggeredDurationSec: number;
+    readonly source: Readonly<Record<NcAlarmDelayField, NcAlarmDelaySource>>;
+}
+/**
+ * A settings answer as it travels on the wire. Clients do not parse answers, so a hub older
+ * than D697 sends no `modeDelays` (nor, before D636, `nonBlocking`); every reader here treats an absent key as "no overrides".
+ */
+export type NcAlarmSettingsAnswer = Omit<NcAlarmSettings, 'modeDelays' | 'nonBlocking'> & {
+    readonly modeDelays?: readonly NcAlarmModeDelays[];
+    /** Absent on a hub older than D636: read as "no lists". */
+    readonly nonBlocking?: readonly NcAlarmNonBlocking[];
+};
+export type NcAlarmDelaySettings = Pick<NcAlarmSettingsAnswer, NcAlarmDelayField | 'modeDelays'>;
+/** What `mode` actually runs on: its own overrides, the global value for every other field. */
+export declare function resolveModeDelays(settings: NcAlarmDelaySettings, mode: AlarmArmMode): NcAlarmResolvedDelays;
+/**
+ * Apply per-field edits to the stored overrides. Returns new arrays, never mutates the input;
+ * an entry with no field left is dropped (the mode inherits everything again).
+ */
+export declare function applyModeDelaysEdits(current: readonly NcAlarmModeDelays[], edits: readonly NcAlarmModeDelaysEdit[]): NcAlarmModeDelays[];
+export type NcAlarmNonBlockingEditResult = {
+    readonly kind: 'applied';
+    readonly lists: NcAlarmNonBlocking[];
+    readonly changed: boolean;
+} | {
+    readonly kind: 'refused';
+    readonly reason: 'list-full';
+    readonly mode: AlarmArmMode;
+    readonly max: number;
+};
+/**
+ * Put ONE device on, or take it off, ONE mode's list. A no-op answers `changed: false`; an add
+ * to a full list is REFUSED by reason (never silently dropped); an emptied list drops its entry.
+ */
+export declare function applyNonBlockingEdit(lists: readonly NcAlarmNonBlocking[], edit: NcAlarmNonBlockingEdit): NcAlarmNonBlockingEditResult;
+/**
+ * True iff every key the patch sent is reflected in what the host returned. A host older than
+ * this build strips the keys it does not know; this is how a client tells "saved" from "parsed
+ * and dropped". `announceArm` is ignored (parsed, never read). A `null` clear "lands" on a host
+ * that stripped the key (it lacks the field) — harmless, because such a host stores no overrides.
+ * A whole-list `nonBlocking` naming a mode the panel does not offer reads as "not landed" (the host
+ * drops it); only older clients and the prune send whole lists, and they do not call this.
+ */
+export declare function alarmPatchLanded(patch: NcAlarmSettingsPatch, returned: NcAlarmSettingsAnswer): boolean;

package/dist/pipeline/camera-sensors.d.ts

@@ -28,18 +28,45 @@ export declare const CameraSensorRefSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type CameraSensorRef = z.infer<typeof CameraSensorRefSchema>;
 export declare function cameraSensorRefKey(ref: CameraSensorRef): string;
-/** CS-1 accepts exactly one mode; CS-2 (D673) widens it to confirm / replace. */
-export declare const CameraSensorsModeSchema: z.ZodEnum<{
+/**
+ * A sensor's mode (D673). `in-addition`: its motion is the camera's motion too.
+ * `replace`: its motion is the camera's, and while one is READY the camera's
+ * own motion no longer counts on its own. `confirm`: while one is READY the
+ * camera's own motion counts only while a confirm sensor is active — with or
+ * without a replace sensor (spec C2, the controller's ruling on Q1).
+ */
+export declare const CameraSensorModeSchema: z.ZodEnum<{
     "in-addition": "in-addition";
+    confirm: "confirm";
+    replace: "replace";
 }>;
-export type CameraSensorsMode = z.infer<typeof CameraSensorsModeSchema>;
-export declare const CameraSensorsConfigSchema: z.ZodObject<{
-    mode: z.ZodEnum<{
+export type CameraSensorMode = z.infer<typeof CameraSensorModeSchema>;
+/** A stored sensor with no mode — every CS-1 row — is in addition. */
+export declare const DEFAULT_CAMERA_SENSOR_MODE: CameraSensorMode;
+export declare const CameraSensorEntrySchema: z.ZodObject<{
+    addonId: z.ZodString;
+    stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
         "in-addition": "in-addition";
-    }>;
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
+}, z.core.$strip>;
+export type CameraSensorEntry = z.infer<typeof CameraSensorEntrySchema>;
+/**
+ * A camera's attached sensors. A CS-1 row carried an envelope
+ * `mode: 'in-addition'`: `z.object` drops it on parse, and the PARSED value is
+ * what the write stores (D672 rule 3), so it is never written again.
+ */
+export declare const CameraSensorsConfigSchema: z.ZodObject<{
     sensors: z.ZodArray<z.ZodObject<{
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type CameraSensorsConfig = z.infer<typeof CameraSensorsConfigSchema>;
@@ -50,6 +77,11 @@ export declare const CameraSensorAttachmentSchema: z.ZodDiscriminatedUnion<[z.Zo
     caps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     addonId: z.ZodString;
     stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "in-addition": "in-addition";
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"offline">;
     deviceId: z.ZodNumber;
@@ -60,11 +92,21 @@ export declare const CameraSensorAttachmentSchema: z.ZodDiscriminatedUnion<[z.Zo
     }>;
     addonId: z.ZodString;
     stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "in-addition": "in-addition";
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"missing">;
     reason: z.ZodString;
     addonId: z.ZodString;
     stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "in-addition": "in-addition";
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"unsupported">;
     deviceId: z.ZodNumber;
@@ -72,11 +114,21 @@ export declare const CameraSensorAttachmentSchema: z.ZodDiscriminatedUnion<[z.Zo
     reason: z.ZodString;
     addonId: z.ZodString;
     stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "in-addition": "in-addition";
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"unreadable">;
     reason: z.ZodString;
     addonId: z.ZodString;
     stableId: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        "in-addition": "in-addition";
+        confirm: "confirm";
+        replace: "replace";
+    }>>;
 }, z.core.$strip>], "state">;
 export type CameraSensorAttachment = z.infer<typeof CameraSensorAttachmentSchema>;
 /**
@@ -91,16 +143,55 @@ export declare const CameraSensorsNotForwardedSchema: z.ZodEnum<{
     "no-active-detection": "no-active-detection";
 }>;
 export type CameraSensorsNotForwarded = z.infer<typeof CameraSensorsNotForwardedSchema>;
+/** Whether the camera's OWN motion counts on its own (D673 C2), from its READY sensors (C3). */
+export declare const CameraOwnMotionSchema: z.ZodEnum<{
+    never: "never";
+    always: "always";
+    "when-confirmed": "when-confirmed";
+}>;
+export type CameraOwnMotion = z.infer<typeof CameraOwnMotionSchema>;
+/** Confirm / Replace cannot suppress this camera's motion: its provider still emits it directly (D673 C13). */
+export declare const CameraSensorsNotEnforcedSchema: z.ZodEnum<{
+    "provider-not-split": "provider-not-split";
+}>;
+export type CameraSensorsNotEnforced = z.infer<typeof CameraSensorsNotEnforcedSchema>;
+/**
+ * The camera's OWN onboard motion (D696): the raw input the bridge combines,
+ * never the effective value. The camera's `motion` slice is the effective one,
+ * so a view of the camera's own row reads this.
+ * - `atMs`: when the bridge received the camera's last own edge.
+ * - `detected`: evaluated WHEN THE STATUS IS ASKED — the last edge said `true`
+ *   AND it is younger than the window the bridge counts the camera's own motion
+ *   for (`motionCooldownMs`, floored at two sustain ticks). A camera that never
+ *   sends a clear (heartbeats only) therefore reads `false` once no push came
+ *   within the window; a status read is a snapshot, so a live view re-asks.
+ * Absent = this orchestrator has not received the camera's own motion since it
+ * started (unknown, never "quiet"), or an orchestrator older than D696.
+ */
+export declare const CameraRawLevelSchema: z.ZodObject<{
+    detected: z.ZodBoolean;
+    atMs: z.ZodNumber;
+}, z.core.$strip>;
+export type CameraRawLevel = z.infer<typeof CameraRawLevelSchema>;
 export declare const CameraSensorsStatusSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     state: z.ZodLiteral<"not-configured">;
+    cameraLevel: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        atMs: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"unreadable">;
     reason: z.ZodString;
+    cameraLevel: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        atMs: z.ZodNumber;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     state: z.ZodLiteral<"configured">;
-    mode: z.ZodEnum<{
-        "in-addition": "in-addition";
-    }>;
+    cameraLevel: z.ZodOptional<z.ZodObject<{
+        detected: z.ZodBoolean;
+        atMs: z.ZodNumber;
+    }, z.core.$strip>>;
     sensors: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         state: z.ZodLiteral<"ready">;
         deviceId: z.ZodNumber;
@@ -108,6 +199,11 @@ export declare const CameraSensorsStatusSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         caps: z.ZodReadonly<z.ZodArray<z.ZodString>>;
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         state: z.ZodLiteral<"offline">;
         deviceId: z.ZodNumber;
@@ -118,11 +214,21 @@ export declare const CameraSensorsStatusSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         }>;
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         state: z.ZodLiteral<"missing">;
         reason: z.ZodString;
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         state: z.ZodLiteral<"unsupported">;
         deviceId: z.ZodNumber;
@@ -130,16 +236,34 @@ export declare const CameraSensorsStatusSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         reason: z.ZodString;
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>, z.ZodObject<{
         state: z.ZodLiteral<"unreadable">;
         reason: z.ZodString;
         addonId: z.ZodString;
         stableId: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+            "in-addition": "in-addition";
+            confirm: "confirm";
+            replace: "replace";
+        }>>;
     }, z.core.$strip>], "state">>>;
+    cameraMotion: z.ZodOptional<z.ZodEnum<{
+        never: "never";
+        always: "always";
+        "when-confirmed": "when-confirmed";
+    }>>;
     notForwarded: z.ZodOptional<z.ZodEnum<{
         "onboard-not-listed": "onboard-not-listed";
         "no-active-detection": "no-active-detection";
     }>>;
+    notEnforced: z.ZodOptional<z.ZodEnum<{
+        "provider-not-split": "provider-not-split";
+    }>>;
 }, z.core.$strip>], "state">;
 export type CameraSensorsStatus = z.infer<typeof CameraSensorsStatusSchema>;
 /** What a camera reads before its first settings read ANSWERED (D315). */

package/dist/pipeline/motion-ownership.d.ts

@@ -0,0 +1,13 @@
+/**
+ * D475's rule, in ONE place: a camera whose `motionSources` lists anything
+ * other than `'analyzer'` (firmware `onboard`, a device's own
+ * `device-activity`) owns its motion through that SENSOR, and the analyzer
+ * never re-describes it — even when the list carries `'analyzer'` too. A
+ * camera with `['analyzer']` alone is driven by the analyzer.
+ *
+ * Read by the runner (which analyzer edge reaches its phase machine) and by
+ * the orchestrator's camera motion slice (which motion events the slice
+ * counts, D696). Two copies of the rule would be two authorities.
+ */
+import type { MotionSources } from '../capabilities/pipeline-runner.cap.js';
+export declare function cameraOwnsMotionViaSensor(motionSources: MotionSources): boolean;

package/dist/pipeline/provider-motion.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A camera provider's RAW onboard motion push (D673). Providers emit THIS —
+ * never `MotionOnMotionChanged` — and the orchestrator's camera-sensors bridge
+ * is the one emitter of the camera's EFFECTIVE onboard motion (a pass-through
+ * for a camera with no attached sensor). Guarded by
+ * `scripts/check-onboard-motion-emitters.ts`.
+ */
+import type { z } from 'zod';
+import { EventCategory } from '../enums/event-category.js';
+import { type EventSource, type TypedSystemEvent } from '../interfaces/event-bus.js';
+/** The motion event's data without `triggeredBy`: only the bridge names a trigger. */
+export declare const ProviderMotionDataSchema: z.ZodObject<{
+    timestamp: z.ZodNumber;
+    deviceId: z.ZodNumber;
+    detected: z.ZodBoolean;
+    source: z.ZodEnum<{
+        onboard: "onboard";
+        analyzer: "analyzer";
+        "device-activity": "device-activity";
+    }>;
+    regions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        bbox: z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            w: z.ZodNumber;
+            h: z.ZodNumber;
+        }, z.core.$strip>;
+        pixelCount: z.ZodNumber;
+        intensity: z.ZodNumber;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>;
+export type ProviderMotionData = z.infer<typeof ProviderMotionDataSchema>;
+export declare function providerMotionEvent(source: EventSource, data: ProviderMotionData): TypedSystemEvent<EventCategory.ProviderMotion>;

package/dist/{sleep-gU6hqv4_.mjs → sleep-CDCONfkt.mjs}

@@ -1,4 +1,4 @@
-import { t as EventCategory } from "./event-category-C5xZWqz6.mjs";
+import { t as EventCategory } from "./event-category-BGmz_oxW.mjs";
 import { z } from "zod";
 //#region src/audio/audio-chunk-format.ts
 /**

package/dist/{sleep-DCbD8sdg.js → sleep-G4F3X9X_.js}

@@ -1,4 +1,4 @@
-const require_event_category = require("./event-category-MbnB-6AN.js");
+const require_event_category = require("./event-category-DmS_tLsU.js");
 let zod = require("zod");
 //#region src/audio/audio-chunk-format.ts
 /**

package/dist/utils/addon-id.d.ts

@@ -17,8 +17,8 @@
  * So `entry.providerAddonId === this.ctx.id` is silently, permanently false
  * for a builtin — and only for a builtin, which is why it survives a green
  * suite whose fake supplies the bare id. That is exactly how camera 615's
- * virtual doorbell latched `unbound` for twelve hours on 2026-08-07 while its
- * binding was intact ([D72](../../../../docs/decisions/adr-0072.md)).
+ * virtual doorbell (retired since, D671) latched `unbound` for twelve hours on
+ * 2026-08-07 while its binding was intact ([D72](../../../../docs/decisions/adr-0072.md)).
  *
  * Route every comparison between `ctx.id` and a registry/store addon id
  * through {@link isSameAddonId}. `scripts/check-addon-id-comparison.ts`

package/package.json

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