@camstack/addon-post-analysis 1.2.24 → 1.2.26

package/dist/{dist-MQmqxd7v.js → dist-CP-FTAl5.js}

@@ -20,7 +20,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-//#region ../types/dist/event-category-Bz24uP1U.mjs
+//#region ../types/dist/event-category-41fKf-q9.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -80,6 +80,26 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["AddonRetryScheduled"] = "addon.retry-scheduled";
 	/**
+	* A liveness invariant of this node is false — it has no devices, every
+	* camera is offline, or a camera that was recording has stopped producing
+	* segments. Emitted by the `liveness-monitor` builtin, once per fault (the
+	* `findingId` is stable across ticks), only after its boot grace period.
+	* AlertCenter raises a persistent operator-visible alert.
+	*
+	* It exists because on 2026-08-03 the hub ran four hours with zero devices
+	* and zero recordings while every surface stayed quiet.
+	*
+	* Payload: `{ findingId, severity, title, message, deviceId? }`.
+	*/
+	EventCategory["SystemLivenessFailed"] = "system.liveness-failed";
+	/**
+	* A previously reported liveness fault is true again. AlertCenter dismisses
+	* the matching `SystemLivenessFailed` alert.
+	*
+	* Payload: `{ findingId }`.
+	*/
+	EventCategory["SystemLivenessRecovered"] = "system.liveness-recovered";
+	/**
 	* Monitor is attempting to reload a failed addon NOW. UI uses this
 	* to show a spinner during the retry attempt. Same transient nature
 	* as AddonRetryScheduled.
@@ -8394,6 +8414,60 @@ function buildNcTaxonomy() {
 /** The frozen NC taxonomy, derived once from the taxonomy dictionary. */
 var NC_TAXONOMY = Object.freeze(buildNcTaxonomy());
 /**
+* Most specific first. Extending this list is how a new device kind becomes
+* gateable; nothing else needs to change.
+*/
+var DEVICE_STATE_READERS = [
+	{
+		cap: "alarm-panel",
+		field: "state"
+	},
+	{
+		cap: "cover",
+		field: "state"
+	},
+	{
+		cap: "presence",
+		field: "state"
+	},
+	{
+		cap: "lock",
+		field: "locked",
+		booleanWords: ["locked", "unlocked"]
+	},
+	{
+		cap: "contact",
+		field: "entryOpen",
+		booleanWords: ["open", "closed"]
+	},
+	{
+		cap: "switch",
+		field: "on",
+		booleanWords: ["on", "off"]
+	},
+	{
+		cap: "binary",
+		field: "on",
+		booleanWords: ["on", "off"]
+	}
+];
+/**
+* Collapse a device's full runtime state to the one string a rule compares
+* against, or `undefined` when nothing in the table applies.
+*
+* `undefined` is the safe answer everywhere: the gate treats it as "does not
+* match", so a device whose kind we cannot read simply never arms a rule.
+*/
+function readDeviceStateFrom(runtimeState) {
+	for (const reader of DEVICE_STATE_READERS) {
+		const slice = runtimeState[reader.cap];
+		if (slice === null || typeof slice !== "object") continue;
+		const value = slice[reader.field];
+		if (typeof value === "string" && value.length > 0) return value;
+		if (typeof value === "boolean" && reader.booleanWords !== void 0) return value ? reader.booleanWords[0] : reader.booleanWords[1];
+	}
+}
+/**
 * Error types for the safe expression engine. Two distinct classes so callers
 * can tell a compile-time (grammar) failure from a runtime (evaluation)
 * failure — both are non-fatal to the host: read paths degrade to "skip link".
@@ -9216,11 +9290,13 @@ var NcZoneConditionSchema = object({
 	/** Quantifier over `ids` — at least one / every one visited. */
 	match: _enum(["any", "all"]).default("any")
 });
