@camstack/types 1.2.66 → 1.2.68

package/dist/index.d.ts

@@ -119,7 +119,7 @@ export { AutomationActionSchema, AutomationConditionOperatorSchema, AutomationCo
 export * from './cap-call-context.js';
 export * from './capabilities/index.js';
 export { APPLE_SA_TO_MACRO, AUDIO_MACRO_LABELS, getAudioMacroClassIds, mapAudioLabelToMacro, YAMNET_TO_MACRO, } from './catalogs/audio-classmap.js';
-export { COCO_80_LABELS, COCO_TO_MACRO, MACRO_LABELS, } from './catalogs/coco-classmap.js';
+export { COCO_80_LABELS, COCO_TO_MACRO, DETECTION_MACRO_CLASSES, isDetectionMacroClass, MACRO_LABELS, } from './catalogs/coco-classmap.js';
 export { DEVICE_STATE_READERS, readDeviceStateFrom, stateVocabularyFor, } from './catalogs/device-state-vocabulary.js';
 export { colorForKind, DEFAULT_EVENT_COLOR, EVENT_TAXONOMY, type EventTaxonomyCategory, type EventTaxonomyEntry, type EventTaxonomyLevel, getTaxonomyEntry, subKindsOf, TAXONOMY_COLORS, } from './catalogs/event-taxonomy.js';
 export { buildNcTaxonomy, NC_TAXONOMY, type NcTaxonomy, type NcTaxonomyEntry, NcTaxonomyEntrySchema, NcTaxonomySchema, } from './catalogs/nc-taxonomy.js';

package/dist/index.js

@@ -10467,11 +10467,33 @@ var NotificationFormatSchema = zod.z.enum([
 * Named by INTENT, never by glyph. "check" would tie the vocabulary to one
 * renderer's icon set; "acknowledge" survives an adapter that draws it
 * differently.
+*
+* ── A TOKEN IS NOT A WIRE VALUE ─────────────────────────────────────
+*
+* These names are for US. **No adapter may forward one verbatim.** Each maps
+* the whole set onto its own renderer's vocabulary through a
+* `Record<NotificationActionIcon, string>` — a Record, never a lookup with a
+* fallback, so adding a member here fails every adapter's build until someone
+* decides its glyph, which is the only place that decision can be made
+* honestly.
+*
+* This paragraph is the bug. Zentik declared `actionIcons: true` and passed
+* `disarm` straight through; iOS feeds that string to
+* `UNNotificationActionIcon(systemImageName:)`, `disarm` is not an SF Symbol,
+* and every snooze and alarm button arrived BLANK. A pass-through is not a
+* mapping, and "the field is documented" is not "the value renders".
+*
+* Adding a member is TRAIN-BOUND. The enum lives in the published
+* `@camstack/server` closure and the cap seam validates against the HUB's copy,
+* so an addon that emits a token the running hub does not know does not lose an
+* icon — its whole `send` fails Zod validation and the notification never
+* arrives. Never emit a new token from an addon before the train carrying it.
 */
 var NotificationActionIconSchema = zod.z.enum([
 	"acknowledge",
 	"dismiss",
 	"silence",
+	"snooze",
 	"view",
 	"play",
 	"open",
@@ -10479,9 +10501,13 @@ var NotificationActionIconSchema = zod.z.enum([
 	"lock",
 	"unlock",
 	"arm",
+	"arm-home",
+	"arm-away",
+	"arm-night",
 	"disarm",
 	"light",
-	"alert"
+	"alert",
+	"camera"
 ]);
 /** A single tap-through action button. */
 var NotificationActionSchema = zod.z.object({
@@ -11039,6 +11065,29 @@ var MACRO_LABELS = [
 		name: "Package"
 	}
 ];
+/**
+* The class names a per-class COUNT can ever be keyed on — the macro ids, and
+* only those.
+*
+* `preserveOriginal: false` below is the whole reason this set exists: the
+* executor maps each raw COCO label onto its macro and DROPS everything else,
+* so a tracked detection's `className` is always one of {@link MACRO_LABELS}.
+* Any surface that indexes counts by class name — the ZoneAnalytics occupancy
+* snapshot's `byClass`, and therefore every occupancy rule — can match nothing
+* else. Derived from the catalog, never hand-listed, so a new macro joins it by
+* being declared once.
+*
+* Cost of not having it, 2026-08-12: the notification rule editor offered the
+* full taxonomy for an occupancy class (occupancy is the one condition that
+* does not go through the engine's macro-expanding `expandClassSelector`), two
+* live rules were authored on `car`, and both counters read 0 forever.
+*/
+var DETECTION_MACRO_CLASSES = new Set(MACRO_LABELS.map((l) => l.id));
+/** True when `className` is a macro the detector can actually emit (and hence a
+*  class a count can be keyed on) — see {@link DETECTION_MACRO_CLASSES}. */
+function isDetectionMacroClass(className) {
+	return DETECTION_MACRO_CLASSES.has(className.trim().toLowerCase());
+}
 var COCO_TO_MACRO = {
 	mapping: {
 		person: "person",
@@ -11914,6 +11963,8 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"alarm-triggered",
 	"alarm-armed",
 	"alarm-disarmed",
+	"alarm-arming",
+	"alarm-arm-refused",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -11933,16 +11984,22 @@ var NC_LEGACY_SYSTEM_EVENT_KINDS = new Set([
 */
 var NC_AUTHORABLE_SYSTEM_EVENT_KINDS = NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KINDS.has(kind));
 /**
-* The panel's three transitions, as ONE list.
+* The panel's transitions, as ONE list.
 *
 * Named here rather than spelled out at each of the four sites that need them
 * (the emitter, the intake, the editor group, the combined-notification gate),
-* because a fourth transition added to the enum and forgotten at one of them is
-* an alarm state nobody can be notified about.
+* because a transition added to the enum and forgotten at one of them is an
+* alarm state nobody can be notified about. That is exactly what this list
+* failed to prevent while it held three: `alarm-arming` was the fourth.
+*
+* In LIFECYCLE order, which is the order an editor lists them in and the order
+* a person experiences them — not the order they were added.
 */
 var NC_ALARM_SYSTEM_EVENT_KINDS = [
-	"alarm-triggered",
+	"alarm-arm-refused",
+	"alarm-arming",
 	"alarm-armed",
+	"alarm-triggered",
 	"alarm-disarmed"
 ];
 /**
@@ -12873,13 +12930,17 @@ var NC_CONDITION_CATALOG = [
 				label: "Server update available"
 			},
 			{
-				value: "alarm-triggered",
-				label: "Alarm triggered"
+				value: "alarm-arming",
+				label: "Alarm arming (exit delay)"
 			},
 			{
 				value: "alarm-armed",
 				label: "Alarm armed"
 			},
+			{
+				value: "alarm-triggered",
+				label: "Alarm triggered"
+			},
 			{
 				value: "alarm-disarmed",
 				label: "Alarm disarmed"
@@ -16350,10 +16411,26 @@ var detectionFpsField = {
 	default: 10,
 	step: 1
 };
+/**
+* The occupancy re-check interval. DEFAULT 300 s (2026-08-13 — was 30 s).
+*
+* The recheck is now on by default (a parked car is invisible to occupancy
+* rules until the stationary registry has been rebuilt by motion, which after a
+* restart may be never on a quiet camera). Each cycle re-subscribes a detection
+* session — an RTSP re-dial — so the switch is only affordable at a WIDE
+* interval: 300 s is ~12 re-dials an hour per camera, against 120 at the old
+* 30 s. A parked car is therefore counted within 5 minutes of a restart.
+*
+* Why not wider: `max` is 300 and raising it is TRAIN-BOUND, not addon-bound —
+* the host validates `attachCamera` against ITS copy of this schema, so a
+* runner asked for 600 would be rejected by the hub until a `@camstack/server`
+* carrying the wider bound is installed everywhere. 300 is the widest value
+* that ships with an addon deploy.
+*/
 var occupancyRecheckSecField = {
 	min: 0,
 	max: 300,
-	default: 30,
+	default: 300,
 	step: 5
 };
 var occupancyRecheckFramesField = {
@@ -16551,15 +16628,21 @@ var RunnerCameraConfigSchema = zod.z.object({
 	*/
 	onboardMotionDrivesAnalyzer: zod.z.boolean().default(true),
 	/**
-	* Master toggle for the occupancy re-check. When `false` (DEFAULT) the runner
-	* never arms the periodic recheck timer, regardless of `occupancyRecheckSec` —
-	* this is off by default because the recheck re-subscribes a detection session
-	* every N seconds while `watching`, a major source of pull-decoder re-dial
-	* churn (each cycle creates+tears a session → RTSP re-dial → latency). The
+	* Master toggle for the occupancy re-check. When `false` the runner never arms
+	* the periodic recheck timer, regardless of `occupancyRecheckSec`; the
 	* `occupancyRecheckSec` / `occupancyRecheckFrames` sliders only take effect
 	* (and only render) when this is enabled.
-	*/
-	occupancyRecheckEnabled: zod.z.boolean().default(false),
+	*
+	* DEFAULT `true` since 2026-08-13 (was `false`). It was off because the
+	* recheck re-subscribes a detection session every N seconds while `watching`
+	* — each cycle creates+tears a session ⇒ an RTSP re-dial ⇒ latency, a major
+	* pull-decoder churn source. What that bought was a blind spot: a STATIONARY
+	* object is counted only while the stationary registry holds it, and the
+	* registry rebuilds from motion, so after a restart a parked car was invisible
+	* to every occupancy rule until something moved in front of it. The churn is
+	* now paid on the interval instead — see `occupancyRecheckSecField`.
+	*/
+	occupancyRecheckEnabled: zod.z.boolean().default(true),
 	occupancyRecheckSec: zod.z.number().min(occupancyRecheckSecField.min).max(occupancyRecheckSecField.max).default(occupancyRecheckSecField.default),
 	occupancyRecheckFrames: zod.z.number().min(occupancyRecheckFramesField.min).max(occupancyRecheckFramesField.max).default(occupancyRecheckFramesField.default),
 	/**
@@ -16692,8 +16775,8 @@ var RunnerCameraDeviceUIFields = [
 		type: "boolean",
 		style: "checkbox",
 		label: "Occupancy re-check",
-		description: "Periodically re-sample a few frames during the watching phase to confirm the scene is truly empty (catches stationary objects motion-gating would miss). Off by default — it adds decoder re-dial churn.",
-		default: false
+		description: "Periodically re-sample a few frames during the watching phase, so objects that are simply parked are still counted (motion gating alone loses them after a restart). On by default at a wide interval; turn it off on cameras where the extra decoder re-dial is expensive.",
+		default: true
 	},
 	{
 		key: "occupancyRecheckSec",
@@ -31657,11 +31740,40 @@ var SystemMirror = class {
 			cb(deviceId, lastInfo);
 		} catch {}
 	}
+	/**
+	* ONE device's bindings, not the fleet's.
+	*
+	* This runs on every `capability.binding-changed` AND on every
+	* `device.registered`, per mirror. It used to answer that with
+	* `getAllBindings` and `.find()` the one row — measured on the live
+	* hub (524 devices): 903 ms and 373 KB per call, against 21 ms and
+	* 613 bytes for `getBindings({deviceId})`.
+	*
+	* Adopting 20 Home Assistant devices registers 166 devices (parents +
+	* accessories), so an operator with the admin UI open bought 166
+	* full-fleet binding sweeps: ~150 s of hub main-thread time inside a
+	* 219 s adoption, with every other RPC — including the adoption's own —
+	* queued behind them. Same defect, same fix, as `refreshDeviceMetadata`
+	* below (`listAll` → `getDevice`).
+	*
+	* Removal is the destructive direction (every proxy handle a consumer
+	* holds goes inert), and an EMPTY binding list is not a claim that the
+	* device is gone — a device can legitimately bind nothing. So it needs
+	* a second read to agree (D49); `device.unregistered` remains the
+	* primary removal path.
+	*/
 	async refreshBinding(deviceId) {
 		try {
-			const fresh = (await this.api.deviceManager.getAllBindings.query({})).find((b) => b.deviceId === deviceId);
-			if (fresh) this.bindings.set(deviceId, fresh);
-			else this.applyDeviceRemoval(deviceId);
+			const fresh = await this.api.deviceManager.getBindings.query({ deviceId });
+			if (fresh.entries.length > 0) {
+				this.bindings.set(deviceId, fresh);
+				return;
+			}
+			if (await this.api.deviceManager.getDevice.query({ deviceId }) === null) {
+				this.applyDeviceRemoval(deviceId);
+				return;
+			}
+			this.bindings.set(deviceId, fresh);
 		} catch {}
 	}
 	async refreshDeviceMetadata(deviceId, kind) {
@@ -39833,6 +39945,21 @@ function toggleAudioLabel(labels, id) {
 var CLASS_CONDITION_IDS = new Set(["classes", "classesExclude"]);
 /** Condition ids that render the sensor/control label picker. */
 var LABEL_CONDITION_IDS = new Set(["sensorKinds"]);
+/**
+* Condition ids whose class scope is a COUNT, not a match — they get the
+* MACRO-ONLY vocabulary.
+*
+* Every other class condition goes through the engine's `expandClassSelector`,
+* which expands a macro to its subs and matches a sub against the detection's
+* own class. Occupancy does not: it reads `byClass[className]` out of the
+* ZoneAnalytics snapshot, and that record is keyed on MACROS only (the executor
+* maps COCO onto the macro and drops the rest). A sub-type therefore names a key
+* that does not exist — the counter is 0 forever and the rule cannot fire.
+*
+* Live cost, 2026-08-12: two rules on device 617 were authored with `car`
+* because this picker offered the whole taxonomy. They were silent for a day.
+*/
+var COUNT_CLASS_CONDITION_IDS = new Set(["occupancy"]);
 function toOption(entry) {
 	return {
 		value: entry.kind,
@@ -39910,6 +40037,14 @@ function pickerForCondition(conditionId, taxonomy) {
 		});
 		return groups.length > 0 ? { groups } : null;
 	}
+	if (COUNT_CLASS_CONDITION_IDS.has(conditionId)) {
+		const options = taxonomy.videoClasses.filter((e) => e.parentKind === null).map(toOption);
+		return options.length > 0 ? { groups: [{
+			key: "macro",
+			fallbackLabel: "Classes",
+			options
+		}] } : null;
+	}
 	if (LABEL_CONDITION_IDS.has(conditionId)) {
 		const groups = groupLabels(taxonomy.labels);
 		return groups.length > 0 ? { groups } : null;
@@ -42512,6 +42647,7 @@ exports.DETAIL_CROP_PADDING_FIELD = DETAIL_CROP_PADDING_FIELD;
 exports.DETAIL_CROP_PADDING_KEY = DETAIL_CROP_PADDING_KEY;
 exports.DETAIL_CROP_SECTION_ID = DETAIL_CROP_SECTION_ID;
 exports.DETAIL_CROP_SQUARE_KEY = DETAIL_CROP_SQUARE_KEY;
+exports.DETECTION_MACRO_CLASSES = DETECTION_MACRO_CLASSES;
 exports.DETECTION_PIPELINE_CAP_NAME = DETECTION_PIPELINE_CAP_NAME;
 exports.DEVICE_BACKEND_TO_FORMAT = DEVICE_BACKEND_TO_FORMAT;
 exports.DEVICE_CAP_NAMES = DEVICE_CAP_NAMES;
@@ -43337,6 +43473,7 @@ exports.isAudioLabelSelected = isAudioLabelSelected;
 exports.isBaseConditionKey = isBaseConditionKey;
 exports.isCollectionArrayMethod = isCollectionArrayMethod;
 exports.isDeployableToAgent = isDeployableToAgent;
+exports.isDetectionMacroClass = isDetectionMacroClass;
 exports.isDeviceConfigCap = require_sleep.isDeviceConfigCap;
 exports.isDeviceScopedCap = require_sleep.isDeviceScopedCap;
 exports.isEvent = require_sleep.isEvent;