@camstack/types 1.2.267 → 1.2.269

package/dist/err-msg-Dx2Kor0g.js

@@ -0,0 +1,368 @@
+//#region src/device/device-type.ts
+var DeviceType = /* @__PURE__ */ function(DeviceType) {
+	DeviceType["Camera"] = "camera";
+	DeviceType["Hub"] = "hub";
+	DeviceType["Light"] = "light";
+	DeviceType["Siren"] = "siren";
+	DeviceType["Switch"] = "switch";
+	DeviceType["Sensor"] = "sensor";
+	DeviceType["Thermostat"] = "thermostat";
+	/** Air-conditioner / heat-pump climate device (HVAC) — shares the
+	*  `climate-control` cap surface with `Thermostat` but renders a
+	*  dedicated AC-appropriate control UI (mode chips, fan speed,
+	*  independent vertical/horizontal swing). Sources: native Gree, and
+	*  reusable by other AC integrations. */
+	DeviceType["Climate"] = "climate";
+	DeviceType["Button"] = "button";
+	/** Generic stateless event emitter — carries a device's EXACT declared
+	*  event vocabulary verbatim (no normalization). Installed with the
+	*  `event-emitter` cap. Sources: HA `event.*` entities (structured) and
+	*  HA bus events (e.g. `zha_event`, generic). */
+	DeviceType["EventEmitter"] = "event-emitter";
+	/** Firmware/software update entity — current vs available version,
+	*  updatable flag, update state, and an install action. Installed with
+	*  the `update` cap. Sources: Homematic firmware-update channels (and
+	*  reusable by other providers, e.g. HA `update.*` entities). */
+	DeviceType["Update"] = "update";
+	DeviceType["Generic"] = "generic";
+	/** Generic notification delivery target (HA `notify.<service>`, future
+	*  Telegram / Discord / ntfy / SMTP, …). One device per delivery
+	*  endpoint; the `notifier` cap defines the send surface. */
+	DeviceType["Notifier"] = "notifier";
+	/** Pre-recorded action sequence with optional parameters
+	*  (HA `script.*`). Runnable via `script-runner` cap. */
+	DeviceType["Script"] = "script";
+	/** Automation rule (HA `automation.*`) — enable/disable + manual
+	*  trigger surface exposed via `automation-control` cap. */
+	DeviceType["Automation"] = "automation";
+	/** Door / smart lock device (HA `lock.*`). `lock-control` cap. */
+	DeviceType["Lock"] = "lock";
+	/** Window covering, blinds, garage door, valve, etc. (HA `cover.*`,
+	*  `valve.*`). `cover` cap with sub-roles for variant. */
+	DeviceType["Cover"] = "cover";
+	/** Pipe / water / gas valve with open/close/stop and optional
+	*  position (HA `valve.*`). `valve` cap — a cover-sibling actuator
+	*  modelled on the same open/closed lifecycle. */
+	DeviceType["Valve"] = "valve";
+	/** Humidifier / dehumidifier with on/off + target humidity + mode
+	*  (HA `humidifier.*`). `humidifier` cap — a climate-family actuator
+	*  modelled on the same target / mode lifecycle. */
+	DeviceType["Humidifier"] = "humidifier";
+	/** Water heater / boiler with target temperature + operation mode +
+	*  away mode (HA `water_heater.*`). `water-heater` cap — a
+	*  climate-family actuator. */
+	DeviceType["WaterHeater"] = "water-heater";
+	/** Ceiling / standing / exhaust fan (HA `fan.*`). `fan-control` cap. */
+	DeviceType["Fan"] = "fan";
+	/** Audio / video playback endpoint (HA `media_player.*`). Disjoint from
+	*  the camera surface — those use `Camera`. `media-player` cap. */
+	DeviceType["MediaPlayer"] = "media-player";
+	/** Security panel / alarm system (HA `alarm_control_panel.*`).
+	*  `alarm-panel` cap. */
+	DeviceType["AlarmPanel"] = "alarm-panel";
+	/** Generic user-settable input (HA `number` / `input_number` / `select`
+	*  / `input_select` / `text` / `input_text` / `input_datetime`).
+	*  Sub-type via `DeviceRole`: NumericControl / SelectControl /
+	*  TextControl / DateTimeControl. */
+	DeviceType["Control"] = "control";
+	/** Person / device-tracker presence (HA `person.*`, `device_tracker.*`).
+	*  `presence` cap. */
+	DeviceType["Presence"] = "presence";
+	/** Weather provider (HA `weather.*`). Tier-3, low MVP priority.
+	*  `weather` cap. */
+	DeviceType["Weather"] = "weather";
+	/** Robot vacuum (HA `vacuum.*`). Tier-3. `vacuum-control` cap. */
+	DeviceType["Vacuum"] = "vacuum";
+	/** Robotic lawn mower (HA `lawn_mower.*`). Tier-3.
+	*  `lawn-mower-control` cap. */
+	DeviceType["LawnMower"] = "lawn-mower";
+	/** Physical HA device group — parent container for entity-children
+	*  adopted from a single HA device entry. Not renderable as a
+	*  standalone device; exists only to anchor child entities. */
+	DeviceType["Container"] = "container";
+	/** Single still-image entity (HA `image.*`). Read-only display of an
+	*  `entity_picture` signed URL the browser loads directly. `image` cap. */
+	DeviceType["Image"] = "image";
+	/** Smart pet feeder — cloud-connected food dispenser with a bowl food
+	*  level, battery, desiccant life, feeding state and manual-feed /
+	*  call-pet / maintenance actions. Installed with the `pet-feeder` cap;
+	*  dual-hopper models (D4S/D4SH) expose per-hopper portions. Sources:
+	*  native PetKit (`nodepetkit` `FeederDevice`), reusable by other feeder
+	*  integrations sharing the same food/desiccant/hopper surface. */
+	DeviceType["PetFeeder"] = "pet-feeder";
+	return DeviceType;
+}({});
+var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
+	DeviceFeature["BatteryOperated"] = "battery-operated";
+	DeviceFeature["Rebootable"] = "rebootable";
+	/**
+	* Device supports an on-demand re-sync of its derived spec with its
+	* upstream source — drives the generic Re-sync button. The owning
+	* provider implements the action via the `device-adoption.resync` cap.
+	*/
+	DeviceFeature["Resyncable"] = "resyncable";
+	DeviceFeature["NativeSnapshot"] = "native-snapshot";
+	DeviceFeature["DoorbellButton"] = "doorbell-button";
+	DeviceFeature["TwoWayAudio"] = "two-way-audio";
+	DeviceFeature["PanTiltZoom"] = "pan-tilt-zoom";
+	/**
+	* Camera supports the on-firmware autotrack subsystem (subject-
+	* following). Distinct from `PanTiltZoom` because not every PTZ
+	* camera ships autotrack — the admin UI uses this flag to gate
+	* the autotrack toggle / settings card without re-deriving from
+	* the cap registry. Mirrors `ptz-autotrack` cap registration:
+	* driver sets this feature when probe confirms the firmware
+	* surface, and registers the cap in the same code path.
+	*/
+	DeviceFeature["PtzAutotrack"] = "ptz-autotrack";
+	/**
+	* Accessory exposes a "trigger on motion" toggle — the parent camera's
+	* motion detection automatically activates this device. Mirrors
+	* `motion-trigger` cap registration: drivers set this feature in the
+	* same code path that calls `ctx.registerNativeCap(motionTriggerCapability, ...)`.
+	*
+	* Used by admin UI (gate the in-hero `MotionTriggerToggle` against a
+	* fast scalar without binding fetch), notifier rules, and `listAll`
+	* filters that want "all devices with on-motion behaviour".
+	*/
+	DeviceFeature["MotionTrigger"] = "motion-trigger";
+	/** Light supports rgb-triplet color via `color` cap. */
+	DeviceFeature["LightColorRgb"] = "light-color-rgb";
+	/** Light supports HSV color via `color` cap. */
+	DeviceFeature["LightColorHsv"] = "light-color-hsv";
+	/** Light supports color-temperature (mired) via `color` cap. */
+	DeviceFeature["LightColorMired"] = "light-color-mired";
+	/** Thermostat supports a `heat_cool` dual setpoint (targetLow +
+	*  targetHigh). Gates the range slider UI. */
+	DeviceFeature["ClimateDualSetpoint"] = "climate-dual-setpoint";
+	/** Thermostat exposes target humidity and/or current humidity
+	*  readings. Gates the humidity controls. */
+	DeviceFeature["ClimateHumidity"] = "climate-humidity";
+	/** Thermostat exposes a fan-mode selector. */
+	DeviceFeature["ClimateFanMode"] = "climate-fan-mode";
+	/** Thermostat exposes preset modes (eco / away / sleep / vendor). */
+	DeviceFeature["ClimatePreset"] = "climate-preset";
+	/** Thermostat exposes a vertical louver swing toggle. Gates the
+	*  vertical-swing switch in the climate UI. Independent of horizontal. */
+	DeviceFeature["ClimateSwingVertical"] = "climate-swing-vertical";
+	/** Thermostat exposes a horizontal louver swing toggle. Gates the
+	*  horizontal-swing switch in the climate UI. Independent of vertical. */
+	DeviceFeature["ClimateSwingHorizontal"] = "climate-swing-horizontal";
+	/** Cover exposes intermediate position control (0..100). Gates the
+	*  position slider UI. */
+	DeviceFeature["CoverPositionable"] = "cover-positionable";
+	/** Cover exposes slat-tilt control. Gates the tilt slider UI. */
+	DeviceFeature["CoverTilt"] = "cover-tilt";
+	/** Valve exposes intermediate position control (0..100). Gates the
+	*  position slider / drag surface UI. */
+	DeviceFeature["ValvePositionable"] = "valve-positionable";
+	/** Fan exposes a speed-percentage setter. Gates the speed slider UI. */
+	DeviceFeature["FanSpeed"] = "fan-speed";
+	/** Fan exposes a preset mode selector. */
+	DeviceFeature["FanPreset"] = "fan-preset";
+	/** Fan exposes blade direction (forward/reverse) — typical of
+	*  ceiling fans. */
+	DeviceFeature["FanDirection"] = "fan-direction";
+	/** Fan exposes an oscillation toggle. */
+	DeviceFeature["FanOscillating"] = "fan-oscillating";
+	/** Lock requires a PIN code on lock/unlock. Gates the code-entry
+	*  field on the UI lock-controls panel. */
+	DeviceFeature["LockPinRequired"] = "lock-pin-required";
+	/** Lock supports a latch-release ("open door") action distinct from
+	*  unlock. Mirrors HA `LockEntityFeature.OPEN` (bit 1) in
+	*  `supported_features`. Gates the Open Door button in the UI. */
+	DeviceFeature["LockOpen"] = "lock-open";
+	/** Media player exposes a seek-to-position surface. */
+	DeviceFeature["MediaPlayerSeek"] = "media-player-seek";
+	/** Media player exposes a volume-level setter. */
+	DeviceFeature["MediaPlayerVolume"] = "media-player-volume";
+	/** Media player exposes a mute toggle distinct from volume=0. */
+	DeviceFeature["MediaPlayerMute"] = "media-player-mute";
+	/** Media player exposes a shuffle toggle. */
+	DeviceFeature["MediaPlayerShuffle"] = "media-player-shuffle";
+	/** Media player exposes a repeat mode (off / all / one). */
+	DeviceFeature["MediaPlayerRepeat"] = "media-player-repeat";
+	/** Media player exposes a source / input selector. */
+	DeviceFeature["MediaPlayerSelectSource"] = "media-player-select-source";
+	/** Media player exposes a play-arbitrary-media surface (URL / id). */
+	DeviceFeature["MediaPlayerPlayMedia"] = "media-player-play-media";
+	/** Media player exposes next-track. */
+	DeviceFeature["MediaPlayerNext"] = "media-player-next";
+	/** Media player exposes previous-track. */
+	DeviceFeature["MediaPlayerPrevious"] = "media-player-previous";
+	/** Media player exposes stop distinct from pause. */
+	DeviceFeature["MediaPlayerStop"] = "media-player-stop";
+	/** Alarm panel requires a PIN code on arm/disarm. */
+	DeviceFeature["AlarmPinRequired"] = "alarm-pin-required";
+	/** Presence device carries GPS coordinates (lat/lng/accuracy) in
+	*  addition to a textual location. */
+	DeviceFeature["PresenceGps"] = "presence-gps";
+	/** Notifier accepts an inline / URL image attachment. */
+	DeviceFeature["NotifierImage"] = "notifier-image";
+	/** Notifier accepts a priority hint (high/normal/low). */
+	DeviceFeature["NotifierPriority"] = "notifier-priority";
+	/** Notifier accepts a free-form `data` payload for platform-specific
+	*  fields. */
+	DeviceFeature["NotifierData"] = "notifier-data";
+	/** Notifier supports interactive action buttons / callbacks. */
+	DeviceFeature["NotifierActions"] = "notifier-actions";
+	/** Notifier supports per-call recipient targeting (multi-user). */
+	DeviceFeature["NotifierRecipients"] = "notifier-recipients";
+	/** Script runner accepts a variables map on each run invocation. */
+	DeviceFeature["ScriptVariables"] = "script-variables";
+	/** Automation `trigger` accepts a skipCondition flag — fires the
+	*  automation's actions while bypassing its condition block. */
+	DeviceFeature["AutomationSkipCondition"] = "automation-skip-condition";
+	/** Robot vacuum exposes a live cleaning map (image child). Gates the
+	*  map tile in the vacuum UI. */
+	DeviceFeature["VacuumHasMap"] = "vacuum-has-map";
+	/** Robot vacuum exposes AI obstacle-detection toggles. Gates the AI
+	*  switches group. */
+	DeviceFeature["VacuumHasAi"] = "vacuum-has-ai";
+	/** Robot mower exposes a live mowing map (SVG image child). Gates the
+	*  mower map tile. */
+	DeviceFeature["MowerHasMap"] = "mower-has-map";
+	/** Robot mower exposes targeted mowing (all-area / zones / edges /
+	*  spots) — gates the Mow action + map selectors. */
+	DeviceFeature["MowerHasTargetedMowing"] = "mower-has-targeted-mowing";
+	return DeviceFeature;
+}({});
+var ChargingStatus = /* @__PURE__ */ function(ChargingStatus) {
+	ChargingStatus["ChargingDC"] = "charging-dc";
+	ChargingStatus["ChargingSolar"] = "charging-solar";
+	ChargingStatus["NotCharging"] = "not-charging";
+	return ChargingStatus;
+}({});
+/**
+* Semantic role a device plays within its parent. Populated by driver
+* addons when creating accessory devices (Reolink siren/floodlight/
+* PIR/chime/autotrack/doorbell, ONVIF relay outputs, …). Used by the
+* admin UI to pick icons, labels, and widgets — a `Switch` with
+* `role: Floodlight` renders as a bulb with a brightness slider,
+* whereas a `Switch` with `role: Siren` renders as a klaxon.
+*
+* Undefined for top-level devices (cameras, NVRs, hubs). Persisted in
+* sqlite as a nullable TEXT column — old rows keep working unchanged.
+*/
+var DeviceRole = /* @__PURE__ */ function(DeviceRole) {
+	DeviceRole["Siren"] = "siren";
+	DeviceRole["Floodlight"] = "floodlight";
+	DeviceRole["Spotlight"] = "spotlight";
+	DeviceRole["PirSensor"] = "pir-sensor";
+	DeviceRole["Chime"] = "chime";
+	DeviceRole["Autotrack"] = "autotrack";
+	DeviceRole["Nightvision"] = "nightvision";
+	DeviceRole["PrivacyMask"] = "privacy-mask";
+	DeviceRole["Doorbell"] = "doorbell";
+	/** Virtual HA toggle (input_boolean.*) — distinguishable from a
+	*  real Switch device for UI rendering / export adapters. */
+	DeviceRole["BinaryHelper"] = "binary-helper";
+	/** Generic motion / occupancy / moving event source. Distinct from
+	*  the camera accessory PirSensor role: that one is a camera child;
+	*  this is a standalone HA / 3rd-party motion sensor. */
+	DeviceRole["MotionSensor"] = "motion-sensor";
+	DeviceRole["ContactSensor"] = "contact-sensor";
+	DeviceRole["LeakSensor"] = "leak-sensor";
+	DeviceRole["SmokeSensor"] = "smoke-sensor";
+	DeviceRole["COSensor"] = "co-sensor";
+	DeviceRole["GasSensor"] = "gas-sensor";
+	DeviceRole["TamperSensor"] = "tamper-sensor";
+	DeviceRole["VibrationSensor"] = "vibration-sensor";
+	DeviceRole["ConnectivitySensor"] = "connectivity-sensor";
+	DeviceRole["SoundSensor"] = "sound-sensor";
+	/** Fallback for `binary_sensor` without a known `device_class`. */
+	DeviceRole["BinarySensor"] = "binary-sensor";
+	DeviceRole["TemperatureSensor"] = "temperature-sensor";
+	DeviceRole["HumiditySensor"] = "humidity-sensor";
+	DeviceRole["AmbientLightSensor"] = "ambient-light-sensor";
+	DeviceRole["PressureSensor"] = "pressure-sensor";
+	/** Wind speed or direction (weather-station `wind-sensor` cap). */
+	DeviceRole["WindSensor"] = "wind-sensor";
+	/** Rain accumulation or rate (weather-station `rain-sensor` cap). */
+	DeviceRole["RainSensor"] = "rain-sensor";
+	/** UV index (weather-station `uv-sensor` cap). */
+	DeviceRole["UvSensor"] = "uv-sensor";
+	/** Solar irradiance W/m² (weather-station `solar-radiation-sensor` cap).
+	*  Distinct from AmbientLightSensor (lux). */
+	DeviceRole["SolarRadiationSensor"] = "solar-radiation-sensor";
+	/** Soil moisture % (garden/weather `soil-moisture-sensor` cap). */
+	DeviceRole["SoilMoistureSensor"] = "soil-moisture-sensor";
+	DeviceRole["PowerSensor"] = "power-sensor";
+	DeviceRole["EnergySensor"] = "energy-sensor";
+	DeviceRole["VoltageSensor"] = "voltage-sensor";
+	DeviceRole["CurrentSensor"] = "current-sensor";
+	DeviceRole["AirQualitySensor"] = "air-quality-sensor";
+	/** Battery level (numeric % via `sensor` OR low-bool via
+	*  `binary_sensor` — the cap distinguishes via the value type). */
+	DeviceRole["BatterySensor"] = "battery-sensor";
+	/** Fallback for `sensor` numeric without a known `device_class`. */
+	DeviceRole["NumericSensor"] = "numeric-sensor";
+	/** String / enum state (HA `sensor` with `state_class: enum` or
+	*  `attributes.options`). */
+	DeviceRole["EnumSensor"] = "enum-sensor";
+	/** Date / timestamp state (HA `sensor` with `device_class: timestamp`
+	*  or `date`). The slice carries the raw ISO string verbatim (hosted on
+	*  the `enum-sensor` cap); the UI renders it locale-formatted. */
+	DeviceRole["DateTimeSensor"] = "datetime-sensor";
+	/** Last-resort fallback when nothing else matches. */
+	DeviceRole["GenericSensor"] = "generic-sensor";
+	DeviceRole["NumericControl"] = "numeric-control";
+	DeviceRole["SelectControl"] = "select-control";
+	DeviceRole["TextControl"] = "text-control";
+	DeviceRole["DateTimeControl"] = "datetime-control";
+	/** Mobile push notifier (HA `notify.mobile_app_*`) — supports
+	*  rich features (image, priority, channel routing). */
+	DeviceRole["MobilePushNotifier"] = "mobile-push-notifier";
+	/** Chat / messaging service (HA `notify.telegram_*`,
+	*  `notify.discord_*`, etc.). */
+	DeviceRole["MessagingNotifier"] = "messaging-notifier";
+	/** Email-based delivery (HA `notify.smtp`, etc.). */
+	DeviceRole["EmailNotifier"] = "email-notifier";
+	/** Fallback when the notifier service name doesn't match a known
+	*  pattern. */
+	DeviceRole["GenericNotifier"] = "generic-notifier";
+	return DeviceRole;
+}({});
+//#endregion
+//#region src/utils/err-msg.ts
+/**
+import { errMsg } from '@camstack/types'
+* Extract a human-readable message from an unknown error value.
+* Replaces the ubiquitous `errMsg(err)` pattern.
+*/
+function errMsg(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return String(err);
+}
+//#endregion
+Object.defineProperty(exports, "ChargingStatus", {
+	enumerable: true,
+	get: function() {
+		return ChargingStatus;
+	}
+});
+Object.defineProperty(exports, "DeviceFeature", {
+	enumerable: true,
+	get: function() {
+		return DeviceFeature;
+	}
+});
+Object.defineProperty(exports, "DeviceRole", {
+	enumerable: true,
+	get: function() {
+		return DeviceRole;
+	}
+});
+Object.defineProperty(exports, "DeviceType", {
+	enumerable: true,
+	get: function() {
+		return DeviceType;
+	}
+});
+Object.defineProperty(exports, "errMsg", {
+	enumerable: true,
+	get: function() {
+		return errMsg;
+	}
+});

