@camstack/types 1.2.255 → 1.2.256

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-BAgDk7I9.js");
+const require_sleep = require("./sleep-DtomDrRW.js");
 const require_event_category = require("./event-category-BVfsrBYA.js");
 const require_canonical_hash = require("./canonical-hash-CSE4ioRi.js");
 const require_enums = require("./enums.js");
@@ -17495,6 +17495,16 @@ var NcCrossingSchema = zod.z.enum([
 	"exit",
 	"any"
 ]);
+/**
+* Which edge of a BOOLEAN sensor fires a device-event rule (D640).
+*  - `raised`  — the sensor went high: water detected, smoke, open, tampered.
+*  - `cleared` — it went back: dry, clear, closed.
+*  - absent    — both edges, which is what every rule authored before this did.
+*
+* There is no third member for "both": absence already says it, and a value
+* that means the same as absence is a second way to write one rule.
+*/
+var NcSensorTransitionSchema = zod.z.enum(["raised", "cleared"]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = zod.z.object({
 	ids: zod.z.array(zod.z.string().min(1)).min(1),
@@ -17684,6 +17694,20 @@ var NcConditionsSchema = zod.z.object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: zod.z.array(zod.z.number()).optional(),
+	/**
+	* Device EXCLUSION (D641) — "every device except these". Judged on the SAME
+	* subject ids {@link devices} is judged on (the camera, the sensor that
+	* fired, a linked set's sensor and row cameras), so a sensor fanned out per
+	* linked camera is excluded exactly where an include would have tested it.
+	* `min(1)`: an empty exclusion excludes nothing and is written as absent.
+	*
+	* Not for `system-event` rules — those carry their own
+	* `systemEvent.excludeDeviceIds` (D636), and the hub refuses this key there.
+	* Editors present the two lists as ONE field (All | Only these | All except
+	* these); the engine evaluates each independently, so a legacy rule
+	* carrying both still means "these, minus those".
+	*/
+	devicesExclude: zod.z.array(zod.z.number()).min(1).optional(),
 	/** Detector class names (any overlap with the record's class set). */
 	classes: zod.z.array(zod.z.string().min(1)).optional(),
 	/** Veto classes — any overlap fails the rule. */
@@ -17817,6 +17841,16 @@ var NcConditionsSchema = zod.z.object({
 	*/
 	sensorKinds: zod.z.array(zod.z.string().min(1)).optional(),
 	/**
+	* DEVICE-EVENT only (D640). Fire on one edge of a boolean sensor —
+	* {@link NcSensorTransitionSchema}. Which field of the slice means "raised"
+	* is `@camstack/types` → `notification/sensor-raised.ts`. A reading the
+	* engine cannot place (a kind with no raise, an unreadable slice) PASSES:
+	* the condition fails open towards notifying, never towards silence. Editors
+	* offer it only when every chosen {@link sensorKinds} member has a raise
+	* (`sensorTransitionOffered`), and the hub refuses it on any other delivery.
+	*/
+	sensorTransition: NcSensorTransitionSchema.optional(),
+	/**
 	* PACKAGE-EVENT only. Which package phase fires the rule — `delivered`
 	* (a parked parcel appeared), `picked-up` (it departed), or `both`. Fails
 	* when the subject's phase does not match (a subject always carries a phase
@@ -18449,6 +18483,7 @@ var NcConditionDescriptorSchema = zod.z.object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: zod.z.enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -18459,6 +18494,7 @@ var NcConditionDescriptorSchema = zod.z.object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -18657,6 +18693,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Restrict the rule to these devices; absent = all devices. A sensor event matches either the SENSOR that fired or the camera it is attributed to, so a rule may name either one."
 	},
+	{
+		id: "devicesExclude",
+		group: "scope",
+		label: "Excluded devices",
+		valueType: "deviceIdExcludeList",
+		operator: "notIn",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P1",
+		description: "Every device except these. Judged on the same device ids as Devices: a sensor event is excluded by the SENSOR that fired or by the camera it is attributed to."
+	},
 	{
 		id: "classes",
 		group: "class",
@@ -18913,6 +18964,33 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Raw device event-type tokens (e.g. doorbell press / press_long) from the event-emitter slice; absent on doorbell-pulse / passive sensors."
 	},
+	{
+		id: "sensorTransition",
+		group: "device",
+		label: "Notify when",
+		valueType: "sensorTransition",
+		options: [
+			{
+				value: "",
+				label: "It triggers and when it clears",
+				hint: "Every change: water detected, and back to dry."
+			},
+			{
+				value: "raised",
+				label: "Only when it triggers",
+				hint: "Water detected, smoke, a contact opening — never the return to normal."
+			},
+			{
+				value: "cleared",
+				label: "Only when it clears",
+				hint: "Back to dry, smoke gone, a contact closing — never the alert itself."
+			}
+		],
+		operator: "in",
+		appliesTo: ["device-event"],
+		phase: "P2",
+		description: "Fire on one edge of a boolean sensor. Offered only when every chosen sensor kind raises and clears; a reading that cannot be placed still notifies."
+	},
 	{
 		id: "packagePhase",
 		group: "package",
@@ -19099,6 +19177,39 @@ var NcHistoryFilterSchema = zod.z.object({
 	limit: zod.z.number().int().min(1).max(500).default(100)
 });
 /**
+* The newest delivery row of ONE rule — the "Last run" of a rules table.
+*
+* A projection of the same outbox rows `getHistory` returns, so it records
+* DELIVERIES only: a throttled or unmatched evaluation never produced a row
+* and is not a run here. When one fire reached several targets (several rows
+* at the same `lastAt`), `status` is the least successful of them
+* (`dead` > `pending` > `sent`): "the last run delivered" must be true for
+* every target it names.
+*/
+var NcRuleLastRunSchema = zod.z.object({
+	ruleId: zod.z.string(),
+	/** Fire time of the newest row (`createdAt`, epoch ms). */
+	lastAt: zod.z.number(),
+	status: NcHistoryStatusSchema,
+	/** The camera/device of that row (a digest row files under its first camera). */
+	deviceId: zod.z.number()
+});
+/**
+* Every rule's last run, in one answer.
+*
+* A rule ABSENT from `runs` produced no delivery inside `horizonMs` — how far
+* back this answer looked, in ms before the hub's now. It is the outbox prune
+* window (7 days by default, operator-configurable), NARROWED when the read hit
+* its row bound: the answer never claims a window it did not read. `null` means
+* the operator keeps the outbox forever AND the read reached its end, so absent
+* means "never on record". A UI derives its "not in the last N days" from this
+* value, never from a constant — and only when the call ANSWERED (D315).
+*/
+var NcRuleLastRunsSchema = zod.z.object({
+	runs: zod.z.array(NcRuleLastRunSchema),
+	horizonMs: zod.z.number().nonnegative().nullable()
+});
+/**
 * What a snooze covers. Broader scopes win when several overlap, so one window
 * leaves ONE digest rather than a rule snooze and a whole-feed snooze both
 * summarising the same silence.
@@ -19285,6 +19396,14 @@ var NcAlarmModeCoverageSchema = zod.z.object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: zod.z.array(zod.z.number().int()),
 	/**
+	* D641: the ids NOT covered although `allDevices` is true — every unscoped
+	* covering rule EXCLUDES them (`conditions.devicesExclude`) and no named rule
+	* covers them. Always `[]` when `allDevices` is false. Excluded by the rules,
+	* which is not the same as skipped by a switch: never in `skippedDevices`.
+	* Defaulted so an answer computed before this field parses as "none".
+	*/
+	allDevicesExcept: zod.z.array(zod.z.number().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -19526,6 +19645,15 @@ var notificationRulesCapability = {
 		*/
 		getHistory: require_sleep.method(zod.z.object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), zod.z.object({ entries: zod.z.array(NcHistoryEntrySchema) }), { auth: "admin" }),
 		/**
+		* The newest delivery of every rule, in ONE bounded read of the outbox —
+		* the "Last run" column. Never a `getHistory` per rule. A rule with no
+		* delivery inside `horizonMs` is absent from `runs`; see
+		* {@link NcRuleLastRunsSchema} for what absent means. A store that cannot
+		* answer FAILS the call rather than answering "nothing ran". Admin-only,
+		* like `getHistory`, of which it is a projection.
+		*/
+		getRuleLastRuns: require_sleep.method(zod.z.object({}), NcRuleLastRunsSchema, { auth: "admin" }),
+		/**
 		* Mint a fresh, externally-reachable URL for one artefact a history row
 		* named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
 		* signed-link mechanism the dispatcher uses to attach media to an
@@ -52863,6 +52991,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getRuleLastRuns": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getTemplateCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -61016,6 +61150,7 @@ function systemFamilyOfKind(kind) {
 */
 var NO_SENSOR_KIND = "An occupancy edge is not a sensor event: it carries no sensor kind, so this condition can never match one.";
 var NO_EVENT_TOKEN = "An occupancy edge carries no device event-type token — that comes from an event-emitter slice, which a count crossing has none of.";
+var NO_SENSOR_EDGE = "An occupancy edge is a count crossing, not a sensor reading: it has no raise or clear, so this choice could never narrow it.";
 var OCCUPANCY_SOURCE = "An occupancy edge is always produced by the pipeline, so any other source can never match and “pipeline” narrows nothing.";
 var AUDIO_SOURCE = "A confirmed sound window is always stamped as an audio subject, so any other source can never match.";
 var SOUND_NOT_A_PICTURE = "A sound rule fires on what the camera HEARD. Its subject carries no detection, so this condition can never match one — name the sounds in the Sound condition instead.";
@@ -61047,6 +61182,7 @@ var NC_RULE_KIND_SPECS = [
 		excluded: {
 			sensorKinds: NO_SENSOR_KIND,
 			eventTypeTokens: NO_EVENT_TOKEN,
+			sensorTransition: NO_SENSOR_EDGE,
 			source: OCCUPANCY_SOURCE
 		},
 		editable: true,
@@ -61500,6 +61636,111 @@ function isScheduleActive(schedule, atMs) {
 	return schedule.invert === true ? !inside : inside;
 }
 //#endregion
+//#region src/notification/alarm-membership.ts
+var ARMED_WORD_PREFIX = "armed_";
+var ALARM_PANEL_CAP = "alarm-panel";
+var ALARM_PANEL_TRIGGER_METHOD = "trigger";
+/**
+* The sensor-event kinds that are OPENINGS to the alarm — the keys of the
+* engine's opening table (`alarm-openings.ts`, which is checked against this
+* list with `satisfies`). Only these carry an opening edge the alarm refuses.
+*/
+var NC_ALARM_OPENING_EVENT_KINDS = [
+	"contact",
+	"cover",
+	"lock"
+];
+/**
+* A rule belongs to the alarm when its `deviceState` gate names ANY device's
+* `armed_*` word, or an ENABLED `onTrigger` sequence pulls the alarm panel's
+* trigger (D630).
+*/
+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));
+}
+function isOpeningKind(kind) {
+	const k = kind.trim().toLowerCase();
+	return NC_ALARM_OPENING_EVENT_KINDS.some((opening) => opening === k);
+}
+/**
+* An alarm rule over openings only, asking for the CLEAR: the alarm edge
+* refuses every closing, and the chosen edge refuses every opening, so nothing
+* is left (D640 × D630). Not refused on save — alarm membership is derived and
+* can change with an action edit — but every editor must SAY it.
+*/
+function sensorTransitionNeverFires(rule) {
+	const kinds = rule.conditions.sensorKinds ?? [];
+	if (rule.conditions.sensorTransition !== "cleared" || kinds.length === 0) return false;
+	if (!kinds.every(isOpeningKind)) return false;
+	return ruleBelongsToAlarm(rule);
+}
+/** The warning an editor shows for {@link sensorTransitionNeverFires}. */
+var NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = "This rule belongs to the alarm, and an alarm rule fires only when an opening OPENS. Set to “only when it clears”, it can never fire.";
+//#endregion
+//#region src/notification/sensor-raised.ts
+/**
+* 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").
+*
+* A device-event rule over a flood sensor notified on BOTH edges: water
+* detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+* name one edge; this file answers, for one `SensorEvent`, which edge it is.
+*
+* NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+* already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+* (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+* table), and a sensor event names its kind, not its cap. So the table here is
+* DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+* Only kinds whose taxonomy category is `sensor` take part — a switch has an
+* `on` boolean too, but "it triggers / it clears" is not a sentence about a
+* light, and offering it there would be a knob with a misleading label.
+* `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+* absent from the source table, so it is absent here.
+*
+* `undefined` = never guessed: a kind with no raise (a doorbell press, a
+* button, a cover), or a slice whose field is missing or not a boolean. The
+* engine then does NOT filter — a flood alert must not go silent because one
+* read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+*
+* Pure, RN-safe: the viewer imports the support rule from here.
+*/
+/** Event kind → the boolean field of its cap slice that means "raised". */
+var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.entries(EVENT_KIND_BY_CAP).flatMap(([capName, descriptor]) => {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0 || descriptor.category !== "sensor") return [];
+	return [[descriptor.kind, field]];
+})));
+/** The sensor kinds `sensorTransition` means something for. */
+var NC_SENSOR_TRANSITION_KINDS = Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
+function normaliseKind(kind) {
+	return kind.trim().toLowerCase();
+}
+/**
+* true = the sensor is raised (water, smoke, open, tampered…), false = it
+* cleared, undefined = this kind has no raise or the slice cannot say.
+*/
+function sensorRaisedOf(kind, value) {
+	if (value === null) return void 0;
+	const field = NC_SENSOR_RAISED_FIELD_BY_KIND[normaliseKind(kind)];
+	if (field === void 0) return void 0;
+	const raw = Object.entries(value).find(([key]) => key === field)?.[1];
+	return typeof raw === "boolean" ? raw : void 0;
+}
+/**
+* THE SUPPORT RULE, shared by both editors: "Notify when" is offered only when
+* the rule names at least one sensor kind and EVERY kind it names has a raise.
+* A mixed rule (flood + doorbell) would hear "only when it clears" as "never
+* for the doorbell" in the operator's head while the engine lets the doorbell
+* through — so the choice is not offered, and an editor prunes it on save.
+*/
+function sensorTransitionOffered(sensorKinds) {
+	if (sensorKinds === void 0 || sensorKinds.length === 0) return false;
+	return sensorKinds.every((kind) => NC_SENSOR_TRANSITION_KINDS.includes(normaliseKind(kind)));
+}
+/** What an editor tells the operator when it is about to prune the choice. */
+var NC_SENSOR_TRANSITION_UNSUPPORTED_REASON = "Only a sensor that raises and clears (water, smoke, gas, CO, vibration, tamper, motion, contact) can fire on one edge. Pick only such sensor kinds, or the rule fires on every change.";
+//#endregion
 //#region src/notification/template-vars.ts
 var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
@@ -65910,6 +66151,7 @@ exports.NATIVE_LEASE_TILE_BUDGET_KEY = NATIVE_LEASE_TILE_BUDGET_KEY;
 exports.NAVIGATION_ACTION_CATALOG = NAVIGATION_ACTION_CATALOG;
 exports.NAVIGATION_LIGHT_LEVEL_MAX = NAVIGATION_LIGHT_LEVEL_MAX;
 exports.NAVIGATION_LIGHT_LEVEL_MIN = NAVIGATION_LIGHT_LEVEL_MIN;
+exports.NC_ALARM_OPENING_EVENT_KINDS = NC_ALARM_OPENING_EVENT_KINDS;
 exports.NC_ALARM_SYSTEM_EVENT_KINDS = NC_ALARM_SYSTEM_EVENT_KINDS;
 exports.NC_AUDIO_CONFIRM_HITS_DEFAULT = NC_AUDIO_CONFIRM_HITS_DEFAULT;
 exports.NC_AUDIO_CONFIRM_HITS_MAX = NC_AUDIO_CONFIRM_HITS_MAX;
@@ -65946,6 +66188,10 @@ exports.NC_RULE_CLEARABLE_KEYS = NC_RULE_CLEARABLE_KEYS;
 exports.NC_RULE_EDITOR_SECTION_ORDER = NC_RULE_EDITOR_SECTION_ORDER;
 exports.NC_RULE_KIND_SPECS = NC_RULE_KIND_SPECS;
 exports.NC_RULE_SECTIONS = NC_RULE_SECTIONS;
+exports.NC_SENSOR_RAISED_FIELD_BY_KIND = NC_SENSOR_RAISED_FIELD_BY_KIND;
+exports.NC_SENSOR_TRANSITION_KINDS = NC_SENSOR_TRANSITION_KINDS;
+exports.NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING = NC_SENSOR_TRANSITION_NEVER_FIRES_WARNING;
+exports.NC_SENSOR_TRANSITION_UNSUPPORTED_REASON = NC_SENSOR_TRANSITION_UNSUPPORTED_REASON;
 exports.NC_SERVER_PACKAGE_NAME = NC_SERVER_PACKAGE_NAME;
 exports.NC_SNOOZE_MAX_MINUTES = NC_SNOOZE_MAX_MINUTES;
 exports.NC_SYSTEM_DELIVERY = NC_SYSTEM_DELIVERY;
@@ -66015,6 +66261,8 @@ exports.NcRuleActionsSchema = NcRuleActionsSchema;
 exports.NcRuleClearableKeySchema = NcRuleClearableKeySchema;
 exports.NcRuleInputSchema = NcRuleInputSchema;
 exports.NcRuleKindSchema = NcRuleKindSchema;
+exports.NcRuleLastRunSchema = NcRuleLastRunSchema;
+exports.NcRuleLastRunsSchema = NcRuleLastRunsSchema;
 exports.NcRuleNotificationButtonSchema = NcRuleNotificationButtonSchema;
 exports.NcRulePatchSchema = NcRulePatchSchema;
 exports.NcRuleSchema = NcRuleSchema;
@@ -66023,6 +66271,7 @@ exports.NcRuleUpdateInputSchema = NcRuleUpdateInputSchema;
 exports.NcSceneConditionSchema = NcSceneConditionSchema;
 exports.NcScheduleSchema = NcScheduleSchema;
 exports.NcScheduleWindowSchema = NcScheduleWindowSchema;
+exports.NcSensorTransitionSchema = NcSensorTransitionSchema;
 exports.NcSnoozeInputSchema = NcSnoozeInputSchema;
 exports.NcSnoozeSchema = NcSnoozeSchema;
 exports.NcSnoozeScopeSchema = NcSnoozeScopeSchema;
@@ -66926,6 +67175,7 @@ exports.resolveStreamMaps = require_canonical_hash.resolveStreamMaps;
 exports.resolveVariantModelId = resolveVariantModelId;
 exports.resolveViewableDeviceIds = resolveViewableDeviceIds;
 exports.roleSpec = roleSpec;
+exports.ruleBelongsToAlarm = ruleBelongsToAlarm;
 exports.ruleEditorSectionsForKind = ruleEditorSectionsForKind;
 exports.ruleKindOf = ruleKindOf;
 exports.ruleKindSpec = ruleKindSpec;
@@ -66946,6 +67196,9 @@ exports.scoreRuntimes = scoreRuntimes;
 exports.scriptRunnerCapability = scriptRunnerCapability;
 exports.searchDisplayIcons = searchDisplayIcons;
 exports.selectAssignedProfileSlots = require_sleep.selectAssignedProfileSlots;
+exports.sensorRaisedOf = sensorRaisedOf;
+exports.sensorTransitionNeverFires = sensorTransitionNeverFires;
+exports.sensorTransitionOffered = sensorTransitionOffered;
 exports.serverManagementCapability = serverManagementCapability;
 exports.setByPath = setByPath;
 exports.settingsStoreCapability = settingsStoreCapability;