@camstack/types 1.2.162 → 1.2.164

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_category = require("./event-category-b8kBSOTT.js");
-const require_sleep = require("./sleep-DDIFZGbc.js");
+const require_event_category = require("./event-category-BVo6ta6_.js");
+const require_sleep = require("./sleep-BZtO-eFY.js");
 const require_canonical_hash = require("./canonical-hash-DNV8S5ET.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -2643,6 +2643,158 @@ var RECOGNITION_TYPES = [
 	"custom"
 ];
 //#endregion
+//#region src/interfaces/storage-location-mode.ts
+/**
+* The storage-location STATE MODEL (D385) — one typed state, one policy module.
+*
+* A location's state used to be split across two authorities: the typed
+* `enabled` field (THE write switch since D383) and an untyped `config.readOnly`
+* key. They did not mean the same thing — `enabled: false` was still evicted
+* under disk pressure while `config.readOnly` was deliberately excluded — and
+* neither name said which. Every consumer re-derived the difference, and the
+* three questions that actually matter were answered in six places.
+*
+* This module is the ONLY place in the repo allowed to interpret the state. It
+* answers three questions and nothing else:
+*
+*   - may this location be WRITTEN to?   {@link modeMayWrite}
+*   - may this location be READ?          {@link modeMayRead}
+*   - what is its eviction policy?        {@link evictionPolicyForMode}
+*
+* | mode       | write | read | eviction                       |
+* | ---------- | ----- | ---- | ------------------------------ |
+* | `active`   | yes   | yes  | `normal` (pressure + usage cap) |
+* | `readonly` | no    | yes  | `never`                        |
+* | `drain`    | no    | yes  | `drain` (paced, until empty)   |
+* | `disabled` | no    | no   | `never`                        |
+*
+* `scripts/check-storage-location-mode-single-owner.ts` fails the build when
+* anything outside this module reads `config['readOnly']` or compares `enabled`
+* directly. A rule nothing checks has already been broken somewhere.
+*/
+var STORAGE_LOCATION_MODES = [
+	"active",
+	"readonly",
+	"drain",
+	"disabled"
+];
+/**
+* The one typed state of a storage location. Authoritative Zod schema — the TS
+* alias below is `z.infer<>` of it, never a second spelling.
+*/
+var StorageLocationModeSchema = zod.z.enum(STORAGE_LOCATION_MODES);
+/**
+* What disk-pressure and usage-cap relief may do to a location.
+*
+* - `normal` — the existing behaviour: free-percent guard plus `maxUsedGb`.
+* - `never`  — excluded entirely. A retiring disk the operator is copying off
+*              must not race the relocate mover, and a disabled one is not the
+*              system's to erase.
+* - `drain`  — a monotonically descending effective usage cap, paced to what
+*              the ACTIVE locations of the same class gained (D386). This is
+*              the only policy that shrinks a location the system is not
+*              writing to.
+*/
+var StorageEvictionPolicySchema = zod.z.enum([
+	"normal",
+	"never",
+	"drain"
+]);
+/**
+* The legacy untyped drain key. Named ONCE, here, so the guard has exactly one
+* sanctioned reader and the string never appears anywhere else.
+*/
+var LEGACY_READ_ONLY_CONFIG_KEY = "readOnly";
+/** Is this mode a write target? Only `active` is. */
+function modeMayWrite(mode) {
+	return mode === "active";
+}
+/** May this mode be read (playback, timeline, scrub, relocate source)? */
+function modeMayRead(mode) {
+	return mode !== "disabled";
+}
+/** What eviction may do here. See {@link StorageEvictionPolicy}. */
+function evictionPolicyForMode(mode) {
+	switch (mode) {
+		case "active": return "normal";
+		case "drain": return "drain";
+		case "readonly":
+		case "disabled": return "never";
+	}
+}
+/**
+* The mode a LEGACY row implies, or `null` when it implies nothing — the row is
+* already stamped, or it carried neither flag.
+*
+* Both legacy flags fold to `readonly`, which is the CONSERVATIVE direction: a
+* state change must never start deleting footage on its own, and it must never
+* make footage that was still being served disappear. `enabled: false` used to
+* leave the location evictable under pressure; folding it to `readonly` stops
+* that, which is a strictly safer answer than the one it replaces.
+*/
+function legacyModeOf(location) {
+	if (location.mode !== void 0) return null;
+	if (location.config["readOnly"] === true) return "readonly";
+	if (location.enabled === false) return "readonly";
+	return null;
+}
+/**
+* The state of a location, stamped or folded. THE one interpretation: a row
+* that predates D385 is never ambiguous, and a stamped `mode` always wins over
+* whatever the legacy pair still says.
+*/
+function resolveLocationMode(location) {
+	return (isStorageLocationMode(location.mode) ? location.mode : void 0) ?? legacyModeOf(location) ?? "active";
+}
+/** Is this one of the four states? The stamped value crosses a wire, and a
+*  value nobody defined must not be rendered as if it were a state. */
+function isStorageLocationMode(value) {
+	return STORAGE_LOCATION_MODES.some((mode) => mode === value);
+}
+/** May this location be written to? */
+function mayWriteToLocation(location) {
+	return modeMayWrite(resolveLocationMode(location));
+}
+/** May this location be read? A `disabled` one may not — and that is an
+*  operator CHOICE, which callers must report as unavailable rather than as an
+*  unknown-location fault. */
+function mayReadLocation(location) {
+	return modeMayRead(resolveLocationMode(location));
+}
+/** What eviction may do to this location. */
+function evictionPolicyOfLocation(location) {
+	return evictionPolicyForMode(resolveLocationMode(location));
+}
+/**
+* The config blob with the retired drain key removed. Returns the SAME object
+* when there was nothing to strip, so a caller can tell "changed" from
+* "unchanged" by identity and skip a pointless persist.
+*/
+function strippedOfLegacyReadOnly(config) {
+	if (!("readOnly" in config)) return config;
+	const next = { ...config };
+	delete next[LEGACY_READ_ONLY_CONFIG_KEY];
+	return next;
+}
+/**
+* Set a location's mode, and with it everything that must agree with it.
+*
+* `enabled` stays readable for one release as a DERIVED value (`mode ===
+* 'active'`) so consumers that have not moved yet keep working, and the legacy
+* `config.readOnly` key is DELETED. This function is the only way to write
+* either, which is what makes it impossible for the two to disagree.
+*
+* Returns a new object — the input is never mutated.
+*/
+function withLocationMode(location, mode) {
+	return {
+		...location,
+		mode,
+		enabled: modeMayWrite(mode),
+		config: strippedOfLegacyReadOnly(location.config)
+	};
+}
+//#endregion
 //#region src/interfaces/storage-location.ts
 /**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
@@ -2710,6 +2862,21 @@ var StorageLocationSchema = zod.z.object({
 	* stops existing rather than being re-derived on every read.
 	*/
 	enabled: zod.z.boolean().optional(),
+	/**
+	* THE state of this location (D385), and the only authority on what may be
+	* written, read or evicted here. Interpreted in exactly one place —
+	* `storage-location-mode.ts` — which also folds the legacy
+	* `enabled` / `config.readOnly` pair into a mode so an old row is never
+	* ambiguous.
+	*
+	* OPTIONAL only for the wire and for rows written before D385: absence is
+	* resolved by `resolveLocationMode`, and the orchestrator stamps every
+	* unstamped row ONCE at hydrate so absence stops existing rather than being
+	* re-derived on every read. `enabled` survives one release as a DERIVED
+	* mirror (`mode === 'active'`); `withLocationMode` is the only writer of
+	* either, so the two cannot disagree.
+	*/
+	mode: StorageLocationModeSchema.optional(),
 	/** COMPUTED at read time by the orchestrator (statfs of the backing volume
 	*  for node-local locations it can reach) — never persisted, absent when the
 	*  volume is remote/unreachable. The single capacity truth every UI reads. */
@@ -2717,6 +2884,25 @@ var StorageLocationSchema = zod.z.object({
 		totalBytes: zod.z.number(),
 		availableBytes: zod.z.number()
 	}).nullable().optional(),
+	/**
+	* How much of that volume CamStack ITSELF holds on this location (D388) —
+	* COMPUTED at read time from the `storage-occupancy` providers' own figures,
+	* never persisted, never a filesystem walk.
+	*
+	* **ABSENT MEANS UNKNOWN, never zero.** No provider has reported for this
+	* location yet — nobody stores here, the owning addon is down, or the first
+	* refresh has not completed. A UI must omit the segment rather than draw it
+	* at zero, which would claim we occupy nothing (D315). It is an OBJECT and
+	* not a bare number precisely so that a `?? 0` on the consuming side has to
+	* be spelled out loud instead of appearing by accident.
+	*
+	* `measuredAtMs` is the OLDEST contributing measurement, so it is honest
+	* about the whole figure rather than about its freshest part.
+	*/
+	owned: zod.z.object({
+		bytes: zod.z.number().int().nonnegative(),
+		measuredAtMs: zod.z.number().int().nonnegative()
+	}).optional(),
 	createdAt: zod.z.number(),
 	updatedAt: zod.z.number()
 });
