@camstack/addon-post-analysis 1.2.319 → 1.2.320

package/dist/pipeline-analytics/index.mjs

@@ -1,4 +1,4 @@
-import { $ as NC_ALARM_SYSTEM_EVENT_KINDS, $n as notificationRulesCapability, $r as object, $t as SCENE_DEFAULT_UNCOVERED_POLICY, A as EMBEDDING_REQUIREMENTS_FAILED, Ar as canonicalHash, At as NcScheduleSchema, B as ListTrackRelationsInputSchema, Bn as isAudioClassName, Br as hydrateSchema, Bt as OPS_LOG_DEFAULT_LIMIT, C as DEFAULT_EVENT_COLOR, Cn as buildEventKindDescriptor, Cr as systemEventSummaryScheduleOf, Ct as NcConditionDescriptorSchema, D as DeclaredDevices, Dn as describeSystemEventDeliveryProblem, Dr as vectorDimFromBase64, Dt as NcRuleSchema, E as DETECTION_PIPELINE_CAP_NAME, En as deriveRecordingMode, Er as templateVarsFor, Et as NcRulePatchSchema, F as EXPORT_DENSE_MAX_RANGES, Fn as evictionPolicyOfLocation, Fr as BaseAddon, Ft as NcSystemEventKindSchema, G as MAX_BIRTH_LATENCY_PROXY_MS, Gn as isRetiredClearKey, Gr as ZodObject, Gt as RebuildObjectEmbeddingsRefusalSchema, H as LockStateSchema, Hn as isEventOwnerType, Hr as nodePin, I as FIRST_LEVEL_MACRO_CLASSES, In as faceGalleryCapability, Ir as CamProfileSchema, It as NcTaxonomySchema, J as MOTION_CLOSE_AFTER_MS, Jn as isSystemEventSummaryRule, Jr as boolean, Jt as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, K as MAX_TRACK_PURITIES, Kn as isScheduleActive, Kr as _enum, Kt as RetrainStatusSchema, L as FULL_IMAGE_BBOX, Ln as failureContributionCapability, Lr as createEvent, Lt as NcTemplatePreviewInputSchema, M as EVENT_DENSITY_BATCH_MAX, Mr as isSourceCap, Mt as NcSnoozeSchema, N as EVENT_KIND_BY_CAP, Nr as DeviceType, Nt as NcSnoozeSuppressedSchema, O as DetectionSourceSchema, On as describeSystemEventFamilyProblem, Or as zoneAnalyticsCapability, Ot as NcRuleTargetSchema, P as EVENT_OWNER_TYPES, Pn as encodeVectorBase64, Pr as errMsg, Pt as NcStateSummarySectionIdSchema, Q as NC_ALARM_DELAY_MAX_SEC, Qn as memoizePinnedFfmpeg, Qr as number, Qt as SCENE_DEFAULT_QUIET_SECONDS, R as FailureCounters, Rn as gifDeriveSpeed, Rr as customAction, Rt as NcTemplatePreviewSchema, S as CoverStateSchema, Sn as audioModeOf, Sr as systemEventFilterApplies, St as NcAlarmSettingsPatchSchema, T as DETECTION_MACRO_CLASSES, Tn as cosineSimilarity$1, Tr as templateCarriesSummary, Tt as NcRuleInputSchema, U as MAX_ARCHIVED_DEBUG_NOTES, Un as isKnownTemplateVar, Ut as RECORDING_EXPORT_MAX_READ_BYTES, V as ListTrackRelationsResultSchema, Vn as isDetectionMacroClass, Vr as isDeviceScopedCap, Vt as OpsLogEntrySchema, W as MAX_BIRTH_DECISION_RECORDS, Wn as isMediaOwnerType, Wr as sleep$1, Wt as RECORDING_SOURCE_CAMSTACK_ADDON, X as MotionTriggeredBySchema, Xn as kebabToCamel, Xr as literal, Xt as SCENE_DEFAULT_CHECK_INTERVAL_SEC, Y as MediaFileKindEnum, Yn as isVectorIndexDimConflict, Yr as discriminatedUnion, Yt as SCENE_DEFAULT_ANCHOR_THRESHOLD, Z as NC_ALARM_DELAY_FIELDS, Zn as mayWriteToLocation, Zr as looseObject, Zt as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, _ as BaseDevice, _n as alarmPanelCapability, _r as servedTemplateVars, _t as NC_TAXONOMY, a as CLIP_EMBEDDING_STEP_ID, ai as tuple, an as SetTrackRelationInputSchema, ar as readMotionTriggeredBy, at as NC_CLIP_RETENTION_MAX_SEC, b as ClearTrackRelationInputSchema, bn as assertTimelapseCadences, br as systemEventDeliveryProblems, bt as NcAlarmSensorsInputSchema, c as resolveClusterModelPin, ci as EventCategory, cn as TimelapseRuleInputSchema, cr as resolveLocationMode, ct as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, d as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, dn as TrackPuritySchema, dr as ruleBelongsToAlarm$1, dt as NC_GROUPING_MAX_SEC, ei as partialRecord, en as SCENE_DIVERGED, er as occupancyScope, et as NC_ALARM_TRIGGERED_MAX_SEC, f as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, fn as TrackRelationKindSchema, fr as ruleDeviceCompatCapQueries, ft as NC_GROUPING_MIN_SEC, g as BIRTH_DECISION_DEFAULT_LIMIT, gn as addonWidgetsSourceCapability, gr as sensorRaisedOf, gt as NC_TANK_SYSTEM_EVENT_KINDS, h as ArchivedDebugNoteSchema, hn as TrackSourceSchema, hr as sceneMonitorCapability, ht as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, ii as templateLiteral, in as SetTrackPurityResultSchema, ir as readDeviceStateFrom, it as NC_CLIP_PRE_ROLL_DEFAULT_SEC, j as EMBEDDING_REQUIREMENTS_UNAVAILABLE, jn as embeddingRefusalOf, jr as evaluateSensorEdge, jt as NcSnoozeInputSchema, k as EMBEDDING_MODEL_FAILED, kr as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, kt as NcRuleUpdateInputSchema, l as APPEARANCE_BIN_COUNT, ln as TimelapseRulePatchSchema, lr as resolveModeDelays, lt as NC_DEFAULT_SNOOZE_MINUTES, m as AlarmArmModeSchema, mn as TrackSideSchema, mr as ruleKindOf, mt as NC_SNOOZE_MAX_MINUTES, ni as strictObject, nn as SceneMonitorSchema, nr as pipelineAnalyticsCapability, nt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, o as FACE_EMBEDDING_STEP_ID, oi as union, on as TIMELAPSE_DENSE_FLOOR_SEC, or as readTimelapseGeneratedAt, ot as NC_CONDITION_CATALOG, p as AUDIO_MACRO_LABELS, pn as TrackRelationSchema, pr as ruleGroupingApplies, pt as NC_SENSOR_TRANSITION_KINDS, q as MAX_TRACK_RELATIONS, qn as isSystemDelivery, qr as array, qt as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, ri as string, rn as SetTrackPurityInputSchema, rr as plateGalleryCapability, rt as NC_CLIP_POST_ROLL_DEFAULT_SEC, s as readClusterModelPinStrict, si as unknown, sn as TRACK_RELATIONS_DEFAULT_LIMIT, sr as resolveClipSearchMinScore, st as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, t as BUILTIN_CLIP_MODELS, ti as record, tn as SCENE_RESET_RECAPTURES, tt as NC_AUDIO_CONFIRM_HITS_DEFAULT, u as APPEARANCE_BLOCKS, un as TimelapseRuleSchema, ut as NC_GROUPING_DEFAULT_SEC, v as BirthDecisionRecordSchema, vn as applyModeDelaysEdits, vr as storageOccupancyCapability, vt as NC_TEMPLATE_VARS, w as DEFAULT_TIMELAPSE_PREVIEW_TEXT, wn as consumableLowPercentOf, wr as systemEventSummarySplitOf, wt as NcConditionsSchema, x as ClearTrackRelationResultSchema, xn as audioMetricsCapability, xr as systemEventFamilyProblems, xt as NcAlarmSensorsSchema, y as COCO_TO_MACRO, yn as applyNonBlockingEdit, yr as subKindsOf, yt as NcAlarmConfigSchema, z as LabelAttributionSchema, zn as gifFromMp4Args, zr as defineCustomActions, zt as NcTemplateVarDescriptorSchema } from "../clip-model-registry-DSqobJfx.mjs";
+import { $ as NC_ALARM_SYSTEM_EVENT_KINDS, $n as isVectorIndexDimConflict, $r as boolean, $t as SCENE_DEFAULT_UNCOVERED_POLICY, A as EMBEDDING_REQUIREMENTS_FAILED, An as describeSystemEventDeliveryProblem, Ar as templateCarriesSummary, At as NcScheduleSchema, B as ListTrackRelationsInputSchema, Bn as failureContributionCapability, Br as BaseAddon, Bt as OPS_LOG_DEFAULT_LIMIT, C as DEFAULT_EVENT_COLOR, Cn as assertTimelapseCadences, Cr as storageOccupancyCapability, Ct as NcConditionDescriptorSchema, D as DeclaredDevices, Dn as consumableLowPercentOf, Dr as systemEventFilterApplies, Dt as NcRuleSchema, E as DETECTION_PIPELINE_CAP_NAME, En as buildEventKindDescriptor, Er as systemEventFamilyProblems, Et as NcRulePatchSchema, F as EXPORT_DENSE_MAX_RANGES, Fr as canonicalHash, Ft as NcSystemEventKindSchema, G as MAX_BIRTH_LATENCY_PROXY_MS, Gn as isDetectionMacroClass, Gr as hydrateSchema, Gt as RebuildObjectEmbeddingsRefusalSchema, H as LockStateSchema, Hn as gifFromMp4Args, Hr as createEvent, I as FIRST_LEVEL_MACRO_CLASSES, Ir as evaluateSensorEdge, It as NcTaxonomySchema, J as MOTION_CLOSE_AFTER_MS, Jn as isMediaOwnerType, Jt as SCENE_CONFIRM_DEFAULT_TIMEOUT_MS, K as MAX_TRACK_PURITIES, Kn as isEventOwnerType, Kr as isDeviceScopedCap, Kt as RetrainStatusSchema, L as FULL_IMAGE_BBOX, Ln as encodeVectorBase64, Lr as isSourceCap, Lt as NcTemplatePreviewInputSchema, M as EVENT_DENSITY_BATCH_MAX, Mr as vectorDimFromBase64, Mt as NcSnoozeSchema, N as EVENT_KIND_BY_CAP, Nr as zoneAnalyticsCapability, Nt as NcSnoozeSuppressedSchema, O as DetectionSourceSchema, On as cosineSimilarity$1, Or as systemEventSummaryScheduleOf, Ot as NcRuleTargetSchema, P as EVENT_OWNER_TYPES, Pn as embeddingRefusalOf, Pr as DEFAULT_FIRST_SIGHTING_FRESHNESS_MS, Pt as NcStateSummarySectionIdSchema, Q as NC_ALARM_DELAY_MAX_SEC, Qn as isSystemEventSummaryRule, Qr as array, Qt as SCENE_DEFAULT_QUIET_SECONDS, R as FailureCounters, Rn as evictionPolicyOfLocation, Rr as DeviceType, Rt as NcTemplatePreviewSchema, S as CoverStateSchema, Sn as applySecureOnArmEdit, Sr as servedTemplateVars, St as NcAlarmSettingsPatchSchema, T as DETECTION_MACRO_CLASSES, Tn as audioModeOf, Tr as systemEventDeliveryProblems, Tt as NcRuleInputSchema, U as MAX_ARCHIVED_DEBUG_NOTES, Un as isAlarmControllableCap, Ur as customAction, Ut as RECORDING_EXPORT_MAX_READ_BYTES, V as ListTrackRelationsResultSchema, Vn as gifDeriveSpeed, Vr as CamProfileSchema, Vt as OpsLogEntrySchema, W as MAX_BIRTH_DECISION_RECORDS, Wn as isAudioClassName, Wr as defineCustomActions, Wt as RECORDING_SOURCE_CAMSTACK_ADDON, X as MotionTriggeredBySchema, Xn as isScheduleActive, Xr as ZodObject, Xt as SCENE_DEFAULT_CHECK_INTERVAL_SEC, Y as MediaFileKindEnum, Yn as isRetiredClearKey, Yr as sleep$1, Yt as SCENE_DEFAULT_ANCHOR_THRESHOLD, Z as NC_ALARM_DELAY_FIELDS, Zn as isSystemDelivery, Zr as _enum, Zt as SCENE_DEFAULT_OBSERVATION_SPACING_SEC, _ as BaseDevice, _n as alarmDeviceSecureOnArm, _r as ruleGroupingApplies, _t as NC_TAXONOMY, a as CLIP_EMBEDDING_STEP_ID, ai as partialRecord, an as SetTrackRelationInputSchema, at as NC_CLIP_RETENTION_MAX_SEC, b as ClearTrackRelationInputSchema, bn as applyModeDelaysEdits, br as secureActuationFor, bt as NcAlarmSensorsInputSchema, c as resolveClusterModelPin, ci as string, cn as TimelapseRuleInputSchema, cr as readDeviceStateFrom, ct as NC_CONSUMABLE_SYSTEM_EVENT_KINDS, d as APPEARANCE_RESOLVES_AMBIGUITY_DEFAULT, di as union, dn as TrackPuritySchema, dr as resolveClipSearchMinScore, dt as NC_GROUPING_MAX_SEC, ei as discriminatedUnion, en as SCENE_DIVERGED, er as kebabToCamel, et as NC_ALARM_TRIGGERED_MAX_SEC, f as ARCHIVED_DEBUG_NOTES_DEFAULT_LIMIT, fi as unknown, fn as TrackRelationKindSchema, fr as resolveLocationMode, ft as NC_GROUPING_MIN_SEC, g as BIRTH_DECISION_DEFAULT_LIMIT, gn as addonWidgetsSourceCapability, gr as ruleDeviceCompatCapQueries, gt as NC_TANK_SYSTEM_EVENT_KINDS, h as ArchivedDebugNoteSchema, hn as TrackSourceSchema, hr as ruleBelongsToAlarm$1, ht as NC_SYSTEM_EVENT_KIND_GROUP_SPECS, ii as object, in as SetTrackPurityResultSchema, ir as occupancyScope, it as NC_CLIP_PRE_ROLL_DEFAULT_SEC, j as EMBEDDING_REQUIREMENTS_UNAVAILABLE, jn as describeSystemEventFamilyProblem, jr as templateVarsFor, jt as NcSnoozeInputSchema, k as EMBEDDING_MODEL_FAILED, kn as deriveRecordingMode, kr as systemEventSummarySplitOf, kt as NcRuleUpdateInputSchema, l as APPEARANCE_BIN_COUNT, li as templateLiteral, ln as TimelapseRulePatchSchema, lr as readMotionTriggeredBy, lt as NC_DEFAULT_SNOOZE_MINUTES, m as AlarmArmModeSchema, mn as TrackSideSchema, mt as NC_SNOOZE_MAX_MINUTES, ni as looseObject, nn as SceneMonitorSchema, nr as memoizePinnedFfmpeg, nt as NC_AUDIO_CONFIRM_WINDOW_SEC_DEFAULT, o as FACE_EMBEDDING_STEP_ID, oi as record, on as TIMELAPSE_DENSE_FLOOR_SEC, or as pipelineAnalyticsCapability, ot as NC_CONDITION_CATALOG, p as AUDIO_MACRO_LABELS, pi as EventCategory, pn as TrackRelationSchema, pr as resolveModeDelays, pt as NC_SENSOR_TRANSITION_KINDS, q as MAX_TRACK_RELATIONS, qn as isKnownTemplateVar, qr as nodePin, qt as SCENE_CONFIRM_DEFAULT_MAX_IMAGE_PX, ri as number, rn as SetTrackPurityInputSchema, rr as notificationRulesCapability, rt as NC_CLIP_POST_ROLL_DEFAULT_SEC, s as readClusterModelPinStrict, si as strictObject, sn as TRACK_RELATIONS_DEFAULT_LIMIT, sr as plateGalleryCapability, st as NC_CONSUMABLE_LOW_PERCENT_DEFAULT, t as BUILTIN_CLIP_MODELS, ti as literal, tn as SCENE_RESET_RECAPTURES, tr as mayWriteToLocation, tt as NC_AUDIO_CONFIRM_HITS_DEFAULT, u as APPEARANCE_BLOCKS, ui as tuple, un as TimelapseRuleSchema, ur as readTimelapseGeneratedAt, ut as NC_GROUPING_DEFAULT_SEC, v as BirthDecisionRecordSchema, vn as alarmPanelCapability, vr as ruleKindOf, vt as NC_TEMPLATE_VARS, w as DEFAULT_TIMELAPSE_PREVIEW_TEXT, wn as audioMetricsCapability, wr as subKindsOf, wt as NcConditionsSchema, x as ClearTrackRelationResultSchema, xn as applyNonBlockingEdit, xr as sensorRaisedOf, xt as NcAlarmSensorsSchema, y as COCO_TO_MACRO, yn as applyBlockingEdit, yr as sceneMonitorCapability, yt as NcAlarmConfigSchema, z as LabelAttributionSchema, zn as faceGalleryCapability, zr as errMsg, zt as NcTemplateVarDescriptorSchema } from "../clip-model-registry-C-IEAIQQ.mjs";
 import { t as __exportAll } from "../embedding-encoder/index.mjs";
 import * as fs$1 from "node:fs";
 import { createWriteStream, promises } from "node:fs";