package/dist/{event-category-BVDXG4tB.mjs → event-category-C5xZWqz6.mjs}

@@ -362,6 +362,16 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["DeviceStateChanged"] = "device.state-changed";
 	/**
+	* The NATIVE shadow of a cap a composition has claimed fields of moved
+	* (D663). Payload: `{ deviceId, capName, native }` — what the provider
+	* wrote, BEFORE the owned fields are overlaid. Owner-only (D224): it is for
+	* the composer's native self-reads, and the public event routers refuse it
+	* (`isOwnerOnlyEventCategory`) so no consumer surface ever shows a second
+	* truth beside the merged `DeviceStateChanged.slice`. Emitted only under a
+	* `replace` claim, one per native write of that cap.
+	*/
+	EventCategory["DeviceNativeShadowChanged"] = "device.native-shadow-changed";
+	/**
 	* Frame occupancy for a camera CHANGED — a tracked object was gained or
 	* lost. Carries `{ deviceId, totalObjects, byClass, zones }`.
 	*
@@ -688,5 +698,25 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ModelConvertProgress"] = "model-convert.progress";
 	return EventCategory;
 }({});
+/**
+* Categories that never leave the hub's trusted addon closure: the public
+* event routers (`systemEvents.*`, `live.*`) refuse them in every path, so a
+* UI or a share-scope subscriber cannot receive them by omitting the category
+* filter. Add a category here when its payload is a truth only one owner may
+* read (D224).
+*/
+var OWNER_ONLY_EVENT_CATEGORIES = new Set(["device.native-shadow-changed"]);
+function isOwnerOnlyEventCategory(category) {
+	return OWNER_ONLY_EVENT_CATEGORIES.has(category);
+}
+/**
+* Every category a PUBLIC surface may offer or show — the enum minus the
+* owner-only set, unique, sorted. A picker built from the raw enum would offer
+* a filter that can never match, because the routers refuse that category.
+*/
+function publicEventCategories() {
+	const all = Object.values(EventCategory).filter((value) => typeof value === "string");
+	return [...new Set(all)].filter((c) => !isOwnerOnlyEventCategory(c)).toSorted();
+}
 //#endregion
