@camstack/addon-post-analysis 1.2.34 → 1.2.35

package/dist/{dist-7ujnICn7.js → dist-Cmb3B0Ij.js}

@@ -9454,6 +9454,100 @@ function shallowEqual(a, b) {
 }
 new Set(["devices", "classes"]);
 /**
+* Alarm-panel cap. Models HA `alarm_control_panel.*` on
+* `DeviceType.AlarmPanel`. State follows HA's canonical lifecycle
+* across disarmed / armed_(home|away|night|vacation|custom_bypass) /
+* arming / pending / triggered / disarming.
+*
+* Many panels require a PIN code on arm / disarm — the optional
+* `code` field on the methods passes it through to the upstream
+* service; it's NEVER persisted in the runtime slice or any event
+* payload. The presence of a required code is signalled by
+* `DeviceFeature.AlarmPinRequired` so the UI gates a code-entry
+* field without a slice fetch.
+*
+* `availableModes` mirrors HA's `supported_features`-derived arm
+* mode list — the UI renders only the buttons the panel accepts.
+*/
+var AlarmStateSchema = _enum([
+	"disarmed",
+	"armed_home",
+	"armed_away",
+	"armed_night",
+	"armed_vacation",
+	"armed_custom_bypass",
+	"arming",
+	"disarming",
+	"pending",
+	"triggered"
+]);
+var AlarmArmModeSchema = _enum([
+	"home",
+	"away",
+	"night",
+	"vacation",
+	"custom_bypass"
+]);
+var AlarmPanelStatusSchema = object({
+	/** Current lifecycle state. */
+	state: AlarmStateSchema,
+	/** Subset of arm modes the panel accepts. UI renders one button per
+	*  mode in this list. */
+	availableModes: array(AlarmArmModeSchema),
+	/** Whether the panel requires a PIN on arm / disarm. Mirrors
+	*  `DeviceFeature.AlarmPinRequired` for slice consumers. */
+	requiresCode: boolean(),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+var alarmPanelCapability = {
+	name: "alarm-panel",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [DeviceType.AlarmPanel],
+	methods: {
+		arm: method(object({
+			deviceId: number().int().nonnegative(),
+			mode: AlarmArmModeSchema,
+			/** Optional PIN code. Required when `requiresCode === true`.
+			*  Passed through to the upstream service; never persisted. */
+			code: string().min(1).optional()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		disarm: method(object({
+			deviceId: number().int().nonnegative(),
+			code: string().min(1).optional()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Force the panel into the `triggered` state — used by HA
+		* automations to surface external sensor events through the panel
+		* (e.g. a Reolink camera intrusion event firing the security
+		* system). Provider rejects when the panel hardware doesn't
+		* support a software-initiated trigger.
+		*/
+		trigger: method(object({ deviceId: number().int().nonnegative() }), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	status: {
+		schema: AlarmPanelStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice — mirrored by the kernel. UI panel reads the
+	* full slice; renders an arm button per `availableModes` entry and
+	* a PIN field iff `requiresCode === true`.
+	*/
+	runtimeState: AlarmPanelStatusSchema
+};
+/**
 * Shared geometry vocabulary for on-frame shape caps — privacy-mask,
 * motion-zones, and the detection zones/lines editor all speak this one
 * language so a single drawing-plane editor and the providers stay
@@ -10442,7 +10536,7 @@ var NC_CONDITION_CATALOG = [
 	{
 		id: "devices",
 		group: "scope",
-		label: "Cameras",
+		label: "Devices",
 		valueType: "deviceIdList",
 		operator: "in",
 		appliesTo: [
@@ -10452,7 +10546,7 @@ var NC_CONDITION_CATALOG = [
 			"package-event"
 		],
 		phase: "P1",
-		description: "Restrict the rule to these devices; absent = all devices."
+		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: "classes",
@@ -10907,6 +11001,67 @@ var NcSnoozeSuppressedSchema = object({
 	firstAt: number(),
 	lastAt: number()
 });
+/**
+* The three durations the panel's state machine runs on, plus who hears about
+* an arm.
+*
+* They live on the NOTIFICATION-RULES cap, not on `alarm-panel`, on purpose:
+* `alarm-panel` is `deviceNative` and its other provider mirrors somebody
+* else's panel, which has its own delays and no way to be told these. This is
+* configuration of the panel CamStack owns, and the Notification Center owns
+* that panel.
+*/
+var NcAlarmSettingsSchema = object({
+	/** Grace period between arming and the mode taking effect. 0 = immediate. */
+	exitDelaySec: number().int().min(0).max(600),
+	/** Grace period between a trigger and the alarm firing. 0 = immediate. */
+	entryDelaySec: number().int().min(0).max(600),
+	/**
+	* 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),
+	/** Send a notification when a mode takes effect. */
+	announceArm: boolean(),
+	/**
+	* Where that notification goes. Target ids from `notification-output`.
+	*
+	* Explicit rather than "everyone": an arm announcement is a household
+	* message, and broadcasting it to every configured endpoint (including a
+	* webhook wired to something else) is not a default anybody would choose.
+	* Empty with `announceArm: true` sends nothing, and the server logs that —
+	* silence must be attributable.
+	*/
+	announceTargets: array(string().min(1)).max(16)
+});
+/** Every field optional — a tab edits one control at a time. */
+var NcAlarmSettingsPatchSchema = NcAlarmSettingsSchema.partial();
+/**
+* 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
+* copy would lie the first time a rule is disabled.
+*/
+var NcAlarmModeCoverageSchema = object({
+	mode: AlarmArmModeSchema,
+	/** Enabled rules gated on `armed_<mode>`. Zero means the mode does nothing. */
+	ruleCount: number().int().min(0),
+	/** At least one covering rule has no device scope, so the mode covers all. */
+	allDevices: boolean(),
+	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
+	deviceIds: array(number().int())
+});
+var NcAlarmConfigSchema = object({
+	/**
+	* The panel's device id, or null when this install has no panel (the ensure
+	* step failed, or this is not the hub). Null is the honest answer: an editor
+	* that rendered delays for a panel that does not exist would be a form whose
+	* Save does nothing.
+	*/
+	deviceId: number().int().nullable(),
+	settings: NcAlarmSettingsSchema,
+	coverage: array(NcAlarmModeCoverageSchema)
+});
 var notificationRulesCapability = {
 	name: "notification-rules",
 	scope: "system",
@@ -11002,6 +11157,26 @@ var notificationRulesCapability = {
 		cancelSnooze: method(object({ snoozeId: string() }), object({ success: literal(true) }), {
 			kind: "mutation",
 			caller: "required"
+		}),
+		/**
+		* The alarm panel's durations, plus what each mode ACTUALLY arms.
+		*
+		* Coverage is returned by the same call as the settings on purpose: they
+		* are read together or not at all. An editor that showed the delays
+		* without the coverage would let an operator tune an exit delay for a mode
+		* that arms nothing, which is the failure this whole surface exists to
+		* make visible.
+		*/
+		getAlarmConfig: method(object({}), NcAlarmConfigSchema, { auth: "admin" }),
+		/**
+		* Patch the durations. Returns the WHOLE config, coverage 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
+		* show a value the alarm is not using.
+		*/
+		setAlarmConfig: method(object({ patch: NcAlarmSettingsPatchSchema }), NcAlarmConfigSchema, {
+			kind: "mutation",
+			auth: "admin"
 		})
 	}
 };
@@ -11265,100 +11440,6 @@ var airQualitySensorCapability = {
 	runtimeState: AirQualitySensorStatusSchema
 };
 /**
-* Alarm-panel cap. Models HA `alarm_control_panel.*` on
-* `DeviceType.AlarmPanel`. State follows HA's canonical lifecycle
-* across disarmed / armed_(home|away|night|vacation|custom_bypass) /
-* arming / pending / triggered / disarming.
-*
-* Many panels require a PIN code on arm / disarm — the optional
-* `code` field on the methods passes it through to the upstream
-* service; it's NEVER persisted in the runtime slice or any event
-* payload. The presence of a required code is signalled by
-* `DeviceFeature.AlarmPinRequired` so the UI gates a code-entry
-* field without a slice fetch.
-*
-* `availableModes` mirrors HA's `supported_features`-derived arm
-* mode list — the UI renders only the buttons the panel accepts.
-*/
-var AlarmStateSchema = _enum([
-	"disarmed",
-	"armed_home",
-	"armed_away",
-	"armed_night",
-	"armed_vacation",
-	"armed_custom_bypass",
-	"arming",
-	"disarming",
-	"pending",
-	"triggered"
-]);
-var AlarmArmModeSchema = _enum([
-	"home",
-	"away",
-	"night",
-	"vacation",
-	"custom_bypass"
-]);
-var AlarmPanelStatusSchema = object({
-	/** Current lifecycle state. */
-	state: AlarmStateSchema,
-	/** Subset of arm modes the panel accepts. UI renders one button per
-	*  mode in this list. */
-	availableModes: array(AlarmArmModeSchema),
-	/** Whether the panel requires a PIN on arm / disarm. Mirrors
-	*  `DeviceFeature.AlarmPinRequired` for slice consumers. */
-	requiresCode: boolean(),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-var alarmPanelCapability = {
-	name: "alarm-panel",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.AlarmPanel],
-	methods: {
-		arm: method(object({
-			deviceId: number().int().nonnegative(),
-			mode: AlarmArmModeSchema,
-			/** Optional PIN code. Required when `requiresCode === true`.
-			*  Passed through to the upstream service; never persisted. */
-			code: string().min(1).optional()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		disarm: method(object({
-			deviceId: number().int().nonnegative(),
-			code: string().min(1).optional()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Force the panel into the `triggered` state — used by HA
-		* automations to surface external sensor events through the panel
-		* (e.g. a Reolink camera intrusion event firing the security
-		* system). Provider rejects when the panel hardware doesn't
-		* support a software-initiated trigger.
-		*/
-		trigger: method(object({ deviceId: number().int().nonnegative() }), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	status: {
-		schema: AlarmPanelStatusSchema,
-		kind: "push"
-	},
-	/**
-	* Runtime-state slice — mirrored by the kernel. UI panel reads the
-	* full slice; renders an arm button per `availableModes` entry and
-	* a PIN field iff `requiresCode === true`.
-	*/
-	runtimeState: AlarmPanelStatusSchema
-};
-/**
 * Ambient illuminance reading in lux. Drives Home Assistant `sensor`
 * entries with `device_class: illuminance`.
 */
@@ -18807,6 +18888,20 @@ var GetInputSchema = object({ id: string() });
 var AddInputSchema = object({
 	kind: string().min(1),
 	name: string().min(1),
+	/**
+	* ADOPT an existing id instead of minting a new one.
+	*
+	* Written the day this cost an outage. A broker's id is not a detail: HA
+	* devices carry it inside their `stableId` (`ha:ha_004:dev:…`), so a broker
+	* lost from config and re-added as `ha_001` leaves every one of its devices
+	* bound to a broker that no longer exists. Re-entering the password under the
+	* ORIGINAL id turns a multi-step device migration back into re-entering a
+	* password.
+	*
+	* A provider MUST refuse an id that is already in use — adopting a live
+	* broker's id would silently take it over.
+	*/
+	id: string().min(1).optional(),
 	/** Kind-specific settings (e.g. MQTT `{url,username,password}` or HA
 	*  `{baseUrl,accessToken}`). Validated by the kind-specific provider
 	*  branch on receipt — invalid shape rejects the add. */
@@ -28586,6 +28681,12 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"notificationRules.getAlarmConfig": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getConditionCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -28616,6 +28717,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.setAlarmConfig": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"notificationRules.setRuleEnabled": {
 		capName: "notification-rules",
 		capScope: "system",