@camstack/addon-pipeline 1.2.199 → 1.2.201

package/dist/{dist-B23u1tmN.mjs → dist-D2jcEuZD.mjs}

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#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";
@@ -8594,362 +8607,6 @@ var CameraSwitchGroupSchema = object({
 	fetchedAt: number()
 });
 /**
-* Per-component log CHANNELS — the gate a hot path consults, and the registry
-* an addon declares its channels in.
-*
-* ## Two axes, deliberately separated
-*
-* - **DECLARATION** — which channels exist. Only the addon knows:
-*   `stream-broker` knows webrtc/ICE/RTP, `provider-reolink` knows
-*   baichuan/handshake. A hand-wired central list rots at the first addition,
-*   and rots silently. So a channel is declared where it is consulted, and the
-*   `log-channels` capability enumerates the declarations.
-* - **VALUE** — at which level, for which scope, until when. That stays ONE
-*   thing: the logging settings document on the `system` cap. Two authorities
-*   over the values is the exact defect
-*   `docs/design/plans/2026-08-26-logging-per-componente.md` was written to
-*   remove; re-introducing it from the cure side would be grotesque.
-*
-* Nothing in this file reads a clock, an env var or a store. The registry is
-* a MIRROR: it is moved only by {@link LogChannelRegistry.apply}, called off
-* the hot path with a value somebody actually read, and by
-* {@link LogChannelRegistry.tick}, called on a timer. A store read that fails
-* never reaches here, so it can neither disarm an armed channel nor arm a
-* disarmed one (D49).
-*
-* ## The canonical call shape
-*
-* ```ts
-* if (CH_RTP.on && CH_RTP.wants(deviceId)) {
-*   CH_RTP.log(logger, 'rtp subscriber added', { tags: { deviceId }, meta: { ssrc } })
-* }
-* ```
-*
-* `on` is a plain boolean FIELD — never a getter — and it is the FIRST thing
-* read. Disarmed, a call site costs one load and one branch, and the `extras`
-* object literal is never constructed because it lives inside the branch. It
-* is the same shape already proven in production at `stream-broker.ts:1650`,
-* and the same discipline `LoggingGate.allowsDestination` uses for the
-* destination floor (measured at 1.93 ns/call when off).
-*
-* ## Why a channel emits at `info`
-*
-* `loki-logging.addon.ts` pins the destination default at `info` and
-* `loki-destination.ts` drops everything below it, so a line emitted at
-* `debug` never reaches Loki and the hub's in-memory ring only holds ~35
-* minutes. A diagnostic that cannot be read an hour later is worse than no
-* diagnostic, because it looks done. {@link LogChannelGate.log} therefore
-* emits at the channel's declared level, whose schema floor is `info`.
-*/
-/**
-* The level a channel writes at once armed.
-*
-* `debug` is absent ON PURPOSE and not by omission: below `info` the line does
-* not leave the process for Loki, and the whole point of arming a channel is
-* to read it later.
-*/
-var LogChannelLevelSchema = _enum([
-	"info",
-	"warn",
-	"error"
-]);
-/**
-* What an addon declares about one channel. No value, no state — a
-* declaration is inert.
-*/
-var LogChannelDescriptorSchema = object({
-	/**
-	* Dotted `area.thing`, unique across the workspace. `area` is conventionally
-	* the addon's short name so an operator reading a channel list can tell who
-	* owns it without a second lookup.
-	*/
-	name: string().min(3).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "a channel name is dotted lower-kebab, e.g. area.thing"),
-	/** One sentence: what the operator will SEE after arming it. */
-	description: string().min(1),
-	/** The level its lines are emitted at. Never below `info`. */
-	defaultLevel: LogChannelLevelSchema,
-	/**
-	* Whether this channel can be narrowed to a camera.
-	*
-	* `true` is a PROMISE with two halves, and both must hold: the gate is
-	* consulted with the numeric device id, AND every line the channel admits
-	* carries `tags: { deviceId }` with that same numeric id. The second half is
-	* what makes `| json | deviceId="617"` work in Loki — `loki-payload.ts`
-	* keeps `deviceId` out of the stream labels for cardinality, so the tag in
-	* the body is the only way to filter.
-	*
-	* A channel whose lines carry the device only in `meta` (or not at all) is
-	* declared `false`. Declaring it `true` anyway would be a lie the UI repeats:
-	* the operator narrows to one camera, sees nothing, and concludes the code
-	* path was never taken.
-	*/
-	perDevice: boolean()
-});
-/**
-* An armed window over one channel, as the document hands it to a mirror.
-*
-* A window is a DEADLINE, never a flag (ADR-0244): a channel somebody forgot
-* expires by itself, which is the one failure a boolean cannot avoid.
-*/
-var LogChannelWindowSchema = object({
-	channel: string().min(1),
-	/** Epoch ms the window closes at. */
-	armedUntilMs: number(),
-	/** `null` = every camera. A non-empty list narrows to those numeric ids. */
-	deviceIds: array(number().int()).readonly().nullable()
-});
-/**
-* The gate a hot path holds.
-*
-* Obtain it ONCE — at module scope or in a constructor — and keep the
-* reference. Looking a channel up by name per line would put a Map lookup on
-* the path this class exists to keep free.
-*/
-var LogChannelGate = class {
-	descriptor;
-	/**
-	* HOT PATH GUARD. A plain data FIELD, and it must stay one.
-	*
-	* `log-channel.spec.ts` asserts the property descriptor has no getter and
-	* booby-traps the device set, so turning this into an accessor — or reading
-	* anything before it — fails the spec instead of taxing every line the
-	* process emits.
-	*/
-	on = false;
-	/** `null` while armed for every camera. Never read while `on` is false. */
-	devices = null;
-	level;
-	closesAtMs = 0;
-	constructor(descriptor) {
-		this.descriptor = descriptor;
-		this.level = descriptor.defaultLevel;
-	}
-	/** Epoch ms this channel disarms itself at. 0 when disarmed. */
-	get armedUntilMs() {
-		return this.on ? this.closesAtMs : 0;
-	}
-	/**
-	* Does this channel want a line about `deviceId`?
-	*
-	* Call it only behind `gate.on &&`. On its own it is still correct — the
-	* guard is repeated inside — but the point of the prefix is that a disarmed
-	* channel must not pay the call at all.
-	*/
-	wants(deviceId) {
-		if (!this.on) return false;
-		return this.devices === null || this.devices.has(deviceId);
-	}
-	/**
-	* Emit one line on this channel, at the channel's declared level.
-	*
-	* The channel name is added as `tags.logChannel` so LogQL can select the
-	* channel without matching on the message text, and whatever `tags` the
-	* caller passed — `deviceId` above all — is preserved.
-	*/
-	log(logger, message, extras) {
-		if (!this.on) return;
-		const tags = {
-			...extras.tags,
-			logChannel: this.descriptor.name
-		};
-		const line = {
-			...extras,
-			tags
-		};
-		if (this.level === "error") logger.error(message, line);
-		else if (this.level === "warn") logger.warn(message, line);
-		else logger.info(message, line);
-	}
-	/**
-	* Arm (or RE-arm, restarting) this channel. Off the hot path only.
-	*
-	* An empty `deviceIds` list is treated as "every camera" rather than "no
-	* camera": a window that matches nothing is indistinguishable from a
-	* disarmed one, and the operator who asked for it would wait for lines that
-	* can never come.
-	*/
-	arm(window) {
-		const ids = window.deviceIds;
-		this.devices = ids === null || ids.length === 0 ? null : new Set(ids);
-		this.closesAtMs = window.armedUntilMs;
-		this.on = true;
-	}
-	/** Disarm. Off the hot path only. */
-	disarm() {
-		this.on = false;
-		this.devices = null;
-		this.closesAtMs = 0;
-	}
-};
-/**
-* Every channel this PROCESS declares, and the mirror of what is armed on it.
-*
-* One per process. A forked runner has its own, and it is refreshed through
-* the `log-channels` capability by the hub that owns the document — the
-* registry never reaches for a value itself.
-*/
-var LogChannelRegistry = class {
-	gates = /* @__PURE__ */ new Map();
-	/**
-	* Declare a channel and get its gate.
-	*
-	* A duplicate name throws. Two declarations of one name is a programming
-	* error, not a merge: the operator would arm one and the other would stay
-	* dark, which is the dead-knob shape (D62) with an extra step.
-	*/
-	declare(descriptor) {
-		const parsed = LogChannelDescriptorSchema.parse(descriptor);
-		if (this.gates.get(parsed.name) !== void 0) throw new Error(`log channel "${parsed.name}" is already declared in this process — two declarations of one name is a programming error, not a merge`);
-		const gate = new LogChannelGate(parsed);
-		this.gates.set(parsed.name, gate);
-		return gate;
-	}
-	/** The declarations, sorted by name so a list is stable to read and diff. */
-	list() {
-		return [...this.gates.values()].map((gate) => gate.descriptor).sort((a, b) => a.name.localeCompare(b.name));
-	}
-	/** The gate for a declared channel, or `undefined`. */
-	gate(name) {
-		return this.gates.get(name);
-	}
-	/**
-	* Apply the FULL set of armed windows. Off the hot path.
-	*
-	* Full, not incremental, and that is the whole design: the document is the
-	* authority, so a channel the document does not name is disarmed here. An
-	* incremental apply would let a disarm get lost in transit and leave a
-	* channel running that nobody can see is running.
-	*
-	* A window already past its deadline is ignored rather than armed — a
-	* restore that re-armed an expired window would make a forgotten diagnostic
-	* immortal across restarts.
-	*
-	* Returns the names it could not place, so the caller can log them: a
-	* channel named in the document that this process does not declare is
-	* either a typo or an addon that has not booted yet, and both deserve a
-	* line rather than silence.
-	*/
-	apply(windows, nowMs) {
-		const wanted = /* @__PURE__ */ new Map();
-		const unknown = [];
-		for (const window of windows) {
-			if (window.armedUntilMs <= nowMs) continue;
-			if (!this.gates.has(window.channel)) {
-				unknown.push(window.channel);
-				continue;
-			}
-			wanted.set(window.channel, window);
-		}
-		for (const [name, gate] of this.gates) {
-			const window = wanted.get(name);
-			if (window === void 0) gate.disarm();
-			else gate.arm(window);
-		}
-		return unknown;
-	}
-	/**
-	* Disarm whatever has run out. Called on a timer, NEVER from a log path — a
-	* diagnostic that adds a `Date.now()` to the path it is measuring measures
-	* itself.
-	*
-	* Returns the names it closed, so the caller can write the one line that
-	* says a window ended and stops "it went quiet" from reading as "the branch
-	* was not taken".
-	*/
-	tick(nowMs) {
-		const closed = [];
-		for (const [name, gate] of this.gates) if (gate.on && gate.armedUntilMs <= nowMs) {
-			gate.disarm();
-			closed.push(name);
-		}
-		return closed;
-	}
-	/** The channels armed right now, as the document would describe them. */
-	armed() {
-		const out = [];
-		for (const [name, gate] of this.gates) if (gate.on) out.push({
-			channel: name,
-			armedUntilMs: gate.armedUntilMs,
-			deviceIds: null
-		});
-		return out;
-	}
-};
-/**
-* Process-wide holder for the {@link LogChannelRegistry}.
-*
-* Three call sites that never meet need the SAME instance: the hot paths that
-* declare a gate at module scope, the `log-channels` provider that enumerates
-* the declarations for the hub, and the same provider applying the windows the
-* document hands down. A registry built inside any one of them would be
-* refreshed and collected — the shape of a knob that never does anything.
-*
-* Same idiom as `logging-gate.singleton.ts` and
-* `http-request-census.singleton.ts`.
-*/
-var instance = null;
-/** The process-wide log channel registry. Created empty on first use. */
-function getLogChannelRegistry() {
-	instance ??= new LogChannelRegistry();
-	return instance;
-}
-/**
-* Declare a channel on the process-wide registry and get its gate.
-*
-* The one call an addon makes. Keep the returned gate in a module-scope
-* `const`: looking a channel up by name per line would put a Map lookup on
-* exactly the path this mechanism exists to keep free.
-*
-* `scripts/check-log-channel-gated.ts` reads these call sites. It pairs the
-* declared name with the binding it is assigned to and refuses to let a
-* channel ship that no `<binding>.on` anywhere consults — a declared channel
-* nobody reads is a knob the operator turns with nothing happening, forever,
-* and without a line. That is D62, and this repo has now shipped it three
-* times (`audioThresholdDbfs`, the HA entities with no source, the second
-* per-camera switch that wrote a store nobody read).
-*/
-function declareLogChannel(descriptor) {
-	return getLogChannelRegistry().declare(descriptor);
-}
-/**
-* Build the `log-channels` provider for this process.
-*
-* `logger` is used ONLY off the hot path — for the arm/expiry lines — so a
-* channel that is never armed costs this module nothing but a timer.
-*/
-function createLogChannelsProvider(logger, options = {}) {
-	const registry = getLogChannelRegistry();
-	const now = options.now ?? Date.now;
-	const tickMs = options.tickMs ?? 5e3;
-	const timer = setInterval(() => {
-		const closed = registry.tick(now());
-		for (const name of closed) logger.info("log channel window closed", {
-			tags: { logChannel: name },
-			meta: { channel: name }
-		});
-	}, tickMs);
-	timer.unref?.();
-	return {
-		list: () => registry.list(),
-		apply: (input) => {
-			const unknown = registry.apply(input.windows, now());
-			const armed = registry.armed();
-			logger.info("log channels applied", { meta: {
-				armed: armed.map((window) => window.channel),
-				unknown,
-				declared: registry.list().length
-			} });
-			return {
-				armed: armed.length,
-				unknown
-			};
-		},
-		stop: () => {
-			clearInterval(timer);
-		}
-	};
-}
-/**
 * Ops-log — the durable, append-only operations audit shared by the
 * recordings and events management surfaces.
 *
@@ -10064,6 +9721,110 @@ var StorageCleanupJobSchema = object({
 });
 var StorageCleanupStatusInputSchema = object({ jobId: 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 = _enum(STORAGE_LOCATION_MODES);
+_enum([
+	"normal",
+	"never",
+	"drain"
+]);
+/** 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));
+}
+/**
 * `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
@@ -10088,8 +9849,11 @@ var StorageLocationTypeSchema = string().regex(/^[a-z][a-zA-Z0-9-]*$/);
 * `STORAGE_LOCATION_CARDINALITY` map has been removed.
 *
 * `id` is a stable namespaced string of the form `<type>:<slug>`.
-* The default location for a type uses `id === <type>:default` by
-* convention (the bare type ref like `'backups'` resolves to it).
+* The seed names its first instance `<type>:default` — a NAME, not a flag.
+* There is no default location any more (D383): `enabled` is the whole write
+* model, and a bare type ref resolves to the sole location of the type, or —
+* transitionally, only while legacy NULL-stamped rows exist — to the row whose
+* slug is `default`.
 *
 * `isSystem` is a legacy persisted flag. Seed still creates the initial
 * `<type>:default` locations; the flag is no longer a lock, a badge, or a
@@ -10110,23 +9874,37 @@ var StorageLocationSchema = object({
 	* flag at upsert time, not here (the schema is provider-agnostic).
 	*/
 	nodeId: string().optional(),
