@camstack/addon-post-analysis 1.2.310 → 1.2.312

package/dist/{clip-model-registry-xYrJkXdS.js → clip-model-registry-CRkjjUyj.js}

@@ -941,7 +941,7 @@ var NUMBER_FORMAT_RANGES = {
 	float32: [-34028234663852886e22, 34028234663852886e22],
 	float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
 };
-function pick(schema, mask) {
+function pick$1(schema, mask) {
 	const currDef = schema._zod.def;
 	const checks = currDef.checks;
 	if (checks && checks.length > 0) throw new Error(".pick() cannot be used on object schemas containing refinements");
@@ -5011,7 +5011,7 @@ var ZodObject = /*@__PURE__*/ $constructor("ZodObject", (inst, def) => {
 			return merge(this, other);
 		},
 		pick(mask) {
-			return pick(this, mask);
+			return pick$1(this, mask);
 		},
 		omit(mask) {
 			return omit(this, mask);
@@ -15662,7 +15662,17 @@ var SiteZoneSchema = object({
 var ProviderStatusSchema = object({
 	connected: boolean(),
 	deviceCount: number(),
-	error: string().optional()
+	error: string().optional(),
+	/**
+	* `'orchestrator'`: this provider writes NO camera's `motion` runtime slice
+	* — the orchestrator is its only writer (D696). Set by `BaseDeviceProvider`,
+	* which every provider bundles, so only a provider BUILT from D696-amended
+	* code says it. ABSENT means an older provider that may still write it (raw
+	* VMD writes, a boot seed), and the orchestrator's provider gate keeps that
+	* provider's cameras unwritten (`camera-sensors/motion-slice-provider-gate.ts`)
+	* — the provider twin of the runner's `getLocalLoad().motionSliceWriter`.
+	*/
+	motionSliceWriter: literal("orchestrator").optional()
 });
 object({
 	externalId: string(),
@@ -21758,6 +21768,31 @@ var NcSnoozeSuppressedSchema = object({
 	firstAt: number(),
 	lastAt: number()
 });
+/** The bounds every alarm delay field carries — settings, per-mode overrides, both editors. */
+var NC_ALARM_DELAY_MAX_SEC = 600;
+var NC_ALARM_TRIGGERED_MAX_SEC = 3600;
+var NcAlarmDelaySecSchema = number().int().min(0).max(600);
+var NcAlarmTriggeredSecSchema = number().int().min(0).max(NC_ALARM_TRIGGERED_MAX_SEC);
+var uniqueModes = (entries) => new Set(entries.map((e) => e.mode)).size === entries.length;
+var NcAlarmModeDelaysListSchema = array(object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.optional()
+})).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
+var NcAlarmModeDelaysEditListSchema = array(object({
+	mode: AlarmArmModeSchema,
+	exitDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	entryDelaySec: NcAlarmDelaySecSchema.nullable().optional(),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema.nullable().optional()
+})).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
+/** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
+var NcAlarmNonBlockingEditSchema = object({
+	mode: AlarmArmModeSchema,
+	deviceId: number().int().positive(),
+	/** true = on the list (may be open, does not block); false = off the list (blocks). */
+	nonBlocking: boolean()
+});
 /**
 * The per-mode lists, at most one per mode. Two lists for one mode have no
 * meaning a reader could agree on (union? the last one?), so they are refused
@@ -21766,10 +21801,10 @@ var NcSnoozeSuppressedSchema = object({
 var NcAlarmNonBlockingListSchema = array(object({
 	mode: AlarmArmModeSchema,
 	deviceIds: array(number().int()).max(200)
-})).max(8).refine((lists) => new Set(lists.map((l) => l.mode)).size === lists.length, { message: "nonBlocking: at most one list per arm mode" });
+})).max(8).refine(uniqueModes, { message: "nonBlocking: at most one list per arm mode" });
 /**
-* The three durations the panel's state machine runs on, who hears about its
-* transitions, and which openings each mode tolerates.
+* The three durations — global, and per mode since D697 — the panel's state
+* machine runs on, who hears about its transitions, and which openings each mode tolerates.
 *
 * They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
 * `alarm-panel` is `deviceNative` and its other provider mirrors somebody
@@ -21779,15 +21814,15 @@ var NcAlarmNonBlockingListSchema = array(object({
 */
 var NcAlarmSettingsSchema = object({
 	/** Grace period between arming and the mode taking effect. 0 = immediate. */
-	exitDelaySec: number().int().min(0).max(600),
+	exitDelaySec: NcAlarmDelaySecSchema,
 	/** Grace period between a trigger and the alarm firing. 0 = immediate. */
-	entryDelaySec: number().int().min(0).max(600),
+	entryDelaySec: NcAlarmDelaySecSchema,
 	/**
 	* How long `triggered` lasts before the panel re-arms itself.
 	* **0 = until an operator disarms it** — the behaviour before this field
 	* existed, and therefore what an untouched install keeps doing.
 	*/
-	triggeredDurationSec: number().int().min(0).max(3600),
+	triggeredDurationSec: NcAlarmTriggeredSecSchema,
 	/**
 	* Deprecated by D630 — every transition is announced. Parsed, never read;
 	* remove after one release. Optional so an older admin's patch (which still
@@ -21810,17 +21845,30 @@ var NcAlarmSettingsSchema = object({
 	* per mode is meaningful. Defaulted to `[]` so a blob stored before D630
 	* parses as "every opening blocks" — the behaviour it was written under.
 	*/
-	nonBlocking: NcAlarmNonBlockingListSchema.default([])
+	nonBlocking: NcAlarmNonBlockingListSchema.default([]),
+	/**
+	* Per arm mode, the delays that mode OVERRIDES (D697). A mode with no entry, or an entry
+	* without a field, uses the global value above — so `[]`, the default, is exactly the
+	* behaviour of a blob stored before this field existed. Read through `resolveModeDelays`.
+	*/
+	modeDelays: NcAlarmModeDelaysListSchema.default([])
 });
 /**
 * Every field optional — a tab edits one control at a time.
 *
-* `nonBlocking` is re-declared WITHOUT its default: `.partial()` does not
-* remove an inner `.default()`, so a patch that never named the field would
-* parse to `nonBlocking: []` and wipe every mode's list on an unrelated edit
-* (the same trap {@link NcRulePatchSchema} documents).
+* `nonBlocking` and `modeDelays` are re-declared WITHOUT their defaults:
+* `.partial()` does not remove an inner `.default()`, so a patch that never
+* named the field would parse to `[]` and wipe every mode's list on an
+* unrelated edit (the same trap {@link NcRulePatchSchema} documents). Here
+* `modeDelays` means EDITS, not the stored overrides.
 */
-var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({ nonBlocking: NcAlarmNonBlockingListSchema }).partial();
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.extend({
+	nonBlocking: NcAlarmNonBlockingListSchema,
+	/** Per-mode, per-field edits — NOT the whole list (see NcAlarmModeDelaysEditSchema). */
+	modeDelays: NcAlarmModeDelaysEditListSchema,
+	/** ONE membership change; the panel applies it to the list it holds at its turn. */
+	nonBlockingEdit: NcAlarmNonBlockingEditSchema
+}).partial().refine((p) => p.nonBlocking === void 0 || p.nonBlockingEdit === void 0, { message: "nonBlocking and nonBlockingEdit are exclusive — send the whole lists or one edit" });
 /**
 * What one arm mode actually arms, DERIVED from the enabled rules gated on it.
 * Never authored, never stored — see `alarm-mode-coverage.ts` for why a stored
@@ -21920,6 +21968,28 @@ var NcAlarmConfigSchema = object({
 	*/
 	live: NcAlarmLiveSchema.optional()
 });
+var NcAlarmSensorReadingSchema = _enum([
+	"open",
+	"closed",
+	"unknown",
+	"not-opening"
+]);
+/** One device's state as the alarm reads it — the classifier the arm check uses. */
+var NcAlarmSensorStateSchema = object({
+	deviceId: number().int().positive(),
+	reading: NcAlarmSensorReadingSchema,
+	/** The word as read (`open`, `closed`, `unlocked`, `stopped`, …); null when unknown / not an opening. */
+	state: string().nullable(),
+	/** Why `unknown`: the read failed, or the slice holds no word its cap defines (a placeholder included). */
+	unknownWhy: _enum(["read-failed", "unknown-word"]).nullable(),
+	/** The device manager's liveness as the centre mirrors it; null = not known. */
+	online: boolean().nullable()
+});
+var NcAlarmSensorsInputSchema = object({ deviceIds: array(number().int().positive()).max(500) });
+var NcAlarmSensorsSchema = object({
+	sensors: array(NcAlarmSensorStateSchema),
+	readAt: number().int().nonnegative()
+});
 /**
 * The most seconds of footage any notification rule may ask a camera to retain.
 *
@@ -22179,8 +22249,9 @@ var notificationRulesCapability = {
 		*/
 		getAlarmConfig: method(object({}), NcAlarmConfigSchema, { auth: "admin" }),
 		/**
-		* Patch the settings (durations, recipients, per-mode non-blocking lists;
-		* `announceArm` is accepted and ignored — D630). Returns the WHOLE config,
+		* Patch the settings (durations — global and per mode —, recipients,
+		* per-mode non-blocking lists or one membership edit; `announceArm` is
+		* accepted and ignored — D630). Returns the WHOLE config,
 		* coverage and `live` included, so a
 		* client never has to guess what the server settled on — the panel clamps
 		* and normalises, and a form that re-rendered from its own input would
@@ -22189,7 +22260,15 @@ var notificationRulesCapability = {
 		setAlarmConfig: method(object({ patch: NcAlarmSettingsPatchSchema }), NcAlarmConfigSchema, {
 			kind: "mutation",
 			auth: "admin"
-		})
+		}),
+		/**
+		* The CURRENT state of each asked device as the alarm reads it (D697) — open, closed,
+		* unknown (why) or not an opening, plus liveness. Classified by the same table the arm
+		* check uses (`alarm-openings.ts`), so the editor and the arm can never disagree. The
+		* caller names the ids (the household openings it already holds); at most
+		* `NC_ALARM_SENSORS_MAX`.
+		*/
+		getAlarmSensors: method(NcAlarmSensorsInputSchema, NcAlarmSensorsSchema, { auth: "admin" })
 	}
 };
 /**
@@ -47464,6 +47543,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getAlarmSensors": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getClipRetentionAsks": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -51947,6 +52032,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"notificationRules.getAlarmSensors": [{
+		name: "deviceIds",
+		form: "array",
+		optional: false
+	}],
 	"notificationRules.setDeviceMuted": [{
 		name: "deviceId",
 		form: "single",
@@ -53729,6 +53819,107 @@ function ruleBelongsToAlarm(rule) {
 	if ((rule.conditions.deviceState?.states ?? []).some((s) => s.trim().toLowerCase().startsWith(ARMED_WORD_PREFIX))) return true;
 	return (rule.onTrigger ?? []).some((sequence) => sequence.enabled && sequence.actions.some((step) => step.kind === "cap" && step.cap === ALARM_PANEL_CAP && step.method === ALARM_PANEL_TRIGGER_METHOD));
 }
+var NC_ALARM_DELAY_FIELDS = [
+	"exitDelaySec",
+	"entryDelaySec",
+	"triggeredDurationSec"
+];
+/** The mode's value when it overrides the field, else the global one. */
+function pick(override, global) {
+	return override === void 0 ? {
+		value: global,
+		source: "default"
+	} : {
+		value: override,
+		source: "mode"
+	};
+}
+/** What `mode` actually runs on: its own overrides, the global value for every other field. */
+function resolveModeDelays(settings, mode) {
+	const entry = (settings.modeDelays ?? []).find((e) => e.mode === mode);
+	const exit = pick(entry?.exitDelaySec, settings.exitDelaySec);
+	const entryDelay = pick(entry?.entryDelaySec, settings.entryDelaySec);
+	const triggered = pick(entry?.triggeredDurationSec, settings.triggeredDurationSec);
+	return {
+		exitDelaySec: exit.value,
+		entryDelaySec: entryDelay.value,
+		triggeredDurationSec: triggered.value,
+		source: {
+			exitDelaySec: exit.source,
+			entryDelaySec: entryDelay.source,
+			triggeredDurationSec: triggered.source
+		}
+	};
+}
+/** One field of an entry after an edit: number sets, null clears, undefined keeps. */
+function edited(current, edit) {
+	if (edit === void 0) return current;
+	return edit === null ? void 0 : edit;
+}
+/**
+* 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).
+*/
+function applyModeDelaysEdits(current, edits) {
+	const out = current.map((e) => ({ ...e }));
+	for (const edit of edits) {
+		const at = out.findIndex((e) => e.mode === edit.mode);
+		const base = at >= 0 ? out[at] ?? { mode: edit.mode } : { mode: edit.mode };
+		const next = { mode: edit.mode };
+		const exit = edited(base.exitDelaySec, edit.exitDelaySec);
+		const entry = edited(base.entryDelaySec, edit.entryDelaySec);
+		const triggered = edited(base.triggeredDurationSec, edit.triggeredDurationSec);
+		if (exit !== void 0) next.exitDelaySec = exit;
+		if (entry !== void 0) next.entryDelaySec = entry;
+		if (triggered !== void 0) next.triggeredDurationSec = triggered;
+		if (at >= 0) out[at] = next;
+		else out.push(next);
+	}
+	return out.filter((e) => e.exitDelaySec !== void 0 || e.entryDelaySec !== void 0 || e.triggeredDurationSec !== void 0);
+}
+/**
+* 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.
+*/
+function applyNonBlockingEdit(lists, edit) {
+	const copy = lists.map((l) => ({
+		mode: l.mode,
+		deviceIds: [...l.deviceIds]
+	}));
+	const at = copy.findIndex((l) => l.mode === edit.mode);
+	const held = at >= 0 ? copy[at]?.deviceIds ?? [] : [];
+	const present = held.includes(edit.deviceId);
+	if (edit.nonBlocking === present) return {
+		kind: "applied",
+		lists: copy,
+		changed: false
+	};
+	if (edit.nonBlocking) {
+		if (held.length >= 200) return {
+			kind: "refused",
+			reason: "list-full",
+			mode: edit.mode,
+			max: 200
+		};
+		const next = {
+			mode: edit.mode,
+			deviceIds: [...held, edit.deviceId]
+		};
+		if (at >= 0) copy[at] = next;
+		else copy.push(next);
+	} else {
+		const next = {
+			mode: edit.mode,
+			deviceIds: held.filter((id) => id !== edit.deviceId)
+		};
+		if (at >= 0) copy[at] = next;
+	}
+	return {
+		kind: "applied",
+		lists: copy.filter((l) => l.deviceIds.length > 0),
+		changed: true
+	};
+}
 /**
 * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
 * persists (D640 "a sensor rule fires on the raise, the clear, or both").
@@ -56464,12 +56655,30 @@ Object.defineProperty(exports, "MotionTriggeredBySchema", {
 		return MotionTriggeredBySchema;
 	}
 });
+Object.defineProperty(exports, "NC_ALARM_DELAY_FIELDS", {
+	enumerable: true,
+	get: function() {
+		return NC_ALARM_DELAY_FIELDS;
+	}
+});
+Object.defineProperty(exports, "NC_ALARM_DELAY_MAX_SEC", {
+	enumerable: true,
+	get: function() {
+		return NC_ALARM_DELAY_MAX_SEC;
+	}
+});
 Object.defineProperty(exports, "NC_ALARM_SYSTEM_EVENT_KINDS", {
 	enumerable: true,
 	get: function() {
 		return NC_ALARM_SYSTEM_EVENT_KINDS;
 	}
 });
+Object.defineProperty(exports, "NC_ALARM_TRIGGERED_MAX_SEC", {
+	enumerable: true,
+	get: function() {
+		return NC_ALARM_TRIGGERED_MAX_SEC;
+	}
+});
 Object.defineProperty(exports, "NC_AUDIO_CONFIRM_HITS_DEFAULT", {
 	enumerable: true,
 	get: function() {
@@ -56566,6 +56775,18 @@ Object.defineProperty(exports, "NcAlarmConfigSchema", {
 		return NcAlarmConfigSchema;
 	}
 });
+Object.defineProperty(exports, "NcAlarmSensorsInputSchema", {
+	enumerable: true,
+	get: function() {
+		return NcAlarmSensorsInputSchema;
+	}
+});
+Object.defineProperty(exports, "NcAlarmSensorsSchema", {
+	enumerable: true,
+	get: function() {
+		return NcAlarmSensorsSchema;
+	}
+});
 Object.defineProperty(exports, "NcAlarmSettingsPatchSchema", {
 	enumerable: true,
 	get: function() {
@@ -56884,6 +57105,18 @@ Object.defineProperty(exports, "alarmPanelCapability", {
 		return alarmPanelCapability;
 	}
 });
+Object.defineProperty(exports, "applyModeDelaysEdits", {
+	enumerable: true,
+	get: function() {
+		return applyModeDelaysEdits;
+	}
+});
+Object.defineProperty(exports, "applyNonBlockingEdit", {
+	enumerable: true,
+	get: function() {
+		return applyNonBlockingEdit;
+	}
+});
 Object.defineProperty(exports, "array", {
 	enumerable: true,
 	get: function() {
@@ -57268,6 +57501,12 @@ Object.defineProperty(exports, "resolveLocationMode", {
 		return resolveLocationMode;
 	}
 });
+Object.defineProperty(exports, "resolveModeDelays", {
+	enumerable: true,
+	get: function() {
+		return resolveModeDelays;
+	}
+});
 Object.defineProperty(exports, "resolvePoolMemoryPolicy", {
 	enumerable: true,
 	get: function() {