@camstack/types 1.2.400 → 1.2.402

package/dist/index.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-CD18m9HF.js");
+const require_sleep = require("./sleep-DVovpDRU.js");
 const require_event_category = require("./event-category-7AwNbPjm.js");
 const require_composition = require("./composition-eoYYVfOp.js");
 const require_node_color = require("./node-color.js");
@@ -8450,7 +8450,11 @@ var ConfigSectionWithValuesSchema = zod.z.object({
 		zod.z.literal(4)
 	]).optional(),
 	tab: zod.z.string().optional(),
-	location: zod.z.enum(["settings", "top-tab"]).optional(),
+	location: zod.z.enum([
+		"settings",
+		"top-tab",
+		"hero"
+	]).optional(),
 	order: zod.z.number().optional(),
 	fields: zod.z.array(zod.z.any())
 });
@@ -15114,6 +15118,56 @@ var TierStatusSchema = zod.z.object({
 	countedAt: zod.z.number().nullable()
 });
 /** Operator/diagnostic view: rows per tier, last runs, refusals and drops since boot. */
+/**
+* Why a series is orphan. `device-gone`: its device is absent from the
+* successful device listings (the departure clock). `undeclared`: its `cap:`
+* key is declared by no capability any more (a field a cap removed).
+*/
+var DeviceHistoryOrphanReasonSchema = zod.z.enum(["device-gone", "undeclared"]);
+/** Rows held per stored tier. */
+var TierRowsSchema = zod.z.object({
+	raw: zod.z.number().int(),
+	"5m": zod.z.number().int(),
+	"1h": zod.z.number().int(),
+	"1d": zod.z.number().int()
+});
+var OrphanSeriesSchema = zod.z.object({
+	seriesId: zod.z.number().int(),
+	deviceId: zod.z.number().int(),
+	key: zod.z.string(),
+	scope: zod.z.string(),
+	/** The metric's display name; `null` when its metric row is gone too. */
+	displayName: zod.z.string().nullable(),
+	reason: DeviceHistoryOrphanReasonSchema,
+	/** `device-gone`: since when the device has been absent; `null` otherwise. */
+	missingSince: zod.z.number().nullable(),
+	firstTs: zod.z.number(),
+	lastTs: zod.z.number(),
+	rows: TierRowsSchema
+});
+/** At most this many orphans are listed (with their row counts) per call. */
+var DEVICE_HISTORY_ORPHAN_LIST_MAX = 200;
+/** At most this many series are deleted per call. */
+var DEVICE_HISTORY_ORPHAN_DELETE_MAX = 50;
+var DeviceHistoryOrphanDeleteRefusalSchema = zod.z.enum([
+	"not-found",
+	"not-orphan",
+	"failed"
+]);
+var OrphanDeleteEntrySchema = zod.z.discriminatedUnion("ok", [zod.z.object({
+	seriesId: zod.z.number().int(),
+	ok: zod.z.literal(true),
+	deleted: TierRowsSchema
+}), zod.z.object({
+	seriesId: zod.z.number().int(),
+	ok: zod.z.literal(false),
+	reason: DeviceHistoryOrphanDeleteRefusalSchema
+})]);
+var OrphanListSchema = zod.z.object({
+	series: zod.z.array(OrphanSeriesSchema).readonly(),
+	/** More orphans exist than {@link DEVICE_HISTORY_ORPHAN_LIST_MAX}. */
+	truncated: zod.z.boolean()
+});
 var DeviceHistoryStatusSchema = zod.z.object({
 	startedAt: zod.z.number(),
 	/** The store is declared, series loaded and the first reconcile has answered. */
@@ -15255,7 +15309,24 @@ var deviceHistoryCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getStatus: require_sleep.method(zod.z.object({}), DeviceHistoryStatusSchema, { auth: "admin" })
+		getStatus: require_sleep.method(zod.z.object({}), DeviceHistoryStatusSchema, { auth: "admin" }),
+		/**
+		* Device series no longer linked to a device (D917): the device is absent
+		* from the listings, or the key is declared by no capability. REPORTED,
+		* never purged by this judgement; each entry counts its rows per tier
+		* (a primary-key range per series). Ordered by device, key, scope.
+		*/
+		listOrphanSeries: require_sleep.method(zod.z.object({}), OrphanListSchema, { auth: "admin" }),
+		/**
+		* Delete orphan series by id. Each id is re-judged NOW: a series that is
+		* not orphan (its device came back) is refused `not-orphan`, an unknown id
+		* `not-found`. Deletes tier by tier in the retention slices, then the
+		* series row; one entry per id, in order.
+		*/
+		deleteOrphanSeries: require_sleep.method(zod.z.object({ seriesIds: zod.z.array(zod.z.number().int()).min(1).max(50) }), zod.z.object({ results: zod.z.array(OrphanDeleteEntrySchema).readonly() }), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -54054,6 +54125,19 @@ var NodeInferenceDeviceSchema = zod.z.object({
 	/** Whether the node's live probe reports the device as usable right now. */
 	available: zod.z.boolean(),
 	/**
+	* Is the device on the node at all (D919)? `present` — the live probe
+	* reported it; `absent` — the probe ANSWERED and did not report it, so only
+	* its stored settings remain (unplugged, moved to another node): never
+	* eligible, whatever its stored `enabled`, and forgettable with
+	* `forgetInferenceDevice`; `unknown` — the probe did not answer, nothing is
+	* claimed (D315). Optional only for an orchestrator older than the field.
+	*/
+	presence: zod.z.enum([
+		"present",
+		"absent",
+		"unknown"
+	]).optional(),
+	/**
 	* Whether this device participates in dispatch. AUTO default (spec C2):
 	* accelerators are opt-OUT (a discovered NPU/iGPU/Coral/ANE with no stored
 	* entry is `true`); CPU is opt-IN (`false` by default — the fallback pool,
@@ -54491,6 +54575,20 @@ var pipelineOrchestratorCapability = {
 		*/
 		getNodeInferenceDevices: require_sleep.method(zod.z.object({ nodeId: zod.z.string() }), NodeInferenceDevicesSchema),
 		/**
+		* Delete ONE stored device entry of a node — the "forget" of a device the
+		* node no longer has (D919). Refused unless the node's probe ANSWERED and
+		* did not report the key: a present device is switched off, not forgotten,
+		* and an unreachable node proves nothing about its hardware. The rest of
+		* the node's map is kept as stored.
+		*/
+		forgetInferenceDevice: require_sleep.method(zod.z.object({
+			agentNodeId: zod.z.string(),
+			deviceKey: zod.z.string()
+		}), zod.z.object({ success: zod.z.literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
 		* Reset one node's pipeline to its hardware-aware defaults — the HONEST
 		* reset (replaces the executor's legacy `resetToDefault`, which cleared a
 		* dead persisted step-tree seed nothing in the live path read):
@@ -61209,17 +61307,88 @@ var connectivityCapability = {
 //#endregion
 //#region src/capabilities/consumables.cap.ts
 /**
-* Generic device-consumables capability — surfaces a device's
-* maintenance items (vacuum filters/brushes, replaceable cartridges,
-* descaling cycles, …) with their remaining life and an optional
-* "Replaced" reset action. Device-agnostic: any provider that knows its
-* device tracks consumables can register it; the cap declares no
-* vocabulary of its own — the provider names each item verbatim.
+* Generic device-consumables capability — the ONE place a device reports what
+* it uses up or fills: wear parts (vacuum filters/brushes, cartridges,
+* descaling cycles), supplies it draws from (a vacuum's clean-water tank and
+* detergent, a dishwasher's salt and rinse aid) and waste it collects (a dirty
+* water tank, a dust bin). Each item carries its remaining life or fill and an
+* optional "Replaced" reset action. Device-agnostic: any provider that knows
+* its device tracks consumables registers it; the provider names each item
+* verbatim and says which `kind` it is.
+*
+* The admin UI renders it as ONE collapsible section directly under the
+* device page's hero card (`placement: 'hero'`), for every device bound to
+* this cap — never drawn by a device type's hero card itself (D915).
 *
 * Like `childLayout`, the cap is INERT until a provider sets items: no
 * provider populates it by guessing (no HA inference). The UI renders a
 * "No consumables reported" placeholder when `items` is empty.
 */
+/**
+* What an item IS, which decides which direction is bad:
+*  - `wear`   — a part that wears out (a brush, a filter); low life is bad.
+*  - `supply` — something the device draws from (clean water, detergent,
+*    salt, rinse aid); low or empty is bad.
+*  - `waste`  — something the device fills (dirty water, a dust bin); full is
+*    bad.
+* Absent = `wear`.
+*/
+var ConsumableKindSchema = zod.z.enum([
+	"wear",
+	"supply",
+	"waste"
+]);
+/**
+* What an item LOOKS like, which decides how a client draws it — independent
+* of `kind`, which decides which direction is bad:
+*  - `part`    — a part that wears (a brush, a filter, a mop pad): a wear bar,
+*    remaining time and a reset.
+*  - `tank`    — a container of liquid (clean water, dirty water): a fill gauge.
+*  - `product` — something bought and refilled (detergent, salt, rinse aid):
+*    a stepped level and "refill".
+*  - `bin`     — a container that collects waste (a dust bin): a fill gauge
+*    that warns when full.
+* Absent = derived from the kind ({@link consumableFormOf}).
+*/
+var ConsumableFormSchema = zod.z.enum([
+	"part",
+	"tank",
+	"product",
+	"bin"
+]);
+/** The provider's own discrete verdict on an item. */
+var ConsumableStatusSchema = zod.z.enum([
+	"ok",
+	"low",
+	"empty",
+	"full",
+	"replace"
+]);
+/**
+* The level vocabulary every client draws a consumable in (badge tone, bar
+* colour): derived from an item by its kind, level and status. `null` beside
+* it means unknown (D393).
+*/
+var ConsumableLevelSchema = zod.z.enum([
+	"ok",
+	"low",
+	"empty",
+	"full"
+]);
+/** The kind of an item, with the documented default for an absent one. */
+function consumableKindOf(item) {
+	return item.kind ?? "wear";
+}
+/** The kind's default form: wear → part, waste → bin, supply → product. */
+var FORM_OF_KIND = {
+	wear: "part",
+	waste: "bin",
+	supply: "product"
+};
+/** The form of an item: its own when the provider names one, else its kind's default. */
+function consumableFormOf(item) {
+	return item.form ?? FORM_OF_KIND[consumableKindOf(item)];
+}
 /** Units a remaining-life counter is reported in. Closed: the panel renders
 *  each. */
 var ConsumableRemainingUnitSchema = zod.z.enum([
@@ -61234,18 +61403,23 @@ var ConsumableRemainingSchema = zod.z.object({
 	unit: ConsumableRemainingUnitSchema
 });
 /** A single consumable item. Either a continuous `level` (remaining
-*  life %) or a discrete `status` may be known — both may be null when a
-*  provider only knows the item exists. `level` and `status` are not
-*  mutually exclusive; a provider may report both. */
+*  life %, or fill % for a `supply` / `waste` item) or a discrete `status`
+*  may be known — both may be null when a provider only knows the item
+*  exists. `level` and `status` are not mutually exclusive; a provider may
+*  report both. */
 var ConsumableItemSchema = zod.z.object({
 	/** Stable id, e.g. 'main-brush'. */
 	key: zod.z.string().min(1),
 	/** Display name. */
 	label: zod.z.string().min(1),
-	/** Remaining life % when known (0..100). */
+	/** Remaining life % (`wear`) or fill % (`supply`, `waste`) when known (0..100). */
 	level: zod.z.number().min(0).max(100).nullable(),
-	/** Discrete state when known (binary mode). */
-	status: zod.z.enum(["ok", "replace"]).nullable(),
+	/** The provider's discrete verdict when known (binary mode). */
+	status: ConsumableStatusSchema.nullable(),
+	/** What the item is — decides whether low or full is bad. Absent = `wear`. */
+	kind: ConsumableKindSchema.optional(),
+	/** How the item is drawn (part, tank, product, bin). Absent = derived from `kind`. */
+	form: ConsumableFormSchema.optional(),
 	/** Ms epoch of the last replace, when known. */
 	lastResetAt: zod.z.number().nullable(),
 	/** Whether `reset()` is meaningful for this item. */
@@ -61268,7 +61442,7 @@ var consumablesCapability = {
 		kind: "widget",
 		widgetId: "host/consumables-panel",
 		tab: "consumables",
-		topTab: true,
+		placement: "hero",
 		label: "Consumables",
 		order: 5
 	} },
@@ -61329,9 +61503,37 @@ reset: require_sleep.method(zod.z.object({
 	*/
 	durability: "restored",
 	/**
-	* History (D850): none — `items` is an array keyed by runtime ids; a history path never enters it.
+	* History (D850, D917): one series per (item field, item `key`) — the item key
+	* is the series scope, the item `label` names it. A vacuum tank's fill, a
+	* brush's remaining life and a dishwasher's salt are each recorded the moment
+	* their provider reports them; an item that appears later gets its series.
 	*/
-	history: "none",
+	history: {
+		fields: {},
+		items: {
+			path: "items",
+			key: "key",
+			label: "label",
+			fields: {
+				level: {
+					kind: "gauge",
+					unit: "%",
+					deadband: 2,
+					displayName: "Level"
+				},
+				status: {
+					kind: "enum",
+					displayName: "Status"
+				},
+				"remaining.value": {
+					kind: "gauge",
+					unitFrom: "remaining.unit",
+					deadband: 1,
+					displayName: "Remaining"
+				}
+			}
+		}
+	},
 	/** Clocks, not content: a re-read that changed no item costs no commit. */
 	volatileStateFields: ["lastChangedAt", "lastFetchedAt"]
 };
@@ -61804,8 +62006,9 @@ onStatusChanged: { data: zod.z.object({
 //#endregion
 //#region src/capabilities/dishwasher.cap.ts
 /**
-* Smart-dishwasher cap — program lifecycle, door / remote-start gates,
-* consumable levels (salt, rinse aid) and common program options.
+* Smart-dishwasher cap — program lifecycle, door / remote-start gates and
+* common program options. Salt and rinse aid are NOT here: they are items of
+* the device's `consumables` cap, like every other device's (D915).
 *
 * Sources: native Bosch Home Connect (`dishwasher` device type). Reusable
 * by any integration that exposes the same program / option surface.
@@ -61853,11 +62056,6 @@ var DishwasherAvailabilitySchema = zod.z.enum([
 	"offline",
 	"description-missing"
 ]);
-var DishwasherConsumableLevelSchema = zod.z.enum([
-	"ok",
-	"low",
-	"empty"
-]);
 var DishwasherStatusSchema = zod.z.object({
 	availability: DishwasherAvailabilitySchema,
 	/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
@@ -61890,8 +62088,6 @@ var DishwasherStatusSchema = zod.z.object({
 	powerOn: zod.z.boolean().nullable(),
 	/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
 	powerState: zod.z.string().nullable(),
-	saltLevel: DishwasherConsumableLevelSchema.nullable(),
-	rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
 	/**
 	* True while the appliance asks for its filter to be cleaned (smart-filter, filter-system or
 	* combined care-and-filter reminder raised); false when every such reminder reads clear; null
@@ -65145,7 +65341,7 @@ var motionTriggerCapability = {
 		enabled: zod.z.boolean()
 	}), zod.z.void(), {
 		kind: "mutation",
-		auth: "admin"
+		auth: "protected"
 	}) },
 	events: { onMotionTriggerChanged: { data: zod.z.object({
 		deviceId: zod.z.number(),
@@ -66075,6 +66271,13 @@ var TopologyNodeSchema = zod.z.object({
 	cpuModel: zod.z.string().nullable(),
 	cpuCores: zod.z.number(),
 	memoryMB: zod.z.number(),
+	/**
+	* The inference RUNTIMES installed on the node (`pythonRuntimes`: onnx,
+	* openvino, edgetpu …) — not its devices. An installed runtime says nothing
+	* about whether its hardware is there (a Coral delegate stays installed
+	* after the stick leaves, D919); the live device set is
+	* `pipelineOrchestrator.getNodeInferenceDevices`.
+	*/
 	engines: zod.z.array(zod.z.string()).readonly(),
 	isHub: zod.z.boolean(),
 	isOnline: zod.z.boolean(),
@@ -67454,6 +67657,24 @@ var ResolvedInferenceConfigSchema = zod.z.object({
 	format: ModelFormatSchema,
 	reason: zod.z.string()
 });
+/**
+* The answer of an accelerator rescan (D919): the node's device list after
+* the re-probe, what changed, and the evidence that decided the Coral answer
+* (`usbBus` — could the USB bus be read at all; `decidedBy` — USB ids, the PCI
+* bus, the installed-delegate fallback, or nothing).
+*/
+var AcceleratorRescanSchema = zod.z.object({
+	devices: zod.z.array(InferenceDeviceDescriptorSchema).readonly(),
+	appeared: zod.z.array(zod.z.string()).readonly(),
+	disappeared: zod.z.array(zod.z.string()).readonly(),
+	usbBus: zod.z.enum(["observed", "unobservable"]),
+	decidedBy: zod.z.enum([
+		"usb-ids",
+		"pci",
+		"delegate-fallback",
+		"none"
+	])
+});
 var platformProbeCapability = {
 	name: "platform-probe",
 	scope: "system",
@@ -67462,7 +67683,18 @@ var platformProbeCapability = {
 		getCapabilities: require_sleep.method(zod.z.void(), PlatformCapabilitiesSchema),
 		getHardware: require_sleep.method(zod.z.void(), HardwareInfoSchema),
 		resolveInferenceConfig: require_sleep.method(zod.z.object({ requirements: zod.z.array(ModelRequirementSchema).readonly() }), ResolvedInferenceConfigSchema),
-		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema)
+		resolveHwAccel: require_sleep.method(zod.z.object({ prefer: HwAccelBackendInputSchema }), HwAccelResolutionSchema),
+		/**
+		* Re-probe this node's accelerators NOW (Coral USB ids + PCIe apex units;
+		* `/sys` and `/dev` reads, no model load) and rebuild the device list that
+		* `getCapabilities` serves. The same re-probe runs every 60 s on its own;
+		* this is the operator's "rescan inference devices". Target a node with the
+		* `{ nodeId }` routing input, like `getCapabilities`.
+		*/
+		rescanAccelerators: require_sleep.method(zod.z.void(), AcceleratorRescanSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 //#endregion
@@ -73144,14 +73376,9 @@ var userManagementCapability = {
 * validates it against the vacuum's own list. `locate` triggers the
 * find-me chirp; `returnToBase` sends it home.
 *
-* Consumable / waste tanks: `cleanWater` / `dirtyWater` / `detergent` /
-* `dustBin` each carry a nullable `{ level (0..100 %), status ('ok' |
-* 'low' | 'full') }` reading. Native providers (e.g. Dreame, Roborock)
-* SHOULD populate whichever tanks the hardware has — leave a field `null`
-* only when the device has no such tank at all, and use a `TankStatus`
-* with both inner fields `null` when the tank exists but its level is
-* currently unknown. HA `vacuum.*` entities expose no per-tank telemetry,
-* so the HA provider leaves all four `null`.
+* Tanks (clean water, dirty water, detergent, dust bin) are NOT here: they
+* are `supply` / `waste` items of the device's `consumables` cap, like every
+* other device's consumables (D915).
 */
 var VacuumStateSchema = zod.z.enum([
 	"idle",
@@ -73162,23 +73389,6 @@ var VacuumStateSchema = zod.z.enum([
 	"drying",
 	"error"
 ]);
-/**
-* One consumable / waste tank on a robot vacuum (clean-water, dirty-water,
-* detergent or dust-bin). A tank can report a numeric fill `level` (0..100),
-* a discrete `status` (binary-style hardware), or both. Both `null` means the
-* level is currently unknown; the OWNING field being `null` means the
-* hardware has no such tank at all.
-*/
-var TankStatusSchema = zod.z.object({
-	/** Numeric fill 0..100 when the hardware reports a percentage; null otherwise. */
-	level: zod.z.number().min(0).max(100).nullable(),
-	/** Discrete state when the hardware is binary-mode; null otherwise. */
-	status: zod.z.enum([
-		"ok",
-		"low",
-		"full"
-	]).nullable()
-});
 var VacuumControlStatusSchema = zod.z.object({
 	/** Lifecycle state of the vacuum. */
 	state: VacuumStateSchema,
@@ -73190,14 +73400,6 @@ var VacuumControlStatusSchema = zod.z.object({
 	fanSpeed: zod.z.string().nullable(),
 	/** Speed tokens the hardware accepts — drives the UI selector. */
 	availableFanSpeeds: zod.z.array(zod.z.string()),
-	/** Clean-water (mop) tank. Null when the hardware has no clean-water tank. */
-	cleanWater: TankStatusSchema.nullable(),
-	/** Dirty-water (recovery) tank. Null when the hardware has no dirty-water tank. */
-	dirtyWater: TankStatusSchema.nullable(),
-	/** Detergent tank. Null when the hardware has no detergent tank. */
-	detergent: TankStatusSchema.nullable(),
-	/** Dust bin. Null when the hardware has no dust bin. */
-	dustBin: TankStatusSchema.nullable(),
 	/** 0..100 cleaning-completion percentage of the current task, or null. */
 	progressPercent: zod.z.number().min(0).max(100).nullable(),
 	/** Current error code (0 / null = no error). */
@@ -73259,35 +73461,14 @@ var vacuumControlCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): recorded series. Tank levels are fixed-object paths (`cleanWater.level`, ...).
+	* History (D850): recorded series. The tanks moved to `consumables` (D915), whose
+	* items are keyed by runtime ids and record no history.
 	*/
-	history: { fields: {
-		batteryLevel: {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"cleanWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dirtyWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"detergent.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dustBin.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		}
-	} }
+	history: { fields: { batteryLevel: {
+		kind: "gauge",
+		unit: "%",
+		deadband: 2
+	} } }
 };
 //#endregion
 //#region src/capabilities/valve.cap.ts
@@ -79805,6 +79986,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceHistory.deleteOrphanSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"deviceHistory.getDeviceEnabled": {
 		capName: "device-history",
 		capScope: "system",
@@ -79823,6 +80010,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceHistory.listOrphanSeries": {
+		capName: "device-history",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceHistory.listSeries": {
 		capName: "device-history",
 		capScope: "system",
@@ -83447,6 +83640,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
+	"pipelineOrchestrator.forgetInferenceDevice": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -84023,6 +84222,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"platformProbe.rescanAccelerators": {
+		capName: "platform-probe",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"platformProbe.resolveHwAccel": {
 		capName: "platform-probe",
 		capScope: "system",
@@ -93343,7 +93548,7 @@ var BucketAccumulator = class {
 //#region src/generated/history-catalog.ts
 /**
 * Cap history catalog, projected from every `*.cap.ts` `history` block.
-* 40 caps with series (77 series), 31 caps answered `'none'`.
+* 40 caps with series (73 series), 30 caps answered `'none'`.
 * Field keys are `runtimeState` paths (`a.b` into fixed objects only).
 */
 var HISTORY_CATALOG = {
@@ -93646,33 +93851,11 @@ var HISTORY_CATALOG = {
 		unit: "°C",
 		deadband: .1
 	} },
-	"vacuum-control": {
-		"batteryLevel": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"cleanWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dirtyWater.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"detergent.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		},
-		"dustBin.level": {
-			kind: "gauge",
-			unit: "%",
-			deadband: 2
-		}
-	},
+	"vacuum-control": { "batteryLevel": {
+		kind: "gauge",
+		unit: "%",
+		deadband: 2
+	} },
 	"valve": { "position": {
 		kind: "gauge",
 		unit: "%",
@@ -93714,13 +93897,47 @@ var HISTORY_CATALOG = {
 		}
 	}
 };
+/**
+* Keyed-array series (D917), projected from every `history.items` block:
+* 1 caps (3 item fields). The item key is the series SCOPE;
+* the series key is `cap:<capName>.<path>[].<field>`.
+*/
+var HISTORY_ITEM_CATALOG = { "consumables": {
+	path: "items",
+	key: "key",
+	label: "label",
+	fields: {
+		"level": {
+			kind: "gauge",
+			unit: "%",
+			deadband: 2,
+			displayName: "Level"
+		},
+		"status": {
+			kind: "enum",
+			displayName: "Status",
+			values: [
+				"ok",
+				"low",
+				"empty",
+				"full",
+				"replace"
+			]
+		},
+		"remaining.value": {
+			kind: "gauge",
+			unitFrom: "remaining.unit",
+			deadband: 1,
+			displayName: "Remaining"
+		}
+	}
+} };
 /** Caps that declared `history: 'none'`, sorted. */
 var HISTORY_NONE_CAPS = [
 	"audio-metrics",
 	"automation-control",
 	"camera-streams",
 	"color",
-	"consumables",
 	"control",
 	"day-night",
 	"device-discovery",
@@ -94018,7 +94235,9 @@ function createSystemProxy(api) {
 			declareSeries: (input) => dispatch("deviceHistory", "declareSeries", "mutation", input),
 			record: (input) => dispatch("deviceHistory", "record", "mutation", input),
 			recordBuckets: (input) => dispatch("deviceHistory", "recordBuckets", "mutation", input),
-			getStatus: (input) => dispatch("deviceHistory", "getStatus", "query", input)
+			getStatus: (input) => dispatch("deviceHistory", "getStatus", "query", input),
+			listOrphanSeries: (input) => dispatch("deviceHistory", "listOrphanSeries", "query", input),
+			deleteOrphanSeries: (input) => dispatch("deviceHistory", "deleteOrphanSeries", "mutation", input)
 		},
 		deviceManager: {
 			allocateDeviceId: (input) => dispatch("deviceManager", "allocateDeviceId", "mutation", input),
@@ -94358,6 +94577,7 @@ function createSystemProxy(api) {
 			setAgentReachableHost: (input) => dispatch("pipelineOrchestrator", "setAgentReachableHost", "mutation", input),
 			setAgentInferenceDevices: (input) => dispatch("pipelineOrchestrator", "setAgentInferenceDevices", "mutation", input),
 			getNodeInferenceDevices: (input) => dispatch("pipelineOrchestrator", "getNodeInferenceDevices", "query", input),
+			forgetInferenceDevice: (input) => dispatch("pipelineOrchestrator", "forgetInferenceDevice", "mutation", input),
 			resetNodePipelineDefaults: (input) => dispatch("pipelineOrchestrator", "resetNodePipelineDefaults", "mutation", input),
 			planAutoTune: (input) => dispatch("pipelineOrchestrator", "planAutoTune", "query", input),
 			applyAutoTune: (input) => dispatch("pipelineOrchestrator", "applyAutoTune", "mutation", input),
@@ -97981,17 +98201,18 @@ var NC_TEMPLATE_VARS = [
 	{
 		name: "item",
 		label: "Consumable",
+		description: "The device's own name for the item: a filter, a brush, the salt, a tank.",
 		example: "Filtro",
 		group: "system",
 		families: ["rule"],
 		fields: [...RULE_TEXT],
 		kinds: ["system"],
-		systemEventKinds: [...CONSUMABLE]
+		systemEventKinds: [...CONSUMABLE, ...TANK]
 	},
 	{
 		name: "tank",
 		label: "Tank",
-		description: "Which tank: clean water, dirty water, detergent or dust bin.",
+		description: "Which tank, as a stable token: cleanWater, dirtyWater, detergent, dustBin, or the device key of any other supply (salt, rinse aid).",
 		example: "clean water",
 		group: "system",
 		families: ["rule"],
@@ -101376,15 +101597,23 @@ function byDeficit(a, b) {
 function spareOf(c) {
 	return c.spare ?? Number.POSITIVE_INFINITY;
 }
-function electByShare(candidates) {
-	if (candidates.length === 0) return { kind: "none" };
+function loadOf(c) {
+	return Math.max(c.running, 0) + Math.max(c.recent ?? 0, 0);
+}
+/** Every candidate with its deficit, the turn holder first. */
+function scoreShares(candidates) {
 	const shareSum = candidates.reduce((s, c) => s + Math.max(c.share, 0), 0);
-	const loadOf = (c) => Math.max(c.running, 0) + Math.max(c.recent ?? 0, 0);
 	const running = candidates.reduce((s, c) => s + loadOf(c), 0);
-	const scored = candidates.map((candidate) => ({
+	return candidates.map((candidate) => ({
 		candidate,
 		deficit: (shareSum > 0 ? Math.max(candidate.share, 0) / shareSum : 1 / candidates.length) * (running + 1) - loadOf(candidate)
 	})).toSorted(byDeficit);
+}
+function electByShare(candidates) {
+	if (candidates.length === 0) return { kind: "none" };
+	return electFromScored(scoreShares(candidates));
+}
+function electFromScored(scored) {
 	const turn = scored[0].candidate;
 	if (!turn.capped && !turn.saturated) return {
 		kind: "elected",
@@ -101408,6 +101637,55 @@ function electByShare(candidates) {
 		reason: "share"
 	};
 }
+/**
+* Affinity (D916, amends D913): a camera's sessions are short and frequent, and
+* every election is a fresh one — with the recency memory rotating on purpose,
+* one camera hopped node on 11 of 14 sessions in ten minutes, each hop a stream
+* dial, a decode-worker fork and a cold pre-roll. The candidate a camera ran on
+* last is kept while its deficit is within {@link SHARE_AFFINITY_TOLERANCE_SESSIONS}
+* of the turn holder's, and while it has room (offered, not capped, not
+* drowning). It moves only when the share is really off — and because a kept
+* session still counts toward its candidate, the cumulative split still follows
+* the shares: no candidate runs more than about one session over its share
+* before its cameras leave.
+*/
+var SHARE_AFFINITY_TOLERANCE_SESSIONS = 1;
+function toScoredCandidate(s) {
+	return {
+		key: s.candidate.key,
+		share: s.candidate.share,
+		running: s.candidate.running,
+		recent: s.candidate.recent ?? 0,
+		deficit: s.deficit
+	};
+}
+/** {@link electByShare}, keeping the previous candidate while the share allows it. */
+function electByShareWithAffinity(candidates, previousKey, toleranceSessions = 1) {
+	const scored = candidates.length === 0 ? [] : scoreShares(candidates);
+	const plain = scored.length === 0 ? { kind: "none" } : electFromScored(scored);
+	const turnKey = plain.kind === "elected" ? plain.key : null;
+	const result = (election, sticky, affinityReason) => ({
+		election,
+		sticky,
+		affinityReason,
+		previousKey,
+		turnKey,
+		scored: scored.map(toScoredCandidate)
+	});
+	if (previousKey === null) return result(plain, false, "no-previous");
+	if (turnKey === previousKey) return result(plain, true, "previous-is-turn");
+	const previous = scored.find((s) => s.candidate.key === previousKey);
+	if (previous === void 0) return result(plain, false, "previous-ineligible");
+	if (previous.candidate.capped || previous.candidate.saturated) return result(plain, false, "previous-no-room");
+	const elected = scored.find((s) => s.candidate.key === turnKey);
+	if (elected === void 0) return result(plain, false, "share-off");
+	if (previous.deficit >= elected.deficit - toleranceSessions - DEFICIT_EPSILON) return result({
+		kind: "elected",
+		key: previousKey,
+		reason: "share"
+	}, true, "within-one-session");
+	return result(plain, false, "share-off");
+}
 //#endregion
 //#region src/pipeline/load-balancing/effective-shares.ts
 /**
@@ -101443,7 +101721,8 @@ function resolveEffectiveShares(input) {
 	const nodes = input.nodeIds.map((nodeId) => {
 		const eligibleKeys = new Set(input.eligibleDevices[nodeId] ?? []);
 		const named = weights.devices[nodeId] ?? {};
-		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].toSorted();
+		const absent = new Set(input.absentDevices?.[nodeId] ?? []);
+		const keys = [...new Set([...Object.keys(named), ...eligibleKeys])].filter((k) => !absent.has(k)).toSorted();
 		const perDevice = {};
 		for (const key of keys) perDevice[key] = positive(named[key]);
 		if (keys.length > 0) deviceWeights[nodeId] = perDevice;
@@ -104640,9 +104919,13 @@ exports.ConnectionTestDescriptorSchema = ConnectionTestDescriptorSchema;
 exports.ConnectionTestInputSchema = ConnectionTestInputSchema;
 exports.ConnectionTestOutcomeSchema = ConnectionTestOutcomeSchema;
 exports.ConnectivityStatusSchema = ConnectivityStatusSchema;
+exports.ConsumableFormSchema = ConsumableFormSchema;
 exports.ConsumableItemSchema = ConsumableItemSchema;
+exports.ConsumableKindSchema = ConsumableKindSchema;
+exports.ConsumableLevelSchema = ConsumableLevelSchema;
 exports.ConsumableRemainingSchema = ConsumableRemainingSchema;
 exports.ConsumableRemainingUnitSchema = ConsumableRemainingUnitSchema;
+exports.ConsumableStatusSchema = ConsumableStatusSchema;
 exports.ConsumablesStatusSchema = ConsumablesStatusSchema;
 exports.ContactStatusSchema = ContactStatusSchema;
 exports.ControlKindSchema = ControlKindSchema;
@@ -104723,6 +105006,8 @@ exports.DEVICE_DEFINITIVE_REFUSALS_BEFORE_DELETE = DEVICE_DEFINITIVE_REFUSALS_BE
 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_ORPHAN_DELETE_MAX = DEVICE_HISTORY_ORPHAN_DELETE_MAX;
+exports.DEVICE_HISTORY_ORPHAN_LIST_MAX = DEVICE_HISTORY_ORPHAN_LIST_MAX;
 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;
@@ -104782,6 +105067,8 @@ exports.DeviceExportStatusSchema = DeviceExportStatusSchema;
 exports.DeviceExportUnexposeInputSchema = UnexposeInputSchema;
 exports.DeviceFeature = require_err_msg.DeviceFeature;
 exports.DeviceHistoryKindSchema = DeviceHistoryKindSchema;
+exports.DeviceHistoryOrphanDeleteRefusalSchema = DeviceHistoryOrphanDeleteRefusalSchema;
+exports.DeviceHistoryOrphanReasonSchema = DeviceHistoryOrphanReasonSchema;
 exports.DeviceHistoryProducerKindSchema = DeviceHistoryProducerKindSchema;
 exports.DeviceHistoryRefusalReasonSchema = DeviceHistoryRefusalReasonSchema;
 exports.DeviceHistoryResolutionSchema = DeviceHistoryResolutionSchema;
@@ -104814,7 +105101,6 @@ exports.DiscoveredDeviceSchema = DiscoveredDeviceSchema;
 exports.DiscoveredTargetSchema = DiscoveredTargetSchema;
 exports.DishwasherAccessSchema = DishwasherAccessSchema;
 exports.DishwasherAvailabilitySchema = DishwasherAvailabilitySchema;
-exports.DishwasherConsumableLevelSchema = DishwasherConsumableLevelSchema;
 exports.DishwasherOperationStateSchema = DishwasherOperationStateSchema;
 exports.DishwasherOptionDescriptorSchema = DishwasherOptionDescriptorSchema;
 exports.DishwasherOptionsSchema = DishwasherOptionsSchema;
@@ -104975,6 +105261,7 @@ exports.HF_REPO = require_sleep.HF_REPO;
 exports.HISTORY_BUCKET_MS = HISTORY_BUCKET_MS;
 exports.HISTORY_CATALOG = HISTORY_CATALOG;
 exports.HISTORY_DEFAULT_MIN_INTERVAL_MS = require_sleep.HISTORY_DEFAULT_MIN_INTERVAL_MS;
+exports.HISTORY_ITEM_CATALOG = HISTORY_ITEM_CATALOG;
 exports.HISTORY_NONE_CAPS = HISTORY_NONE_CAPS;
 exports.HISTORY_UNIT_LABELS = require_sleep.HISTORY_UNIT_LABELS;
 exports.HOURS_PER_DAY = HOURS_PER_DAY;
@@ -105863,6 +106150,7 @@ exports.SENSOR_MAP = SENSOR_MAP;
 exports.SERVER_NAME_MAX_LENGTH = SERVER_NAME_MAX_LENGTH;
 exports.SERVER_NAME_SETTING_KEY = SERVER_NAME_SETTING_KEY;
 exports.SESSION_PLACEMENT_SETTING_KEY = SESSION_PLACEMENT_SETTING_KEY;
+exports.SHARE_AFFINITY_TOLERANCE_SESSIONS = SHARE_AFFINITY_TOLERANCE_SESSIONS;
 exports.SHARE_SOURCE_SETTING_KEY = SHARE_SOURCE_SETTING_KEY;
 exports.SHARE_VIEW_KINDS = require_sleep.SHARE_VIEW_KINDS;
 exports.SHARE_VIEW_MAX_DEVICES = SHARE_VIEW_MAX_DEVICES;
@@ -106027,7 +106315,6 @@ exports.TRAINING_RESULT_SCHEMA = TRAINING_RESULT_SCHEMA;
 exports.TRANSCODE_DOWN_MAX_BITRATE_KBPS = TRANSCODE_DOWN_MAX_BITRATE_KBPS;
 exports.TRANSCODE_DOWN_MAX_HEIGHT = TRANSCODE_DOWN_MAX_HEIGHT;
 exports.TamperStatusSchema = TamperStatusSchema;
-exports.TankStatusSchema = TankStatusSchema;
 exports.TargetKindCapsSchema = TargetKindCapsSchema;
 exports.TargetKindLevelSchema = TargetKindLevelSchema;
 exports.TargetKindSchema = TargetKindSchema;
@@ -106358,6 +106645,8 @@ exports.conditionExclusionReason = conditionExclusionReason;
 exports.conditionVisibleForKind = conditionVisibleForKind;
 exports.connectionTestCapability = connectionTestCapability;
 exports.connectivityCapability = connectivityCapability;
+exports.consumableFormOf = consumableFormOf;
+exports.consumableKindOf = consumableKindOf;
 exports.consumableLowPercentOf = consumableLowPercentOf;
 exports.consumablesCapability = consumablesCapability;
 exports.contactCapability = contactCapability;
@@ -106464,6 +106753,7 @@ exports.effectiveStepSettings = effectiveStepSettings;
 exports.egressTranscodeSharingKey = egressTranscodeSharingKey;
 exports.egressTransportFromRequest = egressTransportFromRequest;
 exports.electByShare = electByShare;
+exports.electByShareWithAffinity = electByShareWithAffinity;
 exports.eligibleUnderBenchmark = eligibleUnderBenchmark;
 exports.embeddingEncoderCapability = embeddingEncoderCapability;
 exports.embeddingModelFailedError = embeddingModelFailedError;
@@ -106557,6 +106847,7 @@ exports.hasUrlScheme = hasUrlScheme;
 exports.heatingValveCapability = heatingValveCapability;
 exports.hfModelUrl = require_sleep.hfModelUrl;
 exports.historyFieldsFor = historyFieldsFor;
+exports.historyItemFieldPath = require_sleep.historyItemFieldPath;
 exports.htmlToText = htmlToText;
 exports.hubAddressHostname = hubAddressHostname;
 exports.hubMotionNativeProvider = hubMotionNativeProvider;