@camstack/types 1.2.387 → 1.2.389

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-6sOPE0EV.js");
+const require_sleep = require("./sleep-DKtoyk6X.js");
 const require_event_category = require("./event-category-eSqkye-K.js");
 const require_composition = require("./composition-eoYYVfOp.js");
 const require_node_color = require("./node-color.js");
@@ -15034,11 +15034,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",
@@ -15071,7 +15090,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()
 });
@@ -15085,17 +15110,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 = {
@@ -15111,6 +15150,25 @@ var QueryResultSchema = zod.z.object({
 	series: zod.z.array(QuerySeriesSchema).readonly(),
 	truncated: zod.z.boolean()
 });
+/** Items one `queryMany` may carry: a dashboard's worth, not a scan. */
+var DEVICE_HISTORY_QUERY_MANY_MAX_ITEMS = 24;
+/** 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. */
@@ -15179,26 +15237,45 @@ var deviceHistoryCapability = {
 		* `listNodeSeries` / `queryNode`.
 		*/
 		listSeries: require_sleep.method(zod.z.object({ deviceId: zod.z.number().int() }), zod.z.array(SeriesInfoSchema).readonly()),
-		listNodeSeries: require_sleep.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: require_sleep.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: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number().int(),
 			...QueryWindowShape
 		}), QueryResultSchema),
 		queryNode: require_sleep.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: require_sleep.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: require_sleep.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"])