-	isDefault: boolean().default(false),
 	isSystem: boolean().default(false),
 	/**
-	* Operator opt-in: whether consumers that BALANCE across several locations
-	* of a type may write here. Recordings reads it today; event media and
-	* backups are the next consumers, which is why the flag lives on the
-	* location rather than in any one addon's store — nothing has to be
-	* extended to add the next consumer.
+	* THE write switch, and the only one (D383). `enabled: true` means every
+	* consumer that chooses a write target for this type may write here, and all
+	* enabled locations of a type are used TOGETHER; `false` means read-only —
+	* still read, still played back, still age-swept, still drained, never
+	* written.
 	*
-	* OPTIONAL, and ABSENT MEANS ACTIVE. Every location persisted before the
-	* flag existed reads back with no flag and keeps working exactly as before;
-	* that is the whole compat story, and it is why no migration ships with it.
-	* A newly CREATED sibling is stamped `false` by the orchestrator (creating a
-	* disk must not silently start writing to it); the default of a type is
-	* always stamped `true`.
+	* OPTIONAL only for the wire: an upsert that omits it means "leave what is
+	* stored" on an update and "born inert unless it is the first location of its
+	* type" on a create. On a PERSISTED row absence is legacy and it means
+	* enabled — {@link isLocationEnabled} is the one place that says so, and the
+	* orchestrator stamps every flagless row `true` once at hydrate so absence
+	* stops existing rather than being re-derived on every read.
 	*/
 	enabled: 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. */