@@ -597,7 +597,19 @@ var ARM_ANYWAY_TTL_MS = 5 * 6e4;
 var NcAlarmOpenDeviceSchema = object({
 	deviceId: number().int(),
 	name: string(),
-	state: string()
+	state: string(),
+	/**
+	* Cover / lock / switch — default false so an older bridge answer still
+	* parses as a contact-style opening.
+	*/
+	controllable: boolean().default(false),
+	/** Opening cap that produced the reading; used to actuate secure-on-arm. */
+	cap: _enum([
+		"contact",
+		"cover",
+		"lock-control",
+		"switch"
+	]).optional()
 }).readonly();
 /** Why an Arm anyway was not honoured — see `NcAlarmPanelDevice.armAnyway`. */
 var NcAlarmArmAnywayRejectionSchema = _enum([
@@ -662,23 +674,22 @@ function alarmCoveredDevices(rules, panelDeviceId, mode) {
 /**
 * Refuse or arm — the whole decision, as one partition of the open devices.
 *
-* A device may be open at arm time for exactly two reasons: the mode TOLERATES
-* it (its non-blocking list), or the operator was shown it in a refusal and
-* pressed that refusal's Arm anyway (`acknowledged`). Anything else open
-* refuses — including a device that opened AFTER the refusal the operator is
-* confirming: they were never shown it, and excluding it would arm the alarm
-* around an opening nobody agreed to.
+* A device may be open at arm time when:
+*  - the mode TOLERATES it (`nonBlocking` for contacts),
+*  - it is controllable and NOT on the mode's `blocking` list (default),
+*  - or the operator confirmed it with Arm anyway (`acknowledged`).
 *
-* There is no memory here. A plain arm pressed twice is the same question
-* twice and gets the same answer; the only way past a refusal is the explicit
-* Arm anyway, whose lifecycle (one-shot, stale, expired) the panel owns.
+* Anything else open refuses — including a device that opened AFTER the refusal
+* the operator is confirming.
 *
 * Excluded is EVERY open device — tolerated and acknowledged alike — and the
 * exclusion is two-phase (`alarm-exclusions.ts`): each one is watched again
 * once it has closed and opened.
 */
 function decideArm(input) {
+	const forceBlock = new Set(input.blocking ?? []);
 	const tolerated = new Set([...input.nonBlocking, ...input.acknowledged ?? []]);
+	for (const d of input.open) if (d.controllable && !forceBlock.has(d.deviceId)) tolerated.add(d.deviceId);
 	const blocking = input.open.filter((d) => !tolerated.has(d.deviceId));
 	if (blocking.length > 0) return {
 		kind: "refused",
@@ -1066,39 +1077,24 @@ var NcActionPlane = class {
 * and never open):
 *
 *  - `not-opening` — no opening slice at all: a camera named by an intrusion
-*    rule, a switch. It takes no part in the arm decision.
+*    rule. It takes no part in the arm decision.
 *  - `unknown` — an opening cap's slice IS there, but its field is missing or
 *    is not a word that cap defines, or the slice is a provider's PLACEHOLDER
-*    (`lastChangedAt === 0`: written by a constructor before anybody read the
-*    device — an HA lock's `unlocked`, an HA cover's `closed`, a binary
-*    sensor's `entryOpen: false`). It carries the cap and the raw value (for a
-*    placeholder, the whole slice) so the caller's log line can say what it
-*    saw. It never blocks and is never armed as secure on a guess — and a
-*    placeholder is never taken for a state, so neither the reconcile tick,
-*    the arm check nor an exclusion lift acts on one.
-*  - `reading` — open or secure, with the state word a person will read.
-*    ANY non-zero `lastChangedAt` is a reading, however old — including `1`,
-*    the stamp a provider writes on a value it REPLAYED after a respawn with
-*    no upstream change time (Homematic `HM_SEEDED_CHANGED_AT`): the value is
-*    known, only its change time is not. The transition gate
-*    (`sensor-transition-gate.ts`, "A placeholder slice is not a state") reads
-*    the same stamp as "not a fresh event"; `0` alone means "not read yet".
+*    (`lastChangedAt === 0`). It never blocks and is never armed as secure on a
+*    guess.
+*  - `reading` — open or secure, with the state word a person will read and the
+*    cap that produced it (so secure-on-arm knows what to actuate).
 *
 * A read that FAILED never reaches {@link alarmOpeningFrom}: the caller leaves
 * that id out of its answer (see {@link readAlarmOpenings}).
 *
 * Anything short of fully secure is open: a cover stopped half-way, a lock that
-* jammed, a cover still closing when the arm is decided.
+* jammed, a cover still closing when the arm is decided, a switch that is on.
 *
 * PRECEDENCE, when one device carries more than one opening slice: `contact`
-* first, then `cover`, then `lock-control`. The contact is the physical truth
-* about the opening — a reed switch on the frame says the window is open even
-* when the motor's last reported word says `closed`. A slice that cannot be
-* read falls through to the next; only when none of them reads is the device
-* `unknown`, naming the first unreadable cap.
-*
-* The vocabulary of each word is its cap's own schema (`CoverStateSchema`,
-* `LockStateSchema`) — a word the cap does not define is not guessed at.
+* first, then `cover`, then `lock-control`, then `switch`. The contact is the
+* physical truth about the opening — a reed switch on the frame says the window
+* is open even when the motor's last reported word says `closed`.
 */
 /** The one state word, per cap, that counts as secure. Everything else is open. */
 var COVER_SECURE = "closed";
@@ -1117,11 +1113,12 @@ function fieldOf(slice, field) {
 function isPlaceholder(slice) {
 	return fieldOf(slice, "lastChangedAt") === 0;
 }
-function reading(word, secure) {
+function reading(word, secure, cap) {
 	return {
 		kind: "reading",
 		reading: word === secure ? "secure" : "open",
-		state: word
+		state: word,
+		cap
 	};
 }
 function readContact(runtime) {
@@ -1141,11 +1138,13 @@ function readContact(runtime) {
 	return raw ? {
 		kind: "reading",
 		reading: "open",
-		state: "open"
+		state: "open",
+		cap: "contact"
 	} : {
 		kind: "reading",
 		reading: "secure",
-		state: "closed"
+		state: "closed",
+		cap: "contact"
 	};
 }
 function readCover(runtime) {
@@ -1158,7 +1157,7 @@ function readCover(runtime) {
 	};
 	const raw = fieldOf(slice, "state");
 	const parsed = CoverStateSchema.safeParse(raw);
-	return parsed.success ? reading(parsed.data, COVER_SECURE) : {
+	return parsed.success ? reading(parsed.data, COVER_SECURE, "cover") : {
 		kind: "unknown",
 		cap: "cover",
 		raw
@@ -1174,19 +1173,46 @@ function readLock(runtime) {
 	};
 	const raw = fieldOf(slice, "state");
 	const parsed = LockStateSchema.safeParse(raw);
-	return parsed.success ? reading(parsed.data, LOCK_SECURE) : {
+	return parsed.success ? reading(parsed.data, LOCK_SECURE, "lock-control") : {
 		kind: "unknown",
 		cap: "lock-control",
 		raw
 	};
 }
+function readSwitch(runtime) {
+	const slice = sliceOf(runtime, "switch");
+	if (slice === void 0) return { kind: "absent" };
+	if (isPlaceholder(slice)) return {
+		kind: "unknown",
+		cap: "switch",
+		raw: slice
+	};
+	const raw = fieldOf(slice, "on");
+	if (typeof raw !== "boolean") return {
+		kind: "unknown",
+		cap: "switch",
+		raw
+	};
+	return raw ? {
+		kind: "reading",
+		reading: "open",
+		state: "on",
+		cap: "switch"
+	} : {
+		kind: "reading",
+		reading: "secure",
+		state: "off",
+		cap: "switch"
+	};
+}
 /** D630's table over one device's runtime slices — see the header for the three answers. */
 function alarmOpeningFrom(runtime) {
 	let firstUnknown = null;
 	for (const read of [
 		readContact(runtime),
 		readCover(runtime),
-		readLock(runtime)
+		readLock(runtime),
+		readSwitch(runtime)
 	]) {
 		if (read.kind === "reading") return read;
 		if (read.kind === "unknown" && firstUnknown === null) firstUnknown = read;
@@ -1201,13 +1227,14 @@ function alarmOpeningFrom(runtime) {
 var OPENING_CAP_BY_EVENT_KIND = {
 	contact: "contact",
 	cover: "cover",
-	lock: "lock-control"
+	lock: "lock-control",
+	switch: "switch"
 };
 /**
 * The same table, read off one sensor-event row: its `value` IS the slice of
 * the cap its `kind` names, so the event path and the reconcile read answer in
 * one vocabulary — a cover is secure only when `closed`, a lock only when
-* `locked`, whichever path saw it.
+* `locked`, a switch only when off, whichever path saw it.
 */
 function alarmOpeningFromSensorEvent(kind, value) {
 	const cap = OPENING_CAP_BY_EVENT_KIND[kind];
@@ -1228,7 +1255,9 @@ function classifyCoveredOpening(opening) {
 	if (opening.kind === "not-opening" || opening.reading !== "open") return { kind: "skip" };
 	return {
 		kind: "open",
-		state: opening.state
+		state: opening.state,
+		controllable: isAlarmControllableCap(opening.cap),
+		cap: opening.cap
 	};
 }
 /**
@@ -1885,6 +1914,22 @@ var ncAlarmPanelSchema = object({
 		deviceIds: array(number().int())
 	})).default([]),
 	/**
+	* Controllable openings that DO block when open (opt-in). Loose + guarded like
+	* {@link nonBlocking}.
+	*/
+	blocking: array(object({
+		mode: string(),
+		deviceIds: array(number().int())
+	})).default([]),
+	/**
+	* Controllable openings that must NOT secure on arm (opt-out). Loose + guarded
+	* like {@link nonBlocking}.
+	*/
+	secureOnArmOff: array(object({
+		mode: string(),
+		deviceIds: array(number().int())
+	})).default([]),
+	/**
 	* Per arm mode, the delays that override the global ones (D697). Loose on purpose — `mode` is
 	* a string and the numbers are unbounded here — and read back through
 	* {@link modeDelaysFromPersisted}, never a cast: an entry this release cannot trust is dropped
@@ -1903,7 +1948,7 @@ var ncAlarmPanelSchema = object({
 * per mode kept — the same "at most one list per mode" the settings schema
 * enforces at the boundary. A type guard (`safeParse`), never a cast.
 */
-function nonBlockingFromPersisted(raw) {
+function modeDeviceListFromPersisted(raw) {
 	const seen = /* @__PURE__ */ new Set();
 	const lists = [];
 	for (const entry of raw) {
@@ -2008,7 +2053,9 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 			...this.readDelays(),
 			announceArm: this.config.get("announceArm"),
 			announceTargets: [...this.config.get("announceTargets")],
-			nonBlocking: nonBlockingFromPersisted(this.config.get("nonBlocking")),
+			nonBlocking: modeDeviceListFromPersisted(this.config.get("nonBlocking")),
+			blocking: modeDeviceListFromPersisted(this.config.get("blocking")),
+			secureOnArmOff: modeDeviceListFromPersisted(this.config.get("secureOnArmOff")),
 			modeDelays: modeDelaysFromPersisted(this.config.get("modeDelays")).entries
 		};
 	}
@@ -2035,30 +2082,73 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 	async applySettings(patch) {
 		const edits = patch.modeDelays ?? [];
 		const membership = patch.nonBlockingEdit;
+		const blockingEdit = patch.blockingEdit;
+		const secureEdit = patch.secureOnArmEdit;
 		for (const edit of edits) this.refuseUnofferedMode(edit.mode);
 		if (membership !== void 0) {
 			this.refuseUnofferedMode(membership.mode, membership.deviceId);
-			const verdict = applyNonBlockingEdit(patch.nonBlocking !== void 0 ? patch.nonBlocking : nonBlockingFromPersisted(this.config.get("nonBlocking")), membership);
+			const verdict = applyNonBlockingEdit(patch.nonBlocking !== void 0 ? patch.nonBlocking : modeDeviceListFromPersisted(this.config.get("nonBlocking")), membership);
 			if (verdict.kind === "refused") {
 				this.ctx.logger.info("alarm settings refused", {
 					tags: { deviceId: membership.deviceId },
 					meta: {
 						panelId: this.id,
 						reason: "list-full",
-						mode: verdict.mode
+						mode: verdict.mode,
+						list: "nonBlocking"
 					}
 				});
 				throw new Error(`the ${verdict.mode} non-blocking list already holds ${verdict.max} devices — remove one first`);
 			}
 		}
+		if (blockingEdit !== void 0) {
+			this.refuseUnofferedMode(blockingEdit.mode, blockingEdit.deviceId);
+			const verdict = applyBlockingEdit(patch.blocking !== void 0 ? patch.blocking : modeDeviceListFromPersisted(this.config.get("blocking")), blockingEdit);
+			if (verdict.kind === "refused") {
+				this.ctx.logger.info("alarm settings refused", {
+					tags: { deviceId: blockingEdit.deviceId },
+					meta: {
+						panelId: this.id,
+						reason: "list-full",
+						mode: verdict.mode,
+						list: "blocking"
+					}
+				});
+				throw new Error(`the ${verdict.mode} blocking list already holds ${verdict.max} devices — remove one first`);
+			}
+		}
+		if (secureEdit !== void 0) {
+			this.refuseUnofferedMode(secureEdit.mode, secureEdit.deviceId);
+			const verdict = applySecureOnArmEdit(patch.secureOnArmOff !== void 0 ? patch.secureOnArmOff : modeDeviceListFromPersisted(this.config.get("secureOnArmOff")), secureEdit);
+			if (verdict.kind === "refused") {
+				this.ctx.logger.info("alarm settings refused", {
+					tags: { deviceId: secureEdit.deviceId },
+					meta: {
+						panelId: this.id,
+						reason: "list-full",
+						mode: verdict.mode,
+						list: "secureOnArmOff"
+					}
+				});
+				throw new Error(`the ${verdict.mode} secure-on-arm-off list already holds ${verdict.max} devices — remove one first`);
+			}
+		}
 		const listWrites = [];
 		if (patch.nonBlocking !== void 0) listWrites.push(this.config.set("nonBlocking", patch.nonBlocking.map((l) => ({
 			mode: l.mode,
 			deviceIds: [...l.deviceIds]
 		}))));
+		if (patch.blocking !== void 0) listWrites.push(this.config.set("blocking", patch.blocking.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		}))));
+		if (patch.secureOnArmOff !== void 0) listWrites.push(this.config.set("secureOnArmOff", patch.secureOnArmOff.map((l) => ({
+			mode: l.mode,
+			deviceIds: [...l.deviceIds]
+		}))));
 		let membershipChanged = null;
 		if (membership !== void 0) {
-			const result = applyNonBlockingEdit(nonBlockingFromPersisted(this.config.get("nonBlocking")), membership);
+			const result = applyNonBlockingEdit(modeDeviceListFromPersisted(this.config.get("nonBlocking")), membership);
 			if (result.kind === "applied") {
 				membershipChanged = result.changed;
 				if (result.changed) listWrites.push(this.config.set("nonBlocking", result.lists.map((l) => ({
@@ -2067,6 +2157,26 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 				}))));
 			}
 		}
+		if (blockingEdit !== void 0) {
+			const result = applyBlockingEdit(modeDeviceListFromPersisted(this.config.get("blocking")), blockingEdit);
+			if (result.kind === "applied" && result.changed) {
+				membershipChanged = true;
+				listWrites.push(this.config.set("blocking", result.lists.map((l) => ({
+					mode: l.mode,
+					deviceIds: [...l.deviceIds]
+				}))));
+			}
+		}
+		if (secureEdit !== void 0) {
+			const result = applySecureOnArmEdit(modeDeviceListFromPersisted(this.config.get("secureOnArmOff")), secureEdit);
+			if (result.kind === "applied" && result.changed) {
+				membershipChanged = true;
+				listWrites.push(this.config.set("secureOnArmOff", result.lists.map((l) => ({
+					mode: l.mode,
+					deviceIds: [...l.deviceIds]
+				}))));
+			}
+		}
 		const persistedDelays = modeDelaysFromPersisted(this.config.get("modeDelays"));
 		const beforeDelays = persistedDelays.entries;
 		const afterDelays = edits.length > 0 ? applyModeDelaysEdits(beforeDelays, edits) : beforeDelays;
@@ -2205,7 +2315,7 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 		if (read.verdict.kind === "refused") return this.refuse(mode, read.verdict.blocking, now);
 		return this.settleArm(mode, read.verdict.excluded.map((device) => ({
 			device,
-			why: "non-blocking"
+			why: this.exclusionWhyFor(mode, device)
 		})), now);
 	}
 	/**
@@ -2254,12 +2364,14 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 			return outcome;
 		}
 		const tolerated = this.nonBlockingFor(held.mode);
+		const forceBlock = this.blockingFor(held.mode);
 		const unknown = new Set(read.openings.unknown);
 		if (read.verdict.kind === "refused") {
 			const plain = decideArm({
 				mode: held.mode,
 				open: read.openings.open,
-				nonBlocking: tolerated
+				nonBlocking: tolerated,
+				blocking: forceBlock
 			});
 			const blockingNow = plain.kind === "refused" ? plain.blocking : read.verdict.blocking;
 			const shownIds = new Set(blockingNow.map((d) => d.deviceId));
@@ -2389,10 +2501,17 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 				error: String(err)
 			};
 		}
+		const toSecure = openings.open.filter((d) => alarmDeviceSecureOnArm({
+			controllable: d.controllable,
+			deviceId: d.deviceId,
+			secureOnArmOff: this.secureOnArmOffFor(mode)
+		}));
+		if (toSecure.length > 0) this.armGuard?.secureOnArm(toSecure);
 		const verdict = decideArm({
 			mode,
 			open: openings.open,
 			nonBlocking: this.nonBlockingFor(mode),
+			blocking: this.blockingFor(mode),
 			...acknowledged !== void 0 ? { acknowledged } : {}
 		});
 		return {
@@ -2417,7 +2536,28 @@ var NcAlarmPanelDevice = class extends BaseDevice {
 	}
 	/** This mode's non-blocking ids, from the persisted lists. */
 	nonBlockingFor(mode) {
-		return nonBlockingFromPersisted(this.config.get("nonBlocking")).find((l) => l.mode === mode)?.deviceIds ?? [];
+		return this.modeListIds("nonBlocking", mode);
+	}
+	/** Controllable openings that force-block when open. */
+	blockingFor(mode) {
+		return this.modeListIds("blocking", mode);
+	}
+	/** Controllable openings that opt out of secure-on-arm. */
+	secureOnArmOffFor(mode) {
+		return this.modeListIds("secureOnArmOff", mode);
+	}
+	modeListIds(key, mode) {
+		return modeDeviceListFromPersisted(this.config.get(key)).find((l) => l.mode === mode)?.deviceIds ?? [];
+	}
+	/** Why an open device was armed around on a plain (non–Arm-anyway) arm. */
+	exclusionWhyFor(mode, device) {
+		if (this.nonBlockingFor(mode).includes(device.deviceId)) return "non-blocking";
+		if (alarmDeviceSecureOnArm({
+			controllable: device.controllable,
+			deviceId: device.deviceId,
+			secureOnArmOff: this.secureOnArmOffFor(mode)
+		})) return "secure-on-arm";
+		return "non-blocking";
 	}
 	/**
 	* Arm, with these exclusions.
@@ -8610,6 +8750,7 @@ function sameWord(a, b) {
 * therefore moves the table with the arm.
 */
 function alarmSensorStateOf(deviceId, opening, online) {
+	const controllable = opening?.kind === "reading" ? isAlarmControllableCap(opening.cap) : false;
 	const verdict = classifyCoveredOpening(opening);
 	switch (verdict.kind) {
 		case "unknown": return {
@@ -8617,27 +8758,31 @@ function alarmSensorStateOf(deviceId, opening, online) {
 			reading: "unknown",
 			state: null,
 			unknownWhy: verdict.why,
-			online
+			online,
+			controllable
 		};
 		case "open": return {
 			deviceId,
 			reading: "open",
 			state: verdict.state,
 			unknownWhy: null,
-			online
+			online,
+			controllable: verdict.controllable
 		};
 		case "skip": return opening?.kind === "reading" ? {
 			deviceId,
 			reading: "closed",
 			state: opening.state,
 			unknownWhy: null,
-			online
+			online,
+			controllable
 		} : {
 			deviceId,
 			reading: "not-opening",
 			state: null,
 			unknownWhy: null,
-			online
+			online,
+			controllable: false
 		};
 	}
 }
@@ -19986,19 +20131,39 @@ function planSummaryDevices(rule, isDead, guard) {
 		notes: notes.notes
 	};
 }
+function stripDeadFromLists(lists, isDead) {
+	const dead = lists.flatMap((list) => list.deviceIds.filter(isDead));
+	if (dead.length === 0) return {
+		next: lists,
+		dead
+	};
+	return {
+		dead,
+		next: lists.map((list) => ({
+			...list,
+			deviceIds: list.deviceIds.filter((id) => !isDead(id))
+		}))
+	};
+}
 function planAlarmDevices(alarm, isDead) {
 	if (alarm === null) return null;
-	const nonBlockingDead = alarm.nonBlocking.flatMap((list) => list.deviceIds.filter(isDead));
-	const touched = nonBlockingDead.length > 0;
+	const nonBlocking = stripDeadFromLists(alarm.nonBlocking, isDead);
+	const blocking = stripDeadFromLists(alarm.blocking, isDead);
+	const secureOnArmOff = stripDeadFromLists(alarm.secureOnArmOff, isDead);
 	const forgetExcluded = alarm.excluded.filter(isDead);
-	if (!touched && forgetExcluded.length === 0) return null;
+	const deadIds = [
+		...nonBlocking.dead,
+		...blocking.dead,
+		...secureOnArmOff.dead,
+		...forgetExcluded
+	];
+	if (deadIds.length === 0) return null;
 	return {
-		dropped: deviceSubjects([...new Set([...nonBlockingDead, ...forgetExcluded])]),
+		dropped: deviceSubjects([...new Set(deadIds)]),
 		droppedKind: "device",
-		...touched ? { nonBlocking: alarm.nonBlocking.map((list) => ({
-			...list,
-			deviceIds: list.deviceIds.filter((id) => !isDead(id))
-		})) } : {},
+		...nonBlocking.dead.length > 0 ? { nonBlocking: nonBlocking.next } : {},
+		...blocking.dead.length > 0 ? { blocking: blocking.next } : {},
+		...secureOnArmOff.dead.length > 0 ? { secureOnArmOff: secureOnArmOff.next } : {},
 		forgetExcluded
 	};
 }
@@ -20040,6 +20205,8 @@ function referencedDeviceIds(snapshot) {
 	for (const rule of snapshot.timelapse) add(rule.deviceIds);
 	for (const rule of snapshot.summary) add(rule.deviceIds);
 	for (const list of snapshot.alarm?.nonBlocking ?? []) add(list.deviceIds);
+	for (const list of snapshot.alarm?.blocking ?? []) add(list.deviceIds);
+	for (const list of snapshot.alarm?.secureOnArmOff ?? []) add(list.deviceIds);
 	add(snapshot.alarm?.excluded);
 	add(snapshot.mutedDeviceIds);
 	return ids;
@@ -20384,6 +20551,8 @@ var NcDeletedSubjectPruner = class {
 			summary: this.writable("summary", this.deps.summary.list()),
 			alarm: panel !== null && settings !== void 0 ? {
 				nonBlocking: settings.nonBlocking,
+				blocking: settings.blocking,
+				secureOnArmOff: settings.secureOnArmOff,
 				announceTargets: settings.announceTargets,
 				excluded: panel.excludedDevices()
 			} : null,
@@ -20540,6 +20709,8 @@ var NcDeletedSubjectPruner = class {
 			...NO_SNAPSHOT,
 			alarm: {
 				nonBlocking: settings.nonBlocking,
+				blocking: settings.blocking,
+				secureOnArmOff: settings.secureOnArmOff,
 				announceTargets: settings.announceTargets,
 				excluded: panel.excludedDevices()
 			}
@@ -20548,6 +20719,8 @@ var NcDeletedSubjectPruner = class {
 		try {
 			const patch = {
 				...edit.nonBlocking !== void 0 ? { nonBlocking: edit.nonBlocking } : {},
+				...edit.blocking !== void 0 ? { blocking: edit.blocking } : {},
+				...edit.secureOnArmOff !== void 0 ? { secureOnArmOff: edit.secureOnArmOff } : {},
 				...edit.announceTargets !== void 0 ? { announceTargets: [...edit.announceTargets] } : {}
 			};
 			if (Object.keys(patch).length > 0) await panel.applySettings(patch);
@@ -35550,6 +35723,8 @@ var NC_ALARM_SETTINGS_FALLBACK = {
 	...DEFAULT_DELAYS,
 	announceTargets: [],
 	nonBlocking: [],
+	blocking: [],
+	secureOnArmOff: [],
 	modeDelays: []
 };
 /**
@@ -38554,6 +38729,9 @@ var NotificationCenter = class {
 	alarmArmGuard() {
 		return {
 			openings: (mode) => this.alarmOpenings(mode),
+			secureOnArm: (devices) => {
+				this.secureDevicesOnArm(devices);
+			},
 			announceRefusal: (input) => this.announceArmRefused(input),
 			announceCheckFailed: (input) => this.announceArmCheckFailed(input)
 		};
@@ -38620,7 +38798,9 @@ var NotificationCenter = class {
 			if (verdict.kind === "open") open.push({
 				deviceId,
 				name: name(deviceId),
-				state: verdict.state
+				state: verdict.state,
+				controllable: verdict.controllable,
+				cap: verdict.cap
 			});
 		}
 		this.logger.info("alarm arm check", {
@@ -38639,6 +38819,47 @@ var NotificationCenter = class {
 		};
 	}
 	/**
+	* Fire-and-forget secure actuation for controllable openings on arm.
+	* Failures are WARN per device — they never refuse the arm.
+	*/
+	async secureDevicesOnArm(devices) {
+		for (const device of devices) {
+			const actuation = device.cap !== void 0 ? secureActuationFor(device.cap) : null;
+			if (actuation === null) continue;
+			try {
+				await this.actuateWithAttribution({
+					deviceId: device.deviceId,
+					cap: actuation.cap,
+					method: actuation.method,
+					args: {
+						deviceId: device.deviceId,
+						...actuation.args
+					}
+				});
+				this.logger.info("alarm secure-on-arm actuated", {
+					tags: { deviceId: device.deviceId },
+					meta: {
+						name: device.name,
+						state: device.state,
+						cap: actuation.cap,
+						method: actuation.method
+					}
+				});
+			} catch (err) {
+				this.logger.warn("alarm secure-on-arm actuation failed — arm continues", {
+					tags: { deviceId: device.deviceId },
+					meta: {
+						name: device.name,
+						state: device.state,
+						cap: actuation.cap,
+						method: actuation.method,
+						error: String(err)
+					}
+				});
+			}
+		}
+	}
+	/**
 	* The refusal, as an ordinary notification.
 	*
 	* Same path every alarm announcement takes (D126: the alarm speaks through

package/dist/pipeline-analytics/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-CKHzDA_B.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_pipeline_analytics_widgets-D553qWb_.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }