@camstack/addon-provider-bosch 0.1.47 → 0.1.49

package/dist/{bosch-instances-D0eF-Jjy.js → bosch-instances-BHFcR1TK.js}

@@ -802,7 +802,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/composed-stable-id-DLcPInGv.mjs
+//#region ../types/dist/composed-stable-id-DFNyOFzz.mjs
 /**
 import { errMsg } from '@camstack/types'
 * Extract a human-readable message from an unknown error value.
@@ -815,6 +815,7 @@ function errMsg(err) {
 }
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
 	DeviceType["Camera"] = "camera";
+	/** Legacy stored value, read only by the hub-to-integration migrations; no live device carries it. */
 	DeviceType["Hub"] = "hub";
 	DeviceType["Light"] = "light";
 	DeviceType["Siren"] = "siren";
@@ -1090,6 +1091,10 @@ var DeviceFeature = /* @__PURE__ */ function(DeviceFeature) {
 	/** Robot mower exposes targeted mowing (all-area / zones / edges /
 	*  spots) — gates the Mow action + map selectors. */
 	DeviceFeature["MowerHasTargetedMowing"] = "mower-has-targeted-mowing";
+	/** The device has a drive/navigation surface (`navigation` cap): a robot camera. */
+	DeviceFeature["Navigation"] = "navigation";
+	/** The device has a network-link reading (`network-link` cap). */
+	DeviceFeature["NetworkLink"] = "network-link";
 	return DeviceFeature;
 }({});
 /**
@@ -6022,7 +6027,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-B36hHDDz.mjs
+//#region ../types/dist/sleep-D_NpiLFP.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -10109,15 +10114,52 @@ var PeerBytesTicketSchema = object({
 	*/
 	declaredBytes: number$1().int().nonnegative().nullable()
 });
