@camstack/system 1.2.202 → 1.2.203

package/dist/{dist-CiHYspij.mjs → dist-DcMUcdeq.mjs}

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region ../types/dist/event-category-zAv7pMUz.mjs
+//#region ../types/dist/event-category-CnLqLOKs.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -194,6 +194,19 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["ProcessCrashed"] = "process.crashed";
 	EventCategory["ProcessRestartScheduled"] = "process.restart_scheduled";
 	EventCategory["ProcessRestarted"] = "process.restarted";
+	/**
+	* The SET of storage locations changed — one was created, edited, enabled,
+	* disabled or deleted through `storage.upsertLocation` / `deleteLocation`.
+	*
+	* Telemetry, not a transaction (D8/D11): every consumer that re-resolves on
+	* it must also converge on its own periodic path, because a dropped event
+	* must not leave a node writing to yesterday's disk set forever. It exists
+	* because there was NO signal at all — an operator who added a second
+	* recordings disk in the admin UI got nothing, and the recorder kept its
+	* resolved locations until something else happened to re-resolve them
+	* (D387). Payload `StorageLocationsChangedPayload`.
+	*/
+	EventCategory["StorageLocationsChanged"] = "storage.locations-changed";
 	EventCategory["RecordingStarted"] = "recording.started";
 	EventCategory["RecordingStopped"] = "recording.stopped";
 	EventCategory["RecordingError"] = "recording.error";
@@ -4768,6 +4781,144 @@ var StorageCleanupJobSchema = z.object({
 });
 var StorageCleanupStatusInputSchema = z.object({ jobId: z.string().optional() });
 /**
+* 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 = z.enum(STORAGE_LOCATION_MODES);
+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)
+	};
+}
+/**
 * `StorageLocationType` — an addon-declared id that identifies the *kind* of
 * storage a location serves. Defined here (not in `capabilities/storage.cap.ts`)
 * so the persisted record schema and the consumer-facing cap can both consume it
@@ -4833,6 +4984,21 @@ var StorageLocationSchema = z.object({
 	* stops existing rather than being re-derived on every read.
 	*/
 	enabled: 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. */
@@ -4840,6 +5006,25 @@ var StorageLocationSchema = z.object({
 		totalBytes: z.number(),
 		availableBytes: 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: z.object({
+		bytes: z.number().int().nonnegative(),
+		measuredAtMs: z.number().int().nonnegative()
+	}).optional(),
 	createdAt: z.number(),
 	updatedAt: z.number()
 });