@@ -2732,16 +2918,45 @@ var StorageLocationSchema = zod.z.object({
 * the repo may read it; `scripts/check-no-storage-default.ts` enforces that.
 */
 var LegacyStorageLocationDefaultSchema = zod.z.object({ isDefault: zod.z.boolean().optional() });
+function isLocationEnabled(location) {
+	return mayWriteToLocation({
+		...location,
+		config: location.config ?? {}
+	});
+}
 /**
-* Is this location a write target? THE one place that decides what an absent
-* `enabled` means on a persisted row — legacy rows predate the flag and were
-* active, so absence is enabled. Every consumer asks here rather than spelling
-* `enabled !== false` again, so the tri-state has exactly one interpretation.
+* Bytes in one GB, for every storage figure an operator types.
+*
+* BINARY (1024³), everywhere. The repo had both: the orchestrator's
+* `maxUsedGb` → bytes conversion used 1024³ while the recorder's placement
+* headroom used 10⁹ for the SAME stored key, so a location with a cap set was
+* silently 7.4% off depending on which side of the pipe asked. The persisted
+* values were entered against the binary unit and the admin UI reads it, so
+* that is the one that stays. Every GB knob — `maxUsedGb`, `minFreeGb` —
+* converts through {@link gbToBytes} and nowhere else.
 */
-function isLocationEnabled(location) {
-	return location.enabled !== false;
+var STORAGE_BYTES_PER_GB = 1024 ** 3;
+/** GB → bytes, binary. Fractional GB is admitted and floored. */
+function gbToBytes(gb) {
+	return Math.floor(gb * STORAGE_BYTES_PER_GB);
 }
 /**
+* How far a `drain` has got (D386) — the read a UI renders, and nothing more.
+*
+* `estimatedEmptyAtMs` is derived from the growth the ratchet has actually
+* OBSERVED and is `null` when it has observed none. Never a fabricated date: a
+* drain with no observed growth has no honest ETA, and inventing one is how an
+* operator learns not to believe the screen.
+*/
+var StorageDrainProgressSchema = zod.z.object({
+	locationId: zod.z.string(),
+	startedAtMs: zod.z.number(),
+	startBytes: zod.z.number(),
+	bytesRemaining: zod.z.number(),
+	drained: zod.z.boolean(),
+	estimatedEmptyAtMs: zod.z.number().nullable()
+});
+/**
 * Reference accepted by consumer-facing `api.storage.*` calls.
 * Either:
 *  - a `StorageLocationType` (e.g. `'backups'`) → the sole location of that type
@@ -20724,8 +20939,25 @@ var occupancyRecheckFramesField = {
 * (analyzer attaches detected `regions[]`; onboard does not — the
 * camera typically only reports a binary signal plus an optional
 * channel/AI class which lives in dedicated event channels).
-*/
-var MotionSourceEnum = zod.z.enum(["onboard", "analyzer"]);
+*
+* - `onboard` — the camera's firmware said something moved.
+* - `analyzer` — this runner's frame-diff said so, and attaches `regions[]`.
+* - `device-activity` — the DEVICE said it is doing its job: the
+*   `recording-signal` LEVEL the same device raises for the recorder
+*   ([D380](../../../../docs/decisions/adr-0380-a-device-decided-recording-is-a-mode-with-no-schedule-seeded-once.md)),
+*   republished as a motion source. It attaches **nothing** — no regions, no
+*   class: the only fact it carries is that the device is active, and a robot
+*   vacuum that is itself the moving object has no region worth sending. It is
+*   a LEVEL, so unlike `onboard` it has a real falling edge, and unlike
+*   `analyzer` it must not open the frame-diff side-channel — the runner's
+*   `handleOnboardMotionAnalyzer` gate is `source === 'onboard'` and stays that
+*   way ([D392](../../../../docs/decisions/adr-0392-a-device-that-says-it-is-working-is-a-motion-source-of-its-own.md)).
+*/
+var MotionSourceEnum = zod.z.enum([
+	"onboard",
+	"analyzer",
+	"device-activity"
+]);
 /**
 * List of motion sources active on a camera. Empty array is valid:
 * "no source" — happens for battery cams without firmware motion when
@@ -20989,13 +21221,20 @@ var RunnerCameraDeviceUIFields = [
 		type: "multiselect",
 		label: "Motion Sources",
 		default: ["analyzer"],
-		options: [{
-			value: "analyzer",
-			label: "Frame-diff Analyzer (motion addon)"
-		}, {
-			value: "onboard",
-			label: "Camera Onboard Sensor"
-		}]
+		options: [
+			{
+				value: "analyzer",
+				label: "Frame-diff Analyzer (motion addon)"
+			},
+			{
+				value: "onboard",
+				label: "Camera Onboard Sensor"
+			},
+			{
+				value: "device-activity",
+				label: "Device activity (the device says it is working)"
+			}
+		]
 	},
 	{
 		key: "motionFps",
@@ -23201,6 +23440,12 @@ var storageCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* How far each draining location has got (D386). A pure READ of what the
+		* last pressure sweep computed — it starts no work, and a location that is
+		* not draining simply does not appear.
+		*/
+		listDrainProgress: require_sleep.method(zod.z.void(), zod.z.array(StorageDrainProgressSchema).readonly()),
 		testLocation: require_sleep.method(zod.z.object({ id: zod.z.string() }), zod.z.object({
 			ok: zod.z.boolean(),
 			error: zod.z.string().optional()
@@ -23353,6 +23598,73 @@ var storageMigrationCapability = {
 	}
 };
 //#endregion
+//#region src/capabilities/storage-occupancy.cap.ts
+/**
+* `storage-occupancy` — how many bytes an addon actually HOLDS on a storage
+* location (D388).
+*
+* ## Why this is not `storage-evictable`
+*
+* `storage-evictable.getEvictableUsage` looks like the same question and is
+* not, in two ways that both matter and both bite hardest on the locations an
+* operator most wants a figure for:
+*
+*  - it reports the whole eviction DOMAIN, not the location. `recordings:default`
+*    and `recordingsLow:default` deliberately share one root and evict as one
+*    oldest-first pool, so both answer with the SAME combined total. As an
+*    occupancy figure that double-counts the disk.
+*  - it reports ZERO for a location whose eviction policy is `never` (D385) —
+*    a `readonly` or `disabled` disk. Those are exactly the disks an operator
+*    is retiring and staring at.
+*
+* So this is its own contract with its own quantity, and the quantity is
+* OCCUPIED: every byte the addon holds on that location, whether or not it
+* would ever be willing to delete it. A provider that can only answer
+* "evictable" must not register here — a number that silently means different
+* things per class is worse than no number.
+*
+* ## Absence is an answer
+*
+* A location nobody reports for is UNKNOWN, never zero (D315). The orchestrator
+* stamps `StorageLocation.owned` only for locations it has a report for, and
+* the field is an OBJECT rather than a bare number so that a `?? 0` on the
+* consuming side has to be written out loud instead of appearing by accident.
+*
+* `internal: true` — consumed by the orchestrator's `listLocations` stamp, never
+* a public client surface. Clients read the stamped `StorageLocation.owned`.
+*/
+/** One provider's occupancy answer for one location. */
+var StorageOccupancyReportSchema = zod.z.object({
+	locationId: zod.z.string(),
+	/** Bytes this provider holds on THAT location — not its eviction domain, and
+	*  not net of what it is willing to delete. */
+	ownedBytes: zod.z.number().int().nonnegative(),
+	/** When the provider last actually measured this. The orchestrator carries it
+	*  through so a UI can say how old the figure is instead of implying "now". */
+	measuredAtMs: zod.z.number().int().nonnegative()
+});
+var storageOccupancyCapability = {
+	name: "storage-occupancy",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: { 
+	/**
+	* Occupancy for the given locations, in ONE round trip.
+	*
+	* A provider answers only for the locations it actually holds bytes on and
+	* OMITS the rest — an omitted location is "I hold nothing measurable here",
+	* which the orchestrator merges as a contribution of nothing rather than as
+	* a claim that the location is empty. Only a location no provider reports
+	* at all stays unknown.
+	*
+	* This must be CHEAP and must never walk a filesystem: it is on the admin
+	* UI's `listLocations` path. The owner keeps its own figure fresh (D224) and
+	* answers from what it already has.
+	*/
+getOccupancy: require_sleep.method(zod.z.object({ locationIds: zod.z.array(zod.z.string()).readonly() }), zod.z.array(StorageOccupancyReportSchema).readonly(), { auth: "admin" }) }
+};
+//#endregion
 //#region src/capabilities/storage-provider.cap.ts
 var ProviderInfoSchema = zod.z.discriminatedUnion("shouldSaveDiskSpace", [zod.z.object({
 	providerId: zod.z.string().min(1),
@@ -25769,125 +26081,6 @@ onStatusChanged: { data: zod.z.object({
 	volatileStateFields: ["lastUpdated"]
 };
 //#endregion
-//#region src/capabilities/network-link.cap.ts
-/**
-* How a device reaches the network, and how well.
-*
-* NOT `connectivity`: that cap is an UPSTREAM system's binary view of whether
-* an entity is reachable (a Home Assistant `binary_sensor` with
-* `device_class: connectivity`). This one is the device's OWN link — the
-* medium it is on and the signal it sees — the way `battery` is the device's
-* own charge.
-*
-* `'wifi'`, `'ethernet'` and `'cellular'` are links the firmware actually
-* reported. `'unknown'` is the ABSENCE of an answer — the provider has
-* registered the capability but has not read the link yet (D315: unknown is
-* not empty). Consumers skip it rather than draw a wire or a bar.
-*/
-var NETWORK_LINK_TYPES = [
-	"wifi",
-	"ethernet",
-	"cellular",
-	"unknown"
-];
-/**
-* Network-link snapshot. Same shape for every provider (a Reolink wifi
-* camera, a Home Assistant device with a signal-strength sensor, a Tapo
-* plug): one slice under `device.runtimeState['network-link']`, one badge,
-* one Home Assistant projection.
-*/
-var NetworkLinkStatusSchema = zod.z.object({
-	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
-	type: zod.z.enum(NETWORK_LINK_TYPES),
-	/**
-	* Link quality, 0..100 inclusive, normalised by the provider from whatever
-	* the firmware reports (bars, RSSI, a vendor scale). **`null` means NOT
-	* KNOWN or NOT APPLICABLE** — a wired link has no signal, and a wireless
-	* one whose reading has not landed must not be drawn at 0 %. Consumers
-	* SKIP a null rather than coerce it.
-	*/
-	signalPercent: zod.z.number().min(0).max(100).nullable(),
-	/** Raw received signal strength in dBm, when the firmware reports one. */
-	rssiDbm: zod.z.number().optional(),
-	/** Network name of a wireless link, when the firmware reports it. */
-	ssid: zod.z.string().optional(),
-	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
-	lastUpdated: zod.z.number()
-});
-/** The slice a provider seeds before its first read: nothing is known yet. */
-var NETWORK_LINK_UNKNOWN = {
-	type: "unknown",
-	signalPercent: null,
-	lastUpdated: 0
-};
-/**
-* Normalise a signal the firmware reports as BARS (0..`maxBars`) to 0..100.
-* Out-of-range or non-finite input is not a reading: `null`.
-*/
-function signalPercentFromBars(bars, maxBars) {
-	if (bars === void 0 || !Number.isFinite(bars) || maxBars <= 0) return null;
-	if (bars < 0 || bars > maxBars) return null;
-	return Math.round(bars / maxBars * 100);
-}
-/**
-* Normalise an RSSI in dBm to 0..100 on the usual wifi scale: -100 dBm and
-* below is 0 %, -50 dBm and above is 100 %, linear between. Non-finite or
-* positive input is not an RSSI: `null`.
-*/
-function signalPercentFromRssi(rssiDbm) {
-	if (rssiDbm === void 0 || !Number.isFinite(rssiDbm) || rssiDbm > 0) return null;
-	return Math.round((Math.min(-50, Math.max(-100, rssiDbm)) + 100) * 2);
-}
-var networkLinkCapability = {
-	name: "network-link",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [
-		require_sleep.DeviceType.Camera,
-		require_sleep.DeviceType.Sensor,
-		require_sleep.DeviceType.Button,
-		require_sleep.DeviceType.Switch,
-		require_sleep.DeviceType.Light,
-		require_sleep.DeviceType.Lock,
-		require_sleep.DeviceType.Siren
-	],
-	methods: {},
-	events: { 
-	/**
-	* Emitted whenever the cached status changes (a link switch, a signal
-	* reading that moved). Mirrored on the parent chain by the
-	* DeviceEventPropagator like `battery.onStatusChanged`.
-	*/
-onStatusChanged: { data: zod.z.object({
-		deviceId: zod.z.number(),
-		status: NetworkLinkStatusSchema
-	}) } },
-	status: {
-		schema: NetworkLinkStatusSchema,
-		kind: "push",
-		empty: NETWORK_LINK_UNKNOWN
-	},
-	/**
-	* Runtime-state slice — every provider stores the same shape under
-	* `device.runtimeState['network-link']`, read once by the badge and the
-	* Home Assistant projector regardless of the driver.
-	*/
-	runtimeState: NetworkLinkStatusSchema,
-	/**
-	* Runtime-state durability: **restored** — a link reading is slow to
-	* change and a sleeping battery camera may not report for hours; the
-	* restored slice is what the badge shows until the next read.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored",
-	/** Clock fields: written, but excluded from the compare that decides
-	*  whether persisting is worth a SQLite commit. */
-	volatileStateFields: ["lastUpdated"]
-};
-//#endregion
 //#region src/capabilities/binary.cap.ts
 /**
 * Generic boolean sensor — last-resort fallback when no domain-
@@ -29897,6 +30090,550 @@ var nativeObjectDetectionCapability = {
 	volatileStateFields: ["lastFetchedAt"]
 };
 //#endregion
+//#region src/capabilities/navigation.cap.ts
+/**
+* `navigation` — a device-scoped capability that natively expresses the FULL
+* navigation / action surface of a robot that DRIVES ITSELF and carries an
+* on-board camera (the Dreame robot-vacuum camera is the first provider).
+*
+* Why a NEW cap rather than overloading `ptz`:
+*   - `ptz` moves a *gimbal* on a fixed camera (pan/tilt/zoom of the lens). A
+*     robot vacuum has no gimbal — the whole chassis drives, turns and spins.
+*     The two are different physical models: PTZ is absolute-position + presets,
+*     navigation is momentary drive nudges + discrete robot ACTIONS
+*     (dock / spot-clean / follow-pet / go-to-point / …).
+*   - This cap is the SOURCE OF TRUTH. Two consumers adapt from it rather than
+*     the reverse:
+*       1. a native CamStack navigation panel (data-driven from `listActions`
+*          / `getOptions`), and
+*       2. the PTZ surface — a thin adapter mimics `ptz` from `navigation` so a
+*          robot camera shows up in the existing PTZ control path without every
+*          PTZ provider learning about robots. The mapping lives in the adapter,
+*          not here (see the addon design note):
+*            ptz.continuousMove({pan,tilt}) → navigation.move({pan,tilt})
+*            ptz.stop()                      → navigation.stop()
+*            ptz.goHome()                    → navigation.runAction('goHome')
+*            ptz.getPresets()                → navigation.listActions()  (id→preset)
+*            ptz.goToPreset(id)              → navigation.runAction(id)
+*
+* ## Continuous drive
+*
+* `move` is MOMENTARY. Fluid navigation comes from the UI (or the PTZ adapter)
+* sending `move({pan,tilt})` REPEATEDLY at ~1 Hz while a direction is held, and
+* one `stop()` on release — exactly like the robot app's remote-drive joystick.
+* The provider forwards EACH `move` to one drive write; it must NOT debounce or
+* coalesce them. The UI owns the cadence.
+*
+* ## The action dictionary
+*
+* The discrete controls (dock / locate / spot-clean / follow / flash / sounds)
+* are a DATA-DRIVEN dictionary the cap exposes via `listActions()`. Each entry
+* carries `{ id, kind, label, icon }` (plus `soundId` for sound entries) so the
+* native panel AND the PTZ mimic render buttons WITHOUT hardcoding a
+* vendor-specific list. `kind: 'action'` entries are triggered with
+* `runAction({ actionId })`; `kind: 'sound'` entries with `playSound({ soundId })`
+* (the entry carries the `soundId` to pass). The general primitives — `move`,
+* `stop`, `goToPoint` — stay as first-class methods, not dictionary entries.
+*
+* NOTE (provider wiring): the first provider (Dreame) drives this with the RAW
+* `callAction(siid,aiid,in)` / `setProperty({siid,piid,value})` MIoT primitives
+* that the currently-published `@apocaliss92/nodedreame` already exposes on
+* every device handle. A future nodedreame publish adds a typed
+* `DreameCameraController` (drive / playPetSound / spotClean / findPet / …); the
+* provider can then swap the raw calls for the typed methods with no change to
+* THIS contract.
+*/
+/**
+* A momentary drive nudge. The robot MOVES (no gimbal) for as long as the caller
+* keeps sending nudges (~1 Hz); an explicit `stop` (or letting the nudges lapse)
+* halts it.
+*
+*   - `pan`   — turn: negative = left, positive = right, 0 = straight.
+*   - `tilt`  — throttle: positive = forward, negative = spin / turn-around.
+*   - `speed` — optional intensity hint [0, 1]; the provider may scale the drive
+*               vector by it (drivers without proportional drive ignore it).
+*
+* `pan` / `tilt` are normalized [-1, 1]. Both optional so a caller can nudge one
+* axis alone; an all-undefined nudge is a no-op.
+*/
+var NavigationMoveCommandSchema = zod.z.object({
+	pan: zod.z.number().min(-1).max(1).optional(),
+	tilt: zod.z.number().min(-1).max(1).optional(),
+	speed: zod.z.number().min(0).max(1).optional()
+});
+/**
+* The enumerated discrete actions a navigation-capable robot can perform via
+* `runAction`. This is the CLOSED vocabulary; a given device advertises the
+* subset it supports through `listActions`. Sounds are NOT here — they go through
+* `playSound` (see the `sound` dictionary entries).
+*/
+var NavigationActionIdSchema = zod.z.enum([
+	"goHome",
+	"locate",
+	"spotClean",
+	"findPet",
+	"personFollow",
+	"stop",
+	"startClean",
+	"pauseClean",
+	"dockWash",
+	"autoEmpty",
+	"flashOn",
+	"flashOff"
+]);
+/** Whether a dictionary entry is a `runAction` action or a `playSound` sound. */
+var NavigationEntryKindSchema = zod.z.enum(["action", "sound"]);
+/**
+* One entry in the navigation action dictionary — the DATA-DRIVEN unit both the
+* native panel and the PTZ mimic render as a button.
+*
+*   - `id`      — stable id. For `kind:'action'` it is a {@link NavigationActionId}
+*                 (pass to `runAction`); for `kind:'sound'` it is a namespaced id
+*                 (`sound:meow`) whose `soundId` is passed to `playSound`.
+*   - `icon`    — icon HINT (lucide-style name; the UI maps it to its own set).
+*   - `label`   — operator-facing English label.
+*   - `soundId` — wire sound id, present only on `kind:'sound'` entries.
+*   - `enabled` — per-device FEATURE FLAG. `listActions` reports it so the UI /
+*                 PTZ render ONLY enabled entries. Data-driven: the provider
+*                 flips it from config, never by editing code.
+*/
+var NavigationActionEntrySchema = zod.z.object({
+	id: zod.z.string(),
+	kind: NavigationEntryKindSchema,
+	label: zod.z.string(),
+	icon: zod.z.string(),
+	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
+	soundId: zod.z.number().int().optional(),
+	/** Per-device feature flag — render this entry only when true. */
+	enabled: zod.z.boolean()
+});
+/**
+* Canonical dictionary of every navigation control (discrete actions + sounds)
+* with its default label + icon hint. A provider filters this to the subset a
+* device supports (and may override a label). Exported so the provider AND the
+* UI share ONE list instead of re-deriving labels / ids independently.
+*
+* Icons are lucide-style hints; the viewer maps them to its own icon set. Every
+* catalog default is `enabled: true`; a provider overrides per-device from
+* config (data-driven — enabling / disabling one later is a config change, not a
+* code change).
+*/
+var NAVIGATION_ACTION_CATALOG = [
+	{
+		id: "startClean",
+		kind: "action",
+		label: "Start cleaning",
+		icon: "play",
+		enabled: true
+	},
+	{
+		id: "pauseClean",
+		kind: "action",
+		label: "Pause cleaning",
+		icon: "pause",
+		enabled: true
+	},
+	{
+		id: "stop",
+		kind: "action",
+		label: "Stop",
+		icon: "hand",
+		enabled: true
+	},
+	{
+		id: "goHome",
+		kind: "action",
+		label: "Return to dock",
+		icon: "home",
+		enabled: true
+	},
+	{
+		id: "locate",
+		kind: "action",
+		label: "Locate",
+		icon: "bell",
+		enabled: true
+	},
+	{
+		id: "spotClean",
+		kind: "action",
+		label: "Spot clean here",
+		icon: "crosshair",
+		enabled: true
+	},
+	{
+		id: "findPet",
+		kind: "action",
+		label: "Find pet",
+		icon: "paw-print",
+		enabled: true
+	},
+	{
+		id: "personFollow",
+		kind: "action",
+		label: "Follow me",
+		icon: "footprints",
+		enabled: true
+	},
+	{
+		id: "dockWash",
+		kind: "action",
+		label: "Wash mop",
+		icon: "droplets",
+		enabled: true
+	},
+	{
+		id: "autoEmpty",
+		kind: "action",
+		label: "Empty dustbin",
+		icon: "trash-2",
+		enabled: true
+	},
+	{
+		id: "flashOn",
+		kind: "action",
+		label: "Flash on",
+		icon: "flashlight",
+		enabled: true
+	},
+	{
+		id: "flashOff",
+		kind: "action",
+		label: "Flash off",
+		icon: "flashlight-off",
+		enabled: true
+	},
+	{
+		id: "sound:meow",
+		kind: "sound",
+		label: "Meow",
+		icon: "cat",
+		soundId: 684,
+		enabled: true
+	},
+	{
+		id: "sound:bark",
+		kind: "sound",
+		label: "Woof",
+		icon: "dog",
+		soundId: 685,
+		enabled: true
+	},
+	{
+		id: "sound:footsteps",
+		kind: "sound",
+		label: "Footsteps",
+		icon: "footprints",
+		soundId: 686,
+		enabled: true
+	},
+	{
+		id: "sound:purring",
+		kind: "sound",
+		label: "Purring",
+		icon: "cat",
+		soundId: 687,
+		enabled: true
+	},
+	{
+		id: "sound:tickTock",
+		kind: "sound",
+		label: "Tick-tock",
+		icon: "clock",
+		soundId: 688,
+		enabled: true
+	}
+];
+/** Coordinates for `goToPoint` — a point on the robot's live map. */
+var NavigationPointSchema = zod.z.object({
+	x: zod.z.number(),
+	y: zod.z.number()
+});
+/**
+* Per-device FEATURE-FLAG report for the general (non-dictionary) primitives.
+* The cap reports which are enabled so the UI / PTZ render only the controls
+* that are turned on for THIS device. Data-driven: the provider derives these
+* from config + probe, never hardcoded in the UI. The per-DICTIONARY-entry flags
+* live on {@link NavigationActionEntrySchema.enabled}; these gate the primitives
+* that are not dictionary entries.
+*
+*   - `move` / `stop`   — the momentary drive joystick.
+*   - `goToPoint`       — send-to-map-coordinate. Ships OFF on Dreame until the
+*                         map-coordinate plumbing is wired.
+*   - `runAction`       — the discrete action buttons (dictionary `kind:'action'`).
+*   - `playSound`       — the sound buttons (dictionary `kind:'sound'`).
+*   - `light`           — the on/off fill-light toggle (works anytime).
+*   - `lightMode`       — the auto/manual selector + manual level slider (a
+*                         camera-service control; needs an active stream).
+*/
+var NavigationFeaturesSchema = zod.z.object({
+	move: zod.z.boolean(),
+	stop: zod.z.boolean(),
+	goToPoint: zod.z.boolean(),
+	runAction: zod.z.boolean(),
+	playSound: zod.z.boolean(),
+	light: zod.z.boolean(),
+	lightMode: zod.z.boolean()
+});
+/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
+var NavigationLightModeSchema = zod.z.enum(["auto", "manual"]);
+/** Manual fill-light level bounds (the camera-service accepts 40..100). */
+var NAVIGATION_LIGHT_LEVEL_MIN = 40;
+var NAVIGATION_LIGHT_LEVEL_MAX = 100;
+/** Coarse work mode the robot reports — drives the UI's active-state chips. */
+var NavigationModeSchema = zod.z.enum([
+	"idle",
+	"cleaning",
+	"spot",
+	"following",
+	"goto",
+	"returning",
+	"paused",
+	"unknown"
+]);
+/**
+* Live navigation state so the UI can reflect what the robot is doing:
+*   - `mode`       — coarse activity (idle / cleaning / following / …).
+*   - `following`  — person/pet follow is currently armed.
+*   - `flash`      — the on-camera fill light is on.
+*   - `lightMode`  — auto vs manual fill-light mode.
+*   - `lightLevel` — manual fill-light level (40..100); meaningful when
+*                    `lightMode === 'manual'`.
+*/
+var NavigationStatusSchema = zod.z.object({
+	mode: NavigationModeSchema,
+	following: zod.z.boolean(),
+	flash: zod.z.boolean(),
+	lightMode: NavigationLightModeSchema,
+	lightLevel: zod.z.number().min(40).max(100),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: zod.z.number()
+});
+/**
+* Runtime-state slice owned by this cap (kernel-managed: validated, mirrored,
+* observable). Adds `lastFetchedAt` on top of the status shape per the
+* convention.
+*/
+var NavigationRuntimeStateSchema = NavigationStatusSchema.extend({ lastFetchedAt: zod.z.number() });
+var navigationCapability = {
+	name: "navigation",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [require_sleep.DeviceType.Camera],
+	deviceConfig: { ui: {
+		kind: "widget",
+		widgetId: "host/navigation-panel",
+		tab: "navigation",
+		topTab: true,
+		label: "Navigation",
+		order: 0
+	} },
+	methods: {
+		/**
+		* Momentary drive nudge (the robot moves). `protected` — mirrors
+		* `ptz.continuousMove` so the Viewer navigation panel (and the PTZ-mimic
+		* path) works for any authenticated user, not admin-only. The UI sends
+		* these at ~1 Hz while a control is held; the provider forwards each one to
+		* a single drive write WITHOUT debouncing.
+		*/
+		move: require_sleep.method(NavigationMoveCommandSchema.extend({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
+		/** Halt all motion immediately (zero drive vector). */
+		stop: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
+		/** Send the robot to a point on its live map. */
+		goToPoint: require_sleep.method(NavigationPointSchema.extend({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
+		/**
+		* Enumerate the discrete controls THIS device supports (data-driven UI +
+		* PTZ mimic). Camera-probed subset of {@link NAVIGATION_ACTION_CATALOG}.
+		*/
+		listActions: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(NavigationActionEntrySchema)),
+		/**
+		* Run one discrete action (a `kind:'action'` dictionary entry). Invalid /
+		* unsupported action ids are rejected by the provider.
+		*/
+		runAction: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			actionId: NavigationActionIdSchema
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Play a sound by its wire id (the `soundId` of a `kind:'sound'` entry). */
+		playSound: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			soundId: zod.z.number().int()
+		}), zod.z.void(), { kind: "mutation" }),
+		/**
+		* Turn the on-camera fill light on / off (the `OpenFullLight` control —
+		* works anytime, no active stream required).
+		*/
+		setLightOn: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			on: zod.z.boolean()
+		}), zod.z.void(), { kind: "mutation" }),
+		/**
+		* Set the fill-light mode (auto vs manual). `manual` optionally carries the
+		* initial `level`. The auto/manual + level control is a CAMERA-service
+		* action that generally needs an active camera stream/monitor session — the
+		* UI shows the manual level slider ONLY when `mode === 'manual'`.
+		*/
+		setLightMode: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			mode: NavigationLightModeSchema,
+			level: zod.z.number().min(40).max(100).optional()
+		}), zod.z.void(), { kind: "mutation" }),
+		/** Set the MANUAL fill-light level (40..100). Implies `manual` mode. */
+		setLightLevel: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number(),
+			level: zod.z.number().min(40).max(100)
+		}), zod.z.void(), { kind: "mutation" }),
+		/**
+		* Per-device FEATURE-FLAG report for the general primitives — drives which
+		* controls the UI shows (the per-entry flags for the dictionary come back on
+		* `listActions`).
+		*/
+		getFeatures: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), NavigationFeaturesSchema)
+	},
+	events: { onStatusChanged: { data: zod.z.object({
+		deviceId: zod.z.number(),
+		status: NavigationStatusSchema
+	}) } },
+	status: {
+		schema: NavigationStatusSchema,
+		kind: "push"
+	},
+	/**
+	* Runtime-state slice mirrored by the kernel. The navigation panel watches it
+	* for live mode / follow / flash changes.
+	*/
+	runtimeState: NavigationRuntimeStateSchema,
+	/**
+	* Runtime-state durability: **session** — like `vacuum-control`, a restored
+	* `mode: cleaning` / `following: true` is a robot that is not actually doing
+	* that. The live handle re-publishes on connect.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "session"
+};
+//#endregion
+//#region src/capabilities/network-link.cap.ts
+/**
+* How a device reaches the network, and how well.
+*
+* NOT `connectivity`: that cap is an UPSTREAM system's binary view of whether
+* an entity is reachable (a Home Assistant `binary_sensor` with
+* `device_class: connectivity`). This one is the device's OWN link — the
+* medium it is on and the signal it sees — the way `battery` is the device's
+* own charge.
+*
+* `'wifi'`, `'ethernet'` and `'cellular'` are links the firmware actually
+* reported. `'unknown'` is the ABSENCE of an answer — the provider has
+* registered the capability but has not read the link yet (D315: unknown is
+* not empty). Consumers skip it rather than draw a wire or a bar.
+*/
+var NETWORK_LINK_TYPES = [
+	"wifi",
+	"ethernet",
+	"cellular",
+	"unknown"
+];
+/**
+* Network-link snapshot. Same shape for every provider (a Reolink wifi
+* camera, a Home Assistant device with a signal-strength sensor, a Tapo
+* plug): one slice under `device.runtimeState['network-link']`, one badge,
+* one Home Assistant projection.
+*/
+var NetworkLinkStatusSchema = zod.z.object({
+	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
+	type: zod.z.enum(NETWORK_LINK_TYPES),
+	/**
+	* Link quality, 0..100 inclusive, normalised by the provider from whatever
+	* the firmware reports (bars, RSSI, a vendor scale). **`null` means NOT
+	* KNOWN or NOT APPLICABLE** — a wired link has no signal, and a wireless
+	* one whose reading has not landed must not be drawn at 0 %. Consumers
+	* SKIP a null rather than coerce it.
+	*/
+	signalPercent: zod.z.number().min(0).max(100).nullable(),
+	/** Raw received signal strength in dBm, when the firmware reports one. */
+	rssiDbm: zod.z.number().optional(),
+	/** Network name of a wireless link, when the firmware reports it. */
+	ssid: zod.z.string().optional(),
+	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
+	lastUpdated: zod.z.number()
+});
+/** The slice a provider seeds before its first read: nothing is known yet. */
+var NETWORK_LINK_UNKNOWN = {
+	type: "unknown",
+	signalPercent: null,
+	lastUpdated: 0
+};
+/**
+* Normalise a signal the firmware reports as BARS (0..`maxBars`) to 0..100.
+* Out-of-range or non-finite input is not a reading: `null`.
+*/
+function signalPercentFromBars(bars, maxBars) {
+	if (bars === void 0 || !Number.isFinite(bars) || maxBars <= 0) return null;
+	if (bars < 0 || bars > maxBars) return null;
+	return Math.round(bars / maxBars * 100);
+}
+/**
+* Normalise an RSSI in dBm to 0..100 on the usual wifi scale: -100 dBm and
+* below is 0 %, -50 dBm and above is 100 %, linear between. Non-finite or
+* positive input is not an RSSI: `null`.
+*/
+function signalPercentFromRssi(rssiDbm) {
+	if (rssiDbm === void 0 || !Number.isFinite(rssiDbm) || rssiDbm > 0) return null;
+	return Math.round((Math.min(-50, Math.max(-100, rssiDbm)) + 100) * 2);
+}
+var networkLinkCapability = {
+	name: "network-link",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		require_sleep.DeviceType.Camera,
+		require_sleep.DeviceType.Sensor,
+		require_sleep.DeviceType.Button,
+		require_sleep.DeviceType.Switch,
+		require_sleep.DeviceType.Light,
+		require_sleep.DeviceType.Lock,
+		require_sleep.DeviceType.Siren
+	],
+	methods: {},
+	events: { 
+	/**
+	* Emitted whenever the cached status changes (a link switch, a signal
+	* reading that moved). Mirrored on the parent chain by the
+	* DeviceEventPropagator like `battery.onStatusChanged`.
+	*/
+onStatusChanged: { data: zod.z.object({
+		deviceId: zod.z.number(),
+		status: NetworkLinkStatusSchema
+	}) } },
+	status: {
+		schema: NetworkLinkStatusSchema,
+		kind: "push",
+		empty: NETWORK_LINK_UNKNOWN
+	},
+	/**
+	* Runtime-state slice — every provider stores the same shape under
+	* `device.runtimeState['network-link']`, read once by the badge and the
+	* Home Assistant projector regardless of the driver.
+	*/
+	runtimeState: NetworkLinkStatusSchema,
+	/**
+	* Runtime-state durability: **restored** — a link reading is slow to
+	* change and a sleeping battery camera may not report for hours; the
+	* restored slice is what the badge shows until the next read.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored",
+	/** Clock fields: written, but excluded from the compare that decides
+	*  whether persisting is worth a SQLite commit. */
+	volatileStateFields: ["lastUpdated"]
+};
+//#endregion
 //#region src/capabilities/network-quality.cap.ts
 /**
 * network-quality — system-scoped singleton capability tracking RTT,
@@ -31829,431 +32566,6 @@ var ptzAutotrackCapability = {
 	durability: "session"
 };
 //#endregion
-//#region src/capabilities/navigation.cap.ts
-/**
-* `navigation` — a device-scoped capability that natively expresses the FULL
-* navigation / action surface of a robot that DRIVES ITSELF and carries an
-* on-board camera (the Dreame robot-vacuum camera is the first provider).
-*
-* Why a NEW cap rather than overloading `ptz`:
-*   - `ptz` moves a *gimbal* on a fixed camera (pan/tilt/zoom of the lens). A
-*     robot vacuum has no gimbal — the whole chassis drives, turns and spins.
-*     The two are different physical models: PTZ is absolute-position + presets,
-*     navigation is momentary drive nudges + discrete robot ACTIONS
-*     (dock / spot-clean / follow-pet / go-to-point / …).
-*   - This cap is the SOURCE OF TRUTH. Two consumers adapt from it rather than
-*     the reverse:
-*       1. a native CamStack navigation panel (data-driven from `listActions`
-*          / `getOptions`), and
-*       2. the PTZ surface — a thin adapter mimics `ptz` from `navigation` so a
-*          robot camera shows up in the existing PTZ control path without every
-*          PTZ provider learning about robots. The mapping lives in the adapter,
-*          not here (see the addon design note):
-*            ptz.continuousMove({pan,tilt}) → navigation.move({pan,tilt})
-*            ptz.stop()                      → navigation.stop()
-*            ptz.goHome()                    → navigation.runAction('goHome')
-*            ptz.getPresets()                → navigation.listActions()  (id→preset)
-*            ptz.goToPreset(id)              → navigation.runAction(id)
-*
-* ## Continuous drive
-*
-* `move` is MOMENTARY. Fluid navigation comes from the UI (or the PTZ adapter)
-* sending `move({pan,tilt})` REPEATEDLY at ~1 Hz while a direction is held, and
-* one `stop()` on release — exactly like the robot app's remote-drive joystick.
-* The provider forwards EACH `move` to one drive write; it must NOT debounce or
-* coalesce them. The UI owns the cadence.
-*
-* ## The action dictionary
-*
-* The discrete controls (dock / locate / spot-clean / follow / flash / sounds)
-* are a DATA-DRIVEN dictionary the cap exposes via `listActions()`. Each entry
-* carries `{ id, kind, label, icon }` (plus `soundId` for sound entries) so the
-* native panel AND the PTZ mimic render buttons WITHOUT hardcoding a
-* vendor-specific list. `kind: 'action'` entries are triggered with
-* `runAction({ actionId })`; `kind: 'sound'` entries with `playSound({ soundId })`
-* (the entry carries the `soundId` to pass). The general primitives — `move`,
-* `stop`, `goToPoint` — stay as first-class methods, not dictionary entries.
-*
-* NOTE (provider wiring): the first provider (Dreame) drives this with the RAW
-* `callAction(siid,aiid,in)` / `setProperty({siid,piid,value})` MIoT primitives
-* that the currently-published `@apocaliss92/nodedreame` already exposes on
-* every device handle. A future nodedreame publish adds a typed
-* `DreameCameraController` (drive / playPetSound / spotClean / findPet / …); the
-* provider can then swap the raw calls for the typed methods with no change to
-* THIS contract.
-*/
-/**
-* A momentary drive nudge. The robot MOVES (no gimbal) for as long as the caller
-* keeps sending nudges (~1 Hz); an explicit `stop` (or letting the nudges lapse)
-* halts it.
-*
-*   - `pan`   — turn: negative = left, positive = right, 0 = straight.
-*   - `tilt`  — throttle: positive = forward, negative = spin / turn-around.
-*   - `speed` — optional intensity hint [0, 1]; the provider may scale the drive
-*               vector by it (drivers without proportional drive ignore it).
-*
-* `pan` / `tilt` are normalized [-1, 1]. Both optional so a caller can nudge one
-* axis alone; an all-undefined nudge is a no-op.
-*/
-var NavigationMoveCommandSchema = zod.z.object({
-	pan: zod.z.number().min(-1).max(1).optional(),
-	tilt: zod.z.number().min(-1).max(1).optional(),
-	speed: zod.z.number().min(0).max(1).optional()
-});
-/**
-* The enumerated discrete actions a navigation-capable robot can perform via
-* `runAction`. This is the CLOSED vocabulary; a given device advertises the
-* subset it supports through `listActions`. Sounds are NOT here — they go through
-* `playSound` (see the `sound` dictionary entries).
-*/
-var NavigationActionIdSchema = zod.z.enum([
-	"goHome",
-	"locate",
-	"spotClean",
-	"findPet",
-	"personFollow",
-	"stop",
-	"startClean",
-	"pauseClean",
-	"dockWash",
-	"autoEmpty",
-	"flashOn",
-	"flashOff"
-]);
-/** Whether a dictionary entry is a `runAction` action or a `playSound` sound. */
-var NavigationEntryKindSchema = zod.z.enum(["action", "sound"]);
-/**
-* One entry in the navigation action dictionary — the DATA-DRIVEN unit both the
-* native panel and the PTZ mimic render as a button.
-*
-*   - `id`      — stable id. For `kind:'action'` it is a {@link NavigationActionId}
-*                 (pass to `runAction`); for `kind:'sound'` it is a namespaced id
-*                 (`sound:meow`) whose `soundId` is passed to `playSound`.
-*   - `icon`    — icon HINT (lucide-style name; the UI maps it to its own set).
-*   - `label`   — operator-facing English label.
-*   - `soundId` — wire sound id, present only on `kind:'sound'` entries.
-*   - `enabled` — per-device FEATURE FLAG. `listActions` reports it so the UI /
-*                 PTZ render ONLY enabled entries. Data-driven: the provider
-*                 flips it from config, never by editing code.
-*/
-var NavigationActionEntrySchema = zod.z.object({
-	id: zod.z.string(),
-	kind: NavigationEntryKindSchema,
-	label: zod.z.string(),
-	icon: zod.z.string(),
-	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
-	soundId: zod.z.number().int().optional(),
-	/** Per-device feature flag — render this entry only when true. */
-	enabled: zod.z.boolean()
-});
-/**
-* Canonical dictionary of every navigation control (discrete actions + sounds)
-* with its default label + icon hint. A provider filters this to the subset a
-* device supports (and may override a label). Exported so the provider AND the
-* UI share ONE list instead of re-deriving labels / ids independently.
-*
-* Icons are lucide-style hints; the viewer maps them to its own icon set. Every
-* catalog default is `enabled: true`; a provider overrides per-device from
-* config (data-driven — enabling / disabling one later is a config change, not a
-* code change).
-*/
-var NAVIGATION_ACTION_CATALOG = [
-	{
-		id: "startClean",
-		kind: "action",
-		label: "Start cleaning",
-		icon: "play",
-		enabled: true
-	},
-	{
-		id: "pauseClean",
-		kind: "action",
-		label: "Pause cleaning",
-		icon: "pause",
-		enabled: true
-	},
-	{
-		id: "stop",
-		kind: "action",
-		label: "Stop",
-		icon: "hand",
-		enabled: true
-	},
-	{
-		id: "goHome",
-		kind: "action",
-		label: "Return to dock",
-		icon: "home",
-		enabled: true
-	},
-	{
-		id: "locate",
-		kind: "action",
-		label: "Locate",
-		icon: "bell",
-		enabled: true
-	},
-	{
-		id: "spotClean",
-		kind: "action",
-		label: "Spot clean here",
-		icon: "crosshair",
-		enabled: true
-	},
-	{
-		id: "findPet",
-		kind: "action",
-		label: "Find pet",
-		icon: "paw-print",
-		enabled: true
-	},
-	{
-		id: "personFollow",
-		kind: "action",
-		label: "Follow me",
-		icon: "footprints",
-		enabled: true
-	},
-	{
-		id: "dockWash",
-		kind: "action",
-		label: "Wash mop",
-		icon: "droplets",
-		enabled: true
-	},
-	{
-		id: "autoEmpty",
-		kind: "action",
-		label: "Empty dustbin",
-		icon: "trash-2",
-		enabled: true
-	},
-	{
-		id: "flashOn",
-		kind: "action",
-		label: "Flash on",
-		icon: "flashlight",
-		enabled: true
-	},
-	{
-		id: "flashOff",
-		kind: "action",
-		label: "Flash off",
-		icon: "flashlight-off",
-		enabled: true
-	},
-	{
-		id: "sound:meow",
-		kind: "sound",
-		label: "Meow",
-		icon: "cat",
-		soundId: 684,
-		enabled: true
-	},
-	{
-		id: "sound:bark",
-		kind: "sound",
-		label: "Woof",
-		icon: "dog",
-		soundId: 685,
-		enabled: true
-	},
-	{
-		id: "sound:footsteps",
-		kind: "sound",
-		label: "Footsteps",
-		icon: "footprints",
-		soundId: 686,
-		enabled: true
-	},
-	{
-		id: "sound:purring",
-		kind: "sound",
-		label: "Purring",
-		icon: "cat",
-		soundId: 687,
-		enabled: true
-	},
-	{
-		id: "sound:tickTock",
-		kind: "sound",
-		label: "Tick-tock",
-		icon: "clock",
-		soundId: 688,
-		enabled: true
-	}
-];
-/** Coordinates for `goToPoint` — a point on the robot's live map. */
-var NavigationPointSchema = zod.z.object({
-	x: zod.z.number(),
-	y: zod.z.number()
-});
-/**
-* Per-device FEATURE-FLAG report for the general (non-dictionary) primitives.
-* The cap reports which are enabled so the UI / PTZ render only the controls
-* that are turned on for THIS device. Data-driven: the provider derives these
-* from config + probe, never hardcoded in the UI. The per-DICTIONARY-entry flags
-* live on {@link NavigationActionEntrySchema.enabled}; these gate the primitives
-* that are not dictionary entries.
-*
-*   - `move` / `stop`   — the momentary drive joystick.
-*   - `goToPoint`       — send-to-map-coordinate. Ships OFF on Dreame until the
-*                         map-coordinate plumbing is wired.
-*   - `runAction`       — the discrete action buttons (dictionary `kind:'action'`).
-*   - `playSound`       — the sound buttons (dictionary `kind:'sound'`).
-*   - `light`           — the on/off fill-light toggle (works anytime).
-*   - `lightMode`       — the auto/manual selector + manual level slider (a
-*                         camera-service control; needs an active stream).
-*/
-var NavigationFeaturesSchema = zod.z.object({
-	move: zod.z.boolean(),
-	stop: zod.z.boolean(),
-	goToPoint: zod.z.boolean(),
-	runAction: zod.z.boolean(),
-	playSound: zod.z.boolean(),
-	light: zod.z.boolean(),
-	lightMode: zod.z.boolean()
-});
-/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
-var NavigationLightModeSchema = zod.z.enum(["auto", "manual"]);
-/** Manual fill-light level bounds (the camera-service accepts 40..100). */
-var NAVIGATION_LIGHT_LEVEL_MIN = 40;
-var NAVIGATION_LIGHT_LEVEL_MAX = 100;
-/** Coarse work mode the robot reports — drives the UI's active-state chips. */
-var NavigationModeSchema = zod.z.enum([
-	"idle",
-	"cleaning",
-	"spot",
-	"following",
-	"goto",
-	"returning",
-	"paused",
-	"unknown"
-]);
-/**
-* Live navigation state so the UI can reflect what the robot is doing:
-*   - `mode`       — coarse activity (idle / cleaning / following / …).
-*   - `following`  — person/pet follow is currently armed.
-*   - `flash`      — the on-camera fill light is on.
-*   - `lightMode`  — auto vs manual fill-light mode.
-*   - `lightLevel` — manual fill-light level (40..100); meaningful when
-*                    `lightMode === 'manual'`.
-*/
-var NavigationStatusSchema = zod.z.object({
-	mode: NavigationModeSchema,
-	following: zod.z.boolean(),
-	flash: zod.z.boolean(),
-	lightMode: NavigationLightModeSchema,
-	lightLevel: zod.z.number().min(40).max(100),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: zod.z.number()
-});
-/**
-* Runtime-state slice owned by this cap (kernel-managed: validated, mirrored,
-* observable). Adds `lastFetchedAt` on top of the status shape per the
-* convention.
-*/
-var NavigationRuntimeStateSchema = NavigationStatusSchema.extend({ lastFetchedAt: zod.z.number() });
-var navigationCapability = {
-	name: "navigation",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [require_sleep.DeviceType.Camera],
-	deviceConfig: { ui: {
-		kind: "widget",
-		widgetId: "host/navigation-panel",
-		tab: "navigation",
-		topTab: true,
-		label: "Navigation",
-		order: 0
-	} },
-	methods: {
-		/**
-		* Momentary drive nudge (the robot moves). `protected` — mirrors
-		* `ptz.continuousMove` so the Viewer navigation panel (and the PTZ-mimic
-		* path) works for any authenticated user, not admin-only. The UI sends
-		* these at ~1 Hz while a control is held; the provider forwards each one to
-		* a single drive write WITHOUT debouncing.
-		*/
-		move: require_sleep.method(NavigationMoveCommandSchema.extend({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
-		/** Halt all motion immediately (zero drive vector). */
-		stop: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
-		/** Send the robot to a point on its live map. */
-		goToPoint: require_sleep.method(NavigationPointSchema.extend({ deviceId: zod.z.number() }), zod.z.void(), { kind: "mutation" }),
-		/**
-		* Enumerate the discrete controls THIS device supports (data-driven UI +
-		* PTZ mimic). Camera-probed subset of {@link NAVIGATION_ACTION_CATALOG}.
-		*/
-		listActions: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), zod.z.array(NavigationActionEntrySchema)),
-		/**
-		* Run one discrete action (a `kind:'action'` dictionary entry). Invalid /
-		* unsupported action ids are rejected by the provider.
-		*/
-		runAction: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			actionId: NavigationActionIdSchema
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Play a sound by its wire id (the `soundId` of a `kind:'sound'` entry). */
-		playSound: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			soundId: zod.z.number().int()
-		}), zod.z.void(), { kind: "mutation" }),
-		/**
-		* Turn the on-camera fill light on / off (the `OpenFullLight` control —
-		* works anytime, no active stream required).
-		*/
-		setLightOn: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			on: zod.z.boolean()
-		}), zod.z.void(), { kind: "mutation" }),
-		/**
-		* Set the fill-light mode (auto vs manual). `manual` optionally carries the
-		* initial `level`. The auto/manual + level control is a CAMERA-service
-		* action that generally needs an active camera stream/monitor session — the
-		* UI shows the manual level slider ONLY when `mode === 'manual'`.
-		*/
-		setLightMode: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			mode: NavigationLightModeSchema,
-			level: zod.z.number().min(40).max(100).optional()
-		}), zod.z.void(), { kind: "mutation" }),
-		/** Set the MANUAL fill-light level (40..100). Implies `manual` mode. */
-		setLightLevel: require_sleep.method(zod.z.object({
-			deviceId: zod.z.number(),
-			level: zod.z.number().min(40).max(100)
-		}), zod.z.void(), { kind: "mutation" }),
-		/**
-		* Per-device FEATURE-FLAG report for the general primitives — drives which
-		* controls the UI shows (the per-entry flags for the dictionary come back on
-		* `listActions`).
-		*/
-		getFeatures: require_sleep.method(zod.z.object({ deviceId: zod.z.number() }), NavigationFeaturesSchema)
-	},
-	events: { onStatusChanged: { data: zod.z.object({
-		deviceId: zod.z.number(),
-		status: NavigationStatusSchema
-	}) } },
-	status: {
-		schema: NavigationStatusSchema,
-		kind: "push"
-	},
-	/**
-	* Runtime-state slice mirrored by the kernel. The navigation panel watches it
-	* for live mode / follow / flash changes.
-	*/
-	runtimeState: NavigationRuntimeStateSchema,
-	/**
-	* Runtime-state durability: **session** — like `vacuum-control`, a restored
-	* `mode: cleaning` / `following: true` is a robot that is not actually doing
-	* that. The live handle re-publishes on connect.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session"
-};
-//#endregion
 //#region src/capabilities/reboot.cap.ts
 /**
 * reboot — device-scoped capability for "soft" device reboots (firmware
@@ -39914,6 +40226,7 @@ var CAPABILITY_NAMES = {
 	storage: "storage",
 	storageEvictable: "storage-evictable",
 	storageMigration: "storage-migration",
+	storageOccupancy: "storage-occupancy",
 	storageProvider: "storage-provider",
 	streamBroker: "stream-broker",
 	streamCatalog: "stream-catalog",
@@ -40459,6 +40772,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "storageMigration",
 		name: "storage-migration"
 	},
+	{
+		key: "storageOccupancy",
+		name: "storage-occupancy"
+	},
 	{
 		key: "storageProvider",
 		name: "storage-provider"
@@ -40703,6 +41020,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	storageCapability,
 	storageEvictableCapability,
 	storageMigrationCapability,
+	storageOccupancyCapability,
 	storageProviderCapability,
 	streamBrokerCapability,
 	streamCatalogCapability,
@@ -45677,6 +45995,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storage.listDrainProgress": {
+		capName: "storage",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storage.listLocationDeclarations": {
 		capName: "storage",
 		capScope: "system",
@@ -45821,6 +46145,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storageOccupancy.getOccupancy": {
+		capName: "storage-occupancy",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageProvider.abortUpload": {
 		capName: "storage-provider",
 		capScope: "system",
@@ -46956,6 +47286,7 @@ var KNOWN_CAP_NAMES = [
 	"storage",
 	"storage-evictable",
 	"storage-migration",
+	"storage-occupancy",
 	"storage-provider",
 	"stream-broker",
 	"stream-catalog",
@@ -47102,6 +47433,7 @@ var SYSTEM_CAP_NAMES = [
 	"storage",
 	"storage-evictable",
 	"storage-migration",
+	"storage-occupancy",
 	"storage-provider",
 	"stream-broker",
 	"system",
@@ -50101,6 +50433,7 @@ function createSystemProxy(api) {
 			listLocationDeclarations: (input) => dispatch("storage", "listLocationDeclarations", "query", input),
 			upsertLocation: (input) => dispatch("storage", "upsertLocation", "mutation", input),
 			deleteLocation: (input) => dispatch("storage", "deleteLocation", "mutation", input),
+			listDrainProgress: (input) => dispatch("storage", "listDrainProgress", "query", input),
 			testLocation: (input) => dispatch("storage", "testLocation", "query", input),
 			listProviders: (input) => dispatch("storage", "listProviders", "query", input),
 			testConfig: (input) => dispatch("storage", "testConfig", "query", input)
@@ -54550,6 +54883,7 @@ exports.IntercomAbilitySchema = IntercomAbilitySchema;
 exports.IntercomStatusSchema = IntercomStatusSchema;
 exports.KNOWN_CAP_NAMES = KNOWN_CAP_NAMES;
 exports.KeyEventSchema = KeyEventSchema;
+exports.LEGACY_READ_ONLY_CONFIG_KEY = LEGACY_READ_ONLY_CONFIG_KEY;
 exports.LOAD_CONTRIBUTION_ATTRIBUTIONS = LOAD_CONTRIBUTION_ATTRIBUTIONS;
 exports.LOAD_CONTRIBUTION_ROLES = LOAD_CONTRIBUTION_ROLES;
 exports.LOG_CHANNEL_TICK_MS = LOG_CHANNEL_TICK_MS;
@@ -55001,6 +55335,8 @@ exports.SOURCE_CAP_CHANGED_AT_FIELD = SOURCE_CAP_CHANGED_AT_FIELD;
 exports.SOURCE_DEVICE_TYPES = SOURCE_DEVICE_TYPES;
 exports.SOURCE_INFO_METADATA_KEY = SOURCE_INFO_METADATA_KEY;
 exports.STORAGE_ACCESS_FALLBACK = STORAGE_ACCESS_FALLBACK;
+exports.STORAGE_BYTES_PER_GB = STORAGE_BYTES_PER_GB;
+exports.STORAGE_LOCATION_MODES = STORAGE_LOCATION_MODES;
 exports.STREAM_PROFILE_META = STREAM_PROFILE_META;
 exports.STREAM_QUALITY_LABELS = STREAM_QUALITY_LABELS;
 exports.SUB_DETECTION_TYPES = SUB_DETECTION_TYPES;
@@ -55062,9 +55398,12 @@ exports.StorageCleanupInputSchema = StorageCleanupInputSchema;
 exports.StorageCleanupJobSchema = StorageCleanupJobSchema;
 exports.StorageCleanupPhaseSchema = StorageCleanupPhaseSchema;
 exports.StorageCleanupStatusInputSchema = StorageCleanupStatusInputSchema;
+exports.StorageDrainProgressSchema = StorageDrainProgressSchema;
 exports.StorageEndDownloadInputSchema = EndDownloadInputSchema;
+exports.StorageEvictionPolicySchema = StorageEvictionPolicySchema;
 exports.StorageFinalizeUploadInputSchema = FinalizeUploadInputSchema;
 exports.StorageLocationDeclarationSchema = StorageLocationDeclarationSchema;
+exports.StorageLocationModeSchema = StorageLocationModeSchema;
 exports.StorageLocationRefSchema = StorageLocationRefSchema;
 exports.StorageLocationSchema = StorageLocationSchema;
 exports.StorageLocationTypeSchema = StorageLocationTypeSchema;
@@ -55088,6 +55427,7 @@ exports.StorageMigrationPhaseSchema = StorageMigrationPhaseSchema;
 exports.StorageMigrationPlanSchema = StorageMigrationPlanSchema;
 exports.StorageMigrationResidueSchema = StorageMigrationResidueSchema;
 exports.StorageMigrationSourcesSchema = StorageMigrationSourcesSchema;
+exports.StorageOccupancyReportSchema = StorageOccupancyReportSchema;
 exports.StorageProviderInfoSchema = ProviderInfoSchema;
 exports.StorageReadChunkInputSchema = ReadChunkInputSchema;
 exports.StorageTestLocationResultSchema = TestLocationResultSchema;
@@ -55369,6 +55709,8 @@ exports.evaluateZoneRules = evaluateZoneRules;
 exports.event = require_sleep.event;
 exports.eventEmitterCapability = eventEmitterCapability;
 exports.eventsCapability = eventsCapability;
+exports.evictionPolicyForMode = evictionPolicyForMode;
+exports.evictionPolicyOfLocation = evictionPolicyOfLocation;
 exports.expandCapMethods = require_sleep.expandCapMethods;
 exports.extractNestedAddonId = extractNestedAddonId;
 exports.extractSourceInfoFromMetadata = extractSourceInfoFromMetadata;
@@ -55384,6 +55726,7 @@ exports.foldSnapshotByFunction = foldSnapshotByFunction;
 exports.formatForBackend = formatForBackend;
 exports.formatForRuntime = formatForRuntime;
 exports.gasCapability = gasCapability;
+exports.gbToBytes = gbToBytes;
 exports.generateAutomationBlock = generateAutomationBlock;
 exports.getAudioMacroClassIds = getAudioMacroClassIds;
 exports.getByPath = getByPath;
@@ -55428,12 +55771,14 @@ exports.isScheduleActive = isScheduleActive;
 exports.isSecretConfigField = isSecretConfigField;
 exports.isSoftwareDecode = require_canonical_hash.isSoftwareDecode;
 exports.isSourceCap = isSourceCap;
+exports.isStorageLocationMode = isStorageLocationMode;
 exports.isSystemDelivery = isSystemDelivery;
 exports.isVoidInput = isVoidInput;
 exports.jobKindSchema = jobKindSchema;
 exports.kebabToCamel = kebabToCamel;
 exports.knownValues = knownValues;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
+exports.legacyModeOf = legacyModeOf;
 exports.lifecycleJobSchema = lifecycleJobSchema;
 exports.lifecycleJobScopeSchema = lifecycleJobScopeSchema;
 exports.lifecycleJobStateSchema = lifecycleJobStateSchema;
@@ -55456,6 +55801,8 @@ exports.mapAudioLabelToMacro = mapAudioLabelToMacro;
 exports.markdownToHtmlLite = markdownToHtmlLite;
 exports.markdownToText = markdownToText;
 exports.maskUrlCredentials = maskUrlCredentials;
+exports.mayReadLocation = mayReadLocation;
+exports.mayWriteToLocation = mayWriteToLocation;
 exports.mediaPlayerCapability = mediaPlayerCapability;
 exports.mergeSourceInfo = mergeSourceInfo;
 exports.meshNetworkCapability = meshNetworkCapability;
@@ -55463,6 +55810,8 @@ exports.method = require_sleep.method;
 exports.methodAccessForHttpMethod = methodAccessForHttpMethod;
 exports.metricsProviderCapability = metricsProviderCapability;
 exports.migrateLegacyDeviceSignalConfig = migrateLegacyDeviceSignalConfig;
+exports.modeMayRead = modeMayRead;
+exports.modeMayWrite = modeMayWrite;
 exports.modelConvertCapability = modelConvertCapability;
 exports.modelDistributorCapability = modelDistributorCapability;
 exports.modelFormatForRuntime = modelFormatForRuntime;
@@ -55558,6 +55907,7 @@ exports.resolveDeviceProfile = resolveDeviceProfile;
 exports.resolveEgressDecodeHwAccel = resolveEgressDecodeHwAccel;
 exports.resolveFormat = resolveFormat;
 exports.resolveHydratedFieldValue = require_sleep.resolveHydratedFieldValue;
+exports.resolveLocationMode = resolveLocationMode;
 exports.resolveMethodAuth = resolveMethodAuth;
 exports.resolveModelFormat = resolveModelFormat;
 exports.resolveMutate = resolveMutate;
@@ -55604,6 +55954,7 @@ exports.stateVocabularyFor = stateVocabularyFor;
 exports.storageCapability = storageCapability;
 exports.storageEvictableCapability = storageEvictableCapability;
 exports.storageMigrationCapability = storageMigrationCapability;
+exports.storageOccupancyCapability = storageOccupancyCapability;
 exports.storageProviderCapability = storageProviderCapability;
 exports.streamBrokerCapability = streamBrokerCapability;
 exports.streamCatalogCapability = streamCatalogCapability;
@@ -55611,6 +55962,7 @@ exports.streamParamsCapability = streamParamsCapability;
 exports.streamPixels = streamPixels;
 exports.streamQualityLabel = streamQualityLabel;
 exports.stripRetiredBandPreBufferSec = stripRetiredBandPreBufferSec;
+exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
 exports.subKindsOf = subKindsOf;
 exports.summarisePrivacyAudio = summarisePrivacyAudio;
 exports.summarizeEffectiveScope = summarizeEffectiveScope;
@@ -55661,6 +56013,7 @@ exports.wiringHealthSnapshotSchema = wiringHealthSnapshotSchema;
 exports.wiringNodeHealthSchema = wiringNodeHealthSchema;
 exports.wiringProbeKindSchema = wiringProbeKindSchema;
 exports.wiringProbeResultSchema = wiringProbeResultSchema;
+exports.withLocationMode = withLocationMode;
 exports.zodEntriesToConfigUI = zodEntriesToConfigUI;
 exports.zoneAnalyticsCapability = zoneAnalyticsCapability;
 exports.zoneRulesCapability = zoneRulesCapability;