-/**
-* The P1 condition set — a flat AND of groups; absent group = pass;
-* membership lists are OR within the list (spec §2.3).
-*/
 var NcConditionsSchema = object({
+	/** Gate on ANOTHER device's current state (the alarm armed, a switch on). */
+	deviceState: object({
+		deviceId: number().int(),
+		/** Any of these matches. */
+		states: array(string().min(1)).min(1)
+	}).optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number()).optional(),
 	/** Detector class names (any overlap with the record's class set). */
@@ -9421,6 +9497,14 @@ var NcMediaPolicySchema = object({
 	clipPreRollSec: number().int().min(0).max(30).optional(),
 	clipPostRollSec: number().int().min(0).max(30).optional(),
 	/**
+	* Playback rate of the attached gif / clip. Absent = 2x.
+	*
+	* A notification clip is GLANCED at on a lock screen, not watched: at real
+	* time an eight-second passage is eight seconds of the recipient's attention
+	* and twice the bytes. 1 is real time for the operator who wants it.
+	*/
+	clipSpeed: number().min(1).max(8).optional(),
+	/**
 	* Which stream profile the footage is cut from. Absent = the CHEAPEST
 	* assigned profile: a notification is watched on a phone, so the 4K
 	* rendition would burn CPU to produce a file the client downscales anyway.
@@ -9492,7 +9576,21 @@ var NcRuleInputSchema = object({
 	* behaviour, visible to all, read-only in the viewer). Present = personal
 	* rule owned by this userId. Server-stamped; never trusted from a client.
 	*/
-	ownerUserId: string().optional()
+	ownerUserId: string().optional(),
+	/**
+	* May a non-admin snooze this rule for EVERYONE, not just themselves?
+	*
+	* A snooze is personal by default — it silences the person who set it. This
+	* opts THIS rule into the "the gardener is here all afternoon" case, where
+	* silencing the camera for the whole household is legitimate. It silences
+	* other people, so it is off unless a rule deliberately allows it.
+	*
+	* `.optional()`, deliberately NOT `.default()`: a Zod default does not run on
+	* the addon cap path (three production failures in one day), so absent is
+	* read as `false` by {@link canSetGlobal} in the engine. Admins are not bound
+	* by this flag — see the scope rules on that function.
+	*/
+	snoozeAllowGlobal: boolean().optional()
 });
 /**
 * Partial patch for `updateRule` — any subset of the input fields, plus the
@@ -9563,7 +9661,8 @@ var NcConditionDescriptorSchema = object({
 		"packagePhase",
 		"crossingSelect",
 		"polygonDraw",
-		"occupancy"
+		"occupancy",
+		"deviceState"
 	]),
 	operator: _enum([
 		"in",
@@ -9577,7 +9676,28 @@ var NcConditionDescriptorSchema = object({
 	/** Which delivery kinds the condition applies to. */
 	appliesTo: array(NcDeliverySchema),
 	phase: string(),
-	description: string().optional()
+	description: string().optional(),
+	/**
+	* The CHOICES for a single-choice widget (`sourceSelect`, `crossingSelect`,
+	* `packagePhase`, …), served with the descriptor.
+	*
+	* Before this the descriptor said which widget to render and not what to put
+	* in it, so every option list lived in three places: this file's enums, the
+	* admin's `NC_*_OPTIONS` and the viewer's `NC_*_VALUES`. That triple mirror
+	* is the drift that emptied the viewer's rule editor on 2026-08-04 — the app
+	* mirrors the cap by hand, so it is only ever as current as its last build.
+	*
+	* With the options on the wire, a condition of an EXISTING `valueType` costs
+	* zero client changes. Clients keep a local fallback for an older hub that
+	* does not send them; absent here is "use your own list", not "no choices".
+	*/
+	options: array(object({
+		/** Written to the rule verbatim. `''` means the ABSENT state. */
+		value: string(),
+		label: string(),
+		/** What THIS choice matches — shown one at a time, under the control. */
+		hint: string().optional()
+	})).readonly().optional()
 });
 /**
 * The P1 condition surface as data — served by `getConditionCatalog` so
@@ -9671,6 +9791,28 @@ var NC_CONDITION_CATALOG = [
 		group: "zones",
 		label: "Zone crossing",
 		valueType: "crossingSelect",
+		options: [
+			{
+				value: "",
+				label: "Not set — entering",
+				hint: "Entries, and every detection that is not a crossing at all. Exits are excluded. This is what a rule without a crossing condition already does, and choosing it writes nothing to the rule."
+			},
+			{
+				value: "enter",
+				label: "Entered a zone",
+				hint: "The same matches as \"not set\", stated explicitly: entries and non-crossing detections pass, exits do not."
+			},
+			{
+				value: "exit",
+				label: "Left a zone",
+				hint: "ONLY an exit crossing. A detection that is not a crossing fails, so this rule cannot fire on ordinary movement — pair it with the zones the subject must have left. Also matches a tripwire crossed against its drawn direction."
+			},
+			{
+				value: "any",
+				label: "Entered or left",
+				hint: "No direction filter: entries, exits and non-crossing detections alike. This is the only choice that adds exits to what the rule already matched."
+			}
+		],
 		operator: "in",
 		appliesTo: ["immediate"],
 		phase: "P1",
@@ -9751,6 +9893,24 @@ var NC_CONDITION_CATALOG = [
 		group: "scope",
 		label: "Detection source",
 		valueType: "sourceSelect",
+		options: [
+			{
+				value: "any",
+				label: "Any source"
+			},
+			{
+				value: "pipeline",
+				label: "Pipeline"
+			},
+			{
+				value: "onboard",
+				label: "Onboard (camera)"
+			},
+			{
+				value: "sensor",
+				label: "Sensor"
+			}
+		],
 		operator: "in",
 		appliesTo: [
 			"immediate",
@@ -9761,6 +9921,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "pipeline / onboard / sensor; a record with no stamped source counts as pipeline."
 	},
+	{
+		id: "deviceState",
+		group: "scope",
+		label: "Device state",
+		valueType: "deviceState",
+		operator: "in",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P2",
+		description: "Only fire while another device is in one of the chosen states — the alarm armed, a switch on, a contact closed. A state that cannot be read does NOT fire."
+	},
 	{
 		id: "sensorKinds",
 		group: "device",
@@ -9786,6 +9961,20 @@ var NC_CONDITION_CATALOG = [
 		group: "package",
 		label: "Package phase",
 		valueType: "packagePhase",
+		options: [
+			{
+				value: "delivered",
+				label: "Delivered"
+			},
+			{
+				value: "picked-up",
+				label: "Picked up"
+			},
+			{
+				value: "both",
+				label: "Both"
+			}
+		],
 		operator: "in",
 		appliesTo: ["package-event"],
 		phase: "P1",
@@ -9914,6 +10103,75 @@ var NcHistoryFilterSchema = object({
 	until: number().optional(),
 	limit: number().int().min(1).max(500).default(100)
 });
+/**
+* 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.
+*/
+var NcSnoozeScopeSchema = _enum([
+	"rule",
+	"device",
+	"all"
+]);
+/**
+* Client-authored snooze. The server stamps `userId`, `startedAt` and
+* `expiresAt` — a DURATION is sent rather than an instant so a client with a
+* skewed clock cannot author a window that is already over, or never ends.
+*/
+var NcSnoozeInputSchema = object({
+	scope: NcSnoozeScopeSchema,
+	/** Required when `scope: 'rule'` — a scoped snooze with no id matches
+	*  NOTHING rather than degrading to "everything". */
+	ruleId: string().optional(),
+	/** Required when `scope: 'device'`. */
+	deviceId: number().int().optional(),
+	durationMinutes: number().int().min(1).max(1440),
+	/**
+	* Silence this for EVERY recipient, not just the caller. Permission is
+	* checked server-side (the rule's `snoozeAllowGlobal`, or admin for the
+	* broader scopes). Absent = personal.
+	*/
+	global: boolean().optional(),
+	/**
+	* Deliver a summary of what was suppressed when the window ends. Absent =
+	* ON: someone silencing a nuisance camera wants it off, someone silencing a
+	* SECURITY camera wants to know what they missed, and choosing "off" for
+	* everybody is how a snooze becomes an outage. Resolved to a concrete
+	* boolean by the server at create time — never left to a Zod default, which
+	* does not run on the addon cap path.
+	*/
+	summary: boolean().optional()
+});
+/** A persisted snooze window. */
+var NcSnoozeSchema = object({
+	id: string(),
+	/** Who set it. Also who it silences, unless `global`. */
+	userId: string(),
+	scope: NcSnoozeScopeSchema,
+	ruleId: string().optional(),
+	deviceId: number().int().optional(),
+	startedAt: number(),
+	/** Exclusive: at exactly this instant the snooze is over. Expiry is a
+	*  COMPARISON, not a job — no sweeper can leave the operator silenced. */
+	expiresAt: number(),
+	global: boolean(),
+	summary: boolean(),
+	/** When the end-of-window digest went out. Absent = not sent (yet, or the
+	*  window has not closed, or `summary` is false). */
+	digestSentAt: number().optional()
+});
+/** One line of an end-of-window digest: what one rule hid on one camera. */
+var NcSnoozeSuppressedSchema = object({
+	snoozeId: string(),
+	targetId: string(),
+	ruleId: string(),
+	ruleName: string(),
+	deviceId: number().int(),
+	/** How many notifications this snooze hid for that pair. */
+	count: number().int(),
+	firstAt: number(),
+	lastAt: number()
+});
 var notificationRulesCapability = {
 	name: "notification-rules",
 	scope: "system",
@@ -9980,7 +10238,36 @@ var notificationRulesCapability = {
 		* P1 (no user dimension); the P2 viewer History screen adds per-caller
 		* scoping on the same method.
 		*/
-		getHistory: method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" })
+		getHistory: method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }),
+		/**
+		* Snooze windows currently in effect, plus any whose digest has not yet
+		* gone out. `caller: 'required'`: a user sees their OWN windows and the
+		* global ones that silence them, never another person's private silence.
+		* An admin sees every window — a household-wide silence is exactly the
+		* thing an operator has to be able to find and cancel.
+		*/
+		listSnoozes: method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }),
+		/**
+		* Open a window. `userId` is stamped from the caller; a GLOBAL window is
+		* permission-checked server-side (the rule's `snoozeAllowGlobal` for a
+		* rule-scoped one, admin for a camera or the whole feed) — a client asking
+		* for one it may not have is rejected, never silently downgraded, because
+		* a snooze the operator believes is in effect and is not is the same
+		* failure as one they cannot end.
+		*/
+		createSnooze: method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
+			kind: "mutation",
+			caller: "required"
+		}),
+		/**
+		* End a window NOW. The digest still goes out (what was hidden while it
+		* was open is still what the operator missed); only the silence stops.
+		* A user may cancel their own; an admin may cancel any.
+		*/
+		cancelSnooze: method(object({ snoozeId: string() }), object({ success: literal(true) }), {
+			kind: "mutation",
+			caller: "required"
+		})
 	}
 };
 /**
@@ -10760,7 +11047,15 @@ method(object({
 	format: _enum(["gif", "mp4"]).default("gif"),
 	maxWidth: number().int().min(120).max(1920).default(480),
 	/** GIF only — MP4 keeps the source cadence. */