@@ -4855,16 +5040,45 @@ var StorageLocationSchema = z.object({
 * the repo may read it; `scripts/check-no-storage-default.ts` enforces that.
 */
 var LegacyStorageLocationDefaultSchema = z.object({ isDefault: 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 = z.object({
+	locationId: z.string(),
+	startedAtMs: z.number(),
+	startBytes: z.number(),
+	bytesRemaining: z.number(),
+	drained: z.boolean(),
+	estimatedEmptyAtMs: z.number().nullable()
+});
+/**
 * Reference accepted by consumer-facing `api.storage.*` calls.
 * Either:
 *  - a `StorageLocationType` (e.g. `'backups'`) → the sole location of that type
@@ -22143,6 +22357,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: method(z.void(), z.array(StorageDrainProgressSchema).readonly()),
 		testLocation: method(z.object({ id: z.string() }), z.object({
 			ok: z.boolean(),
 			error: z.string().optional()
@@ -22290,6 +22510,71 @@ var storageMigrationCapability = {
 		history: method(z.object({}), z.array(StorageMigrationJobSchema).readonly(), { auth: "admin" })
 	}
 };
+/**
+* `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 = z.object({
+	locationId: z.string(),
+	/** Bytes this provider holds on THAT location — not its eviction domain, and
+	*  not net of what it is willing to delete. */
+	ownedBytes: 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: 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: method(z.object({ locationIds: z.array(z.string()).readonly() }), z.array(StorageOccupancyReportSchema).readonly(), { auth: "admin" }) }
+};
 var ProviderInfoSchema = z.discriminatedUnion("shouldSaveDiskSpace", [z.object({
 	providerId: z.string().min(1),
 	displayName: z.string().min(1),
@@ -24654,88 +24939,6 @@ onStatusChanged: { data: z.object({
 	volatileStateFields: ["lastUpdated"]
 };
 /**
-* 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 = z.object({
-	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
-	type: z.enum([
-		"wifi",
-		"ethernet",
-		"cellular",
-		"unknown"
-	]),
-	/**
-	* 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: z.number().min(0).max(100).nullable(),
-	/** Raw received signal strength in dBm, when the firmware reports one. */
-	rssiDbm: z.number().optional(),
-	/** Network name of a wireless link, when the firmware reports it. */
-	ssid: z.string().optional(),
-	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
-	lastUpdated: z.number()
-});
-var networkLinkCapability = {
-	name: "network-link",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [
-		DeviceType.Camera,
-		DeviceType.Sensor,
-		DeviceType.Button,
-		DeviceType.Switch,
-		DeviceType.Light,
-		DeviceType.Lock,
-		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: z.object({
-		deviceId: z.number(),
-		status: NetworkLinkStatusSchema
-	}) } },
-	status: {
-		schema: NetworkLinkStatusSchema,
-		kind: "push",
-		empty: {
-			type: "unknown",
-			signalPercent: null,
-			lastUpdated: 0
-		}
-	},
-	/**
-	* 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"]
-};
-/**
 * Generic boolean sensor — last-resort fallback when no domain-
 * specific binary cap fits (Home Assistant `binary_sensor` without a
 * known `device_class`, or a domain we haven't typed yet). Pure
@@ -28613,6 +28816,371 @@ var nativeObjectDetectionCapability = {
 	volatileStateFields: ["lastFetchedAt"]
 };
 /**
+* `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 = z.object({
+	pan: z.number().min(-1).max(1).optional(),
+	tilt: z.number().min(-1).max(1).optional(),
+	speed: 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 = 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 = 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 = z.object({
+	id: z.string(),
+	kind: NavigationEntryKindSchema,
+	label: z.string(),
+	icon: z.string(),
+	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
+	soundId: z.number().int().optional(),
+	/** Per-device feature flag — render this entry only when true. */
+	enabled: z.boolean()
+});
+/** Coordinates for `goToPoint` — a point on the robot's live map. */
+var NavigationPointSchema = z.object({
+	x: z.number(),
+	y: 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 = z.object({
+	move: z.boolean(),
+	stop: z.boolean(),
+	goToPoint: z.boolean(),
+	runAction: z.boolean(),
+	playSound: z.boolean(),
+	light: z.boolean(),
+	lightMode: z.boolean()
+});
+/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
+var NavigationLightModeSchema = z.enum(["auto", "manual"]);
+/** Coarse work mode the robot reports — drives the UI's active-state chips. */
+var NavigationModeSchema = 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 = z.object({
+	mode: NavigationModeSchema,
+	following: z.boolean(),
+	flash: z.boolean(),
+	lightMode: NavigationLightModeSchema,
+	lightLevel: z.number().min(40).max(100),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: 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: z.number() });
+var navigationCapability = {
+	name: "navigation",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [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: method(NavigationMoveCommandSchema.extend({ deviceId: z.number() }), z.void(), { kind: "mutation" }),
+		/** Halt all motion immediately (zero drive vector). */
+		stop: method(z.object({ deviceId: z.number() }), z.void(), { kind: "mutation" }),
+		/** Send the robot to a point on its live map. */
+		goToPoint: method(NavigationPointSchema.extend({ deviceId: z.number() }), 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: method(z.object({ deviceId: z.number() }), z.array(NavigationActionEntrySchema)),
+		/**
+		* Run one discrete action (a `kind:'action'` dictionary entry). Invalid /
+		* unsupported action ids are rejected by the provider.
+		*/
+		runAction: method(z.object({
+			deviceId: z.number(),
+			actionId: NavigationActionIdSchema
+		}), z.void(), { kind: "mutation" }),
+		/** Play a sound by its wire id (the `soundId` of a `kind:'sound'` entry). */
+		playSound: method(z.object({
+			deviceId: z.number(),
+			soundId: z.number().int()
+		}), z.void(), { kind: "mutation" }),
+		/**
+		* Turn the on-camera fill light on / off (the `OpenFullLight` control —
+		* works anytime, no active stream required).
+		*/
+		setLightOn: method(z.object({
+			deviceId: z.number(),
+			on: z.boolean()
+		}), 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: method(z.object({
+			deviceId: z.number(),
+			mode: NavigationLightModeSchema,
+			level: z.number().min(40).max(100).optional()
+		}), z.void(), { kind: "mutation" }),
+		/** Set the MANUAL fill-light level (40..100). Implies `manual` mode. */
+		setLightLevel: method(z.object({
+			deviceId: z.number(),
+			level: z.number().min(40).max(100)
+		}), 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: method(z.object({ deviceId: z.number() }), NavigationFeaturesSchema)
+	},
+	events: { onStatusChanged: { data: z.object({
+		deviceId: 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"
+};
+/**
+* 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 = z.object({
+	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
+	type: z.enum([
+		"wifi",
+		"ethernet",
+		"cellular",
+		"unknown"
+	]),
+	/**
+	* 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: z.number().min(0).max(100).nullable(),
+	/** Raw received signal strength in dBm, when the firmware reports one. */
+	rssiDbm: z.number().optional(),
+	/** Network name of a wireless link, when the firmware reports it. */
+	ssid: z.string().optional(),
+	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
+	lastUpdated: z.number()
+});
+var networkLinkCapability = {
+	name: "network-link",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: [
+		DeviceType.Camera,
+		DeviceType.Sensor,
+		DeviceType.Button,
+		DeviceType.Switch,
+		DeviceType.Light,
+		DeviceType.Lock,
+		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: z.object({
+		deviceId: z.number(),
+		status: NetworkLinkStatusSchema
+	}) } },
+	status: {
+		schema: NetworkLinkStatusSchema,
+		kind: "push",
+		empty: {
+			type: "unknown",
+			signalPercent: null,
+			lastUpdated: 0
+		}
+	},
+	/**
+	* 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"]
+};
+/**
 * network-quality — system-scoped singleton capability tracking RTT,
 * jitter, and observed/peak bandwidth per device + per client.
 *
@@ -30463,289 +31031,6 @@ var ptzAutotrackCapability = {
 	durability: "session"
 };
 /**
-* `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 = z.object({
-	pan: z.number().min(-1).max(1).optional(),
-	tilt: z.number().min(-1).max(1).optional(),
-	speed: 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 = 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 = 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 = z.object({
-	id: z.string(),
-	kind: NavigationEntryKindSchema,
-	label: z.string(),
-	icon: z.string(),
-	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
-	soundId: z.number().int().optional(),
-	/** Per-device feature flag — render this entry only when true. */
-	enabled: z.boolean()
-});
-/** Coordinates for `goToPoint` — a point on the robot's live map. */
-var NavigationPointSchema = z.object({
-	x: z.number(),
-	y: 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 = z.object({
-	move: z.boolean(),
-	stop: z.boolean(),
-	goToPoint: z.boolean(),
-	runAction: z.boolean(),
-	playSound: z.boolean(),
-	light: z.boolean(),
-	lightMode: z.boolean()
-});
-/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
-var NavigationLightModeSchema = z.enum(["auto", "manual"]);
-/** Coarse work mode the robot reports — drives the UI's active-state chips. */
-var NavigationModeSchema = 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 = z.object({
-	mode: NavigationModeSchema,
-	following: z.boolean(),
-	flash: z.boolean(),
-	lightMode: NavigationLightModeSchema,
-	lightLevel: z.number().min(40).max(100),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: 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: z.number() });
-var navigationCapability = {
-	name: "navigation",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [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: method(NavigationMoveCommandSchema.extend({ deviceId: z.number() }), z.void(), { kind: "mutation" }),
-		/** Halt all motion immediately (zero drive vector). */
-		stop: method(z.object({ deviceId: z.number() }), z.void(), { kind: "mutation" }),
-		/** Send the robot to a point on its live map. */
-		goToPoint: method(NavigationPointSchema.extend({ deviceId: z.number() }), 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: method(z.object({ deviceId: z.number() }), z.array(NavigationActionEntrySchema)),
-		/**
-		* Run one discrete action (a `kind:'action'` dictionary entry). Invalid /
-		* unsupported action ids are rejected by the provider.
-		*/
-		runAction: method(z.object({
-			deviceId: z.number(),
-			actionId: NavigationActionIdSchema
-		}), z.void(), { kind: "mutation" }),
-		/** Play a sound by its wire id (the `soundId` of a `kind:'sound'` entry). */
-		playSound: method(z.object({
-			deviceId: z.number(),
-			soundId: z.number().int()
-		}), z.void(), { kind: "mutation" }),
-		/**
-		* Turn the on-camera fill light on / off (the `OpenFullLight` control —
-		* works anytime, no active stream required).
-		*/
-		setLightOn: method(z.object({
-			deviceId: z.number(),
-			on: z.boolean()
-		}), 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: method(z.object({
-			deviceId: z.number(),
-			mode: NavigationLightModeSchema,
-			level: z.number().min(40).max(100).optional()
-		}), z.void(), { kind: "mutation" }),
-		/** Set the MANUAL fill-light level (40..100). Implies `manual` mode. */
-		setLightLevel: method(z.object({
-			deviceId: z.number(),
-			level: z.number().min(40).max(100)
-		}), 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: method(z.object({ deviceId: z.number() }), NavigationFeaturesSchema)
-	},
-	events: { onStatusChanged: { data: z.object({
-		deviceId: 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"
-};
-/**
 * reboot — device-scoped capability for "soft" device reboots (firmware
 * reboot via vendor protocol; cameras, NVRs, doorbells). Surfaces a
 * single mutation so the UI can offer a confirm-and-reboot button for
@@ -35326,6 +35611,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	storageCapability,
 	storageEvictableCapability,
 	storageMigrationCapability,
+	storageOccupancyCapability,
 	storageProviderCapability,
 	streamBrokerCapability,
 	streamCatalogCapability,
@@ -40298,6 +40584,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",
@@ -40442,6 +40734,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",
@@ -44282,4 +44580,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { filesystemBrowseCapability as $, emitReadiness as $t, addonWidgetsCapability as A, storageCapability as At, coreBlocksCapability as B, DEVICE_SETTINGS_CONTRIBUTION_METHODS as Bt, ScopedTokenSchema as C, resolveMethodAuth as Ct, UserRecordSchema as D, scoreRuntimes as Dt, StorageMigrationJobSchema as E, scopesAllowDeviceCap as Et, batteryCapability as F, vectorDimFromBase64 as Ft, deviceStateCapability as G, ReadinessRegistry as Gt, decodeVectorBase64 as H, DeviceFeature as Ht, buildStreamParamsConfigSchema as I, vectorStoreCapability as It, enumerateInferenceDevices as J, asJsonObject as Jt, deviceStatusCapability as K, ReadinessTimeoutError as Kt, collectSecretConfigKeys as L, errMsg as Lt, authProviderCapability as M, storageProviderCapability as Mt, backupCapability as N, streamQualityLabel as Nt, addonPagesCapability as O, settingsStoreCapability as Ot, bareAddonId as P, userManagementCapability as Pt, extractNestedAddonId as Q, emitDownForOwnedCaps as Qt, coreBlockAddonId as R, BaseAddon as Rt, STREAM_PROFILE_META as S, resolveContainerPrimaryChild as St, StorageLocationTypeSchema as T, scopesAllowAddon as Tt, deriveBatteryPresence as U, DeviceRole as Ut, dataStoreProviderCapability as V, DEVICE_STATUS_METHOD as Vt, deviceManagerCapability as W, DeviceType as Wt, enumerateSchemaFields as X, asString as Xt, enumerateItemArrayFields as Y, asNumber as Yt, evaluateSensorEdge as Z, createEvent as Zt, RUNTIME_DEFAULTS as _, parseStreamParamsFormPatch as _t, CAMERA_SWITCH_ORDER as a, parseJsonUnknown as an, isSameAddonId as at, SOURCE_DEVICE_TYPES as b, reducePoints as bt, CORE_BLOCK_ADDON_PREFIX as c, scopeKey as cn, kebabToCamel as ct, DeclaredDevices as d, logDestinationCapability as dt, expandCapMethods as en, foldSnapshotByFunction as et, DeviceStatusSchema as f, logLevelAtMost as ft, REDACTED_SECRET as g, objectInputDeclaresAddonId as gt, METHOD_ACCESS_MAP as h, normalizeUnit as ht, BatteryStatusSchema as i, parseJsonObject as in, isObjectInput as it, alertsCapability as j, storageMigrationCapability as jt, addonSettingsCapability as k, snapshotCapability as kt, CoreBlockSchema as l, sleep as ln, lifecycleJobSchema as lt, LegacyStorageLocationDefaultSchema as m, metricsProviderCapability as mt, AlertSchema as n, isDeviceConfigCap as nn, isCollectionArrayMethod as nt, CAP_NAMES_WITH_STATUS as o, readinessKey as on, isSourceCap as ot, LOG_LEVEL_RANK as p, looseSchema as pt, doorbellCapability as q, WELL_KNOWN_TAB_MAP as qt, ApiKeyRecordSchema as r, nodePin as rn, isLocationEnabled as rt, CORE_BLOCKS_ADDON_ID as s, resolveCapMount as sn, isVoidInput as st, ALL_CAPABILITY_DEFINITIONS as t, hydrateSchema as tn, isArrayOutputSchema as tt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as u, EventCategory as un, localNetworkCapability as ut, RecordingStatusSchema as v, platformProbeCapability as vt, StorageCleanupJobSchema as w, runtimeStatePolicyFor as wt, STORAGE_ACCESS_FALLBACK as x, resolveBucketMs as xt, SOURCE_CAPS as y, procedureAuthKey as yt, coreBlockIdFromAddonId as z, DATAPLANE_SECRET_HEADER as zt };
+export { evictionPolicyOfLocation as $, DeviceRole as $t, addonSettingsCapability as A, resolveLocationMode as At, coreBlockIdFromAddonId as B, storageOccupancyCapability as Bt, ScopedTokenSchema as C, objectInputDeclaresAddonId as Ct, StorageMigrationJobSchema as D, reducePoints as Dt, StorageLocationTypeSchema as E, procedureAuthKey as Et, bareAddonId as F, scoreRuntimes as Ft, deviceManagerCapability as G, vectorStoreCapability as Gt, dataStoreProviderCapability as H, streamQualityLabel as Ht, batteryCapability as I, settingsStoreCapability as It, doorbellCapability as J, BaseAddon as Jt, deviceStateCapability as K, withLocationMode as Kt, buildStreamParamsConfigSchema as L, snapshotCapability as Lt, alertsCapability as M, runtimeStatePolicyFor as Mt, authProviderCapability as N, scopesAllowAddon as Nt, UserRecordSchema as O, resolveBucketMs as Ot, backupCapability as P, scopesAllowDeviceCap as Pt, evaluateSensorEdge as Q, DeviceFeature as Qt, collectSecretConfigKeys as R, storageCapability as Rt, STREAM_PROFILE_META as S, normalizeUnit as St, StorageLocationModeSchema as T, platformProbeCapability as Tt, decodeVectorBase64 as U, userManagementCapability as Ut, coreBlocksCapability as V, storageProviderCapability as Vt, deriveBatteryPresence as W, vectorDimFromBase64 as Wt, enumerateItemArrayFields as X, DEVICE_SETTINGS_CONTRIBUTION_METHODS as Xt, enumerateInferenceDevices as Y, DATAPLANE_SECRET_HEADER as Yt, enumerateSchemaFields as Z, DEVICE_STATUS_METHOD as Zt, RUNTIME_DEFAULTS as _, resolveCapMount as _n, looseSchema as _t, CAMERA_SWITCH_ORDER as a, asNumber as an, isCollectionArrayMethod as at, SOURCE_DEVICE_TYPES as b, EventCategory as bn, metricsProviderCapability as bt, CORE_BLOCK_ADDON_PREFIX as c, emitDownForOwnedCaps as cn, isSameAddonId as ct, DeclaredDevices as d, hydrateSchema as dn, kebabToCamel as dt, DeviceType as en, extractNestedAddonId as et, DeviceStatusSchema as f, isDeviceConfigCap as fn, legacyModeOf as ft, REDACTED_SECRET as g, readinessKey as gn, logLevelAtMost as gt, METHOD_ACCESS_MAP as h, parseJsonUnknown as hn, logDestinationCapability as ht, BatteryStatusSchema as i, asJsonObject as in, isArrayOutputSchema as it, addonWidgetsCapability as j, resolveMethodAuth as jt, addonPagesCapability as k, resolveContainerPrimaryChild as kt, CoreBlockSchema as l, emitReadiness as ln, isSourceCap as lt, LegacyStorageLocationDefaultSchema as m, parseJsonObject as mn, localNetworkCapability as mt, AlertSchema as n, ReadinessTimeoutError as nn, foldSnapshotByFunction as nt, CAP_NAMES_WITH_STATUS as o, asString as on, isLocationEnabled as ot, LOG_LEVEL_RANK as p, nodePin as pn, lifecycleJobSchema as pt, deviceStatusCapability as q, errMsg as qt, ApiKeyRecordSchema as r, WELL_KNOWN_TAB_MAP as rn, gbToBytes as rt, CORE_BLOCKS_ADDON_ID as s, createEvent as sn, isObjectInput as st, ALL_CAPABILITY_DEFINITIONS as t, ReadinessRegistry as tn, filesystemBrowseCapability as tt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as u, expandCapMethods as un, isVoidInput as ut, RecordingStatusSchema as v, scopeKey as vn, mayReadLocation as vt, StorageCleanupJobSchema as w, parseStreamParamsFormPatch as wt, STORAGE_ACCESS_FALLBACK as x, modeMayWrite as xt, SOURCE_CAPS as y, sleep as yn, mayWriteToLocation as yt, coreBlockAddonId as z, storageMigrationCapability as zt };