@@ -10134,13 +9912,66 @@ var StorageLocationSchema = object({
 		totalBytes: number(),
 		availableBytes: 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: object({
+		bytes: number().int().nonnegative(),
+		measuredAtMs: number().int().nonnegative()
+	}).optional(),
 	createdAt: number(),
 	updatedAt: number()
 });
+object({ isDefault: boolean().optional() });
+/**
+* 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.
+*/
+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 = object({
+	locationId: string(),
+	startedAtMs: number(),
+	startBytes: number(),
+	bytesRemaining: number(),
+	drained: boolean(),
+	estimatedEmptyAtMs: number().nullable()
+});
 /**
 * Reference accepted by consumer-facing `api.storage.*` calls.
 * Either:
-*  - a `StorageLocationType` (e.g. `'backups'`) → orchestrator resolves to the default of that type
+*  - a `StorageLocationType` (e.g. `'backups'`) → the sole location of that type
+*    (transitionally, the `<type>:default`-slugged row when several exist)
 *  - a fully-qualified id (e.g. `'backups:nas-01'`) → addresses a specific instance
 *
 * The orchestrator's `resolveRef(ref)` handles both cases.
@@ -10317,6 +10148,362 @@ var DecoderSessionConfigSchema = object({
 	debug: boolean().optional()
 });
 /**
+* Per-component log CHANNELS — the gate a hot path consults, and the registry
+* an addon declares its channels in.
+*
+* ## Two axes, deliberately separated
+*
+* - **DECLARATION** — which channels exist. Only the addon knows:
+*   `stream-broker` knows webrtc/ICE/RTP, `provider-reolink` knows
+*   baichuan/handshake. A hand-wired central list rots at the first addition,
+*   and rots silently. So a channel is declared where it is consulted, and the
+*   `log-channels` capability enumerates the declarations.
+* - **VALUE** — at which level, for which scope, until when. That stays ONE
+*   thing: the logging settings document on the `system` cap. Two authorities
+*   over the values is the exact defect
+*   `docs/design/plans/2026-08-26-logging-per-componente.md` was written to
+*   remove; re-introducing it from the cure side would be grotesque.
+*
+* Nothing in this file reads a clock, an env var or a store. The registry is
+* a MIRROR: it is moved only by {@link LogChannelRegistry.apply}, called off
+* the hot path with a value somebody actually read, and by
+* {@link LogChannelRegistry.tick}, called on a timer. A store read that fails
+* never reaches here, so it can neither disarm an armed channel nor arm a
+* disarmed one (D49).
+*
+* ## The canonical call shape
+*
+* ```ts
+* if (CH_RTP.on && CH_RTP.wants(deviceId)) {
+*   CH_RTP.log(logger, 'rtp subscriber added', { tags: { deviceId }, meta: { ssrc } })
+* }
+* ```
+*
+* `on` is a plain boolean FIELD — never a getter — and it is the FIRST thing
+* read. Disarmed, a call site costs one load and one branch, and the `extras`
+* object literal is never constructed because it lives inside the branch. It
+* is the same shape already proven in production at `stream-broker.ts:1650`,
+* and the same discipline `LoggingGate.allowsDestination` uses for the
+* destination floor (measured at 1.93 ns/call when off).
+*
+* ## Why a channel emits at `info`
+*
+* `loki-logging.addon.ts` pins the destination default at `info` and
+* `loki-destination.ts` drops everything below it, so a line emitted at
+* `debug` never reaches Loki and the hub's in-memory ring only holds ~35
+* minutes. A diagnostic that cannot be read an hour later is worse than no
+* diagnostic, because it looks done. {@link LogChannelGate.log} therefore
+* emits at the channel's declared level, whose schema floor is `info`.
+*/
+/**
+* The level a channel writes at once armed.
+*
+* `debug` is absent ON PURPOSE and not by omission: below `info` the line does
+* not leave the process for Loki, and the whole point of arming a channel is
+* to read it later.
+*/
+var LogChannelLevelSchema = _enum([
+	"info",
+	"warn",
+	"error"
+]);
+/**
+* What an addon declares about one channel. No value, no state — a
+* declaration is inert.
+*/
+var LogChannelDescriptorSchema = object({
+	/**
+	* Dotted `area.thing`, unique across the workspace. `area` is conventionally
+	* the addon's short name so an operator reading a channel list can tell who
+	* owns it without a second lookup.
+	*/
+	name: string().min(3).regex(/^[a-z0-9-]+(\.[a-z0-9-]+)+$/, "a channel name is dotted lower-kebab, e.g. area.thing"),
+	/** One sentence: what the operator will SEE after arming it. */
+	description: string().min(1),
+	/** The level its lines are emitted at. Never below `info`. */
+	defaultLevel: LogChannelLevelSchema,
+	/**
+	* Whether this channel can be narrowed to a camera.
+	*
+	* `true` is a PROMISE with two halves, and both must hold: the gate is
+	* consulted with the numeric device id, AND every line the channel admits
+	* carries `tags: { deviceId }` with that same numeric id. The second half is
+	* what makes `| json | deviceId="617"` work in Loki — `loki-payload.ts`
+	* keeps `deviceId` out of the stream labels for cardinality, so the tag in
+	* the body is the only way to filter.
+	*
+	* A channel whose lines carry the device only in `meta` (or not at all) is
+	* declared `false`. Declaring it `true` anyway would be a lie the UI repeats:
+	* the operator narrows to one camera, sees nothing, and concludes the code
+	* path was never taken.
+	*/
+	perDevice: boolean()
+});
+/**
+* An armed window over one channel, as the document hands it to a mirror.
+*
+* A window is a DEADLINE, never a flag (ADR-0244): a channel somebody forgot
+* expires by itself, which is the one failure a boolean cannot avoid.
+*/
+var LogChannelWindowSchema = object({
+	channel: string().min(1),
+	/** Epoch ms the window closes at. */
+	armedUntilMs: number(),
+	/** `null` = every camera. A non-empty list narrows to those numeric ids. */
+	deviceIds: array(number().int()).readonly().nullable()
+});
+/**
+* The gate a hot path holds.
+*
+* Obtain it ONCE — at module scope or in a constructor — and keep the
+* reference. Looking a channel up by name per line would put a Map lookup on
+* the path this class exists to keep free.
+*/
+var LogChannelGate = class {
+	descriptor;
+	/**
+	* HOT PATH GUARD. A plain data FIELD, and it must stay one.
+	*
+	* `log-channel.spec.ts` asserts the property descriptor has no getter and
+	* booby-traps the device set, so turning this into an accessor — or reading
+	* anything before it — fails the spec instead of taxing every line the
+	* process emits.
+	*/
+	on = false;
+	/** `null` while armed for every camera. Never read while `on` is false. */
+	devices = null;
+	level;
+	closesAtMs = 0;
+	constructor(descriptor) {
+		this.descriptor = descriptor;
+		this.level = descriptor.defaultLevel;
+	}
+	/** Epoch ms this channel disarms itself at. 0 when disarmed. */
+	get armedUntilMs() {
+		return this.on ? this.closesAtMs : 0;
+	}
+	/**
+	* Does this channel want a line about `deviceId`?
+	*
+	* Call it only behind `gate.on &&`. On its own it is still correct — the
+	* guard is repeated inside — but the point of the prefix is that a disarmed
+	* channel must not pay the call at all.
+	*/
+	wants(deviceId) {
+		if (!this.on) return false;
+		return this.devices === null || this.devices.has(deviceId);
+	}
+	/**
+	* Emit one line on this channel, at the channel's declared level.
+	*
+	* The channel name is added as `tags.logChannel` so LogQL can select the
+	* channel without matching on the message text, and whatever `tags` the
+	* caller passed — `deviceId` above all — is preserved.
+	*/
+	log(logger, message, extras) {
+		if (!this.on) return;
+		const tags = {
+			...extras.tags,
+			logChannel: this.descriptor.name
+		};
+		const line = {
+			...extras,
+			tags
+		};
+		if (this.level === "error") logger.error(message, line);
+		else if (this.level === "warn") logger.warn(message, line);
+		else logger.info(message, line);
+	}
+	/**
+	* Arm (or RE-arm, restarting) this channel. Off the hot path only.
+	*
+	* An empty `deviceIds` list is treated as "every camera" rather than "no
+	* camera": a window that matches nothing is indistinguishable from a
+	* disarmed one, and the operator who asked for it would wait for lines that
+	* can never come.
+	*/
+	arm(window) {
+		const ids = window.deviceIds;
+		this.devices = ids === null || ids.length === 0 ? null : new Set(ids);
+		this.closesAtMs = window.armedUntilMs;
+		this.on = true;
+	}
+	/** Disarm. Off the hot path only. */
+	disarm() {
+		this.on = false;
+		this.devices = null;
+		this.closesAtMs = 0;
+	}
+};
+/**
+* Every channel this PROCESS declares, and the mirror of what is armed on it.
+*
+* One per process. A forked runner has its own, and it is refreshed through
+* the `log-channels` capability by the hub that owns the document — the
+* registry never reaches for a value itself.
+*/
+var LogChannelRegistry = class {
+	gates = /* @__PURE__ */ new Map();
+	/**
+	* Declare a channel and get its gate.
+	*
+	* A duplicate name throws. Two declarations of one name is a programming
+	* error, not a merge: the operator would arm one and the other would stay
+	* dark, which is the dead-knob shape (D62) with an extra step.
+	*/
+	declare(descriptor) {
+		const parsed = LogChannelDescriptorSchema.parse(descriptor);
+		if (this.gates.get(parsed.name) !== void 0) throw new Error(`log channel "${parsed.name}" is already declared in this process — two declarations of one name is a programming error, not a merge`);
+		const gate = new LogChannelGate(parsed);
+		this.gates.set(parsed.name, gate);
+		return gate;
+	}
+	/** The declarations, sorted by name so a list is stable to read and diff. */
+	list() {
+		return [...this.gates.values()].map((gate) => gate.descriptor).sort((a, b) => a.name.localeCompare(b.name));
+	}
+	/** The gate for a declared channel, or `undefined`. */
+	gate(name) {
+		return this.gates.get(name);
+	}
+	/**
+	* Apply the FULL set of armed windows. Off the hot path.
+	*
+	* Full, not incremental, and that is the whole design: the document is the
+	* authority, so a channel the document does not name is disarmed here. An
+	* incremental apply would let a disarm get lost in transit and leave a
+	* channel running that nobody can see is running.
+	*
+	* A window already past its deadline is ignored rather than armed — a
+	* restore that re-armed an expired window would make a forgotten diagnostic
+	* immortal across restarts.
+	*
+	* Returns the names it could not place, so the caller can log them: a
+	* channel named in the document that this process does not declare is
+	* either a typo or an addon that has not booted yet, and both deserve a
+	* line rather than silence.
+	*/
+	apply(windows, nowMs) {
+		const wanted = /* @__PURE__ */ new Map();
+		const unknown = [];
+		for (const window of windows) {
+			if (window.armedUntilMs <= nowMs) continue;
+			if (!this.gates.has(window.channel)) {
+				unknown.push(window.channel);
+				continue;
+			}
+			wanted.set(window.channel, window);
+		}
+		for (const [name, gate] of this.gates) {
+			const window = wanted.get(name);
+			if (window === void 0) gate.disarm();
+			else gate.arm(window);
+		}
+		return unknown;
+	}
+	/**
+	* Disarm whatever has run out. Called on a timer, NEVER from a log path — a
+	* diagnostic that adds a `Date.now()` to the path it is measuring measures
+	* itself.
+	*
+	* Returns the names it closed, so the caller can write the one line that
+	* says a window ended and stops "it went quiet" from reading as "the branch
+	* was not taken".
+	*/
+	tick(nowMs) {
+		const closed = [];
+		for (const [name, gate] of this.gates) if (gate.on && gate.armedUntilMs <= nowMs) {
+			gate.disarm();
+			closed.push(name);
+		}
+		return closed;
+	}
+	/** The channels armed right now, as the document would describe them. */
+	armed() {
+		const out = [];
+		for (const [name, gate] of this.gates) if (gate.on) out.push({
+			channel: name,
+			armedUntilMs: gate.armedUntilMs,
+			deviceIds: null
+		});
+		return out;
+	}
+};
+/**
+* Process-wide holder for the {@link LogChannelRegistry}.
+*
+* Three call sites that never meet need the SAME instance: the hot paths that
+* declare a gate at module scope, the `log-channels` provider that enumerates
+* the declarations for the hub, and the same provider applying the windows the
+* document hands down. A registry built inside any one of them would be
+* refreshed and collected — the shape of a knob that never does anything.
+*
+* Same idiom as `logging-gate.singleton.ts` and
+* `http-request-census.singleton.ts`.
+*/
+var instance = null;
+/** The process-wide log channel registry. Created empty on first use. */
+function getLogChannelRegistry() {
+	instance ??= new LogChannelRegistry();
+	return instance;
+}
+/**
+* Declare a channel on the process-wide registry and get its gate.
+*
+* The one call an addon makes. Keep the returned gate in a module-scope
+* `const`: looking a channel up by name per line would put a Map lookup on
+* exactly the path this mechanism exists to keep free.
+*
+* `scripts/check-log-channel-gated.ts` reads these call sites. It pairs the
+* declared name with the binding it is assigned to and refuses to let a
+* channel ship that no `<binding>.on` anywhere consults — a declared channel
+* nobody reads is a knob the operator turns with nothing happening, forever,
+* and without a line. That is D62, and this repo has now shipped it three
+* times (`audioThresholdDbfs`, the HA entities with no source, the second
+* per-camera switch that wrote a store nobody read).
+*/
+function declareLogChannel(descriptor) {
+	return getLogChannelRegistry().declare(descriptor);
+}
+/**
+* Build the `log-channels` provider for this process.
+*
+* `logger` is used ONLY off the hot path — for the arm/expiry lines — so a
+* channel that is never armed costs this module nothing but a timer.
+*/
+function createLogChannelsProvider(logger, options = {}) {
+	const registry = getLogChannelRegistry();
+	const now = options.now ?? Date.now;
+	const tickMs = options.tickMs ?? 5e3;
+	const timer = setInterval(() => {
+		const closed = registry.tick(now());
+		for (const name of closed) logger.info("log channel window closed", {
+			tags: { logChannel: name },
+			meta: { channel: name }
+		});
+	}, tickMs);
+	timer.unref?.();
+	return {
+		list: () => registry.list(),
+		apply: (input) => {
+			const unknown = registry.apply(input.windows, now());
+			const armed = registry.armed();
+			logger.info("log channels applied", { meta: {
+				armed: armed.map((window) => window.channel),
+				unknown,
+				declared: registry.list().length
+			} });
+			return {
+				armed: armed.length,
+				unknown
+			};
+		},
+		stop: () => {
+			clearInterval(timer);
+		}
+	};
+}
+/**
 * Distinct (device, family, variant) counters one instance will hold.
 *
 * A large fleet x the handful of families any single addon reports, with
@@ -24308,7 +24495,7 @@ method(object({
 	downloadId: string(),
 	offset: number(),
 	length: number()
-}), _instanceof(Uint8Array)), method(object({ downloadId: string() }), _void(), { kind: "mutation" }), method(object({ type: StorageLocationTypeSchema.optional() }), array(StorageLocationSchema).readonly()), method(object({ type: StorageLocationTypeSchema }), StorageLocationSchema.nullable()), method(_void(), array(StorageLocationDeclarationSchema).readonly()), method(StorageLocationSchema.omit({
+}), _instanceof(Uint8Array)), method(object({ downloadId: string() }), _void(), { kind: "mutation" }), method(object({ type: StorageLocationTypeSchema.optional() }), array(StorageLocationSchema).readonly()), method(_void(), array(StorageLocationDeclarationSchema).readonly()), method(StorageLocationSchema.omit({
 	createdAt: true,
 	updatedAt: true
 }), StorageLocationSchema, {
@@ -24320,7 +24507,7 @@ method(object({
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ id: string() }), object({
+}), method(_void(), array(StorageDrainProgressSchema).readonly()), method(object({ id: string() }), object({
 	ok: boolean(),
 	error: string().optional()
 }), { auth: "admin" }), method(_void(), array(ProviderListEntrySchema).readonly()), method(object({
@@ -24412,6 +24599,71 @@ method(StorageMigrationInputSchema, StorageMigrationPlanSchema, { auth: "admin"
 	kind: "mutation",
 	auth: "admin"
 }), method(object({}), 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 = object({
+	locationId: string(),
+	/** Bytes this provider holds on THAT location — not its eviction domain, and
+	*  not net of what it is willing to delete. */
+	ownedBytes: 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: 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(object({ locationIds: array(string()).readonly() }), array(StorageOccupancyReportSchema).readonly(), { auth: "admin" }) }
+};
 var ProviderInfoSchema = discriminatedUnion("shouldSaveDiskSpace", [object({
 	providerId: string().min(1),
 	displayName: string().min(1),
@@ -26194,39 +26446,6 @@ onStatusChanged: { data: object({
 	*  whether persisting is worth a SQLite commit. */
 	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 = object({
-	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
-	type: _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: number().min(0).max(100).nullable(),
-	/** Raw received signal strength in dBm, when the firmware reports one. */
-	rssiDbm: number().optional(),
-	/** Network name of a wireless link, when the firmware reports it. */
-	ssid: string().optional(),
-	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
-	lastUpdated: number()
-});
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.Light, DeviceType.Lock, DeviceType.Siren, object({
-	deviceId: number(),
-	status: NetworkLinkStatusSchema
-});
 object({
 	on: boolean(),
 	/** Ms epoch of the last transition. 0 if never observed. */
@@ -28580,6 +28799,236 @@ DeviceType.Camera, method(object({
 	detection: NativeDetectionSchema
 });
 /**
+* `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 = object({
+	pan: number().min(-1).max(1).optional(),
+	tilt: number().min(-1).max(1).optional(),
+	speed: 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 = _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 = _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 = object({
+	id: string(),
+	kind: NavigationEntryKindSchema,
+	label: string(),
+	icon: string(),
+	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
+	soundId: number().int().optional(),
+	/** Per-device feature flag — render this entry only when true. */
+	enabled: boolean()
+});
+/** Coordinates for `goToPoint` — a point on the robot's live map. */
+var NavigationPointSchema = object({
+	x: number(),
+	y: 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 = object({
+	move: boolean(),
+	stop: boolean(),
+	goToPoint: boolean(),
+	runAction: boolean(),
+	playSound: boolean(),
+	light: boolean(),
+	lightMode: boolean()
+});
+/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
+var NavigationLightModeSchema = _enum(["auto", "manual"]);
+/**
+* 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 = object({
+	mode: _enum([
+		"idle",
+		"cleaning",
+		"spot",
+		"following",
+		"goto",
+		"returning",
+		"paused",
+		"unknown"
+	]),
+	following: boolean(),
+	flash: boolean(),
+	lightMode: NavigationLightModeSchema,
+	lightLevel: number().min(40).max(100),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+NavigationStatusSchema.extend({ lastFetchedAt: number() });
+DeviceType.Camera, method(NavigationMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(NavigationPointSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), array(NavigationActionEntrySchema)), method(object({
+	deviceId: number(),
+	actionId: NavigationActionIdSchema
+}), _void(), { kind: "mutation" }), method(object({
+	deviceId: number(),
+	soundId: number().int()
+}), _void(), { kind: "mutation" }), method(object({
+	deviceId: number(),
+	on: boolean()
+}), _void(), { kind: "mutation" }), method(object({
+	deviceId: number(),
+	mode: NavigationLightModeSchema,
+	level: number().min(40).max(100).optional()
+}), _void(), { kind: "mutation" }), method(object({
+	deviceId: number(),
+	level: number().min(40).max(100)
+}), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), NavigationFeaturesSchema), object({
+	deviceId: number(),
+	status: NavigationStatusSchema
+});
+/**
+* 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 = object({
+	/** The link the device is on. `'unknown'` = not read yet, not "no link". */
+	type: _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: number().min(0).max(100).nullable(),
+	/** Raw received signal strength in dBm, when the firmware reports one. */
+	rssiDbm: number().optional(),
+	/** Network name of a wireless link, when the firmware reports it. */
+	ssid: string().optional(),
+	/** Ms epoch of the last observation. Lets consumers reason about freshness. */
+	lastUpdated: number()
+});
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.Light, DeviceType.Lock, DeviceType.Siren, object({
+	deviceId: number(),
+	status: NetworkLinkStatusSchema
+});
+/**
 * network-quality — system-scoped singleton capability tracking RTT,
 * jitter, and observed/peak bandwidth per device + per client.
 *
@@ -29821,203 +30270,6 @@ DeviceType.Camera, method(object({ deviceId: number() }), PtzAutotrackStatusSche
 	deviceId: number(),
 	status: PtzAutotrackStatusSchema
 });
-/**
-* `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 = object({
-	pan: number().min(-1).max(1).optional(),
-	tilt: number().min(-1).max(1).optional(),
-	speed: 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 = _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 = _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 = object({
-	id: string(),
-	kind: NavigationEntryKindSchema,
-	label: string(),
-	icon: string(),
-	/** Present only on `kind:'sound'` entries — the id to pass to `playSound`. */
-	soundId: number().int().optional(),
-	/** Per-device feature flag — render this entry only when true. */
-	enabled: boolean()
-});
-/** Coordinates for `goToPoint` — a point on the robot's live map. */
-var NavigationPointSchema = object({
-	x: number(),
-	y: 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 = object({
-	move: boolean(),
-	stop: boolean(),
-	goToPoint: boolean(),
-	runAction: boolean(),
-	playSound: boolean(),
-	light: boolean(),
-	lightMode: boolean()
-});
-/** Light mode: `auto` lets the camera choose brightness; `manual` uses `level`. */
-var NavigationLightModeSchema = _enum(["auto", "manual"]);
-/**
-* 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 = object({
-	mode: _enum([
-		"idle",
-		"cleaning",
-		"spot",
-		"following",
-		"goto",
-		"returning",
-		"paused",
-		"unknown"
-	]),
-	following: boolean(),
-	flash: boolean(),
-	lightMode: NavigationLightModeSchema,
-	lightLevel: number().min(40).max(100),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-NavigationStatusSchema.extend({ lastFetchedAt: number() });
-DeviceType.Camera, method(NavigationMoveCommandSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), _void(), { kind: "mutation" }), method(NavigationPointSchema.extend({ deviceId: number() }), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), array(NavigationActionEntrySchema)), method(object({
-	deviceId: number(),
-	actionId: NavigationActionIdSchema
-}), _void(), { kind: "mutation" }), method(object({
-	deviceId: number(),
-	soundId: number().int()
-}), _void(), { kind: "mutation" }), method(object({
-	deviceId: number(),
-	on: boolean()
-}), _void(), { kind: "mutation" }), method(object({
-	deviceId: number(),
-	mode: NavigationLightModeSchema,
-	level: number().min(40).max(100).optional()
-}), _void(), { kind: "mutation" }), method(object({
-	deviceId: number(),
-	level: number().min(40).max(100)
-}), _void(), { kind: "mutation" }), method(object({ deviceId: number() }), NavigationFeaturesSchema), object({
-	deviceId: number(),
-	status: NavigationStatusSchema
-});
 DeviceType.Camera, DeviceType.Sensor, DeviceType.Switch, method(object({ deviceId: number().int().nonnegative() }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -37740,13 +37992,13 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"storage.getDefaultLocation": {
+	"storage.list": {
 		capName: "storage",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"storage.list": {
+	"storage.listDrainProgress": {
 		capName: "storage",
 		capScope: "system",
 		addonId: null,
@@ -37896,6 +38148,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storageOccupancy.getOccupancy": {
+		capName: "storage-occupancy",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageProvider.abortUpload": {
 		capName: "storage-provider",
 		capScope: "system",
@@ -42377,4 +42635,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { inferModelProvider as $, lazy as $t, addonWidgetsSourceCapability as A, Fmp4BoxSplitter as At, defaultDeviceFor as B, hydrateSchema as Bt, RATE_CONTROL_RELAXED as C, storageEvictableCapability as Ct, RecordingSignalStatusSchema as D, webrtcSessionCapability as Dt, RecordingConfigSchema as E, supportedRuntimes as Et, cameraStreamsCapability as F, BaseAddon as Ft, detectionPipelineCapability as G, parseJsonUnknown as Gt, deriveBatteryPresence as H, makeProfileBrokerId as Ht, createHwAccelCache as I, CAM_PROFILE_ORDER as It, enumerateInferenceDevices as J, sleep as Jt, egressTranscodeSharingKey as K, parseProfileBrokerId as Kt, createLogChannelsProvider as L, DeviceFeature as Lt, audioAnalyzerCapability as M, invocationFromEncodeProfile as Mt, audioKindId as N, isSoftwareDecode as Nt, RingBuffer as O, errMsg as Ot, batteryCapability as P, BOOT_RECOVERY_BACKOFF_MS as Pt, hfModelUrl as Q, discriminatedUnion as Qt, customAction as R, DeviceType as Rt, PoolMemoryWatchdog as S, runtimeDevices as St, RECORDING_EXPORT_MAX_READ_BYTES as T, stripRetiredBandPreBufferSec as Tt, deriveDetailCropRect as U, makeSourceBrokerId as Ut, defineCustomActions as V, isEvent as Vt, deriveRecordingMode as W, nodePin as Wt, evaluateZoneRules as X, array as Xt, evaluateSensorEdge as Y, _enum as Yt, failureContributionCapability as Z, boolean as Zt, FailureCounters as _, recordingSignalCapability as _t, COCO_80_LABELS as a, string as an, migrateLegacyDeviceSignalConfig as at, NativeLeaseSettingsSchema as b, resolvePoolMemoryPolicy as bt, DEFAULT_CLUSTER_STEP_MODELS as c, parseProcStatus as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, pickDetailCropConvention as dt, literal as en, isFirstLevelMacroClass as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, pickNativeLeaseOverride as ft, ExportRecordSchema as g, recordingExportCapability as gt, EncodeProfileSchema as h, recordingCapability as ht, BatteryStatusSchema as i, record as in, maskUrlCredentials as it, audioAnalysisCapability as j, buildFfmpegArgs as jt, YAMNET_TO_MACRO as k, AUDIO_PRESETS as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, pickClusterStepModels as lt, DEVICE_BACKEND_TO_FORMAT as m, pipelineRunnerCapability as mt, AUDIO_BACKEND_CHOICES as n, object as nn, logChannelsCapability as nt, COCO_TO_MACRO as o, union as on, motionDetectionCapability as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, pipelineExecutorCapability as pt, egressTransportFromRequest as q, selectAssignedProfileSlots as qt, AUDIO_MACRO_LABELS as r, preprocess as rn, mapAudioLabelToMacro as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, EventCategory as sn, overlayClusterStepSettings as st, APPLE_SA_TO_MACRO as t, number as tn, loadContributionCapability as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, pickClusterStepSettings as ut, HF_BASE_URL as v, resolveClusterStepModelId as vt, RATE_CONTROL_TIGHT as w, streamBrokerCapability as wt, OpsLogEntrySchema as x, resolveRecordingProfiles as xt, NativeLeaseAdmissionSchema as y, resolveEgressDecodeHwAccel as yt, declareLogChannel as z, createEvent as zt };
+export { failureContributionCapability as $, parseJsonUnknown as $t, addonWidgetsSourceCapability as A, storageEvictableCapability as At, defaultDeviceFor as B, invocationFromEncodeProfile as Bt, RATE_CONTROL_RELAXED as C, recordingSignalCapability as Ct, RecordingSignalStatusSchema as D, resolvePoolMemoryPolicy as Dt, RecordingConfigSchema as E, resolveLocationMode as Et, cameraStreamsCapability as F, webrtcSessionCapability as Ft, detectionPipelineCapability as G, DeviceFeature as Gt, deriveBatteryPresence as H, BOOT_RECOVERY_BACKOFF_MS as Ht, createHwAccelCache as I, errMsg as It, enumerateInferenceDevices as J, hydrateSchema as Jt, egressTranscodeSharingKey as K, DeviceType as Kt, createLogChannelsProvider as L, AUDIO_PRESETS as Lt, audioAnalyzerCapability as M, streamBrokerCapability as Mt, audioKindId as N, stripRetiredBandPreBufferSec as Nt, RingBuffer as O, resolveRecordingProfiles as Ot, batteryCapability as P, supportedRuntimes as Pt, evictionPolicyOfLocation as Q, nodePin as Qt, customAction as R, Fmp4BoxSplitter as Rt, PoolMemoryWatchdog as S, recordingExportCapability as St, RECORDING_EXPORT_MAX_READ_BYTES as T, resolveEgressDecodeHwAccel as Tt, deriveDetailCropRect as U, BaseAddon as Ut, defineCustomActions as V, isSoftwareDecode as Vt, deriveRecordingMode as W, CAM_PROFILE_ORDER as Wt, evaluateZoneRules as X, makeProfileBrokerId as Xt, evaluateSensorEdge as Y, isEvent as Yt, evictionPolicyForMode as Z, makeSourceBrokerId as Zt, FailureCounters as _, pickDetailCropConvention as _t, COCO_80_LABELS as a, boolean as an, logChannelsCapability as at, NativeLeaseSettingsSchema as b, pipelineRunnerCapability as bt, DEFAULT_CLUSTER_STEP_MODELS as c, literal as cn, mayReadLocation as ct, DEFAULT_EVENTS_BAND_BUFFER_SEC as d, preprocess as dn, modeMayWrite as dt, parseProfileBrokerId as en, gbToBytes as et, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as f, record as fn, motionDetectionCapability as ft, ExportRecordSchema as g, pickClusterStepSettings as gt, EncodeProfileSchema as h, EventCategory as hn, pickClusterStepModels as ht, BatteryStatusSchema as i, array as in, loadContributionCapability as it, audioAnalysisCapability as j, storageOccupancyCapability as jt, YAMNET_TO_MACRO as k, runtimeDevices as kt, DEFAULT_CLUSTER_STEP_SETTINGS as l, number as ln, mayWriteToLocation as lt, DEVICE_BACKEND_TO_FORMAT as m, union as mn, parseProcStatus as mt, AUDIO_BACKEND_CHOICES as n, sleep as nn, inferModelProvider as nt, COCO_TO_MACRO as o, discriminatedUnion as on, mapAudioLabelToMacro as ot, DEFAULT_NATIVE_LEASE_SETTINGS as p, string as pn, overlayClusterStepSettings as pt, egressTransportFromRequest as q, createEvent as qt, AUDIO_MACRO_LABELS as r, _enum as rn, isFirstLevelMacroClass as rt, DEFAULT_AUDIO_ANALYZER_CONFIG as s, lazy as sn, maskUrlCredentials as st, APPLE_SA_TO_MACRO as t, selectAssignedProfileSlots as tn, hfModelUrl as tt, DEFAULT_DETAIL_CROP_CONVENTION as u, object as un, migrateLegacyDeviceSignalConfig as ut, HF_BASE_URL as v, pickNativeLeaseOverride as vt, RATE_CONTROL_TIGHT as w, resolveClusterStepModelId as wt, OpsLogEntrySchema as x, recordingCapability as xt, NativeLeaseAdmissionSchema as y, pipelineExecutorCapability as yt, declareLogChannel as z, buildFfmpegArgs as zt };