@camstack/addon-post-analysis 1.2.655 → 1.2.656

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.656] - 2026-10-31
+
+### Changed
+
+- A lock reporting door-open counts as an opening for the alarm.
+
 ## [1.2.655] - 2026-10-31
 
 ### Changed

package/dist/{clip-model-registry-C-en5vSD.js → clip-model-registry-BQ_2RsIp.js}

@@ -5676,7 +5676,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-CeyhrcOk.mjs
+//#region ../types/dist/sleep-SX9bkW3_.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -9347,6 +9347,7 @@ var CAP_NAMES = Object.freeze([
 	"remote-layout-components",
 	"running-state",
 	"scene-monitor",
+	"schedulers",
 	"script-runner",
 	"server-management",
 	"settings-store",
@@ -10292,7 +10293,8 @@ Object.freeze({
 			"unlocked",
 			"locking",
 			"unlocking",
-			"jammed"
+			"jammed",
+			"door-open"
 		]
 	}],
 	"media-player": [
@@ -17786,6 +17788,11 @@ var ACTUATOR_CAP_VOCABULARY = {
 					value: "jammed",
 					label: t("Jammed", "Inceppata"),
 					phrase: t("When {device} jams", "Quando {device} si inceppa")
+				},
+				{
+					value: "door-open",
+					label: t("Door open", "Porta aperta"),
+					phrase: t("When the door of {device} opens", "Quando la porta di {device} si apre")
 				}
 			],
 			icon: "lock"