-export { EventCategory as t };
+export { publicEventCategories as i, OWNER_ONLY_EVENT_CATEGORIES as n, isOwnerOnlyEventCategory as r, EventCategory as t };

package/dist/{event-category-BVfsrBYA.js → event-category-MbnB-6AN.js}

@@ -362,6 +362,16 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	*/
 	EventCategory["DeviceStateChanged"] = "device.state-changed";
 	/**
+	* The NATIVE shadow of a cap a composition has claimed fields of moved
+	* (D663). Payload: `{ deviceId, capName, native }` — what the provider
+	* wrote, BEFORE the owned fields are overlaid. Owner-only (D224): it is for
+	* the composer's native self-reads, and the public event routers refuse it
+	* (`isOwnerOnlyEventCategory`) so no consumer surface ever shows a second
+	* truth beside the merged `DeviceStateChanged.slice`. Emitted only under a
+	* `replace` claim, one per native write of that cap.
+	*/
+	EventCategory["DeviceNativeShadowChanged"] = "device.native-shadow-changed";
+	/**
 	* Frame occupancy for a camera CHANGED — a tracked object was gained or
 	* lost. Carries `{ deviceId, totalObjects, byClass, zones }`.
 	*
@@ -688,6 +698,26 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ModelConvertProgress"] = "model-convert.progress";
 	return EventCategory;
 }({});
+/**
+* Categories that never leave the hub's trusted addon closure: the public
+* event routers (`systemEvents.*`, `live.*`) refuse them in every path, so a
+* UI or a share-scope subscriber cannot receive them by omitting the category
+* filter. Add a category here when its payload is a truth only one owner may
+* read (D224).
+*/
+var OWNER_ONLY_EVENT_CATEGORIES = new Set(["device.native-shadow-changed"]);
+function isOwnerOnlyEventCategory(category) {
+	return OWNER_ONLY_EVENT_CATEGORIES.has(category);
+}
+/**
+* Every category a PUBLIC surface may offer or show — the enum minus the
+* owner-only set, unique, sorted. A picker built from the raw enum would offer
+* a filter that can never match, because the routers refuse that category.
+*/
+function publicEventCategories() {
+	const all = Object.values(EventCategory).filter((value) => typeof value === "string");
+	return [...new Set(all)].filter((c) => !isOwnerOnlyEventCategory(c)).toSorted();
+}
 //#endregion
 Object.defineProperty(exports, "EventCategory", {
 	enumerable: true,
@@ -695,3 +725,21 @@ Object.defineProperty(exports, "EventCategory", {
 		return EventCategory;
 	}
 });
+Object.defineProperty(exports, "OWNER_ONLY_EVENT_CATEGORIES", {
+	enumerable: true,
+	get: function() {
+		return OWNER_ONLY_EVENT_CATEGORIES;
+	}
+});
+Object.defineProperty(exports, "isOwnerOnlyEventCategory", {
+	enumerable: true,
+	get: function() {
+		return isOwnerOnlyEventCategory;
+	}
+});
+Object.defineProperty(exports, "publicEventCategories", {
+	enumerable: true,
+	get: function() {
+		return publicEventCategories;
+	}
+});

package/dist/expression/ast.d.ts

@@ -14,6 +14,8 @@
  */
 /** The only value types the engine produces or consumes. */
 export type ExpressionValue = number | string | boolean | null;
+/** Stable structural address of a node within one parsed expression AST. */
+export type ExpressionNodePath = string;
 export type ExpressionBinaryOperator = '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '<=' | '>' | '>=';
 export type ExpressionLogicalOperator = '&&' | '||';
 export type ExpressionUnaryOperator = '-' | '!';

package/dist/expression/builtins.d.ts

@@ -16,6 +16,7 @@
  * closed rather than emitting a garbage value.
  */
 import type { ExpressionValue } from './ast.js';
+import type { CountCallState, RoseCallState, StatefulExpressionMemory } from './expression-source.js';
 /** Optional runtime hooks the evaluator threads through to builtins. */
 export interface ExpressionEvalHooks {
     /** Convert `value` from unit `from` to unit `to`; `null` when the pair is
@@ -40,6 +41,14 @@ export interface ExpressionBuiltin {
     readonly maxArgs: number;
     readonly apply: (args: readonly ExpressionValue[], hooks: ExpressionEvalHooks) => ExpressionValue;
 }
+export type StatefulExpressionBuiltin = 'rose' | 'count';
+export declare function isStatefulBuiltin(name: string): name is StatefulExpressionBuiltin;
+export declare function evaluateRose(level: unknown, changedAt: unknown, debounceMs: unknown, call: RoseCallState, field: StatefulExpressionMemory, env: {
+    readonly currentOutput: number | null;
+    readonly startedAtMs: number;
+    readonly nowMs: number;
+}): number | null;
+export declare function evaluateCount(input: unknown, call: CountCallState, currentOutput: unknown): number;
 /** Frozen, null-prototype builtin table. */
 export declare const EXPRESSION_BUILTINS: Readonly<Record<string, ExpressionBuiltin>>;
 /** The set of valid builtin names — used by the parser to reject unknown

package/dist/expression/evaluator.d.ts

@@ -1,8 +1,14 @@
-import { type ExpressionEvalHooks } from './builtins.js';
-import type { ExpressionNode, ExpressionValue } from './ast.js';
+import { type ExpressionEvalHooks, type StatefulExpressionBuiltin } from './builtins.js';
+import type { ExpressionNode, ExpressionNodePath, ExpressionValue } from './ast.js';
+export interface StatefulCallInvocation {
+    readonly name: StatefulExpressionBuiltin;
+    readonly path: ExpressionNodePath;
+    readonly args: readonly ExpressionValue[];
+}
 export interface ExpressionEvalOptions {
     readonly hooks?: ExpressionEvalHooks;
     readonly maxSteps?: number;
+    readonly invokeStateful?: (call: StatefulCallInvocation) => ExpressionValue;
 }
 /** Build a null-prototype scope from own-enumerable binding entries. Inherited
  *  keys of the input (e.g. from a `{__proto__: {...}}` payload) are NOT copied,

package/dist/expression/expression-source.d.ts

@@ -9,7 +9,28 @@
  * positions (derive a value, gate a trigger, compute an argument).
  */
 import type { ExpressionValue } from './ast.js';
-import { type ExpressionEvalOptions } from './evaluator.js';
+import { type ExpressionEvalOptions, type StatefulCallInvocation } from './evaluator.js';
+export interface RoseCallState {
+    readonly kind: 'rose';
+    priorLevel?: boolean;
+}
+export interface CountCallState {
+    readonly kind: 'count';
+    highWater: number | null;
+}
+export type StatefulCallState = RoseCallState | CountCallState;
+export interface StatefulExpressionMemory {
+    readonly calls: Map<string, StatefulCallState>;
+    acceptedEdgeAt: number | null;
+}
+export declare function createStatefulExpressionMemory(): StatefulExpressionMemory;
+export declare function cloneStatefulExpressionMemory(memory: StatefulExpressionMemory): StatefulExpressionMemory;
+export interface StatefulExpressionEnvironment {
+    readonly currentOutput: unknown;
+    readonly startedAtMs: number;
+    readonly nowMs: number;
+}
+export declare function evaluateStatefulExpressionCall(invocation: StatefulCallInvocation, memory: StatefulExpressionMemory, env: StatefulExpressionEnvironment): ExpressionValue;
 /** The `now` epoch-ms binding is auto-injected into every evaluation and is a
  *  reserved binding name (authors may not rebind it). */
 export declare const EXPRESSION_INJECTED_NOW = "now";
@@ -46,8 +67,9 @@ export type EvaluateExpressionSourceResult = {
 /**
  * Shared read-path evaluation. Builds a null-proto scope from `bindingValues`
  * plus the injected `now` (supplied by the caller for determinism and
- * testability), compiles via the LRU, and evaluates. Any failure (parse or
- * eval) returns `{ ok: false }` — the caller treats that as "skip this
- * derivation", never as a throw that takes the pass down.
+ * testability), compiles via the LRU, and evaluates. Stateful calls are
+ * delegated through `opts.invokeStateful` with their stable AST path. Any
+ * failure (parse or eval) returns `{ ok: false }` — the caller treats that as
+ * "skip this derivation", never as a throw that takes the pass down.
  */
 export declare function evaluateExpressionSource(expr: string, bindingValues: Readonly<Record<string, ExpressionValue>>, now: number, opts?: ExpressionEvalOptions): EvaluateExpressionSourceResult;

package/dist/expression/index.d.ts

@@ -9,18 +9,18 @@
  * the deep modules (e.g. `../expression/compile.js`), never through this file
  * OR the root barrel (see biome-plugins/no-types-barrel-leaf-import.grit).
  */
-export type { ExpressionBinaryNode, ExpressionBinaryOperator, ExpressionCallNode, ExpressionConditionalNode, ExpressionIdentifierNode, ExpressionLiteralNode, ExpressionLogicalNode, ExpressionLogicalOperator, ExpressionNode, ExpressionUnaryNode, ExpressionUnaryOperator, ExpressionValue, } from './ast.js';
+export type { ExpressionBinaryNode, ExpressionBinaryOperator, ExpressionCallNode, ExpressionConditionalNode, ExpressionIdentifierNode, ExpressionLiteralNode, ExpressionLogicalNode, ExpressionLogicalOperator, ExpressionNode, ExpressionNodePath, ExpressionUnaryNode, ExpressionUnaryOperator, ExpressionValue, } from './ast.js';
 export type { ExpressionBindingSource, ExpressionFieldBinding, ExpressionGlobalBinding, ExpressionLiteralBinding, ExpressionSource, } from './binding-source.js';
 export { ExpressionBindingSourceSchema, ExpressionFieldBindingSchema, ExpressionGlobalBindingSchema, ExpressionLiteralBindingSchema, ExpressionSourceSchema, } from './binding-source.js';
-export type { ExpressionBuiltin, ExpressionEvalHooks } from './builtins.js';
-export { EXPRESSION_BUILTIN_NAMES, EXPRESSION_BUILTINS, } from './builtins.js';
+export type { ExpressionBuiltin, ExpressionEvalHooks, StatefulExpressionBuiltin, } from './builtins.js';
+export { evaluateCount, evaluateRose, EXPRESSION_BUILTIN_NAMES, EXPRESSION_BUILTINS, isStatefulBuiltin, } from './builtins.js';
 export type { CompileResult } from './compile.js';
 export { compileExpression, compileExpressionSafe } from './compile.js';
 export { ExpressionEvalError, ExpressionParseError } from './errors.js';
-export type { ExpressionEvalOptions } from './evaluator.js';
+export type { ExpressionEvalOptions, StatefulCallInvocation } from './evaluator.js';
 export { createExpressionScope, evaluateAst } from './evaluator.js';
-export type { EvaluateExpressionSourceResult, ExpressionSourceInput, } from './expression-source.js';
-export { EXPRESSION_INJECTED_NOW, evaluateExpressionSource, toExpressionValue, validateExpressionSource, } from './expression-source.js';
+export type { CountCallState, EvaluateExpressionSourceResult, ExpressionSourceInput, RoseCallState, StatefulCallState, StatefulExpressionEnvironment, StatefulExpressionMemory, } from './expression-source.js';
+export { cloneStatefulExpressionMemory, createStatefulExpressionMemory, EXPRESSION_INJECTED_NOW, evaluateExpressionSource, evaluateStatefulExpressionCall, toExpressionValue, validateExpressionSource, } from './expression-source.js';
 export { EXPRESSION_COMPILE_CACHE_CAPACITY, EXPRESSION_IDENTIFIER_RE, MAX_EXPRESSION_AST_NODES, MAX_EXPRESSION_BINDINGS, MAX_EXPRESSION_CALL_ARGS, MAX_EXPRESSION_EVAL_STEPS, MAX_EXPRESSION_SOURCE_LENGTH, RESERVED_BINDING_NAMES, } from './limits.js';
 export type { ParsedExpression } from './parser.js';
 export { parseExpression } from './parser.js';

package/dist/generated/addon-api.d.ts

@@ -1624,6 +1624,13 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof coreBlocksCapability.methods.listCompositions.output>;
             meta: object;
         }>;
+        getCustomization: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof coreBlocksCapability.methods.getCustomization.input>;
+            output: z.infer<typeof coreBlocksCapability.methods.getCustomization.output>;
+            meta: object;
+        }>;
         validateComposition: TRPCMutationProcedure<{
             input: {
                 [x: string]: unknown;
@@ -3026,6 +3033,41 @@ export type AppRouter = TrpcCoreRouter<{
             output: z.infer<typeof deviceStateCapability.methods.setCapSlice.output>;
             meta: object;
         }>;
+        claimFields: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceStateCapability.methods.claimFields.input>;
+            output: z.infer<typeof deviceStateCapability.methods.claimFields.output>;
+            meta: object;
+        }>;
+        patchOwnedFields: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceStateCapability.methods.patchOwnedFields.input>;
+            output: z.infer<typeof deviceStateCapability.methods.patchOwnedFields.output>;
+            meta: object;
+        }>;
+        releaseClaim: TRPCMutationProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceStateCapability.methods.releaseClaim.input>;
+            output: z.infer<typeof deviceStateCapability.methods.releaseClaim.output>;
+            meta: object;
+        }>;
+        listClaims: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceStateCapability.methods.listClaims.input>;
+            output: z.infer<typeof deviceStateCapability.methods.listClaims.output>;
+            meta: object;
+        }>;
+        getNativeCapSlice: TRPCQueryProcedure<{
+            input: {
+                [x: string]: unknown;
+            } & z.input<typeof deviceStateCapability.methods.getNativeCapSlice.input>;
+            output: z.infer<typeof deviceStateCapability.methods.getNativeCapSlice.output>;
+            meta: object;
+        }>;
     }>>;
     deviceStatus: TRPCBuiltRouter<{
         ctx: TrpcContext;