-	fps: number().int().min(1).max(15).default(5)
+	fps: number().int().min(1).max(15).default(5),
+	/**
+	* Playback rate. A notification clip is GLANCED at on a lock screen,
+	* not watched, so 2x is the default: the recipient sees the whole
+	* passage in half the time and the GIF is half the bytes. `1` is real
+	* time. Applies to MP4 as well — the operator set a speed, not a GIF
+	* speed.
+	*/
+	speed: number().min(1).max(8).default(2)
 }), object({
 	base64: string(),
 	mime: string(),
@@ -25159,12 +25454,24 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.cancelSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.createRule": {
 		capName: "notification-rules",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"notificationRules.createSnooze": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.deleteRule": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -25195,6 +25502,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.listSnoozes": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.setRuleEnabled": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -27600,6 +27913,24 @@ Object.defineProperty(exports, "NcRuleSchema", {
 		return NcRuleSchema;
 	}
 });
+Object.defineProperty(exports, "NcSnoozeInputSchema", {
+	enumerable: true,
+	get: function() {
+		return NcSnoozeInputSchema;
+	}
+});
+Object.defineProperty(exports, "NcSnoozeSchema", {
+	enumerable: true,
+	get: function() {
+		return NcSnoozeSchema;
+	}
+});
+Object.defineProperty(exports, "NcSnoozeSuppressedSchema", {
+	enumerable: true,
+	get: function() {
+		return NcSnoozeSuppressedSchema;
+	}
+});
 Object.defineProperty(exports, "NcTaxonomySchema", {
 	enumerable: true,
 	get: function() {
@@ -27762,6 +28093,12 @@ Object.defineProperty(exports, "plateGalleryCapability", {
 		return plateGalleryCapability;
 	}
 });
+Object.defineProperty(exports, "readDeviceStateFrom", {
+	enumerable: true,
+	get: function() {
+		return readDeviceStateFrom;
+	}
+});
 Object.defineProperty(exports, "string", {
 	enumerable: true,
 	get: function() {