@@ -21276,6 +21283,7 @@ var SYSTEM_CAP_VOCABULARY = {
 	records: system(INTERNAL),
 	remote: system("the per-device remote setup — authored in the Customize remote editor, sent through the remote UI"),
 	"remote-layout-components": system("the palette of the remote template editor — read-only data, never actuated"),
+	schedulers: system("time schedulers — authored on their own page, not device actions"),
 	"server-management": system(CLUSTER),
 	"settings-store": system(INTERNAL),
 	"smtp-provider": system(INTERNAL),
@@ -42399,6 +42407,122 @@ var AutomationWhenSchema = lazy(() => discriminatedUnion("kind", [
 	StationaryPresentLeafSchema,
 	ExpressionLeafSchema
 ]));
+var EVENT_KINDS = new Set([
+	"device-becomes",
+	"device-event",
+	"schedule",
+	"manual",
+	"interval",
+	"detection",
+	"stationary"
+]);
+function isEventLeaf(node) {
+	return EVENT_KINDS.has(node.kind);
+}
+function isLeaf(node) {
+	return node.kind !== "all" && node.kind !== "any" && node.kind !== "not";
+}
+/** Depth of a tree, root container = 1. A bare leaf is depth 1. */
+function whenDepth(node) {
+	if (isLeaf(node)) return 1;
+	if (node.kind === "not") return 1 + whenDepth(node.child);
+	let deepest = 0;
+	for (const child of node.children) deepest = Math.max(deepest, whenDepth(child));
+	return 1 + deepest;
+}
+/** Leaves only — containers do not count toward the leaf budget. */
+function countWhenLeaves(node) {
+	if (isLeaf(node)) return 1;
+	if (node.kind === "not") return countWhenLeaves(node.child);
+	let total = 0;
+	for (const child of node.children) total += countWhenLeaves(child);
+	return total;
+}
+/** Every leaf with its path (`when`, `when.0`, `when.0.1`, `when.0` under a `not`). */
+function forEachLeaf(node, visit, path = "when") {
+	if (isLeaf(node)) {
+		visit(node, path);
+		return;
+	}
+	if (node.kind === "not") {
+		forEachLeaf(node.child, visit, `${path}.0`);
+		return;
+	}
+	node.children.forEach((child, i) => {
+		forEachLeaf(child, visit, `${path}.${i}`);
+	});
+}
+function hasEventLeaves(node) {
+	let found = false;
+	forEachLeaf(node, (leaf) => {
+		if (isEventLeaf(leaf)) found = true;
+	});
+	return found;
+}
+function hasEmptyContainer(node) {
+	if (isLeaf(node)) return false;
+	if (node.kind === "not") return hasEmptyContainer(node.child);
+	if (node.children.length === 0) return true;
+	return node.children.some(hasEmptyContainer);
+}
+var LEAF_WORDS = {
+	"device-becomes": "a device value that becomes",
+	"device-event": "a device event",
+	schedule: "a schedule",
+	manual: "a manual run",
+	interval: "an interval",
+	detection: "a detection",
+	stationary: "a parked object appearing or leaving"
+};
+function say(kind) {
+	return LEAF_WORDS[kind] ?? kind;
+}
+/**
+* The cheapest set of event leaves that makes `node` true, with negation pushed
+* down to the leaves first (De Morgan), so `not(any(A, B))` and `all(not A,
+* not B)` are the same shape to the check. A negated event is its own error: an
+* event is an instant, "the event did not occur" is true at every other moment.
+*/
+function eventNeed(node, path, negated) {
+	if (isLeaf(node)) {
+		if (!isEventLeaf(node)) return { paths: [] };
+		if (negated) return { error: `"not" is applied to ${say(node.kind)} (${path}) — an event is an instant, so "it did not happen" is true at every other moment and can never start a run. Negate a state ("is") instead, or remove the "not"` };
+		return { paths: [{
+			path,
+			kind: node.kind
+		}] };
+	}
+	if (node.kind === "not") return eventNeed(node.child, `${path}.0`, !negated);
+	const conjunctive = node.kind === "all" !== negated;
+	const parts = [];
+	for (let i = 0; i < node.children.length; i += 1) {
+		const child = node.children[i];
+		if (child === void 0) continue;
+		const need = eventNeed(child, `${path}.${i}`, negated);
+		if ("error" in need) return need;
+		parts.push(need);
+	}
+	if (conjunctive) return { paths: parts.flatMap((p) => p.paths) };
+	let best;
+	for (const part of parts) if (best === void 0 || part.paths.length < best.paths.length) best = part;
+	return best ?? { paths: [] };
+}
+/**
+* Author-time bounds and sense check of a `when` tree. Returns `null` when it
+* is legal, else a message the editor shows verbatim.
+*/
+function validateWhenTree(when) {
+	if (hasEmptyContainer(when)) return "a group is empty — group existing rows instead of leaving a container to fill";
+	const depth = whenDepth(when);
+	if (depth > 4) return `the rules nest ${depth} levels deep — the limit is 4. "not (any of …)" is the same as "all of (not …)", which is one level shallower`;
+	const leaves = countWhenLeaves(when);
+	if (leaves > 32) return `the rules use ${leaves} rows — the limit is 32`;
+	const need = eventNeed(when, "when", false);
+	if ("error" in need) return need.error;
+	const [first, second] = need.paths;
+	if (first !== void 0 && second !== void 0) return `${say(first.kind)} (${first.path}) and ${say(second.kind)} (${second.path}) would both have to happen at the same instant, and an event happens at one moment — this can never run. Use "any of" to start on either, or turn one of them into a state ("is") that must already hold`;
+	return null;
+}
 /**
 * The recipe shape before the single `when` tree: a flat list of triggers
 * (OR'd, each an instant) and an optional condition tree. Stored recipes —
@@ -42754,6 +42878,187 @@ function convertLegacyRecipe(legacy) {
 var AutomationRecipeSchema = union([CurrentAutomationRecipeSchema, LegacyAutomationRecipeSchema.transform(convertLegacyRecipe)]);
 new Set(Object.values(COCO_TO_MACRO.mapping));
 /**
+* Schedulers (D983) — an entity that performs actions over the day.
+*
+* A scheduler has profiles; a profile has weekdays and a timeline of POINTS.
+* A point is an `edge` (run once at its time), a `hold` (from this point until
+* the next point of the profile, keep the steps' effects true) or a `release`
+* (end the current hold without acting). The scheduler AND each profile carry
+* a manual `enabled` flag and an optional `activeWhen`: a `when` STATE tree
+* (facts only — an event leaf is an instant and cannot be "in force").
+*
+* This file is the data half: the schemas, and the author-time rules that
+* decide whether a scheduler can be saved at all (a hold needs an action that
+* leads to a state; a sun point needs the site location). It holds no runtime.
+*/
+/** A `when` tree that is a STATE: no event leaf, and legal as a tree. */
+var SchedulerStateTreeSchema = AutomationWhenSchema.superRefine((when, ctx) => {
+	if (hasEventLeaves(when)) {
+		ctx.addIssue({
+			code: "custom",
+			message: "a scheduler condition is a state — an event (\"becomes\", \"detects\", \"at a time\") is an instant and cannot be in force"
+		});
+		return;
+	}
+	const problem = validateWhenTree(when);
+	if (problem !== null) ctx.addIssue({
+		code: "custom",
+		message: problem
+	});
+});
+/** A point's moment: a clock time or a sun event. A one-shot date is not a position on a day. */
+var SchedulerTimeSpecSchema = TimeSpecSchema.refine((spec) => spec.kind !== "date", { message: "a scheduler point is a clock time or a sun event — a one-shot date has no place on a timeline" });
+var SchedulerPointModeSchema = _enum([
+	"edge",
+	"hold",
+	"release"
+]);
+/** What a hold does when someone changes the device by hand. */
+var HoldOverrideSchema = discriminatedUnion("mode", [object({ mode: literal("respect") }), object({
+	mode: literal("reassert"),
+	/** How long the manual state is left alone before the hold puts its own back. */
+	graceMs: number().int().min(0).max(24 * 36e5)
+})]);
+/** A missed edge up to this late still runs. */
+var DEFAULT_MAX_LATE_MS = 10 * 6e4;
+var SchedulerPointSchema = object({
+	id: string().min(1).max(64),
+	at: SchedulerTimeSpecSchema,
+	mode: SchedulerPointModeSchema,
+	/** The actions of an `edge` or `hold`; a `release` has none. */
+	steps: array(ActionStepSchema).max(20).default([]),
+	/** Checked when the point runs (an edge) or is applied (a hold). */
+	conditions: SchedulerStateTreeSchema.optional(),
+	/** Hold only; absent means `respect`. */
+	override: HoldOverrideSchema.optional(),
+	/** Hold only: re-applications per window; absent means {@link DEFAULT_MAX_HOLD_ATTEMPTS}. */
+	maxHoldAttempts: number().int().min(1).max(20).optional()
+});
+var SchedulerProfileSchema = object({
+	id: string().min(1).max(64),
+	name: string().min(1).max(120),
+	enabled: boolean().default(true),
+	activeWhen: SchedulerStateTreeSchema.optional(),
+	days: array(WeekdayKeySchema).min(1).max(7),
+	points: array(SchedulerPointSchema).max(50)
+});
+/** What an operator writes. */
+var SchedulerInputSchema = object({
+	name: string().min(1).max(120),
+	enabled: boolean().default(true),
+	activeWhen: SchedulerStateTreeSchema.optional(),
+	/** Higher wins when two holds want the same device in different states. */
+	priority: number().int().min(0).max(100).default(0),
+	maxLateMs: number().int().min(1e3).max(24 * 36e5).default(DEFAULT_MAX_LATE_MS),
+	profiles: array(SchedulerProfileSchema).max(20)
+});
+var SchedulerSchema = SchedulerInputSchema.extend({
+	id: string().min(1),
+	createdAt: number(),
+	updatedAt: number()
+});
+/** Every outcome a scheduler reports to the runs ledger (`AutomationRunTrace.scheduler`). */
+var SchedulerOutcomeSchema = _enum([
+	"done",
+	"missed",
+	"inactive",
+	"condition-false",
+	"failed",
+	"held",
+	"gave-up",
+	"overridden",
+	"suspended-manual"
+]);
+_enum([
+	"not-found",
+	"invalid-scheduler",
+	"invalid-date"
+]);
+var LOCAL_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+/** One point of the day, placed. `at` is `null` when the sun never crosses that day. */
+var SchedulerPreviewPointSchema = object({
+	pointId: string(),
+	mode: SchedulerPointModeSchema,
+	at: number().nullable(),
+	/** A hold: when its window ends (the next point, else the end of the day). */
+	until: number().nullable(),
+	/** The point's steps are held on a different scheduler's claim at this time — see `conflicts`. */
+	stepCount: number().int()
+});
+var SchedulerPreviewSchema = object({
+	schedulerId: string(),
+	/** The site-local day previewed. */
+	date: string().regex(LOCAL_DATE_PATTERN),
+	timeZone: string(),
+	/** Why no profile is in force, or `null` when one is. */
+	idleReason: string().nullable(),
+	/** The profile in force that day: first in list order whose rules hold. */
+	profileId: string().nullable(),
+	points: array(SchedulerPreviewPointSchema)
+});
+/** Two holds that want the same device in different states at the same time. */
+var SchedulerConflictSchema = object({
+	deviceId: number().int(),
+	cap: string(),
+	field: string(),
+	mine: object({
+		profileId: string(),
+		pointId: string(),
+		value: union([
+			string(),
+			number(),
+			boolean()
+		]),
+		priority: number().int()
+	}),
+	other: object({
+		schedulerId: string(),
+		schedulerName: string(),
+		profileId: string(),
+		pointId: string(),
+		value: union([
+			string(),
+			number(),
+			boolean()
+		]),
+		priority: number().int()
+	}),
+	/** The overlapping stretch, as site-local minutes of the day. */
+	fromMinute: number().int(),
+	toMinute: number().int(),
+	/** `mine` | `other` | `tie` — who holds when it happens (a tie: the one that started first). */
+	winner: _enum([
+		"mine",
+		"other",
+		"tie"
+	])
+});
+var HoldTargetStatusSchema = _enum([
+	"pending",
+	"held",
+	"suspended-manual",
+	"gave-up",
+	"overridden"
+]);
+var SchedulerStatusSchema = object({
+	schedulerId: string(),
+	profileId: string().nullable(),
+	/** The hold in force right now, with where each target stands. */
+	hold: object({
+		pointId: string(),
+		until: number(),
+		/** `true` while the scheduler or profile `activeWhen` is false. */
+		suspendedInactive: boolean(),
+		targets: array(object({
+			deviceId: number().int(),
+			cap: string(),
+			field: string(),
+			status: HoldTargetStatusSchema,
+			attempts: number().int()
+		}))
+	}).nullable()
+});
+/**
 * Run traces — what an automation (or, later, an Action run) DID, node by node,
 * so the editor can paint every block green or red with its reason.
 *
@@ -42889,7 +43194,13 @@ var AutomationRunTraceSchema = object({
 	/** How many identical consecutive skips this trace stands for (>= 1). */
 	repeat: number().int().min(1),
 	/** When the latest of those repeats happened. */
-	lastAt: number()
+	lastAt: number(),
+	/**
+	* A scheduler point's own outcome (D983). `outcome` carries the closest
+	* automation outcome so a reader that does not know schedulers still reads
+	* the trace; this field says exactly what happened.
+	*/
+	scheduler: SchedulerOutcomeSchema.optional()
 });
 /**
 * What the hub's `runs` ledger holds for one owner (`automation:<blockId>` or
@@ -46430,6 +46741,7 @@ method(object({
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ blockIds: array(string()) }), object({ states: array(CompositionBlockStateSchema) }), { auth: "admin" });
+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.Dryer, DeviceType.Gateway, DeviceType.Camera, 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.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.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.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.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;
 var NUMBER = {
 	kind: "fixed",
 	result: ["number"]
@@ -67251,6 +67563,43 @@ method(object({}), array(ActionEntrySchema), { auth: "admin" }), method(object({
 	auth: "admin"
 });
 /**
+* schedulers — timelines of edge and hold points that perform actions over the
+* day (D983). Provided by the core-blocks builtin on the hub, beside `actions`:
+* the same runs ledger (owner `scheduler:<id>`), the same target resolver, the
+* same step runner.
+*
+* The hub runs ONE timer for the next point across every scheduler. A save is
+* refused with its reason (`[invalid-scheduler] …`) when a hold has a step that
+* leads to no state, or a sun point has no site location to read.
+*/
+var SchedulerIdInput = object({ schedulerId: string().min(1) });
+method(object({}), array(SchedulerSchema), { auth: "admin" }), method(SchedulerIdInput, object({ scheduler: SchedulerSchema.nullable() }), { auth: "admin" }), method(object({ scheduler: SchedulerInputSchema }), object({ scheduler: SchedulerSchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	schedulerId: string().min(1),
+	scheduler: SchedulerInputSchema
+}), object({ scheduler: SchedulerSchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(SchedulerIdInput, _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	schedulerId: string().min(1),
+	profileId: string().min(1).optional(),
+	enabled: boolean()
+}), object({ scheduler: SchedulerSchema }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	schedulerId: string().min(1),
+	date: string().regex(LOCAL_DATE_PATTERN).optional()
+}), SchedulerPreviewSchema, { auth: "admin" }), method(object({
+	scheduler: SchedulerInputSchema,
+	schedulerId: string().min(1).optional()
+}), object({ conflicts: array(SchedulerConflictSchema) }), { auth: "admin" }), method(object({}), array(SchedulerStatusSchema), { auth: "admin" }), method(SchedulerIdInput, object({ traces: array(AutomationRunTraceSchema) }), { auth: "admin" });
+/**
 * actions — the ONE surface for runnable actions, for the UI and for
 * automations. Provided by the core-blocks builtin on the hub.
 *
@@ -71556,6 +71905,8 @@ var IntegrationWithStateSchema = object({
 	name: string(),
 	enabled: boolean(),
 	info: record(string(), unknown()).readonly(),
+	/** The discovery candidate this integration was set up from (D984). */
+	originStableId: string().optional(),
 	createdAt: number(),
 	updatedAt: number(),
 	processState: string()