-discriminatedUnion("kind", [object({
-	kind: literal("action"),
-	actionId: string(),
-	runId: string(),
-	automationId: string().optional()
-}), object({
-	kind: literal("scheduler"),
-	schedulerId: string()
-})]);
+/**
+* The match a notification rule fired on (D705). Carried as a command origin so an
+* Action the rule starts can press `alarm-panel.trigger` as that match, not as an
+* anonymous press (D735). The same fields a rule fire ref freezes.
+*/
+var RuleFireOriginSchema = object({
+	ruleId: string(),
+	ruleName: string(),
+	deviceId: number$1().int(),
+	sourceDeviceId: number$1().int().optional(),
+	recordId: string(),
+	timestamp: number$1(),
+	trackId: string().optional(),
+	eventId: string().optional(),
+	className: string().optional(),
+	label: string().optional(),
+	zones: array(string()).optional(),
+	confidence: number$1().optional(),
+	sensorChange: object({
+		name: string(),
+		kind: string(),
+		state: string()
+	}).optional(),
+	extraStills: array(object({
+		ownerId: string(),
+		cameraId: number$1().int()
+	})).optional()
+});
+discriminatedUnion("kind", [
+	object({
+		kind: literal("action"),
+		actionId: string(),
+		runId: string(),
+		automationId: string().optional(),
+		/** The rule fire that started this run, when one did (D705). */
+		ruleFire: RuleFireOriginSchema.optional()
+	}),
+	object({
+		kind: literal("scheduler"),
+		schedulerId: string()
+	}),
+	object({
+		kind: literal("rule"),
+		fire: RuleFireOriginSchema
+	})
+]);
 /**
 * One recorded device transition (D1022): a status field of a device went from
 * one value to another, with who or what asked for it.
@@ -13851,10 +13893,6 @@ var CAMERA_CAP_VOCABULARY = {
 		scope: "device",
 		noun: t("Admin link", "Link di amministrazione")
 	},
-	"device-discovery": {
-		scope: "device",
-		noun: t("Discovery", "Rilevamento dispositivi")
-	},
 	"device-extension": {
 		scope: "device",
 		noun: t("Device extension", "Estensione del dispositivo")
@@ -15026,6 +15064,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	backup: system("system backups — run and restored from the Backups page"),
 	broker: system("message-broker connections — configured, not actuated"),
 	"calendar-source": system(INTERNAL),
+	"cluster-update": system(CLUSTER),
 	calendars: system("calendars feed schedules and conditions, not device actions"),
 	composer: system("device composition — an authoring tool, not an action"),
 	"core-blocks": system(INTERNAL),
@@ -15315,6 +15354,7 @@ var CAP_NAMES = Object.freeze([
 	"camera-streams",
 	"carbon-monoxide",
 	"climate-control",
+	"cluster-update",
 	"color",
 	"composer",
 	"connectivity",
@@ -15332,7 +15372,6 @@ var CAP_NAMES = Object.freeze([
 	"device-admin-link",
 	"device-adoption",
 	"device-credentials",
-	"device-discovery",
 	"device-export",
 	"device-extension",
 	"device-history",
@@ -15954,13 +15993,6 @@ Object.freeze({
 			"valueType": "string"
 		}
 	],
-	"device-discovery": [{
-		"path": "lastDiscoveryAt",
-		"valueType": "number"
-	}, {
-		"path": "lastError",
-		"valueType": "string"
-	}],
 	"device-export": [
 		{
 			"path": "linkState",
@@ -17412,7 +17444,7 @@ Object.freeze({
 	}
 });
 //#endregion
-//#region ../types/dist/composition-BFJq1Y88.mjs
+//#region ../types/dist/implemented-methods-M5aguGon.mjs
 /**
 * The ffmpeg build every CamStack node downloads, per platform and arch.
 *
@@ -19352,18 +19384,43 @@ var TargetKindLevelSchema = object({
 	requires: array(string()).optional(),
 	description: string().optional()
 });
+/** Attachment capabilities for a kind (drives the degrade engine + test panel). */
+var TargetKindAttachmentsCapsSchema = object({
+	mediaTypes: array(AttachmentMediaTypeSchema),
+	mode: _enum([
+		"url",
+		"bytes",
+		"both"
+	]),
+	max: number$1().int().nonnegative(),
+	maxBytes: number$1().int().positive().optional()
+});
+/**
+* Which TEXT fields a kind delivers (#483). Alexa speaks a title and nothing
+* else; a push service shows both.
+*
+* `.optional()` on the caps block, never defaulted: absent = both, which is
+* what every kind declared before this field meant (D938's rule for a Zod
+* default on the addon cap path).
+*/
+var TargetKindTextCapsSchema = object({
+	title: boolean(),
+	body: boolean()
+});
+_enum([
+	"title",
+	"body",
+	"attachments",
+	"actions",
+	"priority",
+	"sound",
+	"clickUrl"
+]);
 /** The full capability block consulted before dispatch. */
 var TargetKindCapsSchema = object({
-	attachments: object({
-		mediaTypes: array(AttachmentMediaTypeSchema),
-		mode: _enum([
-			"url",
-			"bytes",
-			"both"
-		]),
-		max: number$1().int().nonnegative(),
-		maxBytes: number$1().int().positive().optional()
-	}),
+	/** Text fields this kind delivers (#483). Absent = title AND body. */
+	text: TargetKindTextCapsSchema.optional(),
+	attachments: TargetKindAttachmentsCapsSchema,
 	/** Max action buttons (0 = none). */
 	actions: number$1().int().nonnegative(),
 	/**
@@ -44027,6 +44084,62 @@ var WeekdayKeySchema = _enum([
 	"sat",
 	"sun"
 ]);
+/**
+* Hold semantics — "for N seconds" on a leaf of the `when` tree (#498).
+*
+* ONE primitive, `for: { ms, mode, tolerance? }`, shared by `device-becomes`,
+* `device-is` and `expression`:
+*
+*  - `held`: the condition stays true for `ms`;
+*  - `stable`: the value does not move by more than `tolerance` (absolute, in
+*    the field's base unit) for `ms` while the condition holds.
+*
+* {@link HoldCore} is the pure state machine (an input observation → a reading).
+* {@link HoldTracker} keys cores by a leaf path for the STATE leaves the tree
+* evaluator judges. {@link BecomesWatch} wraps a core with a timer for the
+* `device-becomes` EVENT leaf: the deadline is armed when the hold starts and
+* cancelled when it breaks, and the leaf fires ONCE per episode.
+*
+* Hold state is memory only. A hold that is already running when the watcher
+* first looks (a restart) is INHERITED: nobody knows when it began, so it never
+* fires for that episode and a state leaf reads it as unknown until the window
+* has elapsed from the moment the watcher started (D49: not-known is not false).
+*/
+var HOLD_MAX_MS = 864e5;
+var HoldModeSchema = _enum(["held", "stable"]);
+var HoldSpecSchema = object({
+	/** How long the condition (or the value) must hold. */
+	ms: number$1().int().min(1).max(HOLD_MAX_MS),
+	mode: HoldModeSchema,
+	/** `stable` only: the largest move of the value that still counts as unchanged (absolute, base unit). */
+	tolerance: number$1().min(0).optional()
+});
+/** What a trace says about a hold. */
+var HoldTraceSchema = object({
+	phase: _enum([
+		"pending",
+		"cancelled",
+		"fired",
+		"reseeded"
+	]),
+	ms: number$1().int(),
+	mode: HoldModeSchema,
+	/** When the hold started (ms epoch). */
+	since: number$1().optional(),
+	/** When it completes (ms epoch), for a pending hold. */
+	deadline: number$1().optional()
+});
+/** The operators a `device-becomes` leaf may carry: a threshold or a range. */
+var BecomesOperatorSchema = _enum([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"between",
+	"outside"
+]);
 /** How a state leaf compares a device field to a value. Derived from the
 *  field's `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
 var AutomationConditionOperatorSchema = _enum([
@@ -44050,18 +44163,52 @@ var DeviceBecomesLeafSchema = object({
 	deviceId: number$1().int().nonnegative(),
 	cap: string().min(1),
 	fieldPath: string().min(1),
-	/** Fire when the field takes this value. Omit to fire on any change. */
+	/** Fire when the field takes this value. Omit (with no `operator`) to fire on any change. */
 	becomes: union([
 		string(),
 		number$1(),
 		boolean()
 	]).optional(),
-	/** Only on a CHANGE of value, not on every re-report. */
+	/**
+	* A threshold or a range instead of an equality: "crosses above 3000", "enters
+	* 18..24". The leaf fires on the TRANSITION into the predicate, never on a re-report.
+	* `value` is in the field's base unit; `between` / `outside` take `[low, high]`.
+	*/
+	operator: BecomesOperatorSchema.optional(),
+	value: union([
+		number$1(),
+		string(),
+		boolean(),
+		array(number$1()).length(2)
+	]).optional(),
+	/**
+	* Hold: the transition (or, with no predicate, the new value) must stay for
+	* `for.ms` before the leaf fires, ONCE per episode. See `hold.ts`.
+	*/
+	for: HoldSpecSchema.optional(),
+	/** @deprecated every leaf fires on a transition now; read as always on. */
 	edge: boolean().optional(),
-	/** The new value must hold this long before it counts. */
-	forMs: number$1().int().min(0).max(864e5).optional(),
+	/** @deprecated legacy `held` window — read through `holdOf` as `for: { ms, mode: 'held' }`. */
+	forMs: number$1().int().min(0).max(HOLD_MAX_MS).optional(),
 	/** Collapse a burst into one occurrence. */
 	debounceMs: number$1().int().min(0).max(6e5).optional()
+}).superRefine((leaf, ctx) => {
+	if (leaf.becomes !== void 0 && leaf.operator !== void 0) ctx.addIssue({
+		code: "custom",
+		message: "a leaf names `becomes` or `operator`, not both",
+		path: ["operator"]
+	});
+	if (leaf.operator !== void 0 && leaf.value === void 0) ctx.addIssue({
+		code: "custom",
+		message: "an operator needs the value to compare to",
+		path: ["value"]
+	});
+	const range = leaf.operator === "between" || leaf.operator === "outside";
+	if (leaf.operator !== void 0 && range !== Array.isArray(leaf.value)) ctx.addIssue({
+		code: "custom",
+		message: range ? "a range takes [low, high]" : "only a range takes [low, high]",
+		path: ["value"]
+	});
 });
 var DeviceEventLeafSchema = object({
 	kind: literal("device-event"),
@@ -44126,7 +44273,9 @@ var DeviceIsLeafSchema = object({
 		QuantityValueSchema
 	]),
 	/** The unit the person picked for `value` (display only; `value` is in the base unit). */
-	unit: string().min(1).optional()
+	unit: string().min(1).optional(),
+	/** The comparison must hold (`held`) or the value stay put (`stable`) this long. */
+	for: HoldSpecSchema.optional()
 });
 /**
 * True when the camera currently has a PARKED object matching `subjects` in at
@@ -44149,7 +44298,9 @@ var StationaryPresentLeafSchema = object({
 var ExpressionLeafSchema = object({
 	kind: literal("expression"),
 	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
-	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema),
+	/** The expression must stay true this long. An expression has no single value, so only `held`. */
+	for: HoldSpecSchema.optional()
 }).superRefine((src, ctx) => {
 	const err = validateExpressionSource(src);
 	if (err !== null) ctx.addIssue({
@@ -44157,6 +44308,11 @@ var ExpressionLeafSchema = object({
 		message: err,
 		path: ["expr"]
 	});
+	if (src.for?.mode === "stable") ctx.addIssue({
+		code: "custom",
+		message: "an expression is held, not stable: it has no single value to keep still",
+		path: ["for", "mode"]
+	});
 });
 var AutomationWhenSchema = lazy(() => discriminatedUnion("kind", [
 	object({
@@ -44487,30 +44643,21 @@ function convertLegacyWhen(half) {
 *    (instants) and state leaves (durations). It replaces the flat trigger list
 *    plus the separate condition tree; the firing rule is in that file and in
 *    ADR "one tree".
-*  - **Actions** — `NcRuleActionSchema`'s two steps, plus the `{kind:'code'}`
-*    fragment of §3.2.2. See {@link AutomationActionSchema} for the ONE place
-*    this had to diverge from "verbatim", and why.
+*  - **Actions** — the `wait` and `cap` steps, plus the `{kind:'code'}`
+*    fragment of §3.2.2. See {@link AutomationActionSchema}.
 *
 * A recipe stored in the old shape (`triggers` + `conditions`) still LOADS:
 * {@link AutomationRecipeSchema} (the parse-anywhere schema) converts it on parse. Nothing writes it.
 */
 /**
-* One action step.
+* One action step: `wait`, or a `cap` call.
 *
-* `wait` and `cap` are `NcRuleActionSchema`'s two members, kept structurally
-* identical so `NcRuleActionRunner` runs them unchanged — its device-scope
-* check, stop-at-first-failure and per-sequence throttle are the whole reason
-* to reuse it, and none of them are re-implemented here.
-*
-* **The one divergence, and it is forced.** `NcRuleActionSchema.cap.deviceId` is
-* a literal `z.number().int()`, and the NC runner's own `RunSequencesInput`
-* documents its subject device as *"for the log tag, never for routing"*. So an
-* NC action can never target the device that triggered it — which is fine for
-* the NC (its rules already scope to a device) and fatal for an automation
-* ("sound the siren of the camera that saw the person"). `deviceId` therefore
-* also accepts `{ $var }`, resolved from the run's `vars` bag BEFORE the runner
-* is called. The runner still receives a number and is untouched; the
-* resolution is the recipe's job, not the runner's.
+* A cap step's target is who it acts on (D983: `devices`, a `domain`, or a
+* `{ $var }` resolved from the run's variables); the legacy `deviceId` is still
+* READ, never written. The step runner (`runSteps`) owns the device-scope
+* check, the stop-at-first-failure and the variable substitution, once, for
+* every caller — automations, Actions, and the notification centre, which runs
+* only Actions (planning#473).
 */
 var AutomationWaitStepSchema = object({
 	kind: literal("wait"),
@@ -44925,7 +45072,9 @@ var AutomationTriggerTraceSchema = object({
 	/** Why an event was rejected ("class person not in [dog]") or what fired. */
 	reason: string(),
 	/** deviceId, className, trackId, score … — only what the trigger exposes. */
-	vars: record(string(), TraceValueSchema)
+	vars: record(string(), TraceValueSchema),
+	/** A hold (`for`) this occurrence went through: pending, cancelled, fired or re-seeded. */
+	hold: HoldTraceSchema.optional()
 });
 var AutomationConditionTraceNodeSchema = object({
 	/** `when` for the root, `when.<i>` for its i-th child, … (`conditions…` on an old trace). */
@@ -45128,6 +45277,8 @@ var ActionStatusSchema = object({
 	/** The latest run's failure; null on success or when it never ran. */
 	lastError: string().nullable()
 });
+/** The throttle window of an action, in seconds; absent or 0 = no throttle. */
+var ActionMinDelaySecSchema = number$1().int().min(0).max(86400);
 var ActionEntrySchema = object({
 	/** `internal:<uuid>` or `<addonId>:<localId>`. */
 	id: string().min(3),
@@ -45140,6 +45291,14 @@ var ActionEntrySchema = object({
 	/** Internal only: cap and wait steps. No action-in-action, so no cycles. */
 	steps: array(ActionStepSchema).min(1).max(50).optional(),
 	variables: array(ActionVariableSchema).max(20).optional(),
+	/**
+	* Internal only: the least time between two run STARTS. A run that begins
+	* inside the window is skipped (`skipped-cooldown`), traced and logged. It
+	* is an actuator's budget — "how often may this gate physically open" —
+	* not a notification cooldown, and it is shared by every caller of the
+	* action (two rules, a button, an automation).
+	*/
+	minDelaySec: ActionMinDelaySecSchema.optional(),
 	status: ActionStatusSchema
 }).superRefine((entry, ctx) => {
 	if (entry.source === "internal") {
@@ -45170,7 +45329,8 @@ var ActionEntrySchema = object({
 var ActionInputSchema = object({
 	name: string().min(1).max(120),
 	steps: array(ActionStepSchema).min(1).max(50),
-	variables: array(ActionVariableSchema).max(20).optional()
+	variables: array(ActionVariableSchema).max(20).optional(),
+	minDelaySec: ActionMinDelaySecSchema.optional()
 });
 /** Who started a run. Absent = the operator pressed it. */
 var ActionRunOriginSchema = object({ 
@@ -45260,7 +45420,7 @@ object({
 	*  is irrelevant; the array is treated as a set by consumers. */
 	hiddenChildIds: array(number$1()).readonly()
 });
-DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Light, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Cover, DeviceType.Lock, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Generic, method(object({
+DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Cover, DeviceType.Lock, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Generic, method(object({
 	deviceId: number$1().int().nonnegative(),
 	childDeviceId: number$1().int().nonnegative(),
 	hidden: boolean()
@@ -49330,14 +49490,14 @@ var climateControlCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setFanMode: method(object({
+		setFanMode: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			fanMode: string().min(1)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setPreset: method(object({
+		setPreset: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			preset: string().min(1)
 		}), _void(), {
@@ -49351,7 +49511,7 @@ var climateControlCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setTargetRange: method(object({
+		setTargetRange: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			targetLow: number$1(),
 			targetHigh: number$1()
@@ -49359,21 +49519,21 @@ var climateControlCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setTargetHumidity: method(object({
+		setTargetHumidity: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			targetHumidity: number$1().min(0).max(100)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setSwingVertical: method(object({
+		setSwingVertical: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			on: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setSwingHorizontal: method(object({
+		setSwingHorizontal: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			on: boolean()
 		}), _void(), {
@@ -49431,6 +49591,140 @@ var climateControlCapability = {
 	} }
 };
 /**
+* cluster-update — the ONE flow that brings the whole cluster to a release
+* (planning#493). Hub-provided (`server-provided`), hub-only: the hub runs
+* the sequence itself, so the admin UI, the MCP and the CLI all start the same
+* job and read the same report instead of each driving their own loop.
+*
+*   1. backup (`backup.trigger`) — skipped only when the caller says so
+*   2. the hub's server closure (`applyServerUpdate`); the hub restarts and the
+*      job RESUMES on the new boot, verified against the hub's running version
+*   3. every online agent behind the target, one at a time, verified: runs the
+*      target, settled, online, and its capabilities registered (D848) — an
+*      agent that comes back capless is a FAILED step, never a done one
+*   4. every stale addon on the hub (`addons.updatePackage`); agents follow by
+*      reconciliation, which is verified, never pushed
+*
+* The job stops on the first failed step with a typed reason (D877). Its state
+* is durable on the hub and read by RPC (`getClusterUpdateJob`) — events are
+* telemetry and never carry it (D8, D11).
+*/
+/** The steps, in the order they run. */
+var ClusterUpdateStepKindSchema = _enum([
+	"backup",
+	"hub-server",
+	"agent-server",
+	"addons"
+]);
+/**
+* - `pending`  — not reached yet.
+* - `running`  — in progress (for `hub-server`: possibly across the restart).
+* - `ok`       — done AND verified.
+* - `failed`   — did not land; `reason` + `detail` say why. Stops the job.
+* - `skipped`  — not run: nothing to do, opted out, the node is offline, or a
+*                step before it failed. `detail` says which.
+*/
+var ClusterUpdateStepStatusSchema = _enum([
+	"pending",
+	"running",
+	"ok",
+	"failed",
+	"skipped"
+]);
+/**
+* Why a step (and with it the job) failed. Stable, greppable; `detail` carries
+* the prose.
+*/
+var ClusterUpdateFailureReasonSchema = _enum([
+	"backup-unavailable",
+	"backup-failed",
+	"server-refused",
+	"server-not-on-target",
+	"node-capless",
+	"status-unreadable",
+	"addon-update-failed",
+	"addons-not-converged",
+	"interrupted"
+]);
+var ClusterUpdateStepSchema = object({
+	kind: ClusterUpdateStepKindSchema,
+	/** The node the step acts on; absent for `backup` and `addons`. */
+	nodeId: string().optional(),
+	status: ClusterUpdateStepStatusSchema,
+	/** One line for the operator: what happened, or why not. */
+	detail: string(),
+	reason: ClusterUpdateFailureReasonSchema.optional(),
+	/** `hub-server` / `agent-server`: the version the node ran before. */
+	fromVersion: string().nullable().optional(),
+	/** `addons`: the packages this step updates, `name from -> to`. */
+	packages: array(string()).readonly().optional(),
+	startedAt: number$1().optional(),
+	finishedAt: number$1().optional()
+});
+var ClusterUpdateJobStateSchema = _enum([
+	"running",
+	"succeeded",
+	"failed"
+]);
+var ClusterUpdateJobSchema = object({
+	id: string(),
+	state: ClusterUpdateJobStateSchema,
+	/** The server version every node is brought to. */
+	targetVersion: string(),
+	/** Who started it (the user name, or `system`). */
+	requestedBy: string(),
+	startedAt: number$1(),
+	finishedAt: number$1().optional(),
+	/** Every step, in run order; later steps stay `pending` while it runs. */
+	steps: array(ClusterUpdateStepSchema).readonly(),
+	/** On `failed`: the step that stopped it (`nodeId` or the step kind). */
+	stoppedAt: string().optional(),
+	reason: ClusterUpdateFailureReasonSchema.optional(),
+	/** Agents offline when the plan was read: never touched. */
+	skippedOffline: array(string()).readonly()
+});
+var ClusterUpdateOptionsSchema = object({
+	/** Explicit server target; omitted = the hub's latest registry check. */
+	version: string().optional(),
+	/** Update the addons too (default true). */
+	addons: boolean().optional(),
+	/**
+	* Back up before touching anything (default true). `false` is an explicit
+	* operator opt-out; a missing backup provider is otherwise a failure.
+	*/
+	backup: boolean().optional()
+});
+/** Why a plan cannot start. */
+var ClusterUpdateBlockerSchema = _enum([
+	"no-target",
+	"node-busy",
+	"job-running",
+	"nothing-to-do",
+	"status-unreadable"
+]);
+var ClusterUpdatePlanSchema = object({
+	/** `null` when no target could be resolved (`blocker: 'no-target'`). */
+	targetVersion: string().nullable(),
+	/** The steps the job WOULD run, all `pending` (or `skipped` with a reason). */
+	steps: array(ClusterUpdateStepSchema).readonly(),
+	skippedOffline: array(string()).readonly(),
+	/** `null` = the plan can start. */
+	blocker: ClusterUpdateBlockerSchema.nullable(),
+	/** Prose for `blocker`. */
+	blockerDetail: string().nullable()
+});
+var StartClusterUpdateResultSchema = object({
+	accepted: boolean(),
+	/** The job to follow with `getClusterUpdateJob`; `null` when refused. */
+	jobId: string().nullable(),
+	blocker: ClusterUpdateBlockerSchema.nullable(),
+	message: string()
+});
+method(ClusterUpdateOptionsSchema, ClusterUpdatePlanSchema, { auth: "admin" }), method(ClusterUpdateOptionsSchema, StartClusterUpdateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ jobId: string().optional() }), ClusterUpdateJobSchema.nullable(), { auth: "admin" });
+/**
 * Color-light cap. Coexists with `switch` (on/off) and `brightness`
 * (level) on the same device — `switch` toggles the bulb, `brightness`
 * sets the dim level, this cap sets the chromaticity.
@@ -50632,27 +50926,27 @@ var mediaPlayerCapability = {
 	mode: "singleton",
 	deviceTypes: [DeviceType.MediaPlayer],
 	methods: {
-		turnOn: method(deviceOnly, _void(), {
+		turnOn: optionalMethod(deviceOnly, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		turnOff: method(deviceOnly, _void(), {
+		turnOff: optionalMethod(deviceOnly, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		volumeUp: method(stepInput, _void(), {
+		volumeUp: optionalMethod(stepInput, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		volumeDown: method(stepInput, _void(), {
+		volumeDown: optionalMethod(stepInput, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		channelUp: method(stepInput, _void(), {
+		channelUp: optionalMethod(stepInput, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		channelDown: method(stepInput, _void(), {
+		channelDown: optionalMethod(stepInput, _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
@@ -50664,61 +50958,61 @@ var mediaPlayerCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		stop: method(object({ deviceId: number$1().int().nonnegative() }), _void(), {
+		stop: optionalMethod(object({ deviceId: number$1().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		next: method(object({ deviceId: number$1().int().nonnegative() }), _void(), {
+		next: optionalMethod(object({ deviceId: number$1().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		previous: method(object({ deviceId: number$1().int().nonnegative() }), _void(), {
+		previous: optionalMethod(object({ deviceId: number$1().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		seek: method(object({
+		seek: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			position: number$1().int().nonnegative()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setVolume: method(object({
+		setVolume: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			volumeLevel: number$1().min(0).max(100)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setMute: method(object({
+		setMute: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			muted: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setShuffle: method(object({
+		setShuffle: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			shuffle: boolean()
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setRepeat: method(object({
+		setRepeat: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			repeat: MediaPlayerRepeatSchema
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		selectSource: method(object({
+		selectSource: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			source: string().min(1)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		playMedia: method(object({
+		playMedia: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			/** Media identifier / URL. */
 			mediaId: string().min(1),
@@ -50761,7 +51055,7 @@ var mediaPlayerCapability = {
 		isMuted: { kind: "boolean" }
 	} }
 };
-DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway, DeviceType.HeatPump, DeviceType.Camera, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Gateway, DeviceType.Hub, DeviceType.Camera, DeviceType.Sensor, DeviceType.MediaPlayer, DeviceType.Vacuum, DeviceType.Generic, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.PetFountain, DeviceType.Fan, DeviceType.Humidifier, DeviceType.Climate, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.MediaPlayer;
+DeviceType.Camera, DeviceType.Sensor, DeviceType.Button, DeviceType.Switch, DeviceType.PetFeeder, DeviceType.Container, DeviceType.Thermostat, DeviceType.EventEmitter, DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Heater, DeviceType.Dryer, DeviceType.Gateway, DeviceType.HeatPump, DeviceType.Camera, DeviceType.Fan, DeviceType.Lock, DeviceType.Camera, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Switch, DeviceType.Light, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.Gateway, DeviceType.Camera, DeviceType.Sensor, DeviceType.MediaPlayer, DeviceType.Vacuum, DeviceType.Generic, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.PetFountain, DeviceType.Fan, DeviceType.Humidifier, DeviceType.Climate, DeviceType.WaterHeater, DeviceType.MediaPlayer, DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer, DeviceType.WaterHeater, DeviceType.Humidifier, DeviceType.Fan, DeviceType.Climate, DeviceType.Thermostat, DeviceType.PetFeeder, DeviceType.Heater, DeviceType.MediaPlayer;
 var NUMBER = {
 	kind: "fixed",
 	result: ["number"]
@@ -51740,18 +52034,18 @@ var coverCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		stop: method(object({ deviceId: number$1().int().nonnegative() }), _void(), {
+		stop: optionalMethod(object({ deviceId: number$1().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setPosition: method(object({
+		setPosition: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			position: number$1().min(0).max(100)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setTiltPosition: method(object({
+		setTiltPosition: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			tiltPosition: number$1().min(0).max(100)
 		}), _void(), {
@@ -52233,27 +52527,35 @@ var DeviceAdminLinkSchema = object({
 });
 method(object({ deviceId: number$1().int().nonnegative() }), DeviceAdminLinkSchema.nullable(), { auth: "admin" });
 /**
-* device-discovery — device-scoped capability for parents that host /
-* enumerate child devices (Reolink Hub / NVR, ONVIF gateway, future
-* integrations). The parent advertises a list of discoverable children,
-* and the operator promotes a subset to real devices via `adoptDevice`.
-* Child lifecycle (kernel device create/remove, parent reference) is
-* owned by the framework so a single shared `<DiscoveryPanel />` can
-* drive any integration.
-*
-* Boundaries:
-*   - The cap exposes ENUMERATION + ADOPT/RELEASE only. The protocol
-*     used to discover children (CGI poll, mDNS, push from hub, ...)
-*     is the integration's business; results land in `runtimeState`
-*     so the panel can render without a fresh round-trip.
-*   - `childNativeId` is integration-defined and must be stable across
-*     reboots so re-discovery doesn't duplicate adopted children.
-*   - `adoptDevice` returns the new `deviceId` so the UI can navigate
-*     directly to the freshly-created child's settings page.
-*/
-/**
-* Status enum for a discovered device. Mirrors the Reolink simpleEvent
-* lifecycle (`online` / `sleeping` / `offline`) — generic enough for
+* `device-adoption` — generic discovery + adoption surface,
+* system-scoped collection (one provider per integration addon), routed
+* by explicit `{ addonId }` on direct `deviceAdoption.*` calls — the same
+* pin model as `connection-test`. The admin UI keeps using
+* `deviceManager.adoption*` (which already threads `addonId`). The de-HA-ified
+* successor to `ha-discovery`:
+* keyed by `integrationId` (the addon resolves integrationId → broker
+* internally) rather than a connection-specific `brokerId`, and it
+* OWNS the shared `DiscoveredChildDevice` candidate type
+* (declared below) so a single shared adoption modal renders any integration's
+* candidate tree.
+*
+* UI flow (Integrations page → integration detail):
+*   1. `listCandidates({integrationId, page, pageSize, filter})` →
+*      paginated candidate list, each row collapsed.
+*   2. User expands a row → `getCandidate({integrationId,
+*      childNativeId})` returns the single candidate (with its nested
+*      `children`) for the accordion render.
+*   3. User clicks "Adopt" on one or more candidates →
+*      `adopt({integrationId, childNativeIds, perCandidate?})`
+*      materialises one parent CamStack device per candidate plus its
+*      accessory children. `perCandidate[childNativeId]` carries an
+*      optional display-name override + a `hiddenChildIds` pre-hide set
+*      (the parent's `accessories.hiddenChildIds` gates UI visibility).
+*   4. User clicks "Release" → `release({integrationId, camDeviceId})`
+*      removes the parent + every child from the kernel registry.
+*/
+/**
+* Status enum for a discovered device. Generic enough for
 * battery cams, awake cams, and unreachable cams alike.
 */
 var DiscoveredChildStatusSchema = _enum([
@@ -52270,12 +52572,12 @@ var DiscoveredChildDeviceSchema = lazy(() => object({
 	/** DeviceType the child should be created with on adopt. */
 	type: _enum(DeviceType),
 	status: DiscoveredChildStatusSchema,
-	/** Free-form integration-specific metadata surfaced in the panel. */
+	/** Free-form integration-specific metadata surfaced in the adoption modal. */
 	metadata: object({
 		model: string().optional(),
 		serialNumber: string().optional(),
 		uid: string().optional(),
-		/** Reolink: 0-based channel index inside the parent NVR/Hub. */
+		/** Reolink: 0-based channel index inside the parent NVR. */
 		rtspChannel: number$1().int().nonnegative().optional(),
 		isBattery: boolean().optional(),
 		isDoorbell: boolean().optional(),
@@ -52291,137 +52593,24 @@ var DiscoveredChildDeviceSchema = lazy(() => object({
 	}).default({}),
 	/**
 	* `true` when the framework already created a child device for this
-	* `childNativeId` under the current parent. The panel uses it to
+	* `childNativeId` under the current parent. The adoption modal uses it to
 	* gate the Add/Remove button and surface the existing `deviceId`.
 	*/
 	alreadyAdopted: boolean(),
 	/** When `alreadyAdopted=true`, the framework-assigned child device id. */
 	adoptedDeviceId: number$1().int().nonnegative().nullable(),
-	/** Capability names the candidate advertises — integrations populate, Hubs omit. */
+	/** Capability names the candidate advertises — integrations populate, flat enumerations omit. */
 	capabilities: array(string()).readonly().optional(),
-	/** Feature flags the candidate advertises — integrations populate, Hubs omit. */
+	/** Feature flags the candidate advertises — integrations populate, flat enumerations omit. */
 	features: array(string()).readonly().optional(),
 	/** Upstream-system identity + rendering hints for the candidate. */
 	sourceInfo: SourceInfoSchema.optional(),
-	/** Nested entity-children for accordion preview — integrations populate, Hubs omit. */
+	/** Nested entity-children for accordion preview — integrations populate, flat enumerations omit. */
 	children: array(DiscoveredChildDeviceSchema).readonly().optional(),
 	/** `childNativeId` of the gateway candidate in the same list this device sits behind. */
 	parentStableId: string().optional()
 }));
 /**
-* Status block — populated by the integration after each
-* `refreshDiscovery` (or push-driven update). The runtime-state slice
-* is what the panel reads via the per-device proxy; `getStatus`
-* returns the same payload via the codegen'd auto-injection.
-*/
-var DeviceDiscoveryStatusSchema = object({
-	discovered: array(DiscoveredChildDeviceSchema),
-	/** Wall-clock ms of the last successful enumeration. */
-	lastDiscoveryAt: number$1().int().nonnegative().nullable(),
-	/** Last error surfaced from the source (rendered as a banner). */
-	lastError: string().nullable()
-});
-var deviceDiscoveryCapability = {
-	name: "device-discovery",
-	scope: "device",
-	deviceNative: true,
-	mode: "singleton",
-	deviceTypes: [DeviceType.Hub],
-	status: {
-		schema: DeviceDiscoveryStatusSchema,
-		kind: "poll"
-	},
-	runtimeState: DeviceDiscoveryStatusSchema.extend({ lastFetchedAt: number$1().int().nonnegative() }),
-	/**
-	* Runtime-state durability: **session** — 5.7 KB of scan output on the largest device, fully re-derivable by re-scanning.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "session",
-	/**
-	* History (D850): none — inventory.
-	*/
-	history: "none",
-	methods: {
-		/**
-		* Snapshot of the current `discovered` list. Returns the
-		* runtime-state cache — call `refreshDiscovery` first if a
-		* fresh round-trip to the source is required.
-		*/
-		listDiscovered: method(object({ deviceId: number$1().int().nonnegative() }), array(DiscoveredChildDeviceSchema).readonly()),
-		/**
-		* Force the integration to re-enumerate and update the
-		* runtime-state slice. Returns the freshly-enumerated list (also
-		* available via `listDiscovered` post-call).
-		*/
-		refreshDiscovery: method(object({ deviceId: number$1().int().nonnegative() }), array(DiscoveredChildDeviceSchema).readonly(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Promote a discovered entry to a real child device. The framework
-		* creates the child via `kernel.devices.create()` with
-		* `parentDeviceId = parent.id` and seeds the child's config from
-		* `childInitialConfig` (driver-defined; usually carries channel +
-		* uid + parent reference). Returns the kernel-assigned numeric id.
-		*/
-		adoptDevice: method(object({
-			deviceId: number$1().int().nonnegative(),
-			childNativeId: string(),
-			/** Optional override for the child's display name. */
-			name: string().optional()
-		}), object({
-			deviceId: number$1().int().nonnegative(),
-			stableId: string()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Inverse of `adoptDevice`: removes the child device from the
-		* kernel registry. The discovered entry remains in the
-		* enumeration (status updates resume) so the operator can re-adopt
-		* it later without a fresh refresh.
-		*/
-		releaseDevice: method(object({
-			deviceId: number$1().int().nonnegative(),
-			childDeviceId: number$1().int().nonnegative()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	}
-};
-/**
-* `device-adoption` — generic discovery + adoption surface,
-* system-scoped collection (one provider per integration addon), routed
-* by explicit `{ addonId }` on direct `deviceAdoption.*` calls — the same
-* pin model as `connection-test`. The admin UI keeps using
-* `deviceManager.adoption*` (which already threads `addonId`). The de-HA-ified
-* successor to `ha-discovery`:
-* keyed by `integrationId` (the addon resolves integrationId → broker
-* internally) rather than a connection-specific `brokerId`, and it
-* REUSES the shared `DiscoveredChildDevice` candidate type from
-* `device-discovery.cap.ts` so a single shared adoption panel renders
-* any integration's candidate tree.
-*
-* UI flow (Integrations page → integration detail):
-*   1. `listCandidates({integrationId, page, pageSize, filter})` →
-*      paginated candidate list, each row collapsed.
-*   2. User expands a row → `getCandidate({integrationId,
-*      childNativeId})` returns the single candidate (with its nested
-*      `children`) for the accordion render.
-*   3. User clicks "Adopt" on one or more candidates →
-*      `adopt({integrationId, childNativeIds, perCandidate?})`
-*      materialises one parent CamStack device per candidate plus its
-*      accessory children. `perCandidate[childNativeId]` carries an
-*      optional display-name override + a `hiddenChildIds` pre-hide set
-*      (the parent's `accessories.hiddenChildIds` gates UI visibility).
-*   4. User clicks "Release" → `release({integrationId, camDeviceId})`
-*      removes the parent + every child from the kernel registry.
-*/
-/**
 * Provider-declared discovery *granularity* filter (the keystone of the
 * single-entity-import design). A provider advertises which discovery
 * granularities it supports via `listCandidateFilters`; the operator picks
@@ -52781,6 +52970,22 @@ method(InstancePinSchema, DeviceExportStatusSchema), method(_void(), array(Expor
 });
 var DeviceAliasSchema = string().max(64).regex(/^[a-z][a-z0-9_]*$/);
 var DeviceTemplateSchema = string().min(1).max(4096);
+/** One value a caller hands the renderer for `thisDevice`. */
+var DeviceTemplateValueSchema = union([
+	string(),
+	number$1(),
+	boolean()
+]);
+/**
+* The device a render is FOR (`camera` in the text) and the values the caller
+* knows about it that no capability carries, for example `lastPerson` and
+* `lastPlate`. `values` read as `camera.<name>`; a name a capability also carries
+* is `ambiguous` and is written `camera.values.<name>`.
+*/
+var DeviceTemplateThisDeviceSchema = object({
+	deviceId: number$1().int(),
+	values: record(string().min(1).max(64), DeviceTemplateValueSchema).optional()
+});
 var DeviceTemplateRefusalSchema = object({
 	reason: _enum([
 		"too-long",
@@ -52866,6 +53071,90 @@ var SiteZoneSchema = object({
 	*  the ones that most want grouping. */
 	locationKeys: array(string())
 });
+var DeviceSearchRequiresSchema = object({
+	/** Capability names the field wants a value of. */
+	caps: array(string()).readonly(),
+	/** `any` (default): a device with one of them is compatible. `all`: it must hold every one. */
+	mode: _enum(["any", "all"]).optional()
+});
+var DeviceSearchFiltersSchema = object({
+	locations: array(string()).readonly().optional(),
+	integrationIds: array(string()).readonly().optional(),
+	types: array(string()).readonly().optional()
+});
+var DeviceSearchInputSchema = object({
+	/** Matches name, location, type, integration (id and label) and id. Case-insensitive. */
+	text: string().optional(),
+	requires: DeviceSearchRequiresSchema.optional(),
+	filters: DeviceSearchFiltersSchema.optional(),
+	/** List the devices that do not provide the required cap too (greyed, not pickable). */
+	includeIncompatible: boolean().optional(),
+	/** The device the field belongs to: its location drives `suggested`. */
+	contextDeviceId: number$1().optional(),
+	/**
+	* Resolve exactly these devices, regardless of every filter, so a picked
+	* value can be rendered. When given, `items` is these devices in the order
+	* asked (no paging, `nextCursor` null) and the ones that do not exist are
+	* listed in `missingIds`.
+	*/
+	ids: array(number$1()).readonly().optional(),
+	cursor: string().nullable().optional(),
+	limit: number$1().int().min(1).max(200).optional()
+});
+var DeviceValueOptionSchema = object({
+	cap: string(),
+	/** Status-schema field path inside the cap (same paths as `getWireableFields`). */
+	path: string(),
+	label: string(),
+	/** The current value as text; `null` when it is unknown or the read FAILED — never `0`. */
+	reading: string().nullable(),
+	unit: string().nullable().optional(),
+	/** The field's measured quantity, when the cap declares one, so a client can format the reading. */
+	quantity: ReadingQuantitySchema.optional()
+});
+var DeviceSearchItemSchema = object({
+	id: number$1(),
+	name: string(),
+	type: _enum(DeviceType),
+	location: string().nullable(),
+	integrationId: string().nullable(),
+	integrationLabel: string().nullable(),
+	online: boolean().nullable(),
+	disabled: boolean(),
+	compatible: boolean(),
+	/** Only the required caps' fields; empty when nothing was required or the device is incompatible. */
+	values: array(DeviceValueOptionSchema).readonly()
+});
+var DeviceSearchFacetValueSchema = object({
+	value: string(),
+	count: number$1()
+});
+var DeviceSearchFacetIntegrationSchema = object({
+	id: string(),
+	label: string(),
+	count: number$1()
+});
+var DeviceSearchFacetsSchema = object({
+	locations: array(DeviceSearchFacetValueSchema).readonly(),
+	integrations: array(DeviceSearchFacetIntegrationSchema).readonly(),
+	types: array(DeviceSearchFacetValueSchema).readonly()
+});
+var DeviceSearchResultSchema = object({
+	items: array(DeviceSearchItemSchema).readonly(),
+	nextCursor: string().nullable(),
+	/** Devices listed by this query across all pages (filters + text applied; incompatible counted only when `includeIncompatible`). */
+	total: number$1(),
+	/** Compatible devices after filters + text. */
+	compatibleTotal: number$1(),
+	/** Every device the caller's fleet holds, before anything is applied. */
+	fleetTotal: number$1(),
+	/** Incompatible devices after filters + text — the K of "show the K that don't". */
+	hiddenIncompatible: number$1(),
+	facets: DeviceSearchFacetsSchema,
+	/** Same location as `contextDeviceId`; first page only. */
+	suggested: array(DeviceSearchItemSchema).readonly(),
+	missingIds: array(number$1()).readonly()
+});
 var ProviderStatusSchema = object({
 	connected: boolean(),
 	deviceCount: number$1(),
@@ -53351,6 +53640,9 @@ var DeviceInfoSchema = object({
 	*  named accordion sections (with optional intra-section order). See
 	*  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
 	childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+	/** The children a container stands for, most preferred first, by accessory
+	*  `childKey`. Provider-declared. See `DeviceMeta.primaryChildPreference`. */
+	primaryChildPreference: array(string()).readonly().optional(),
 	/** Operator-authored per-device display override. See `DeviceMeta.display`. */
 	display: DeviceDisplayOverrideSchema.optional()
 });
@@ -53412,7 +53704,9 @@ var DeviceBindingsForDeviceSchema = object({
 		kind: _enum(["native", "wrapped"]),
 		providerAddonId: string(),
 		providerNodeId: string(),
-		nativeAddonId: string()
+		nativeAddonId: string(),
+		/** The cap's methods the native provider implements; absent = all. */
+		implementedMethods: array(string()).optional()
 	}))
 });
 /**
@@ -53497,6 +53791,9 @@ var DeviceMetaSchema = object({
 	*  accordion sections (with optional intra-section order). See
 	*  `DeviceMeta.childLayout`. Absent ⇒ no layout declared. */
 	childLayout: array(ChildLayoutEntrySchema).readonly().optional(),
+	/** The children a container stands for, most preferred first, by accessory
+	*  `childKey`. Provider-declared. See `DeviceMeta.primaryChildPreference`. */
+	primaryChildPreference: array(string()).readonly().optional(),
 	/** Semantic role string (`DeviceRole`) — propagated from the spawn pre-seed.
 	*  Optional: only present for accessory children that carry a known role. */
 	role: string().nullable().optional(),
@@ -53655,17 +53952,24 @@ method(object({
 	auth: "admin"
 }), method(object({
 	templates: array(DeviceTemplateSchema).max(64),
-	allowedDeviceIds: array(number$1().int()).optional()
+	allowedDeviceIds: array(number$1().int()).optional(),
+	/** The device `camera` names in the texts, and the values the caller knows of it. */
+	thisDevice: DeviceTemplateThisDeviceSchema.optional()
 }), object({ results: array(DeviceTemplateRenderSchema) }), { auth: "admin" }), method(object({
 	templates: array(string()).max(64),
-	allowedDeviceIds: array(number$1().int()).optional()
+	allowedDeviceIds: array(number$1().int()).optional(),
+	thisDevice: DeviceTemplateThisDeviceSchema.optional()
 }), object({ results: array(discriminatedUnion("ok", [object({
 	ok: literal(true),
 	aliases: array(object({
 		alias: string(),
 		deviceId: number$1().int().nullable(),
-		allowed: boolean()
-	}))
+		allowed: boolean(),
+		/** The fields the text reads on this alias, as written (`temperature`, `cap.field`). */
+		reads: array(string())
+	})),
+	/** Whether the text reads the clock (`now`): it changes every minute. */
+	readsClock: boolean()
 }), object({
 	ok: literal(false),
 	refusal: DeviceTemplateRefusalSchema
@@ -53705,6 +54009,12 @@ method(object({
 }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	primaryChildPreference: array(string()).readonly()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	deviceId: number$1(),
 	display: DeviceDisplayOverrideSchema.nullable()
@@ -53842,7 +54152,7 @@ method(object({
 	* it answers today and the caller filters as it already does.
 	*/
 	deviceIds: array(number$1()).optional()
-}), array(DeviceInfoSchema), { role: "viewer" }), method(object({ deviceId: number$1() }), DeviceInfoSchema.nullable()), method(object({ parentDeviceId: number$1() }), array(DeviceInfoSchema), { role: "viewer" }), method(object({ parentDeviceIds: array(number$1()).max(256) }), record(string(), array(DeviceInfoSchema))), method(object({ deviceId: number$1() }), object({
+}), array(DeviceInfoSchema), { role: "viewer" }), method(DeviceSearchInputSchema, DeviceSearchResultSchema, { role: "viewer" }), method(object({ deviceId: number$1() }), DeviceInfoSchema.nullable()), method(object({ parentDeviceId: number$1() }), array(DeviceInfoSchema), { role: "viewer" }), method(object({ parentDeviceIds: array(number$1()).max(256) }), record(string(), array(DeviceInfoSchema))), method(object({ deviceId: number$1() }), object({
 	mode: LinkedDevicesModeSchema,
 	devices: array(LinkedDeviceSchema)
 }), { role: "viewer" }), method(object({ deviceIds: array(number$1()) }), array(LinkedDevicesForDeviceSchema), { role: "viewer" }), method(object({ deviceId: number$1() }), array(StreamSourceEntrySchema$1)), method(object({ deviceId: number$1() }), array(ConfigEntrySchema)), method(object({ deviceId: number$1() }), ConfigUISchemaOutput), method(object({
@@ -56387,28 +56697,28 @@ var fanControlCapability = {
 	mode: "singleton",
 	deviceTypes: [DeviceType.Fan],
 	methods: {
-		setPercentage: method(object({
+		setPercentage: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			speed: number$1().min(0).max(100)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setPreset: method(object({
+		setPreset: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			preset: string().min(1)
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setDirection: method(object({
+		setDirection: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			direction: FanDirectionSchema
 		}), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setOscillating: method(object({
+		setOscillating: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			oscillating: boolean()
 		}), _void(), {
@@ -57510,13 +57820,11 @@ var HeroConfirmSchema = _enum([
 	"press"
 ]);
 var HeroActionSchema = object({
-	/** Unique within the model; the `gated` list and the specs name it. */
 	id: string(),
 	label: HeroTextSchema,
 	icon: IconKeySchema,
 	call: HeroCallSchema,
 	emphasis: _enum(["primary", "normal"]),
-	/** Ask before running it. */
 	confirm: HeroConfirmSchema.nullable()
 });
 var HeroControlSchema = discriminatedUnion("kind", [
@@ -57567,6 +57875,8 @@ var HeroPillSchema = object({
 });
 var HeroRowSchema = object({
 	id: HeroRowIdSchema,
+	/** `scene`: the row's action and slider controls are drawn on the scene. Absent: an ordinary row. */
+	placement: _enum(["row", "scene"]).optional(),
 	/** The row's own name when the kind's label would not tell rows of one kind apart (a circuit's label). */
 	label: HeroTextSchema.optional(),
 	/** A group header drawn above the row when it differs from the previous row's ("System"). */
@@ -57597,9 +57907,16 @@ var HeroBadgeSchema = object({
 	value: number$1().nullable(),
 	label: HeroTextSchema
 });
-var HeroRemoteSlotSchema = object({ 
-/** Saved commands; `null` = not known yet (the button still shows). */
-commands: number$1().int().nullable() });
+var HeroRemoteSlotSchema = object({
+	/** Saved commands; `null` = not known yet (the button still shows). */
+	commands: number$1().int().nullable(),
+	/**
+	* The control a list row draws as the "open the remote" icon. Recognised by its id
+	* ({@link REMOTE_OPEN_ACTION_ID}); it changes no state, so a client opens the remote
+	* instead of running `call`. Absent on a model from an older server.
+	*/
+	open: HeroActionSchema.optional()
+});
 var HeroConsumablesSlotSchema = object({
 	items: array(object({
 		key: string(),
@@ -57767,6 +58084,8 @@ var HeroModelSchema = object({
 *     the FIRST row that has any (a later row's control is never promoted). When
 *     the model lists that part in `gated`, the row has no inline control: the
 *     projection never falls through to another control the caller could use.
+*   - a climate or thermostat row's primary is its `climate.mode` control (no power
+*     toggle: "off" is a mode); when the model gates it the rule above applies as before;
 *   - a timed run, when the model carries the slot, sits beside that primary:
 *     Run while idle, Stop while armed. Gating the slot hides the control.
 *   - the status line is the head (what plays, else the state) plus at most
@@ -57774,6 +58093,13 @@ var HeroModelSchema = object({
 *     time left on an armed timed run;
 *   - the trailing fact is the first of power, battery, consumables.
 *
+*   - `extras` are the further inline controls of the types that carry more than one
+*     ({@link ROW_EXTRAS_BY_TYPE}): climate setpoint, a robot's return to base,
+*     a player's volume and remote. Each is a control the model already has, named by id,
+*     in that order and at most {@link ROW_EXTRAS_MAX}; one the model lacks, or lists in
+*     `gated`, is absent, and the one `primary` already is never repeats. Empty = the
+*     row of an older server: `primary` alone.
+*
 * `projectDeviceRow` is pure and computes nothing: it selects from a
 * {@link HeroModel}. A row that needed a value the hero lacks would mean the
 * model is missing it, so the fix goes in the model.
@@ -57805,8 +58131,16 @@ var HeroRowModelSchema = object({
 	* while armed. `null` when there is no slot, or the caller may not act.
 	*/
 	timedRun: HeroRowTimedRunSchema.nullable(),
+	/**
+	* The further inline controls after `primary`, in order (see the header). The remote
+	* is an `action` with id `remote.open`: the client opens the remote, it does not run
+	* the call. Absent or empty = `primary` alone.
+	*/
+	extras: array(HeroControlSchema).max(2).optional(),
 	trailing: HeroFactSchema.nullable()
 });
+DeviceType.Climate, DeviceType.Thermostat;
+DeviceType.Climate, DeviceType.Thermostat, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.MediaPlayer;
 /**
 * hero-layout — what a device's hero says (D1023). Read-only: the FIXED
 * layouts live in `@camstack/types` and nothing here stores or edits one.
@@ -60513,7 +60847,7 @@ var lockControlCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		open: method(object({ deviceId: number$1().int().nonnegative() }), _void(), {
+		open: optionalMethod(object({ deviceId: number$1().int().nonnegative() }), _void(), {
 			kind: "mutation",
 			auth: "protected"
 		})
@@ -61710,7 +62044,7 @@ object({
 	deviceId: number$1().int().optional(),
 	atBefore: number$1().optional(),
 	where: RecordWhereSchema.optional()
-}), object({ count: number$1().int().nonnegative() }), object({}), object({ store: Rows }), object({ patch: Rows }), object({}), object({ keys: array(string().min(1)) }), object({ removed: array(string()) }), object({ refs: array(string()) }), object({ values: record(string(), string().nullable()) }), object({
+}), object({ count: number$1().int().nonnegative() }), object({}), object({ store: Rows }), object({ patch: Rows }), object({}), object({ keys: array(string().min(1)) }), object({ removed: array(string()) }), object({}), object({ deviceIds: array(number$1().int()) }), object({ deviceIds: array(number$1().int()) }), object({ blobs: record(string(), Rows) }), object({ refs: array(string()) }), object({ values: record(string(), string().nullable()) }), object({
 	ref: string().min(1),
 	value: string()
 }), object({}), object({ refs: array(string()) }), object({ deleted: number$1().int().nonnegative() }), object({}), object({ integrations: array(MigrationIntegrationSchema) }), object({ id: string().min(1) }), MigrationIntegrationSchema.nullable(), object({
@@ -61721,7 +62055,7 @@ object({
 	integrationId: string().nullable(),
 	/** Whether the device carries any stored config; its content is not offered. */
 	hasConfig: boolean()
-}).nullable(), object({
+}).nullable(), object({ deviceIds: array(number$1().int()) }), object({ aliases: record(string(), string()) }), object({
 	deviceId: number$1().int(),
 	integrationId: string().min(1)
 }), object({}), object({}), object({ nodeId: string() }), object({}), object({});
@@ -68999,92 +69333,21 @@ var NcZoneConditionSchema = object({
 * membership lists are OR within the list (spec §2.3).
 */
 /**
-* What a rule may actuate.
+* What a rule or a button runs: an **Action** of the `actions` surface
+* (`internal:<uuid>` or an addon's), by id, and nothing else (planning#473).
 *
-* **No hand-maintained allowlist** (operator decision, and the right one — a
-* written list of methods is a third parallel map to keep aligned, and this
-* repo has paid for those). The boundary instead comes from a property the
-* capabilities already carry: an action may target only a **device-scoped**
-* capability method.
-*
-* That is not decoration. A rule can be authored by a NON-ADMIN — personal
-* rules are a supported flow — and the executor runs with the addon's
-* privileges, so an unbounded action is an arbitrary RPC channel with a
-* privilege escalation attached. Restricting to device scope excludes the
-* system caps (`device-manager.removeDevice` and friends) by construction,
-* costs nothing to maintain, and cannot rot: a cap that stops being
-* device-scoped stops being actuatable in the same change.
-*
-* The executor enforces it; {@link NcRuleActionSchema} carries the intent.
+* The notification centre has no step vocabulary of its own. The steps, the
+* device-scope boundary, the stop-at-first-failure, the throttle
+* (`minDelaySec`), the variables and the runs ledger all belong to the Action;
+* an operator edits them in ONE place (the Actions page) and a rule points at
+* the result. A rule can be authored by a non-admin (personal rules), which is
+* safe for the same reason: it can only name an Action an admin already wrote.
 */
+var NcActionIdSchema = string().min(1);
+/** Action ids one hook edge runs, in order. Capped so a slot never becomes a second editor. */
+var NcHookActionIdsSchema = array(NcActionIdSchema).max(4);
 /**
-* One step of a sequence.
-*
-* `wait` is a first-class step rather than a property of the next action: it is
-* what makes a sequence a SEQUENCE and not a list — "unlock, wait 5s, open"
-* cannot be expressed otherwise.
-*/
-var NcRuleActionSchema = discriminatedUnion("kind", [object({
-	kind: literal("wait"),
-	seconds: number$1().min(0).max(300)
-}), object({
-	kind: literal("cap"),
-	/**
-	* WHO the step acts on (D983) — the only shape that is written. A sequence
-	* stored before D983 carries `deviceId`; the sequence store reads it as a
-	* `devices` target.
-	*/
-	target: ActionTargetSchema.optional(),
-	/** The vocabulary action the step performs; required for a `domain` target. */
-	actionId: string().min(1).optional(),
-	/** @deprecated The pre-D983 single device. Read, never written. */
-	deviceId: number$1().int().optional(),
-	/** Capability name, e.g. `alarm-panel`. */
-	cap: string().min(1),
-	/** Method on it. The executor refuses a non-device-scoped cap. */
-	method: string().min(1),
-	/** Method arguments, minus `deviceId` (the executor injects it). */
-	args: record(string(), unknown()).optional()
-}).refine((step) => step.target !== void 0 || step.deviceId !== void 0, {
-	message: "a cap step needs a target",
-	path: ["target"]
-}).refine((step) => step.target?.kind !== "domain" || step.actionId !== void 0, {
-	message: "a domain target needs the vocabulary action it applies to (actionId)",
-	path: ["actionId"]
-})]);
-/**
-* A named, ordered run of steps shared across rules, with its own throttle.
-*
-* Sequences live in the notification centre's sequence store — never inline on
-* a rule. A rule binds to one by id ({@link NcActionBindingSchema}), and a
-* button names one the same way. `minDelaySec` exists because a noisy rule
-* otherwise hammers a physical actuator — the rule's own cooldown governs
-* NOTIFICATIONS, which is a different budget from "how often may this gate
-* actually open". The throttle key is the sequence id, so two rules sharing
-* one sequence share its budget.
-*/
-var NcSharedSequenceSchema = object({
-	id: string().min(1),
-	name: string().min(1).max(120),
-	minDelaySec: number$1().int().min(0).max(86400).optional(),
-	actions: array(NcRuleActionSchema).min(1)
-});
-/** Create / update body — the id is minted by the provider. */
-var NcSharedSequenceInputSchema = object({
-	name: string().min(1).max(120),
-	minDelaySec: number$1().int().min(0).max(86400).optional(),
-	actions: array(NcRuleActionSchema).min(1)
-});
-/** Bindings on one hook edge. Cap keeps a slot from becoming a second sequence editor. */
-var NcHookBindingsSchema = array(discriminatedUnion("kind", [object({
-	kind: literal("sequence"),
-	sequenceId: string().min(1)
-}), object({
-	kind: literal("do"),
-	action: NcRuleActionSchema
-})])).max(4);
-/**
-* One button carried by the notification, running a shared sequence on tap.
+* One button carried by the notification, running an Action on tap.
 *
 * **Read this before adding a button that does something physical.** The tap
 * arrives over a link that travelled through third-party infrastructure — ntfy,
@@ -69099,9 +69362,9 @@ var NcRuleNotificationButtonSchema = object({
 	/** Stable id — travels in the callback and identifies the button in logs. */
 	id: string().min(1).max(64),
 	label: string().min(1).max(40),
-	/** Id of a shared sequence. The dispatcher drops a button whose sequence
-	*  does not exist rather than minting a token for nothing. */
-	sequenceId: string().min(1),
+	/** The Action the tap runs. The dispatcher drops a button whose Action does
+	*  not exist rather than minting a token for nothing. */
+	actionId: NcActionIdSchema,
 	icon: NotificationActionIconSchema.optional(),
 	destructive: boolean().optional()
 });
@@ -69116,25 +69379,19 @@ var NcRuleNotificationButtonSchema = object({
 *    leave). A delivery with no clear edge never produces this hook.
 */
 var NcRuleActionsSchema = object({
-	onActivation: NcHookBindingsSchema.optional(),
-	onDeactivation: NcHookBindingsSchema.optional(),
+	onActivation: NcHookActionIdsSchema.optional(),
+	onDeactivation: NcHookActionIdsSchema.optional(),
 	/** Runs on a positive / raised match. */
-	onTrigger: NcHookBindingsSchema.optional(),
+	onTrigger: NcHookActionIdsSchema.optional(),
 	/** Runs on a clear / leave match, when the subject carries one. */
-	onTriggerOff: NcHookBindingsSchema.optional(),
+	onTriggerOff: NcHookActionIdsSchema.optional(),
 	/**
-	* Buttons the NOTIFICATION carries, each running one shared sequence when
-	* tapped. Deliberately a REFERENCE — a button that could define its own
-	* actions would be a parallel actuation vocabulary.
+	* Buttons the NOTIFICATION carries, each running one Action when tapped.
+	* Deliberately a REFERENCE — a button that could define its own steps would
+	* be a parallel actuation vocabulary.
 	*/
 	buttons: array(NcRuleNotificationButtonSchema).max(8).optional()
 });
-object({
-	name: string().min(1).max(120),
-	enabled: boolean(),
-	minDelaySec: number$1().int().min(0).max(86400).optional(),
-	actions: array(NcRuleActionSchema).min(1)
-});
 /**
 * "This rule applies only while `deviceId` is in one of `states`."
 *
@@ -69433,6 +69690,26 @@ var NcRuleTargetSchema = object({
 	*/
 	params: record(string(), unknown()).optional()
 });
+/** Which picture kind one target receives (#487). */
+var NcTargetAttachmentSchema = _enum([
+	"none",
+	"image",
+	"clip",
+	"gif"
+]);
+var NcTargetOverrideSchema = object({
+	template: object({
+		title: string().max(500).optional(),
+		body: string().max(2e3).optional()
+	}).optional(),
+	schedule: NcScheduleSchema.optional(),
+	priority: number$1().int().min(1).max(5).optional(),
+	attachment: NcTargetAttachmentSchema.optional(),
+	/** `false` = no buttons for this target; `true` is the same as absent. */
+	actions: boolean().optional()
+});
+/** Per-target settings keyed by target id (#487). */
+var NcTargetOverridesSchema = record(string(), NcTargetOverrideSchema);
 /**
 * WHAT THE NOTIFICATION'S PICTURE IS (D897) — the ONE media choice of a rule.
 *
@@ -69714,6 +69991,13 @@ var NcRuleInputSchema = object({
 	* targets.
 	*/
 	targetUsers: array(string()).optional(),
+	/**
+	* Per-target settings keyed by target id (#487): texts, schedule, priority.
+	* Absent (and an absent entry) = the rule's own values. A patch that omits
+	* the key keeps the stored map; a patch that names it REPLACES it whole —
+	* `{}` empties it.
+	*/
+	targetOverrides: NcTargetOverridesSchema.optional(),
 	/** 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({}),
@@ -70815,18 +71099,6 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), object({ sequences: array(NcSharedSequenceSchema) }), { auth: "admin" }), method(object({ sequenceId: string().min(1) }), object({ sequence: NcSharedSequenceSchema.nullable() }), { auth: "admin" }), method(object({ sequence: NcSharedSequenceInputSchema }), object({ sequence: NcSharedSequenceSchema }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	sequenceId: string().min(1),
-	sequence: NcSharedSequenceInputSchema
-}), object({ sequence: NcSharedSequenceSchema }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ sequenceId: string().min(1) }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({}), NcClipRetentionPlanSchema, { auth: "admin" }), method(object({}), object({ mutedDeviceIds: array(number$1().int()).readonly() }), { auth: "admin" }), method(object({
 	deviceId: number$1().int(),
 	muted: boolean()
@@ -71265,53 +71537,41 @@ DeviceType.Camera, method(object({
 	deviceId: number$1(),
 	status: OsdStatusSchema
 });
-_enum([
-	"value",
-	"unit",
-	"full"
-]);
-_enum([
-	"value+unit",
-	"value",
-	"unit"
-]);
 /**
-* How the operator reached the leaf device. `deviceId` is ALWAYS the
-* OSD-supported leaf that is read; `containerId` is set when the pick
-* went through a container (gateway) first.
+* `osd-manager` — the ORCHESTRATOR over the device-scope `osd` cap.
+*
+* The `osd` cap is the firmware contract: it probes a camera's overlay
+* SLOTS and writes literal text into one. It has no idea WHERE that text
+* comes from, and it must not — a driver that grew a "show the temperature
+* here" feature would grow it once per vendor.
+*
+* This cap owns the other half: a per-(camera, slot) BINDING that says
+* which value feeds the slot, how it is formatted, and under which
+* conditions it is shown at all. Named TEMPLATES combine many device
+* fields into one overlay string (plugin catalog OSD Manager parity).
 */
-var OsdTemplatePickSchema = object({
-	containerId: number$1().int().optional(),
-	deviceId: number$1().int()
-});
 /**
-* One named binding inside a multi-device template: device path + unit
-* selection + precision. The parser expands `{alias}`, `{alias.value}`,
-* `{alias.unit}`, or `{alias.full}` from the same binding — there is no
-* per-binding format lock.
+* The text of a named template: a device template (D1021) —
+* `{{ camera.temperature | round(1) }}`, `{{ now | time('HH:mm') }}`,
+* `{% if camera.motion %}MOTION{% endif %}` — rendered by the ONE hub renderer
+* (`device-manager.renderDeviceTemplates`), never by this addon.
+*
+* Two names belong to the render rather than to a device:
+* - `now` is the clock; `time('HH:mm')` prints it in the server's zone.
+* - `camera` is the camera the overlay is on, so one template serves every
+*   camera. `camera.lastPerson` and `camera.lastPlate` are the most recent
+*   recognition persisted for it (empty text until there is one, with
+*   `| default('')`).
 */
-var OsdTemplateBindingSchema = object({
-	/** Token stem in the parser, e.g. `t` → `{t}` / `{t.value}`. Unique within the template. */
-	alias: string().min(1).max(32).regex(/^[A-Za-z][A-Za-z0-9_-]*$/, "alias must start with a letter"),
-	pick: OsdTemplatePickSchema,
-	capName: string().min(1).max(64),
-	valuePath: string().min(1).max(64),
-	/** Convert TO this unit at render (`tryConvertUnit`). Absent = source unit. */
-	displayUnit: string().max(16).optional(),
-	maxDecimals: number$1().int().min(0).max(4).default(1),
-	/** Raw value → display text (same shape as slot binding). Empty string hides. */
-	valueMap: record(string(), string()).optional()
-});
+var OSD_TEMPLATE_TEXT_MAX = 1024;
 /**
-* A named template: bindings (alias → leaf field) + a parser that
-* references `{alias}` / `{alias.value}` / `{alias.unit}` / `{alias.full}`.
+* A named template: the unit of reuse. A slot points at one by id; editing it
+* changes every slot that points at it, on every camera.
 */
 var OsdNamedTemplateSchema = object({
 	id: string().min(1).max(64),
 	name: string().min(1).max(64),
-	bindings: array(OsdTemplateBindingSchema).max(32).default([]),
-	/** Parser with alias placeholders, e.g. `{t.value} {t.unit} / {h}`. */
-	parser: string().max(256).default("")
+	text: string().max(OSD_TEMPLATE_TEXT_MAX).default("")
 });
 /** Where a slot's value comes from. */
 var OsdSourceSchema = discriminatedUnion("kind", [
@@ -71320,26 +71580,6 @@ var OsdSourceSchema = discriminatedUnion("kind", [
 		kind: literal("static"),
 		text: string().max(64)
 	}),
-	object({
-		kind: literal("clock"),
-		/** Token pattern: `YYYY MM DD HH mm ss`. Everything else is literal. */
-		pattern: string().min(1).max(32).default("HH:mm"),
-		/** IANA zone. Omitted = the server's zone. */
-		timezone: string().min(1).max(64).optional()
-	}),
-	object({
-		kind: literal("device-state"),
-		deviceId: number$1().int().optional(),
-		capName: string().min(1).max(64),
-		/** Dot path inside the slice, e.g. `detected`, `value`, `mode`. */
-		valuePath: string().min(1).max(64),
-		/** Convert TO this unit at render. Absent = no conversion. */
-		displayUnit: string().max(16).optional()
-	}),
-	object({
-		kind: literal("latest-recognition"),
-		recognition: _enum(["person", "plate"])
-	}),
 	object({
 		kind: literal("template"),
 		templateId: string().min(1).max(64)
@@ -71349,15 +71589,6 @@ var OsdSlotBindingSchema = object({
 	/** Off = the manager stops driving this slot. It does NOT clear it. */
 	enabled: boolean().default(true),
 	source: OsdSourceSchema,
-	/** `${value}` and `${unit}` are substituted; every occurrence. */
-	template: string().max(96).default("${value}"),
-	/**
-	* Decimal places for a numeric value. `0` yields an integer — the
-	* documented workaround for firmwares that reject `.` in overlay text.
-	*/
-	maxDecimals: number$1().int().min(0).max(4).default(1),
-	/** Raw value → display text, e.g. `{"true":"MOTION","false":""}`. */
-	valueMap: record(string(), string()).optional(),
 	/** Time windows in which the slot is shown. Absent = always. */
 	schedule: NcScheduleSchema.optional(),
 	/**
@@ -71399,31 +71630,21 @@ var OsdRenderResultSchema = object({
 	/** Why, whenever the outcome is not a plain write. Never silent. */
 	reason: string().optional()
 });
-var OsdSourceValueTypeEnum = _enum([
-	"number",
-	"boolean",
-	"string",
-	"enum"
-]);
 /**
-* One bindable value, derived from a cap's `runtimeState` schema — never
-* hand-listed. The editor renders from this, so a cap that ships a new
-* state field becomes bindable with no UI change.
+* A template rendered for one camera without being saved: what the editor
+* previews. `text` is what the overlay would carry; a refused render has a
+* `reason` and an empty text.
 */
-var OsdSourceOptionSchema = object({
-	deviceId: number$1().int(),
-	deviceName: string(),
-	capName: string(),
-	valuePath: string(),
-	label: string(),
-	valueType: OsdSourceValueTypeEnum,
-	/** Present for `enum`; the editor offers these as `valueMap` keys. */
-	enumValues: array(string()).readonly().optional()
+var OsdTemplatePreviewSchema = object({
+	ok: boolean(),
+	text: string(),
+	/** The refusal, or `ref: reason` per value that printed `—`. */
+	notes: array(string())
 });
 method(object({ deviceId: number$1().int() }), object({
 	supported: boolean(),
 	slots: array(OsdSlotViewSchema)
-}), { auth: "admin" }), method(object({ deviceId: number$1().int() }), object({ sources: array(OsdSourceOptionSchema) }), { auth: "admin" }), method(object({}), object({
+}), { auth: "admin" }), method(object({}), object({
 	supported: array(string()),
 	catalog: array(NcConditionDescriptorSchema)
 }), { auth: "admin" }), method(object({
@@ -71465,6 +71686,12 @@ method(object({ deviceId: number$1().int() }), object({
 }), OsdRenderResultSchema, {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number$1().int(),
+	text: string().max(OSD_TEMPLATE_TEXT_MAX)
+}), OsdTemplatePreviewSchema, {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ deviceId: number$1().int() }), object({ results: array(OsdRenderResultSchema) }), {
 	kind: "mutation",
 	auth: "admin"
@@ -71670,9 +71897,13 @@ var petFeederCapability = {
 	*/
 	durability: "session",
 	/**
-	* History (D850): recorded series.
+	* History (D850): recorded series. `feeding` / `eating` are the meals the
+	* device hero's "Meals" button names — change-only booleans, so a dispense
+	* or a pet at the bowl is one span on the history.
 	*/
 	history: { fields: {
+		feeding: { kind: "boolean" },
+		eating: { kind: "boolean" },
 		foodLevel: { kind: "gauge" },
 		bowlFood: { kind: "gauge" },
 		food1: { kind: "gauge" },
@@ -73465,7 +73696,6 @@ var PowerSourceStateSchema = object({
 });
 var POWER_SOURCE_DEVICE_TYPES = [
 	DeviceType.Gateway,
-	DeviceType.Hub,
 	DeviceType.Camera,
 	DeviceType.Sensor,
 	DeviceType.MediaPlayer,
@@ -73517,18 +73747,18 @@ var powerSourceCapability = {
 	mode: "singleton",
 	deviceTypes: POWER_SOURCE_DEVICE_TYPES,
 	methods: {
-		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "admin" }),
+		getStatus: systemMethod(deviceInput$1, PowerSourceInfoSchema, { auth: "protected" }),
 		powerOn: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		}),
 		powerOff: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		}),
 		forceRestart: systemMethod(deviceInput$1, PowerSourceActionResultSchema, {
 			kind: "mutation",
-			auth: "admin"
+			auth: "protected"
 		})
 	},
 	runtimeState: PowerSourceStateSchema,
@@ -81064,7 +81294,7 @@ var valveCapability = {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		setPosition: method(object({
+		setPosition: optionalMethod(object({
 			deviceId: number$1().int().nonnegative(),
 			position: number$1().min(0).max(100)
 		}), _void(), {
@@ -83046,7 +83276,6 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	control: controlCapability,
 	cover: coverCapability,
 	dayNight: dayNightCapability,
-	deviceDiscovery: deviceDiscoveryCapability,
 	deviceStatus: deviceStatusCapability,
 	dishwasher: dishwasherCapability,
 	doNotDisturb: doNotDisturbCapability,
@@ -88225,6 +88454,27 @@ Object.freeze({
 		access: "create",
 		role: "viewer"
 	},
+	"clusterUpdate.getClusterUpdateJob": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"clusterUpdate.previewClusterUpdate": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"clusterUpdate.startClusterUpdate": {
+		capName: "cluster-update",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"color.getStatus": {
 		capName: "color",
 		capScope: "device",
@@ -88827,41 +89077,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"deviceDiscovery.adoptDevice": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
-	"deviceDiscovery.getStatus": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "view",
-		role: "viewer"
-	},
-	"deviceDiscovery.listDiscovered": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "view",
-		role: "viewer"
-	},
-	"deviceDiscovery.refreshDiscovery": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
-	"deviceDiscovery.releaseDevice": {
-		capName: "device-discovery",
-		capScope: "device",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"deviceExport.applyDeviceSettingsPatch": {
 		capName: "device-export",
 		capScope: "system",
@@ -89597,6 +89812,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.search": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "viewer"
+	},
 	"deviceManager.setAlias": {
 		capName: "device-manager",
 		capScope: "system",
@@ -89688,6 +89910,13 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
+	"deviceManager.setPrimaryChildPreference": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"deviceManager.setRole": {
 		capName: "device-manager",
 		capScope: "system",
@@ -92369,13 +92598,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"notificationRules.createSequence": {
-		capName: "notification-rules",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"notificationRules.createSnooze": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -92397,13 +92619,6 @@ Object.freeze({
 		access: "delete",
 		role: "admin"
 	},
-	"notificationRules.deleteSequence": {
-		capName: "notification-rules",
-		capScope: "system",
-		addonId: null,
-		access: "delete",
-		role: "admin"
-	},
 	"notificationRules.getAlarmConfig": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -92453,13 +92668,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"notificationRules.getSequence": {
-		capName: "notification-rules",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"notificationRules.getTemplateCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -92481,13 +92689,6 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"notificationRules.listSequences": {
-		capName: "notification-rules",
-		capScope: "system",
-		addonId: null,
-		access: "view",
-		role: "admin"
-	},
 	"notificationRules.listSnoozes": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -92558,13 +92759,6 @@ Object.freeze({
 		access: "create",
 		role: "admin"
 	},
-	"notificationRules.updateSequence": {
-		capName: "notification-rules",
-		capScope: "system",
-		addonId: null,
-		access: "create",
-		role: "admin"
-	},
 	"notifier.cancel": {
 		capName: "notifier",
 		capScope: "device",
@@ -92649,21 +92843,21 @@ Object.freeze({
 		access: "view",
 		role: "admin"
 	},
-	"osdManager.getSourceCatalog": {
+	"osdManager.listTemplates": {
 		capName: "osd-manager",
 		capScope: "system",
 		addonId: null,
 		access: "view",
 		role: "admin"
 	},
-	"osdManager.listTemplates": {
+	"osdManager.previewSlot": {
 		capName: "osd-manager",
 		capScope: "system",
 		addonId: null,
-		access: "view",
+		access: "create",
 		role: "admin"
 	},
-	"osdManager.previewSlot": {
+	"osdManager.previewTemplate": {
 		capName: "osd-manager",
 		capScope: "system",
 		addonId: null,
@@ -94362,28 +94556,28 @@ Object.freeze({
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.getStatus": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "view",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.powerOff": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"powerSource.powerOn": {
 		capName: "power-source",
 		capScope: "device",
 		addonId: null,
 		access: "create",
-		role: "admin"
+		role: "viewer"
 	},
 	"presence.getStatus": {
 		capName: "presence",
@@ -97453,6 +97647,24 @@ function projectAction(cap, action) {
 Object.entries(CAP_VOCABULARY_BY_NAME).flatMap(([cap, entry]) => entry.scope === "device" ? (entry.actions ?? []).map((a) => projectAction(cap, a)) : []);
 DeviceType.Camera, DeviceType.Hub, DeviceType.Light, DeviceType.Siren, DeviceType.Switch, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.HeatPump, DeviceType.Fan, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder, DeviceType.PetFountain, DeviceType.Heater, DeviceType.Dishwasher, DeviceType.Washer, DeviceType.Dryer, DeviceType.Gateway;
 DeviceFeature.BatteryOperated;
+function bound(cap, methods = [], authority = "reported") {
+	return {
+		kind: "cap",
+		cap,
+		methods,
+		authority
+	};
+}
+function derived(cap, methods = []) {
+	return bound(cap, methods, "derived");
+}
+DeviceFeature.BatteryOperated, DeviceFeature.Rebootable, derived("reboot", ["reboot"]), DeviceFeature.Resyncable, DeviceFeature.NativeSnapshot, DeviceFeature.DoorbellButton, derived("doorbell"), DeviceFeature.TwoWayAudio, derived("intercom", [
+	"startTalkSession",
+	"pushTalkAudio",
+	"endTalkSession"
+]), DeviceFeature.PanTiltZoom, derived("ptz"), DeviceFeature.PtzAutotrack, derived("ptz-autotrack"), DeviceFeature.MotionTrigger, derived("motion-trigger", ["setMotionTrigger"]), DeviceFeature.TimedRun, derived("timed-run", ["runFor"]), DeviceFeature.Switch, DeviceFeature.LightColorRgb, DeviceFeature.LightColorHsv, DeviceFeature.LightColorMired, DeviceFeature.ClimateDualSetpoint, DeviceFeature.ClimateHumidity, DeviceFeature.ClimateFanMode, DeviceFeature.ClimatePreset, DeviceFeature.ClimateSwingVertical, DeviceFeature.ClimateSwingHorizontal, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.CoverStoppable, DeviceFeature.ValvePositionable, DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.LockPinRequired, DeviceFeature.LockOpen, DeviceFeature.MediaPlayerSeek, DeviceFeature.MediaPlayerVolume, DeviceFeature.MediaPlayerMute, DeviceFeature.MediaPlayerShuffle, DeviceFeature.MediaPlayerRepeat, DeviceFeature.MediaPlayerSelectSource, DeviceFeature.MediaPlayerPlayMedia, DeviceFeature.MediaPlayerNext, DeviceFeature.MediaPlayerPrevious, DeviceFeature.MediaPlayerStop, DeviceFeature.MediaPlayerVolumeStep, DeviceFeature.MediaPlayerChannelStep, DeviceFeature.MediaPlayerPower, DeviceFeature.AlarmPinRequired, DeviceFeature.PresenceGps, DeviceFeature.NotifierImage, DeviceFeature.NotifierPriority, DeviceFeature.NotifierData, DeviceFeature.NotifierActions, DeviceFeature.NotifierRecipients, DeviceFeature.ScriptVariables, DeviceFeature.AutomationSkipCondition, DeviceFeature.VacuumHasMap, DeviceFeature.VacuumHasAi, DeviceFeature.MowerHasMap, DeviceFeature.MowerHasTargetedMowing, DeviceFeature.Navigation, derived("navigation"), DeviceFeature.NetworkLink, derived("network-link");
+var ALL_FEATURES = Object.values(DeviceFeature);
+new Set(ALL_FEATURES);
 DeviceType.Washer, DeviceType.Dryer, DeviceType.Dishwasher;
 var HA_AS = "a power sensor (device_class power). Home Assistant has no laundry domain. running-state stays unexported until a null reading can be published as unavailable.";
 var HOMEKIT_REASON = "HomeKit has no laundry-appliance service. The export tab would pair an accessory with nothing on it: running-state is withheld until a null reading can be unavailable, and power is not a HomeKit service this export honours.";
@@ -97922,35 +98134,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"deviceDiscovery.adoptDevice": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.getStatus": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.listDiscovered": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.refreshDiscovery": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
-	"deviceDiscovery.releaseDevice": [{
-		name: "childDeviceId",
-		form: "single",
-		optional: false
-	}, {
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"deviceExport.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -98229,6 +98412,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"deviceManager.setPrimaryChildPreference": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"deviceManager.setRole": [{
 		name: "deviceId",
 		form: "single",
@@ -99108,12 +99296,12 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"osdManager.getSourceCatalog": [{
+	"osdManager.previewSlot": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
 	}],
-	"osdManager.previewSlot": [{
+	"osdManager.previewTemplate": [{
 		name: "deviceId",
 		form: "single",
 		optional: false
@@ -101697,7 +101885,9 @@ var TimelapseRuleInputSchema = object({
 	/** Classes the notification counts — see {@link ReportClassesField}. */
 	reportClasses: ReportClassesField.optional(),
 	/** Canonical notification priority ordinal (1..5); per-target overridable. */
-	priority: PriorityField.default(3)
+	priority: PriorityField.default(3),
+	/** Per-target settings keyed by target id (D1032) — absent = every target follows the rule. */
+	targetOverrides: NcTargetOverridesSchema.optional()
 });
 object({
 	name: NameField.optional(),
@@ -101713,7 +101903,9 @@ object({
 	previewText: PreviewTextField.optional(),
 	previewMode: PreviewModeField.optional(),
 	reportClasses: ReportClassesField.optional(),
-	priority: PriorityField.optional()
+	priority: PriorityField.optional(),
+	/** Per-target settings keyed by target id (D1032) — absent = every target follows the rule. */
+	targetOverrides: NcTargetOverridesSchema.optional()
 });
 TimelapseRuleInputSchema.extend({
 	id: string(),