@camstack/system 1.2.456 → 1.2.458

package/dist/{dist-BpqA2CT0.js → dist-BZQjLPiz.js}

@@ -745,7 +745,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-yKL5gfrH.mjs
+//#region ../types/dist/sleep-BSuCCFjf.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -17748,11 +17748,30 @@ var DeviceHistorySubjectSchema = zod.z.discriminatedUnion("kind", [zod.z.object(
 	kind: zod.z.literal("node"),
 	nodeId: zod.z.string().min(1)
 })]);
+/**
+* `enum` stores a STATE as the ordinal of its value in the series' value list
+* (`DeviceHistorySeriesInfo.values`, append-only, so an ordinal never changes
+* meaning); a rollup keeps the time spent in each state (`states`).
+*/
 var DeviceHistoryKindSchema = zod.z.enum([
+	"gauge",
+	"counter",
+	"boolean",
+	"enum"
+]);
+/** What a PRODUCER may declare. `enum` is cap-only: its value list is the cap field's. */
+var DeviceHistoryProducerKindSchema = zod.z.enum([
 	"gauge",
 	"counter",
 	"boolean"
 ]);
+/**
+* A key computed at READ time from stored series of the same device, never
+* stored itself. Energy (kWh per bucket) comes from the power meter's
+* `kwhTotal` counter when the device has one, else from integrating its
+* `watts` gauge over time.
+*/
+var DEVICE_HISTORY_ENERGY_KEY = "derived:energy.kwh";
 var DeviceHistoryResolutionSchema = zod.z.enum([
 	"raw",
 	"5m",
@@ -17785,7 +17804,13 @@ var SeriesInfoSchema = zod.z.object({
 	/** `null` is unknown (a `unitFrom` series whose device does not state a unit right now), never a guess. */
 	unit: zod.z.string().nullable(),
 	displayName: zod.z.string(),
-	source: zod.z.enum(["cap", "addon"]),
+	source: zod.z.enum([
+		"cap",
+		"addon",
+		"derived"
+	]),
+	/** `enum`: the value of each ordinal (index = ordinal); `null` for every other kind. */
+	values: zod.z.array(zod.z.string()).readonly().nullable(),
 	firstTs: zod.z.number(),
 	lastTs: zod.z.number()
 });
@@ -17799,17 +17824,31 @@ var QueryPointSchema = zod.z.object({
 	twMean: zod.z.number().nullable(),
 	min: zod.z.number(),
 	max: zod.z.number(),
-	/** `null` is unknown, never zero (D393). */
-	last: zod.z.number().nullable()
+	/** `null` is unknown, never zero (D393). For an `enum` series: the ordinal of {@link state}. */
+	last: zod.z.number().nullable(),
+	/**
+	* The increase over the point: a `counter`'s growth since the previous point
+	* or bucket (a drop is a reset, counted from zero), and for
+	* {@link DEVICE_HISTORY_ENERGY_KEY} the kWh used in the bucket. `null` for
+	* every other kind, and when it cannot be known.
+	*/
+	delta: zod.z.number().nullable(),
+	/** `enum`: the state in force at the end of the point (the name of `last`); `null` otherwise. */
+	state: zod.z.string().nullable(),
+	/** `enum` rollup: milliseconds spent in each state inside the bucket; `null` for raw points and other kinds. */
+	states: zod.z.record(zod.z.string(), zod.z.number()).nullable()
 });
 var QuerySeriesSchema = zod.z.object({
 	scope: zod.z.string(),
 	/** The last point STRICTLY BEFORE `from` in the chosen tier, so a step chart can start at the held value. */
 	before: zod.z.object({
 		t: zod.z.number(),
-		value: zod.z.number().nullable()
+		value: zod.z.number().nullable(),
+		state: zod.z.string().nullable()
 	}).nullable(),
-	points: zod.z.array(QueryPointSchema).readonly()
+	points: zod.z.array(QueryPointSchema).readonly(),
+	/** A derived key: the stored key its points were computed from; `null` for a stored series. */
+	derivedFrom: zod.z.string().nullable()
 });
 /** The window part of a query, shared by the device and node forms. */
 var QueryWindowShape = {
@@ -17825,6 +17864,23 @@ var QueryResultSchema = zod.z.object({
 	series: zod.z.array(QuerySeriesSchema).readonly(),
 	truncated: zod.z.boolean()
 });
+/** One read of a batch: a device's key or a node's key (exactly one subject). */
+var QueryManyItemSchema = zod.z.union([zod.z.object({
+	deviceId: zod.z.number().int(),
+	key: zod.z.string(),
+	scope: zod.z.string().optional()
+}), zod.z.object({
+	forNodeId: zod.z.string().min(1),
+	key: zod.z.string(),
+	scope: zod.z.string().optional()
+})]);
+var QueryManyEntrySchema = zod.z.discriminatedUnion("ok", [zod.z.object({
+	ok: zod.z.literal(true),
+	result: QueryResultSchema
+}), zod.z.object({
+	ok: zod.z.literal(false),
+	error: zod.z.string()
+})]);
 var TierStatusSchema = zod.z.object({
 	tier: DeviceHistoryResolutionSchema,
 	/** `null` until the first background count answered. */
@@ -17893,26 +17949,45 @@ var deviceHistoryCapability = {
 		* `listNodeSeries` / `queryNode`.
 		*/
 		listSeries: method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.array(SeriesInfoSchema).readonly()),
-		listNodeSeries: method(zod.z.object({ nodeId: zod.z.string().min(1) }), zod.z.array(SeriesInfoSchema).readonly(), { auth: "admin" }),
+		/**
+		* A NODE's series. The subject is `forNodeId`, never `nodeId`: a top-level
+		* `nodeId` is the cap ROUTING key, and `nodeId: 'little-unraid'` sent the
+		* read to that agent, which hosts no device-history.
+		*/
+		listNodeSeries: method(zod.z.object({ forNodeId: zod.z.string().min(1) }), zod.z.array(SeriesInfoSchema).readonly(), { auth: "admin" }),
 		/**
 		* One series (or every scope of it) at one resolution. `auto` picks the
 		* finest tier whose retention covers `from` and whose point count fits
 		* `maxPoints`; when even the coarsest tier does not fit, the newest
-		* `maxPoints` points are returned and `truncated` is true.
+		* `maxPoints` points are returned and `truncated` is true. A series fed by
+		* closed buckets has no raw rows, so `auto` never answers it from raw; nor
+		* {@link DEVICE_HISTORY_ENERGY_KEY}, which is computed from rollups.
 		*/
 		query: method(zod.z.object({
 			deviceId: zod.z.number().int(),
 			...QueryWindowShape
 		}), QueryResultSchema),
 		queryNode: method(zod.z.object({
-			nodeId: zod.z.string().min(1),
+			forNodeId: zod.z.string().min(1),
 			...QueryWindowShape
 		}), QueryResultSchema, { auth: "admin" }),
+		/**
+		* Several reads over ONE window, answered in order (one entry per item).
+		* Admin-only: its subjects are nested in `items`, where the device scope
+		* gate cannot see them — a principal limited to one device uses `query`.
+		*/
+		queryMany: method(zod.z.object({
+			items: zod.z.array(QueryManyItemSchema).min(1).max(24),
+			from: QueryWindowShape.from,
+			to: QueryWindowShape.to,
+			resolution: QueryWindowShape.resolution,
+			maxPoints: QueryWindowShape.maxPoints
+		}), zod.z.object({ results: zod.z.array(QueryManyEntrySchema).readonly() }), { auth: "admin" }),
 		/** Producer: declare (idempotent) a series key this addon owns: `addon:<callerAddonId>/<name>`. */
 		declareSeries: method(zod.z.object({
 			name: zod.z.string().regex(/^[a-z0-9-]+$/),
 			subjectKind: zod.z.enum(["device", "node"]),
-			kind: DeviceHistoryKindSchema,
+			kind: DeviceHistoryProducerKindSchema,
 			unit: zod.z.string().optional(),
 			displayName: zod.z.string().min(1),
 			ingest: zod.z.enum(["points", "buckets"])
@@ -42839,6 +42914,103 @@ var LogEntrySchema = zod.z.object({
 	meta: zod.z.record(zod.z.string(), zod.z.unknown()).optional(),
 	tags: zod.z.record(zod.z.string(), zod.z.string()).optional()
 });
+/**
+* A history READ against one destination (D898).
+*
+* Every filter is applied by the PROVIDER, before the limit — a filter the
+* browser applied after the limit is what made a rare device's lines
+* unreachable behind a busy one's. `before` / `after` are cursors the provider
+* minted (opaque to everyone else): a file position for the rotated files, a
+* nanosecond timestamp for Loki.
+*
+* A read is BOUNDED by `budgetMs`: a filter that matches nothing on a 30-day
+* store answers `done: false` with the cursor it reached and the bytes it
+* scanned, and the caller decides whether to go on. That is what makes a long
+* scan show progress and stop when asked — `cancelRead` ends the slice in
+* flight, and not asking for the next slice ends the scan.
+*/
+var LogReadQuerySchema = zod.z.object({
+	/** Correlates `cancelRead`. Caller-chosen, unique per in-flight read. */
+	requestId: zod.z.string().min(1).max(64).optional(),
+	/** The device the line is about (`tags.deviceId`, numeric). */
+	deviceId: zod.z.number().int().optional(),
+	/**
+	* The emitting addon — bare manifest id; `@<version>` / `::<sub>` suffixes
+	* match. Not `addonId`: a cap router reads that name as "which provider".
+	*/
+	fromAddonId: zod.z.string().min(1).max(200).optional(),
+	/**
+	* The emitting node: matches the agent that emitted the line, the node
+	* itself, or a worker under it (`<agent>/<runner>`) — the `agentId`
+	* semantics of `matchesLogTags`. Not `nodeId`: a cap router reads that
+	* name as "which node's provider".
+	*/
+	fromNodeId: zod.z.string().min(1).max(200).optional(),
+	/** Any other tag, exact match (AND). */
+	tags: zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()])).optional(),
+	/** Severity FLOOR: this level and above. */
+	level: LogLevelSchema.optional(),
+	/** Case-insensitive substring over message, scope, tag values and meta values. */
+	text: zod.z.string().min(1).max(200).optional(),
+	/** Epoch ms, inclusive. */
+	since: zod.z.number().optional(),
+	/** Epoch ms, inclusive. */
+	until: zod.z.number().optional(),
+	/** Older than this cursor (exclusive). Absent with `after` absent ⇒ from the newest. */
+	before: zod.z.string().min(1).max(1024).optional(),
+	/** Newer than this cursor (exclusive). */
+	after: zod.z.string().min(1).max(1024).optional(),
+	limit: zod.z.number().int().min(1).max(1e3).optional(),
+	/** Wall-clock bound of this slice. The provider caps it. */
+	budgetMs: zod.z.number().int().min(50).max(1e4).optional()
+});
+var LogReadEntrySchema = zod.z.object({
+	/** `<bootId>.<seq>` minted by the emitting LogManager — the dedupe key. */
+	id: zod.z.string().optional(),
+	/** Epoch ms. */
+	timestamp: zod.z.number(),
+	level: LogLevelSchema,
+	scope: zod.z.string().optional(),
+	message: zod.z.string(),
+	tags: zod.z.record(zod.z.string(), zod.z.union([zod.z.string(), zod.z.number()])).optional(),
+	meta: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+var LogReadResultSchema = zod.z.object({
+	/** Newest first. */
+	entries: zod.z.array(LogReadEntrySchema),
+	/** Pass as `before` for the next older page; null when nothing older exists. */
+	nextBefore: zod.z.string().nullable(),
+	/** Pass as `after` to read what arrived since; null when unknown. */
+	nextAfter: zod.z.string().nullable(),
+	/** Bytes this slice read (files) or received (remote). Progress, not a promise. */
+	scannedBytes: zod.z.number().int().nonnegative(),
+	/**
+	* True when the scan in this direction reached the end of the store.
+	* False with fewer than `limit` entries means the budget ran out first —
+	* call again with `nextBefore` to go on.
+	*/
+	done: zod.z.boolean(),
+	/** True when `cancelRead` ended this slice early. */
+	cancelled: zod.z.boolean().optional()
+});
+var LogReadCapabilitiesSchema = zod.z.object({
+	/** False ⇒ this destination only ships lines (console, forwarder, an unconfigured Loki). */
+	readable: zod.z.boolean(),
+	/** Why not, when `readable` is false — rendered next to the source. */
+	reason: zod.z.string().nullable(),
+	/** Filters the provider applies itself. A false one is applied by nobody. */
+	filters: zod.z.object({
+		deviceId: zod.z.boolean(),
+		addonId: zod.z.boolean(),
+		nodeId: zod.z.boolean(),
+		tags: zod.z.boolean(),
+		level: zod.z.boolean(),
+		text: zod.z.boolean(),
+		timeRange: zod.z.boolean()
+	}),
+	/** How far back the store reaches, when the provider knows (days). */
+	retentionDays: zod.z.number().nullable()
+});
 var logDestinationCapability = {
 	name: "log-destination",
 	scope: "system",
@@ -42846,14 +43018,13 @@ var logDestinationCapability = {
 	internal: true,
 	methods: {
 		write: method(LogEntrySchema, zod.z.void(), { kind: "mutation" }),
-		query: method(zod.z.object({
-			scope: zod.z.array(zod.z.string()).optional(),
-			level: LogLevelSchema.optional(),
-			since: zod.z.date().optional(),
-			until: zod.z.date().optional(),
-			limit: zod.z.number().optional(),
-			tags: zod.z.record(zod.z.string(), zod.z.string()).optional()
-		}), zod.z.array(LogEntrySchema).readonly())
+		/** Absent ⇒ the destination cannot read back (same as `readable: false`). */
+		describeRead: optionalMethod(zod.z.void(), LogReadCapabilitiesSchema, { auth: "admin" }),
+		read: optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }),
+		cancelRead: optionalMethod(zod.z.object({ requestId: zod.z.string().min(1).max(64) }), zod.z.object({ cancelled: zod.z.boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	},
 	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
 	mount: { kind: "skip" }
@@ -44763,9 +44934,11 @@ var alarmPanelCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — enum state; arm/disarm history belongs in the events ledger.
+	* History (D850): the panel's lifecycle state as an `enum` series —
+	* change-only, no floor, so an `arming -> pending -> triggered` sequence of a
+	* few seconds keeps every step. Who armed it stays in the events ledger.
 	*/
-	history: "none",
+	history: { fields: { state: { kind: "enum" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -45656,6 +45829,33 @@ var NcRuleTargetSchema = zod.z.object({
 	params: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
 /**
+* WHAT THE NOTIFICATION'S PICTURE IS (D897) — the ONE media choice of a rule.
+*
+* Every mode starts from the same CLEAN source frame of the trigger moment
+* (keyFrame → sceneFrame → lastSceneFrame, narrowed to the trigger instant and
+* to the zone that fired the rule) and renders it once at send time:
+*  - `scene-boxes` — the whole scene, the subject outlined thick in the accent
+*    colour and every OTHER track visible at that instant outlined thin, each
+*    labelled with class and confidence ("dog 87%").
+*  - `crop`  — the subject cut out of that frame around its box at that instant.
+*  - `clean` — the whole scene with nothing drawn on it.
+*  - `none`  — no picture.
+*
+* A mode that cannot be honoured (no box at that instant, a photograph with no
+* tracked subject) ships `clean` and names the reason in the log, per camera.
+* It replaces the `attach` × `frame` × `zoneCrop` triple, which let one rule
+* ship a crop on one event and a boxed scene on the next depending on which
+* stored kind had landed.
+*/
+var NcMediaImageSchema = zod.z.enum([
+	"scene-boxes",
+	"crop",
+	"clean",
+	"none"
+]);
+/**
+* @deprecated Read only by `normalizeNcMediaPolicy` (D897) — see {@link NcMediaImageSchema}.
+*
 * Media attachment policy (P1 still-image subset).
 *  - `best` — the best AVAILABLE subject image at dispatch time (D-3).
 *  - `best-matching` — the media that explains WHY the rule fired: a rule
@@ -45669,6 +45869,8 @@ var NcRuleTargetSchema = zod.z.object({
 *  - `none` — no attachment.
 */
 /**
+* @deprecated Read only by `normalizeNcMediaPolicy` (D897) — see {@link NcMediaImageSchema}.
+*
 * WHAT THE PICTURE SHOWS — chosen explicitly, because the implicit ladders
 * conflate it with the selection strategy and betray the request: asking for
 * the clean scene frame on an object-event owner used to start at
@@ -45697,16 +45899,29 @@ var NcMediaFrameSchema = zod.z.enum([
 */
 var NcLinkedCameraModeSchema = zod.z.enum(["mosaic", "each"]);
 var NcMediaPolicySchema = zod.z.object({
+	/**
+	* The picture — see {@link NcMediaImageSchema}. Absent on a rule nobody has
+	* saved since D897: `normalizeNcMediaPolicy` derives it from the legacy
+	* triple below, at load and at every write, and the store keeps only this.
+	*/
+	image: NcMediaImageSchema.optional(),
+	/**
+	* Draw the zone that FIRED the rule on the picture (`scene-boxes` / `clean`;
+	* a `crop` never shows it). Valid only on a rule whose trigger is a zone —
+	* `conditions.zones` or an occupancy zone — and refused on save otherwise.
+	* Replaces `zoneCrop`.
+	*/
+	showTriggerZone: zod.z.boolean().optional(),
+	/** @deprecated D897 — accepted from an editor that predates `image`, folded into it on save. */
 	attach: zod.z.enum([
 		"best",
 		"best-matching",
 		"keyFrame",
 		"none"
-	]).default("best"),
-	/** What the still shows. Absent = `cropped` (the historical `best` shape). */
+	]).optional(),
+	/** @deprecated D897 — accepted from an editor that predates `image`, folded into it on save. */
 	frame: NcMediaFrameSchema.optional(),
-	/** Crop the attached still to the rule's condition-zone bbox (padded) —
-	*  "show me the ZONE", not the whole scene or the subject crop. */
+	/** @deprecated D897 — folded into `image: 'clean'` + `showTriggerZone` on save. */
 	zoneCrop: zod.z.boolean().optional(),
 	/**
 	* Also attach a short GIF cut from the stream broker's clip ring around the
@@ -45878,7 +46093,9 @@ var NcRuleInputSchema = zod.z.object({
 	* targets.
 	*/
 	targetUsers: zod.z.array(zod.z.string()).optional(),
-	media: NcMediaPolicySchema.default({ attach: "best" }),
+	/** Absent = the kind's default picture (`resolveNcMediaImage`): the subject crop for a
+	*  detection, the clean scene for a sensor or a sound. Set explicitly on save (D897). */
+	media: NcMediaPolicySchema.default({}),
 	throttle: NcThrottleSchema.default({
 		cooldownSec: 60,
 		scope: "rule-device"
@@ -46836,13 +47053,37 @@ var NcAlarmModeOpeningsSchema = zod.z.object({
 	/** Covered devices whose state could not be read (D49): neither open nor closed. */
 	unknown: zod.z.array(zod.z.number().int())
 });
+/**
+* One alarm INPUT — a (rule, device) pair — the operator bypassed until the
+* next disarm ("Bypass this input until disarm" on a trigger notification, or
+* `nc.bypassAlarmInput`). Reported so an armed alarm with a silenced input
+* never looks fully armed (D62: off must never look like broken).
+*/
+var NcAlarmInputBypassViewSchema = zod.z.object({
+	ruleId: zod.z.string(),
+	/** The rule's current name (its frozen name when the rule is gone). */
+	ruleName: zod.z.string(),
+	/** The input: the sensor of the match, else its camera. */
+	deviceId: zod.z.number().int(),
+	/** The input's current name. */
+	name: zod.z.string(),
+	/** When it was bypassed (ms epoch). */
+	since: zod.z.number(),
+	/** Triggers from this input dropped since. */
+	dropped: zod.z.number().int().min(0)
+});
 var NcAlarmLiveSchema = zod.z.object({
 	state: AlarmStateSchema,
 	/** The mode being armed into (exit delay) or held; null when disarmed. */
 	targetMode: AlarmArmModeSchema.nullable(),
 	availableModes: zod.z.array(AlarmArmModeSchema),
 	openings: zod.z.array(NcAlarmModeOpeningsSchema),
-	exclusions: zod.z.array(NcAlarmExclusionViewSchema)
+	exclusions: zod.z.array(NcAlarmExclusionViewSchema),
+	/**
+	* Inputs bypassed for the rest of this arm session; cleared on disarm.
+	* Defaulted so an older hub answer still parses (as "none known").
+	*/
+	bypassedInputs: zod.z.array(NcAlarmInputBypassViewSchema).default([])
 });
 var NcAlarmConfigSchema = zod.z.object({
 	/**
@@ -60737,9 +60978,11 @@ var connectivityCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — duplicates device-status.online (one authority for availability).
+	* History (D850): `connected` as a boolean series — change-only, no floor. It
+	* is the upstream entity's own link (a HA connectivity sensor), not the
+	* device's reachability, which stays `device-status.online`.
 	*/
-	history: "none",
+	history: { fields: { connected: { kind: "boolean" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -61609,11 +61852,22 @@ var dishwasherCapability = {
 	},
 	runtimeState: DishwasherStatusSchema,
 	durability: "session",
-	history: { fields: { progressPercent: {
-		kind: "gauge",
-		unit: "%",
-		deadband: 2
-	} } }
+	history: { fields: {
+		progressPercent: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		state: { kind: "enum" },
+		operationState: { kind: "enum" },
+		remainingSeconds: {
+			kind: "gauge",
+			unit: "s",
+			minIntervalMs: 6e4
+		},
+		doorOpen: { kind: "boolean" },
+		powerOn: { kind: "boolean" }
+	} }
 };
 var DoorbellStatusSchema = zod.z.object({
 	/** Ms epoch of the last press. null = never observed since this provider started. */
@@ -61730,9 +61984,15 @@ var enumSensorCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — text/enum state has no history (non-goal).
+	* History (D850): the value as an `enum` series (an appliance's program or
+	* operation state, an HVAC action). The option set is per device, so the
+	* value list is LEARNED as values are first seen (bounded). A sensor with a
+	* `format` carries a timestamp, not a state, and is not recorded.
 	*/
-	history: "none",
+	history: { fields: { value: {
+		kind: "enum",
+		skipWhenSet: "format"
+	} } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -63954,9 +64214,10 @@ var lockControlCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — enum state; lock events belong in the events ledger.
+	* History (D850): the lock's state as an `enum` series — change-only, no
+	* floor: a jam or an unlock lasting seconds is the edge an operator looks for.
 	*/
-	history: "none",
+	history: { fields: { state: { kind: "enum" } } },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastChangedAt"]
@@ -64130,9 +64391,18 @@ var mediaPlayerCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): none — `positionMs` moves continuously while playing; volume is transient.
+	* History (D850): volume (a level an operator or an automation sets; the
+	* default 10 s floor folds a slider drag into its end value) and mute.
+	* `positionMs` is not recorded: it moves continuously while playing.
 	*/
-	history: "none"
+	history: { fields: {
+		volumeLevel: {
+			kind: "gauge",
+			unit: "%",
+			deadband: 1
+		},
+		isMuted: { kind: "boolean" }
+	} }
 };
 /**
 * mesh-network — collection cap for mesh-VPN providers.
@@ -66573,9 +66843,24 @@ var NpuInfoSchema = zod.z.object({
 	name: zod.z.string().optional(),
 	generation: zod.z.enum(["xdna1", "xdna2"]).optional()
 });
+var CoralBusSchema = zod.z.enum(["usb", "pci"]);
 var CoralInfoSchema = zod.z.object({
 	type: zod.z.literal("coral-edgetpu"),
-	bus: zod.z.string().optional()
+	/** Legacy single-bus report (older nodes) — read via `coralUsableUnits`. */
+	bus: zod.z.string().optional(),
+	/** Legacy USB unit count (older nodes) — read via `coralUsableUnits`. */
+	count: zod.z.number().int().nonnegative().optional(),
+	/** Usable units per bus — each one is its own `edgetpu:<bus>[:N]` device. */
+	units: zod.z.array(zod.z.object({
+		bus: CoralBusSchema,
+		count: zod.z.number().int().nonnegative()
+	})).readonly().optional(),
+	/** Present-but-unusable units, each with its typed reason (never "absent"). */
+	unavailable: zod.z.array(zod.z.object({
+		bus: CoralBusSchema,
+		count: zod.z.number().int().nonnegative(),
+		reason: zod.z.enum(["driver-missing", "device-not-accessible"])
+	})).readonly().optional()
 });
 var HardwareInfoSchema = zod.z.object({
 	platform: HardwarePlatformSchema,
@@ -70278,9 +70563,29 @@ var streamParamsCapability = {
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — encoder configuration.
+	* History (D850): the configured bitrate and frame rate of the main and sub
+	* profiles. Configuration, so change-only on the default floor: a point is an
+	* operator's (or a tuner's) edit, which is exactly what a chart of a stream's
+	* quality over time must show.
 	*/
-	history: "none",
+	history: { fields: {
+		"main.bitrate": {
+			kind: "gauge",
+			unit: "kbps"
+		},
+		"main.framerate": {
+			kind: "gauge",
+			unit: "fps"
+		},
+		"sub.bitrate": {
+			kind: "gauge",
+			unit: "kbps"
+		},
+		"sub.framerate": {
+			kind: "gauge",
+			unit: "fps"
+		}
+	} },
 	/** Clock fields: written, but excluded from the compare that decides
 	*  whether persisting is worth a SQLite commit. */
 	volatileStateFields: ["lastFetchedAt"]
@@ -74483,6 +74788,15 @@ var BaseDevice = class {
 	* Drivers can use the `getProbeFlags()` helper to read the flag bag
 	* with a typed cast.
 	*
+	* Answer what you KNOW. A plain array is read as the complete list only
+	* while this device is `online` and probed; return
+	* `accessoryChildrenUnknown(reason)` whenever you cannot know the list right
+	* now (no credentials, parent not connected, a failed or partial read) —
+	* the kernel then deletes nothing. Return `accessoryChildrenComplete(list)`
+	* to say "connected, and this is the complete list" explicitly. A shrink is
+	* deleted only after a second agreeing complete read on a later probe (D49;
+	* `packages/system/src/kernel/moleculer/accessory-prune-gate.ts`).
+	*
 	* Default: no children.
 	*/
 	getAccessoryChildren() {
@@ -78392,7 +78706,19 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"logDestination.query": {
+	"logDestination.cancelRead": {
+		capName: "log-destination",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
+	"logDestination.describeRead": {
+		capName: "log-destination",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"logDestination.read": {
 		capName: "log-destination",
 		capScope: "system",
 		addonId: null,
@@ -84670,6 +84996,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"logDestination.read": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"mediaPlayer.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -86678,7 +87009,7 @@ var SESSION_ONLY_POLICY = {
 };
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 34 caps with series (62 series), 37 caps answered `'none'`.
+* 40 caps with series (77 series), 31 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -86709,6 +87040,21 @@ var HISTORY_CATALOG = {
 			deadband: 1
 		}
 	},
+	"alarm-panel": { "state": {
+		kind: "enum",
+		values: [
+			"disarmed",
+			"armed_home",
+			"armed_away",
+			"armed_night",
+			"armed_vacation",
+			"armed_custom_bypass",
+			"arming",
+			"disarming",
+			"pending",
+			"triggered"
+		]
+	} },
 	"ambient-light-sensor": { "lux": {
 		kind: "gauge",
 		unit: "lx",
@@ -86753,6 +87099,7 @@ var HISTORY_CATALOG = {
 			minIntervalMs: 0
 		}
 	},
+	"connectivity": { "connected": { kind: "boolean" } },
 	"contact": { "entryOpen": { kind: "boolean" } },
 	"cover": { "position": {
 		kind: "gauge",
@@ -86760,10 +87107,48 @@ var HISTORY_CATALOG = {
 		minIntervalMs: 0
 	} },
 	"device-status": { "online": { kind: "boolean" } },
-	"dishwasher": { "progressPercent": {
-		kind: "gauge",
-		unit: "%",
-		deadband: 2
+	"dishwasher": {
+		"progressPercent": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2
+		},
+		"state": {
+			kind: "enum",
+			values: [
+				"idle",
+				"running",
+				"paused",
+				"finished",
+				"error",
+				"unavailable"
+			]
+		},
+		"operationState": {
+			kind: "enum",
+			values: [
+				"Inactive",
+				"Ready",
+				"DelayedStart",
+				"Run",
+				"Pause",
+				"ActionRequired",
+				"Finished",
+				"Error",
+				"Aborting"
+			]
+		},
+		"remainingSeconds": {
+			kind: "gauge",
+			unit: "s",
+			minIntervalMs: 6e4
+		},
+		"doorOpen": { kind: "boolean" },
+		"powerOn": { kind: "boolean" }
+	},
+	"enum-sensor": { "value": {
+		kind: "enum",
+		skipWhenSet: "format"
 	} },
 	"fan-control": {
 		"percentage": {
@@ -86798,6 +87183,24 @@ var HISTORY_CATALOG = {
 		unit: "%",
 		deadband: 2
 	} },
+	"lock-control": { "state": {
+		kind: "enum",
+		values: [
+			"locked",
+			"unlocked",
+			"locking",
+			"unlocking",
+			"jammed"
+		]
+	} },
+	"media-player": {
+		"volumeLevel": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 1
+		},
+		"isMuted": { kind: "boolean" }
+	},
 	"motion": { "detected": {
 		kind: "boolean",
 		excludeDeviceTypes: [DeviceType.Camera]
@@ -86884,6 +87287,24 @@ var HISTORY_CATALOG = {
 		deadband: .1
 	} },
 	"smoke": { "detected": { kind: "boolean" } },
+	"stream-params": {
+		"main.bitrate": {
+			kind: "gauge",
+			unit: "kbps"
+		},
+		"main.framerate": {
+			kind: "gauge",
+			unit: "fps"
+		},
+		"sub.bitrate": {
+			kind: "gauge",
+			unit: "kbps"
+		},
+		"sub.framerate": {
+			kind: "gauge",
+			unit: "fps"
+		}
+	},
 	"switch": { "on": { kind: "boolean" } },
 	"tamper": { "tampered": { kind: "boolean" } },
 	"temperature-sensor": { "celsius": {
@@ -88173,6 +88594,29 @@ function decodeVectorBase64(encoded) {
 function vectorDimFromBase64(encoded) {
 	return Math.floor(Buffer.from(encoded, "base64").byteLength / 4);
 }
+/** Bus order of the enumeration: USB first (the historical key), then PCIe. */
+var BUS_ORDER = ["usb", "pci"];
+function unitDevice(bus, index) {
+	return index === 0 ? bus : `${bus}:${index}`;
+}
+function countOn(coral, bus) {
+	if (coral.units !== void 0) return coral.units.filter((u) => u.bus === bus).reduce((n, u) => n + Math.max(0, u.count), 0);
+	return bus === (coral.bus === "pci" ? "pci" : "usb") ? Math.max(1, coral.count ?? 1) : 0;
+}
+/** Every usable Coral unit on a node, USB first then PCIe, in ordinal order. */
+function coralUsableUnits(coral) {
+	if (coral == null) return [];
+	const out = [];
+	for (const bus of BUS_ORDER) {
+		const count = countOn(coral, bus);
+		for (let index = 0; index < count; index++) out.push({
+			bus,
+			index,
+			device: unitDevice(bus, index)
+		});
+	}
+	return out;
+}
 var AUTO = {
 	value: "auto",
 	label: "Auto"
@@ -88185,6 +88629,14 @@ var USB = {
 	value: "usb",
 	label: "Coral USB"
 };
+function coralUnitOption(unit) {
+	const bus = unit.bus === "pci" ? "PCIe" : "USB";
+	const label = unit.index === 0 ? `Coral ${bus}` : `Coral ${bus} ${unit.index + 1}`;
+	return {
+		value: unit.device,
+		label
+	};
+}
 var RUNTIMES = [
 	{
 		id: "onnx",
@@ -88251,8 +88703,11 @@ var RUNTIMES = [
 	},
 	{
 		id: "edgetpu",
-		supports: (hw) => hw?.coral != null,
-		devices: () => [USB],
+		supports: (hw) => coralUsableUnits(hw?.coral).length > 0,
+		devices: (hw) => {
+			const units = coralUsableUnits(hw?.coral);
+			return units.length > 0 ? units.map(coralUnitOption) : [USB];
+		},
 		defaultDevice: "usb"
 	}
 ];
@@ -88270,7 +88725,7 @@ function supportedRuntimes(hw) {
 * - coreml:   score 95, darwin+arm64
 * - cuda:     score 85, nvidia gpu
 * - openvino: score 90 if intel-npu present, else 80 if intel gpu
-* - edgetpu:  score 70, coral usb present
+* - edgetpu:  score 70, a usable Coral unit (USB or PCIe)
 * - cpu:      score 50 (universal floor, always included)
 *
 * All hardware-matched entries are `available: true`.
@@ -88324,7 +88779,7 @@ function scoreRuntimes(hw) {
 			available: true
 		});
 	}
-	if (hw.coral != null) scores.push({
+	if (coralUsableUnits(hw.coral).length > 0) scores.push({
 		runtime: "python",
 		backend: "edgetpu",
 		format: "tflite",
@@ -88383,11 +88838,7 @@ function enumerateInferenceDevices(hw) {
 			continue;
 		}
 		if (s.backend === "edgetpu") {
-			const coralCount = Math.max(1, hw.coral?.count ?? 1);
-			for (let i = 0; i < coralCount; i++) {
-				const dev = i === 0 ? "usb" : `usb:${i}`;
-				out.push(device("edgetpu", dev, s.format, s.score));
-			}
+			for (const unit of coralUsableUnits(hw.coral)) out.push(device("edgetpu", unit.device, s.format, s.score));
 			continue;
 		}
 		if (s.backend === "onnx" && s.reason.startsWith("ONNX WebGPU")) {
@@ -88662,6 +89113,12 @@ Object.defineProperty(exports, "DEVICE_ENROLLMENT_TTL_MS", {
 		return DEVICE_ENROLLMENT_TTL_MS;
 	}
 });
+Object.defineProperty(exports, "DEVICE_HISTORY_ENERGY_KEY", {
+	enumerable: true,
+	get: function() {
+		return DEVICE_HISTORY_ENERGY_KEY;
+	}
+});
 Object.defineProperty(exports, "DEVICE_NONCE_TTL_MS", {
 	enumerable: true,
 	get: function() {
@@ -88944,6 +89401,12 @@ Object.defineProperty(exports, "REMOVE_LEAF", {
 		return REMOVE_LEAF;
 	}
 });
+Object.defineProperty(exports, "ROOT_BUCKET_KEY", {
+	enumerable: true,
+	get: function() {
+		return ROOT_BUCKET_KEY;
+	}
+});
 Object.defineProperty(exports, "RUNTIME_DEFAULTS", {
 	enumerable: true,
 	get: function() {
@@ -89076,6 +89539,12 @@ Object.defineProperty(exports, "TokenScopeSchema", {
 		return TokenScopeSchema;
 	}
 });
+Object.defineProperty(exports, "UNATTRIBUTED_BUCKET_KEY", {
+	enumerable: true,
+	get: function() {
+		return UNATTRIBUTED_BUCKET_KEY;
+	}
+});
 Object.defineProperty(exports, "UnindexedFilterError", {
 	enumerable: true,
 	get: function() {