@@ -40850,6 +40927,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",
@@ -40857,14 +41031,13 @@ var logDestinationCapability = {
 	internal: true,
 	methods: {
 		write: require_sleep.method(LogEntrySchema, zod.z.void(), { kind: "mutation" }),
-		query: require_sleep.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: require_sleep.optionalMethod(zod.z.void(), LogReadCapabilitiesSchema, { auth: "admin" }),
+		read: require_sleep.optionalMethod(LogReadQuerySchema, LogReadResultSchema, { auth: "admin" }),
+		cancelRead: require_sleep.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" }
@@ -43189,9 +43362,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"]
@@ -44184,6 +44359,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
@@ -44197,6 +44399,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
@@ -44243,16 +44447,29 @@ var NcLinkedCameraModeSchema = zod.z.enum(["mosaic", "each"]);
 var NC_CLIP_PRE_ROLL_DEFAULT_SEC = 4;
 var NC_CLIP_POST_ROLL_DEFAULT_SEC = 6;
 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
@@ -44438,7 +44655,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"
@@ -46010,13 +46229,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({
 	/**
@@ -60985,9 +61228,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"]
@@ -61871,11 +62116,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" }
+	} }
 };
 //#endregion
 //#region src/capabilities/doorbell.cap.ts
@@ -61996,9 +62252,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"]
@@ -64252,9 +64514,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"]
@@ -64430,9 +64693,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" }
+	} }
 };
 //#endregion
 //#region src/capabilities/mesh-network.cap.ts
@@ -67130,9 +67402,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,
@@ -71384,9 +71671,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"]
@@ -76327,6 +76634,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() {
@@ -76350,6 +76666,22 @@ var BaseDevice = class {
 		return (this.runtimeState.getCapState("feature-probe")?.lastProbedAt ?? 0) > 0;
 	}
 };
+function accessoryChildrenUnknown(reason, known) {
+	return known === void 0 ? {
+		kind: "unknown",
+		reason
+	} : {
+		kind: "unknown",
+		reason,
+		known
+	};
+}
+function accessoryChildrenComplete(children) {
+	return {
+		kind: "complete",
+		children
+	};
+}
 //#endregion
 //#region src/device/device-restore-retry.ts
 /**
@@ -81281,7 +81613,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,
@@ -90700,6 +91044,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"logDestination.read": [{
+		name: "deviceId",
+		form: "single",
+		optional: true
+	}],
 	"mediaPlayer.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -92467,6 +92816,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"faceGallery.getFaceByTrack",
 	"faceGallery.listRecentFaces",
 	"keychain.deleteDeviceScope",
+	"logDestination.read",
 	"networkQuality.getDeviceStats",
 	"networkQuality.reportClientStats",
 	"notificationRules.getAlarmSensors",
@@ -93062,7 +93412,7 @@ var BucketAccumulator = class {
 //#region src/generated/history-catalog.ts
 /**
 * 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 = {
@@ -93093,6 +93443,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",
@@ -93137,6 +93502,7 @@ var HISTORY_CATALOG = {
 			minIntervalMs: 0
 		}
 	},
+	"connectivity": { "connected": { kind: "boolean" } },
 	"contact": { "entryOpen": { kind: "boolean" } },
 	"cover": { "position": {
 		kind: "gauge",
@@ -93144,10 +93510,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": {
@@ -93182,6 +93586,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: [require_err_msg.DeviceType.Camera]
@@ -93268,6 +93690,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": {
@@ -93345,25 +93785,20 @@ var HISTORY_CATALOG = {
 };
 /** Caps that declared `history: 'none'`, sorted. */
 var HISTORY_NONE_CAPS = [
-	"alarm-panel",
 	"audio-metrics",
 	"automation-control",
 	"camera-streams",
 	"color",
-	"connectivity",
 	"consumables",
 	"control",
 	"day-night",
 	"device-discovery",
 	"doorbell",
-	"enum-sensor",
 	"event-emitter",
 	"feature-probe",
 	"image",
 	"image-settings",
 	"intercom",
-	"lock-control",
-	"media-player",
 	"motion-trigger",
 	"motion-zones",
 	"native-object-detection",
@@ -93376,7 +93811,6 @@ var HISTORY_NONE_CAPS = [
 	"scene-monitor",
 	"script-runner",
 	"stream-catalog",
-	"stream-params",
 	"stream-signals",
 	"update",
 	"zone-analytics",
@@ -93649,6 +94083,7 @@ function createSystemProxy(api) {
 		deviceHistory: {
 			listNodeSeries: (input) => dispatch("deviceHistory", "listNodeSeries", "query", input),
 			queryNode: (input) => dispatch("deviceHistory", "queryNode", "query", input),
+			queryMany: (input) => dispatch("deviceHistory", "queryMany", "query", input),
 			declareSeries: (input) => dispatch("deviceHistory", "declareSeries", "mutation", input),
 			record: (input) => dispatch("deviceHistory", "record", "mutation", input),
 			recordBuckets: (input) => dispatch("deviceHistory", "recordBuckets", "mutation", input),
@@ -95922,6 +96357,100 @@ function ruleEditorSectionsForKind(kind) {
 	return sections;
 }
 //#endregion
+//#region src/notification/media-image.ts
+/** Every mode, in the order an editor offers them. */
+var NC_MEDIA_IMAGE_MODES = [
+	"scene-boxes",
+	"crop",
+	"clean",
+	"none"
+];
+/**
+* The modes a rule of this kind can honour. A kind that carries no media gets
+* none (its row ships text, or — an alarm — its SOURCE rule's picture); a kind
+* whose subject has no region of the frame (a sound) is never offered `crop`.
+*/
+function imageModesForKind(kind) {
+	const spec = ruleKindSpec(kind);
+	if (!spec.carriesMedia) return [];
+	return spec.carriesSubjectCrop ? NC_MEDIA_IMAGE_MODES : NC_MEDIA_IMAGE_MODES.filter((mode) => mode !== "crop");
+}
+/**
+* The zone ids that FIRE a rule: its `zones` condition, or an occupancy rule's
+* own scoped zone. Empty when the trigger is not a zone — and then
+* `showTriggerZone` has nothing to draw and is refused on save.
+*/
+function ruleTriggerZoneIds(conditions) {
+	if (conditions.zones !== void 0) return conditions.zones.ids;
+	const zoneId = conditions.occupancy?.zoneId;
+	return zoneId !== void 0 ? [zoneId] : [];
+}
+/**
+* What the legacy triple MEANT, as a mode. `zoneCrop` forced the clean
+* keyFrame ladder and dropped `frame`, so it is `clean` whatever else was set;
+* `frame` decided over `attach` when present; `keyFrame` was the clean scene;
+* every other still (`best`, `best-matching`, the default) was the subject.
+*/
+function legacyImageMode(media) {
+	if (media.attach === "none") return "none";
+	if (media.zoneCrop === true) return "clean";
+	if (media.frame === "full") return "clean";
+	if (media.frame === "boxed") return "scene-boxes";
+	if (media.frame === "cropped") return "crop";
+	if (media.attach === "keyFrame") return "clean";
+	return "crop";
+}
+/** A mode the kind cannot honour, mapped to the nearest one it can. */
+function clampToKind(mode, kind) {
+	const offered = imageModesForKind(kind);
+	if (offered.length === 0 || offered.includes(mode)) return mode;
+	return mode === "crop" ? "clean" : mode;
+}
+/**
+* The mode a rule's picture is rendered in. `image` when stored; else what the
+* legacy triple meant — and, for a SENSOR rule written before D897, `clean`
+* whatever it stored (even `attach: 'none'`), because its stored triple was
+* ignored and one plain snapshot always shipped (operator ruling, 2026-10-01):
+* the migration keeps what the rule actually DID. Clamped to what the kind can
+* honour.
+*/
+function resolveNcMediaImage(media, kind) {
+	if (media.image !== void 0) return clampToKind(media.image, kind);
+	if (kind === "sensor") return "clean";
+	return clampToKind(legacyImageMode(media), kind);
+}
+/**
+* The stored shape of a media policy: `image` set, the legacy triple gone.
+* `showTriggerZone` survives only where it can be drawn — a zone trigger and a
+* mode other than `crop`/`none`; a legacy `zoneCrop` on a zone rule becomes it.
+* Every other field (gif, clip, rolls, speed, profile, linked cameras) is
+* carried through untouched. Pure; never throws.
+*/
+function normalizeNcMediaPolicy(media, rule) {
+	const image = resolveNcMediaImage(media, ruleKindOf(rule));
+	const { attach: _attach, frame: _frame, zoneCrop, showTriggerZone, image: _image, ...rest } = media;
+	const drawable = (showTriggerZone === true || media.image === void 0 && zoneCrop === true) && image !== "crop" && image !== "none" && ruleTriggerZoneIds(rule.conditions).length > 0;
+	return {
+		...rest,
+		image,
+		...drawable ? { showTriggerZone: true } : {}
+	};
+}
+/**
+* Why a media policy cannot be SAVED on this rule, or null. Server-side and
+* editor alike: `showTriggerZone` on a rule whose trigger is not a zone, and a
+* mode the rule's kind cannot honour.
+*/
+function ncMediaPolicyError(media, rule) {
+	const kind = ruleKindOf(rule);
+	if (media.image !== void 0) {
+		const offered = imageModesForKind(kind);
+		if (offered.length > 0 && !offered.includes(media.image)) return `media.image '${media.image}' is not available for a ${kind} rule (offered: ${offered.join(", ")})`;
+	}
+	if (media.showTriggerZone === true && ruleTriggerZoneIds(rule.conditions).length === 0) return "media.showTriggerZone needs a rule triggered by a zone (a zones condition or an occupancy zone)";
+	return null;
+}
+//#endregion
 //#region src/notification/schedule.ts
 var WEEKDAY_TO_DAY = {
 	Sun: 0,
@@ -102797,6 +103326,43 @@ function bindAddonActions(api, addonId, catalog) {
 	return out;
 }
 //#endregion
+//#region src/inference/coral-units.ts
+/** 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 KEY_DEVICE = /^(usb|pci)(?::(\d+))?$/;
+/**
+* Map an edgetpu key suffix (`usb`, `usb:1`, `pci`, `pci:1`) to the explicit
+* libedgetpu device string (`usb:0`, `usb:1`, `pci:0`, `pci:1`). Throws on any
+* other string — a pool must never open "whichever Edge TPU comes first".
+*/
+function edgetpuDelegateDevice(device) {
+	const match = KEY_DEVICE.exec(device.trim());
+	if (match === null) throw new Error(`edgetpu device "${device}" is not usb[:N] or pci[:N]`);
+	const [, bus, ordinal] = match;
+	return `${bus}:${ordinal ?? "0"}`;
+}
+//#endregion
 //#region src/inference/runtime-capabilities.ts
 var AUTO = {
 	value: "auto",
@@ -102810,6 +103376,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",
@@ -102876,8 +103450,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"
 	}
 ];
@@ -102921,7 +103498,7 @@ function modelFormatForRuntime(id) {
 * - 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`.
@@ -102975,7 +103552,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",
@@ -103034,11 +103611,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")) {
@@ -103579,6 +104152,8 @@ exports.DEVICE_CHILDREN_BATCH_MAX = require_sleep.DEVICE_CHILDREN_BATCH_MAX;
 exports.DEVICE_DEFINITIVE_REFUSALS_BEFORE_DELETE = DEVICE_DEFINITIVE_REFUSALS_BEFORE_DELETE;
 exports.DEVICE_DO_ACTIONS = DEVICE_DO_ACTIONS;
 exports.DEVICE_ENROLLMENT_TTL_MS = DEVICE_ENROLLMENT_TTL_MS;
+exports.DEVICE_HISTORY_ENERGY_KEY = DEVICE_HISTORY_ENERGY_KEY;
+exports.DEVICE_HISTORY_QUERY_MANY_MAX_ITEMS = DEVICE_HISTORY_QUERY_MANY_MAX_ITEMS;
 exports.DEVICE_NONCE_TTL_MS = DEVICE_NONCE_TTL_MS;
 exports.DEVICE_PROFILES = DEVICE_PROFILES;
 exports.DEVICE_RAMP = DEVICE_RAMP;
@@ -103637,6 +104212,7 @@ exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
 exports.DeviceExportUnexposeInputSchema = UnexposeInputSchema;
 exports.DeviceFeature = require_err_msg.DeviceFeature;
 exports.DeviceHistoryKindSchema = DeviceHistoryKindSchema;
+exports.DeviceHistoryProducerKindSchema = DeviceHistoryProducerKindSchema;
 exports.DeviceHistoryRefusalReasonSchema = DeviceHistoryRefusalReasonSchema;
 exports.DeviceHistoryResolutionSchema = DeviceHistoryResolutionSchema;
 exports.DeviceHistoryStatusSchema = DeviceHistoryStatusSchema;
@@ -103979,6 +104555,10 @@ exports.LogChannelWindowSchema = LogChannelWindowSchema;
 exports.LogChannelWindowStateSchema = LogChannelWindowStateSchema;
 exports.LogEntrySchema = LogEntrySchema;
 exports.LogLevelSchema = LogLevelSchema;
+exports.LogReadCapabilitiesSchema = LogReadCapabilitiesSchema;
+exports.LogReadEntrySchema = LogReadEntrySchema;
+exports.LogReadQuerySchema = LogReadQuerySchema;
+exports.LogReadResultSchema = LogReadResultSchema;
 exports.LogStreamEntrySchema = LogStreamEntrySchema;
 exports.LoggingEffectiveSchema = LoggingEffectiveSchema;
 exports.LoggingExplicitSchema = LoggingExplicitSchema;
@@ -104160,6 +104740,7 @@ exports.NC_GROUPING_MIN_SEC = NC_GROUPING_MIN_SEC;
 exports.NC_HISTORY_LIMIT_DEFAULT = NC_HISTORY_LIMIT_DEFAULT;
 exports.NC_HISTORY_LIMIT_MAX = NC_HISTORY_LIMIT_MAX;
 exports.NC_MAX_PER_TRACK_IMMEDIATE = NC_MAX_PER_TRACK_IMMEDIATE;
+exports.NC_MEDIA_IMAGE_MODES = NC_MEDIA_IMAGE_MODES;
 exports.NC_OCCUPANCY_DEFAULTS = NC_OCCUPANCY_DEFAULTS;
 exports.NC_RULE_CLEARABLE_KEYS = NC_RULE_CLEARABLE_KEYS;
 exports.NC_RULE_EDITOR_SECTION_ORDER = NC_RULE_EDITOR_SECTION_ORDER;
@@ -104258,6 +104839,7 @@ exports.NcHookBindingsSchema = NcHookBindingsSchema;
 exports.NcLegacyRuleActionSequenceSchema = NcLegacyRuleActionSequenceSchema;
 exports.NcLinkedCameraModeSchema = NcLinkedCameraModeSchema;
 exports.NcMediaFrameSchema = NcMediaFrameSchema;
+exports.NcMediaImageSchema = NcMediaImageSchema;
 exports.NcMediaPolicySchema = NcMediaPolicySchema;
 exports.NcOccupancyConditionSchema = NcOccupancyConditionSchema;
 exports.NcPlateMatcherSchema = NcPlateMatcherSchema;
@@ -105032,6 +105614,8 @@ exports.ZoneScopeBreakdownSchema = ZoneScopeBreakdownSchema;
 exports.__resetLogChannelRegistryForTests = __resetLogChannelRegistryForTests;
 exports.acceleratorKindOf = acceleratorKindOf;
 exports.accessoriesCapability = accessoriesCapability;
+exports.accessoryChildrenComplete = accessoryChildrenComplete;
+exports.accessoryChildrenUnknown = accessoryChildrenUnknown;
 exports.accessoryStableId = accessoryStableId;
 exports.actionsForBoundCaps = actionsForBoundCaps;
 exports.actionsForDevice = actionsForDevice;
@@ -105205,6 +105789,7 @@ exports.containingParentIndex = containingParentIndex;
 exports.controlCapability = controlCapability;
 exports.convertPresetFeature = convertPresetFeature;
 exports.convertUnit = convertUnit;
+exports.coralUsableUnits = coralUsableUnits;
 exports.coreBlockAddonId = coreBlockAddonId;
 exports.coreBlockComposition = coreBlockComposition;
 exports.coreBlockIdFromAddonId = coreBlockIdFromAddonId;
@@ -105297,6 +105882,7 @@ exports.doActionSelectValue = doActionSelectValue;
 exports.doorbellCapability = doorbellCapability;
 exports.doorbellFeatureSources = doorbellFeatureSources;
 exports.droppedConditionsForKind = droppedConditionsForKind;
+exports.edgetpuDelegateDevice = edgetpuDelegateDevice;
 exports.effectiveStepSettings = effectiveStepSettings;
 exports.egressTranscodeSharingKey = egressTranscodeSharingKey;
 exports.egressTransportFromRequest = egressTransportFromRequest;
@@ -105402,6 +105988,7 @@ exports.iconCategoryLabel = iconCategoryLabel;
 exports.iconEntry = iconEntry;
 exports.iconsInCategory = iconsInCategory;
 exports.imageCapability = imageCapability;
+exports.imageModesForKind = imageModesForKind;
 exports.imageSettingsCapability = imageSettingsCapability;
 exports.inferExpressionKinds = inferExpressionKinds;
 exports.inferModelProvider = inferModelProvider;
@@ -105494,6 +106081,7 @@ exports.knownSecretCount = require_sleep.knownSecretCount;
 exports.knownValues = knownValues;
 exports.lawnMowerControlCapability = lawnMowerControlCapability;
 exports.legacyAutoLinkIds = legacyAutoLinkIds;
+exports.legacyImageMode = legacyImageMode;
 exports.legacyModeOf = legacyModeOf;
 exports.lifecycleJobSchema = lifecycleJobSchema;
 exports.lifecycleJobScopeSchema = lifecycleJobScopeSchema;
@@ -105556,6 +106144,7 @@ exports.mqttBrokerCapability = mqttBrokerCapability;
 exports.nativeObjectDetectionCapability = nativeObjectDetectionCapability;
 exports.navigationCapability = navigationCapability;
 exports.ncAlarmSystemDefaultSettings = ncAlarmSystemDefaultSettings;
+exports.ncMediaPolicyError = ncMediaPolicyError;
 exports.networkAccessCapability = networkAccessCapability;
 exports.networkLinkCapability = networkLinkCapability;
 exports.networkQualityCapability = networkQualityCapability;
@@ -105567,6 +106156,7 @@ exports.nodesCapability = nodesCapability;
 exports.normalizeAddonInitResult = require_sleep.normalizeAddonInitResult;
 exports.normalizeAudioLabel = normalizeAudioLabel;
 exports.normalizeCoreBlockWrite = normalizeCoreBlockWrite;
+exports.normalizeNcMediaPolicy = normalizeNcMediaPolicy;
 exports.normalizeNodeId = require_sleep.normalizeNodeId;
 exports.normalizeOrigin = normalizeOrigin;
 exports.normalizeSecretOwner = require_sleep.normalizeSecretOwner;
@@ -105724,6 +106314,7 @@ exports.resolveModeDelays = resolveModeDelays;
 exports.resolveModeNotifyPolicy = resolveModeNotifyPolicy;
 exports.resolveModelBoundSetting = resolveModelBoundSetting;
 exports.resolveMutate = resolveMutate;
+exports.resolveNcMediaImage = resolveNcMediaImage;
 exports.resolveNotificationTapAddress = resolveNotificationTapAddress;
 exports.resolvePoolMemoryPolicy = resolvePoolMemoryPolicy;
 exports.resolvePublicEndpoint = resolvePublicEndpoint;
@@ -105757,6 +106348,7 @@ exports.ruleMatchesSection = ruleMatchesSection;
 exports.ruleSection = ruleSection;
 exports.ruleSectionOf = ruleSectionOf;
 exports.ruleSeedForSection = ruleSeedForSection;
+exports.ruleTriggerZoneIds = ruleTriggerZoneIds;
 exports.runInferenceStep = runInferenceStep;
 exports.runtimeDevices = runtimeDevices;
 exports.runtimeStatePolicyFor = runtimeStatePolicyFor;