@@ -71566,6 +71917,8 @@ var IntegrationLiteSchema = object({
 	name: string(),
 	enabled: boolean(),
 	info: record(string(), unknown()).readonly(),
+	/** The discovery candidate this integration was set up from (D984). */
+	originStableId: string().optional(),
 	createdAt: number(),
 	updatedAt: number()
 });
@@ -71663,6 +72016,8 @@ var CreateIntegrationInputSchema = object({
 	name: string(),
 	enabled: boolean().optional(),
 	info: record(string(), unknown()).optional(),
+	/** `stableId` of the discovery candidate the form was seeded from (D984). */
+	originStableId: string().optional(),
 	settings: record(string(), unknown()).optional(),
 	/** Keys of `settings` the form's schema declares secret (by type) — kept in
 	*  the keychain, not the table (D787). */
@@ -72443,12 +72798,22 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 * reports `LockEntityFeature.OPEN` (bit value 1) in HA
 * `supported_features`.
 */
+/**
+* `door-open` (D984): the linked door contact reads open, so the bolt cannot be
+* thrown. It is the lock's REAL reported state, written into the mirrored slice
+* by the door-contact Customize extension — never a provider's own value, and
+* never a projection a reader has to compute. Precedence: a native `jammed`
+* wins; otherwise an open contact reports `door-open` whatever the native state
+* says (`locked` included); a closed or unknown contact leaves the native state.
+* A `lock()` is refused while the state is `door-open`; `unlock()` never is.
+*/
 var LockStateSchema = _enum([
 	"locked",
 	"unlocked",
 	"locking",
 	"unlocking",
-	"jammed"
+	"jammed",
+	"door-open"
 ]);
 var LockControlStatusSchema = object({
 	/** Lifecycle state of the lock. `jammed` means the motor reported
@@ -72457,6 +72822,38 @@ var LockControlStatusSchema = object({
 	/** Ms epoch when the slice was last updated. */
 	lastChangedAt: number()
 });
+/**
+* "Door contact" Customize extension (D984): the ONE extension that replaces a
+* native field. `state` is listed in `overridable` for this target, so the
+* validator and the guard accept it and nothing else.
+*/
+var lockControlCustomize = {
+	version: 1,
+	overridable: [{
+		path: "state",
+		by: "door-contact"
+	}],
+	targets: [{
+		id: "door-contact",
+		cardinality: "scalar",
+		vocabulary: {
+			cap: "lock-control",
+			stateField: "state"
+		},
+		deviceTypes: [DeviceType.Lock],
+		apply: "replace",
+		path: "state",
+		override: {
+			whenSourceTrue: "door-open",
+			unlessNative: ["jammed"]
+		},
+		sources: [{
+			kind: "binary",
+			transforms: [{ kind: "identity" }]
+		}],
+		sourceReport: { status: "assignment-status" }
+	}]
+};
 var lockControlCapability = {
 	name: "lock-control",
 	scope: "device",
@@ -72502,6 +72899,7 @@ var lockControlCapability = {
 	* transitions.
 	*/
 	runtimeState: LockControlStatusSchema,
+	customize: lockControlCustomize,
 	/**
 	* Runtime-state durability: **restored** — a lock left locked must still read locked.
 	*
@@ -81016,7 +81414,6 @@ discriminatedUnion("kind", [object({
 })]);
 DeviceFeature.FanSpeed, DeviceFeature.FanPreset, DeviceFeature.FanDirection, DeviceFeature.FanOscillating, DeviceFeature.CoverPositionable, DeviceFeature.CoverTilt, DeviceFeature.ValvePositionable, DeviceFeature.MediaPlayerVolume, DeviceFeature.ClimateFanMode;
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
-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.Dryer, DeviceType.Gateway, DeviceType.Camera, 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.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.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.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.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;
 String.raw`rose\(active(\d+), changed(\d+), (\d+(?:\.\d+)?)\)`;
 DeviceRole.BinarySensor, DeviceRole.MotionSensor;
 new Set(CAP_NAMES);
@@ -90129,6 +90526,76 @@ Object.freeze({
 		access: "create",
 		role: "feature:scenes"
 	},
+	"schedulers.conflicts": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.create": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"schedulers.delete": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "delete",
+		role: "admin"
+	},
+	"schedulers.get": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.getStatus": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.getTraces": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.list": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.preview": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "view",
+		role: "admin"
+	},
+	"schedulers.setEnabled": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
+	"schedulers.update": {
+		capName: "schedulers",
+		capScope: "system",
+		addonId: null,
+		access: "create",
+		role: "admin"
+	},
 	"scriptRunner.getStatus": {
 		capName: "script-runner",
 		capScope: "device",
@@ -98714,6 +99181,7 @@ new Set([
 	"locking",
 	"unlocking",
 	"jammed",
+	"door-open",
 	"on",
 	"off",
 	"home",