@camstack/addon-pipeline-orchestrator 1.2.33 → 1.2.34

package/dist/index.js

@@ -7679,6 +7679,104 @@ object({
 	})
 });
 /**
+* Adoption job — the background form of `device-adoption.adopt`.
+*
+* ## Why this exists
+*
+* `adopt({childNativeIds: [...]})` materialises one CamStack device per
+* candidate PLUS every accessory child, and the whole array shares ONE UDS
+* request deadline (60s). Measured on the live hub against Home Assistant:
+* each device the kernel creates costs ~450 ms — `devices.create` pre-seeds
+* meta with up to eleven SEQUENTIAL round trips (`setName`, `setType`,
+* `setRole`, … `persistConfig`) before the class is constructed — and an
+* accessory child costs the same as its parent. So the real unit of work is
+* the CHILD, not the candidate:
+*
+* - 25 candidates averaging 6 children  → ~150 devices → **>60s, times out**
+* - ONE candidate with 217 children     → ~217 devices → **>60s, times out**
+*
+* That second line is why this is a job and not a smaller batch. No chunking,
+* no bounded concurrency over candidates and no per-call tuning can fix a
+* shape where **N=1 already exceeds the deadline** — the count that blows the
+* budget is the source system's accessory fan-out, which the operator does not
+* choose and cannot see. A design that only works below some N is the same bug
+* deferred.
+*
+* ## What the timeout did NOT do
+*
+* It did not stop the work. The UDS deadline ends the CALLER's wait; the
+* provider's loop runs to completion. Measured: a 25-candidate adopt that
+* "failed" at 60s had adopted 17 by 87s and all 25 by ~130s. The operator saw
+* an error and had no way to learn that. Every field below exists so that
+* question has an answer.
+*
+* ## Idempotency
+*
+* Jobs are in-RAM; a restart forgets them. That is safe here because adoption
+* is keyed by a stable id (`ha:<broker>:dev:<nativeId>` and equivalents), so
+* re-running a job re-adopts nothing: an already-adopted candidate is SKIPPED
+* by the engine before any provider call and lands in `alreadyAdopted`. It is
+* never a duplicate device, and never an error the operator has to interpret.
+*/
+var AdoptionJobStateSchema = _enum([
+	"running",
+	"done",
+	"failed",
+	"cancelled"
+]);
+/**
+* Per-candidate result. Every candidate the job was asked to adopt ends in
+* exactly one of these buckets — there is no silent drop, and the operator can
+* always answer "which of my 25 landed?".
+*
+* - `adopted` — created now by this job.
+* - `already-adopted` — a device for this candidate existed before the job
+*   reached it (a re-run, or a retry after a timeout). Not an error.
+* - `failed` — the provider threw; `error` carries the message.
+* - `cancelled` — the operator cancelled before this candidate was reached.
+*/
+var AdoptionOutcomeSchema = _enum([
+	"adopted",
+	"already-adopted",
+	"failed",
+	"cancelled"
+]);
+var AdoptionCandidateResultSchema = object({
+	childNativeId: string(),
+	outcome: AdoptionOutcomeSchema,
+	/** The materialised parent device id — null for `failed` / `cancelled`. */
+	parentDeviceId: number().int().nonnegative().nullable(),
+	/** Accessory children created for this candidate. */
+	accessoryCount: number().int().nonnegative(),
+	/** Failure message; null unless `outcome === 'failed'`. */
+	error: string().nullable()
+});
+var AdoptionJobSchema = object({
+	jobId: string(),
+	/** The integration provider this job adopts through (the `addonId` pin). */
+	addonId: string(),
+	integrationId: string(),
+	state: AdoptionJobStateSchema,
+	/** Candidates the job was asked to adopt. Known up front, so never null. */
+	total: number().int().nonnegative(),
+	/** Candidates that have reached a terminal bucket. */
+	processed: number().int().nonnegative(),
+	adopted: number().int().nonnegative(),
+	alreadyAdopted: number().int().nonnegative(),
+	failed: number().int().nonnegative(),
+	/** Accessory child devices created across every candidate — the real unit
+	*  of work, surfaced so a slow job is legible rather than mysterious. */
+	accessoriesCreated: number().int().nonnegative(),
+	/** The candidate currently being adopted; null when idle or finished. */
+	currentChildNativeId: string().nullable(),
+	/** One entry per candidate, in the order they were processed. */
+	results: array(AdoptionCandidateResultSchema).readonly(),
+	startedAt: number(),
+	finishedAt: number().nullable(),
+	/** Set only when the job itself broke (not a per-candidate failure). */
+	error: string().nullable()
+});
+/**
 * Per-camera FUNCTION SWITCHES — the one coherent on/off surface over the
 * pipeline functions an operator thinks in terms of.
 *
@@ -8761,441 +8859,1215 @@ var ConvertResultSchema = object({
 	})).readonly()
 });
 /**
-* `addon-pages` — system-scoped singleton aggregator cap. Public-facing
-* surface that admin-ui consumes through `useAddonPagesListPages()`.
+* Error types for the safe expression engine. Two distinct classes so callers
+* can tell a compile-time (grammar) failure from a runtime (evaluation)
+* failure — both are non-fatal to the host: read paths degrade to "skip link".
+*/
+/** Thrown by the tokenizer / parser. Carries a 0-based source `position` when
+*  the failure is anchored to a character (author-facing inline feedback). */
+var ExpressionParseError = class extends Error {
+	position;
+	constructor(message, position) {
+		super(message);
+		this.name = "ExpressionParseError";
+		this.position = position;
+	}
+};
+/** Thrown by the evaluator (unknown identifier, type mismatch, non-finite
+*  result, unknown builtin, step-budget exceeded). */
+var ExpressionEvalError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "ExpressionEvalError";
+	}
+};
+/**
+* Frozen, null-prototype builtin function table for the expression engine
+* (spec §4 rule 4). The table is the SOLE surface of callable functions: the
+* parser rejects any callee not in it, and the evaluator gates each call on an
+* own-property check against it.
 *
-* The provider iterates every `addon-pages-source` (collection) provider
-* and emits `AddonPageInfo[]` enriched with versioned `bundleUrl` strings
-* pointing at `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. The
-* filesystem `mtime` cache-buster lets the browser pick up addon
-* rebuilds without manual reload.
+* Because the object has a NULL prototype AND is `Object.freeze`d:
+*  - it cannot be polluted (no `__proto__` / `constructor` write reaches it);
+*  - a lookup for `toString` / `hasOwnProperty` / `constructor` finds NOTHING
+*    (there is no `Object.prototype` in the chain), so those names are not
+*    callable — they are simply "unknown function" at parse time.
 *
-* The hub-local builtin `addon-pages-aggregator` (see
-* `@camstack/system/builtins/addon-pages-aggregator`) registers the
-* provider. Splitting the public aggregator from the raw collection
-* keeps both ends in codegen — there's no hand-written
-* `addon-pages.router.ts` wrapper anymore.
+* Every numeric argument is validated as a finite number and every numeric
+* RESULT is re-checked finite, so `/0`, `sqrt(-1)` (→ NaN) and overflow
+* (`pow(10,400)` → Infinity) all raise `ExpressionEvalError` and fail the link
+* closed rather than emitting a garbage value.
 */
-var AddonPageDeclarationSchema$1 = object({
-	id: string(),
-	label: string(),
-	icon: string(),
-	path: string(),
-	remoteName: string(),
-	bundle: string(),
-	section: string().optional(),
-	sectionLabel: string().optional()
-});
-var AddonPageInfoSchema = object({
-	addonId: string(),
-	page: AddonPageDeclarationSchema$1,
-	bundleUrl: string()
-});
-method(_void(), array(AddonPageInfoSchema).readonly());
+function asFiniteNumber(value, name, index) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
+	return value;
+}
+function asString$1(value, name, index) {
+	if (typeof value !== "string") throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a string`);
+	return value;
+}
+function finiteResult(value, name) {
+	if (!Number.isFinite(value)) throw new ExpressionEvalError(`${name}: produced a non-finite result`);
+	return value;
+}
+function allFiniteNumbers(args, name) {
+	return args.map((a, idx) => asFiniteNumber(a, name, idx));
+}
+var INF = Number.POSITIVE_INFINITY;
+var table = {
+	min: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => finiteResult(Math.min(...allFiniteNumbers(args, "min")), "min")
+	},
+	max: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => finiteResult(Math.max(...allFiniteNumbers(args, "max")), "max")
+	},
+	abs: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => finiteResult(Math.abs(asFiniteNumber(args[0], "abs", 0)), "abs")
+	},
+	floor: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => finiteResult(Math.floor(asFiniteNumber(args[0], "floor", 0)), "floor")
+	},
+	ceil: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => finiteResult(Math.ceil(asFiniteNumber(args[0], "ceil", 0)), "ceil")
+	},
+	sqrt: {
+		minArgs: 1,
+		maxArgs: 1,
+		apply: (args) => finiteResult(Math.sqrt(asFiniteNumber(args[0], "sqrt", 0)), "sqrt")
+	},
+	round: {
+		minArgs: 1,
+		maxArgs: 2,
+		apply: (args) => {
+			const x = asFiniteNumber(args[0], "round", 0);
+			const digits = args.length > 1 ? Math.trunc(asFiniteNumber(args[1], "round", 1)) : 0;
+			if (digits < 0 || digits > 100) throw new ExpressionEvalError("round: digits must be between 0 and 100");
+			const factor = 10 ** digits;
+			return finiteResult(Math.round(x * factor) / factor, "round");
+		}
+	},
+	pow: {
+		minArgs: 2,
+		maxArgs: 2,
+		apply: (args) => finiteResult(asFiniteNumber(args[0], "pow", 0) ** asFiniteNumber(args[1], "pow", 1), "pow")
+	},
+	clamp: {
+		minArgs: 3,
+		maxArgs: 3,
+		apply: (args) => {
+			const x = asFiniteNumber(args[0], "clamp", 0);
+			const lo = asFiniteNumber(args[1], "clamp", 1);
+			const hi = asFiniteNumber(args[2], "clamp", 2);
+			if (lo > hi) throw new ExpressionEvalError("clamp: lower bound is greater than upper bound");
+			return finiteResult(Math.min(hi, Math.max(lo, x)), "clamp");
+		}
+	},
+	avg: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => {
+			const nums = allFiniteNumbers(args, "avg");
+			return finiteResult(nums.reduce((acc, v) => acc + v, 0) / nums.length, "avg");
+		}
+	},
+	sum: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => finiteResult(allFiniteNumbers(args, "sum").reduce((acc, v) => acc + v, 0), "sum")
+	},
+	coalesce: {
+		minArgs: 1,
+		maxArgs: INF,
+		apply: (args) => {
+			for (const a of args) if (a !== null) return a;
+			return null;
+		}
+	},
+	age: {
+		minArgs: 2,
+		maxArgs: 2,
+		apply: (args) => finiteResult(asFiniteNumber(args[0], "age", 0) - asFiniteNumber(args[1], "age", 1), "age")
+	},
+	convert: {
+		minArgs: 3,
+		maxArgs: 3,
+		apply: (args, hooks) => {
+			const x = asFiniteNumber(args[0], "convert", 0);
+			const from = asString$1(args[1], "convert", 1).trim();
+			const to = asString$1(args[2], "convert", 2).trim();
+			if (hooks.convert) {
+				const out = hooks.convert(x, from, to);
+				if (out === null) throw new ExpressionEvalError(`convert: cannot convert '${from}' to '${to}'`);
+				return finiteResult(out, "convert");
+			}
+			if (from === to) return x;
+			throw new ExpressionEvalError("convert: unit conversion table not installed");
+		}
+	}
+};
+Object.freeze(Object.assign(Object.create(null), table));
+/** The set of valid builtin names — used by the parser to reject unknown
+*  callees at parse time (immediate author feedback). */
+var EXPRESSION_BUILTIN_NAMES = new Set(Object.keys(table));
 /**
-* `addon-pages-source` — collection cap exposing per-provider raw page
-* declarations. Every addon that contributes a UI page registers a
-* provider here. The hub-side singleton aggregator (`addon-pages` cap,
-* see `addon-pages.cap.ts`) walks this collection, stamps versioned
-* `bundleUrl` values, and returns the enriched `AddonPageInfo[]` list
-* that admin-ui consumes.
+* Resource-bound constants for the safe expression engine.
 *
-* The split exists because the public listing has a different output
-* shape than the per-provider raw declarations, and we want both ends
-* to flow through codegen instead of relying on a hand-written wrapper.
+* Every bound is defense-in-depth: the grammar is non-Turing-complete (no
+* loops, recursion, lambdas or member access — see `ast.ts`), so evaluation is
+* O(nodeCount) by construction. These caps merely put a hard ceiling on the
+* work a single author-supplied expression can request, so a hostile or
+* accidental pathological string can never spend unbounded CPU/memory.
 */
-var AddonPageDeclarationSchema = object({
-	id: string(),
-	label: string(),
-	icon: string(),
-	path: string(),
-	/**
-	* Module Federation remote name — must match the `name` field on the
-	* page addon's `federation()` plugin config. Used by admin-ui's
-	* `<AddonPageLoader>` to call `loadRemote('<remoteName>/page')`.
-	* Conventionally `addon_<id>_page` (snake_case; MF names cannot
-	* contain hyphens).
-	*/
-	remoteName: string(),
-	/**
-	* Bundle filename inside the addon's `dist/` dir served at
-	* `/api/addon-pages/<addonId>/<bundle>`. With Module Federation this
-	* is always `'remoteEntry.js'`; the value is kept on the metadata so
-	* the static-file route can compute an mtime-based cache-buster URL
-	* without a separate filesystem stat.
-	*/
-	bundle: string(),
-	/**
-	* Sidebar section this page docks into. Well-known ids: `'detection'`,
-	* `'cluster'`, `'administration'` — the page renders inside that group.
-	* Any OTHER string creates (or joins) a custom section rendered after
-	* the built-in groups; its label comes from `sectionLabel` (first
-	* declaration wins), falling back to the id. Absent → the legacy
-	* "Addon Pages" group.
-	*/
-	section: string().optional(),
-	/** Display label for a CUSTOM `section` id (ignored for well-known ids). */
-	sectionLabel: string().optional()
-});
-method(_void(), array(AddonPageDeclarationSchema).readonly());
-var AddonHttpRouteSchema = object({
-	method: _enum([
-		"GET",
-		"POST",
-		"PUT",
-		"DELETE",
-		"PATCH"
-	]),
-	path: string(),
-	access: _enum([
-		"public",
-		"authenticated",
-		"admin"
-	]).optional(),
-	description: string().optional()
-});
-/**
-* Cross-process route invocation envelope. The hub captures the
-* request as plain data, ships it to the worker via Moleculer, and
-* the worker runs the local handler against a capturing reply. The
-* envelope returned describes what the handler intended (status,
-* headers, body, or a redirect) so the hub can translate it back to
-* the Fastify reply that's actually wired to the socket.
-*/
-var InvokeRequestSchema = object({
-	method: string(),
-	path: string(),
-	params: record(string(), string()),
-	query: record(string(), string()),
-	body: unknown(),
-	headers: record(string(), string()),
-	user: object({
-		id: string(),
-		username: string(),
-		isAdmin: boolean()
-	}).optional(),
-	scopedToken: unknown().optional()
-});
-var InvokeReplyEnvelopeSchema = object({
-	status: number().int(),
-	headers: record(string(), string()),
-	/** When set, the hub MUST `reply.redirect(redirectUrl)` instead of
-	*  sending `body`. Status defaults to 302 when this is set unless
-	*  the handler called `reply.code(...)` explicitly. */
-	redirectUrl: string().nullable(),
-	/** JSON-serializable body. `undefined` is treated as "no body". */
-	body: unknown().optional(),
-	/** Set when the handler called `reply.type(mime)`. */
-	contentType: string().optional()
-});
-method(_void(), array(AddonHttpRouteSchema)), method(InvokeRequestSchema, InvokeReplyEnvelopeSchema, { kind: "mutation" });
-var ConfigTabDeclarationSchema = object({
-	id: string(),
-	label: string(),
-	icon: string(),
-	order: number().optional()
-});
-var ConfigSectionWithValuesSchema = object({
-	id: string(),
-	title: string(),
-	description: string().optional(),
-	style: _enum(["card", "accordion"]).optional(),
-	defaultCollapsed: boolean().optional(),
-	columns: union([
-		literal(1),
-		literal(2),
-		literal(3),
-		literal(4)
-	]).optional(),
-	tab: string().optional(),
-	location: _enum(["settings", "top-tab"]).optional(),
-	order: number().optional(),
-	fields: array(any())
-});
-var SettingsSchemaWithValuesSchema = object({
-	tabs: array(ConfigTabDeclarationSchema).optional(),
-	sections: array(ConfigSectionWithValuesSchema)
-});
-/** Patch object — keys are field names, values are the new field values. */
-var SettingsPatchSchema = record(string(), unknown());
-/** Standard success response for update operations. */
-var SettingsUpdateResultSchema = object({ success: literal(true) });
-method(object({
-	addonId: string(),
-	nodeId: string().optional(),
-	overlay: record(string(), unknown()).optional(),
-	cap: string().optional()
-}), SettingsSchemaWithValuesSchema.nullable()), method(object({
-	addonId: string(),
-	nodeId: string().optional(),
-	patch: SettingsPatchSchema
-}), SettingsUpdateResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	addonId: string(),
-	deviceId: number(),
-	nodeId: string().optional()
-}), SettingsSchemaWithValuesSchema.nullable()), method(object({
-	addonId: string(),
-	deviceId: number(),
-	nodeId: string().optional(),
-	patch: SettingsPatchSchema
-}), SettingsUpdateResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-});
-/**
-* `addon-widgets-source` — collection cap exposing per-addon raw widget
-* declarations. Mirrors the addon-pages split: every addon shipping
-* widgets registers a provider on this collection cap; the hub-local
-* aggregator (`addon-widgets`, see `addon-widgets.cap.ts`) walks the
-* collection, stamps versioned `bundleUrl`s onto each declaration, and
-* exposes the public listing surface that admin-ui consumes.
-*
-* The split exists because the public listing has a different output
-* shape (flat enriched metadata with `addonId` + `bundleUrl`) than the
-* per-provider raw declarations. Both ends flow through codegen.
-*
-* Unified UI-contribution model (Task 10): a widget descriptor IS a
-* `UiContribution` with `kind:'remote'`. The host renders it through the
-* same `ContributionRenderer` / Module-Federation path as every other
-* contributed UI surface — no bespoke widget-rendering path. The widget-
-* only metadata (sizing hints, `requires`) lives as extra fields on the
-* descriptor; the `UiContribution` core (`tab` / `label` / `order` /
-* `kind` / `remote`) carries identity + placement + the MF remote.
-*/
-/** Where the widget makes sense to render — maps to a contribution `tab`. */
-var WidgetHostEnum = _enum([
-	"device-tab",
-	"dashboard",
-	"integration-detail"
-]);
-var WidgetSizeEnum = _enum([
-	"xs",
-	"sm",
-	"md",
-	"lg",
-	"xl"
+/** Max source length (chars) — checked BEFORE tokenizing so a huge string is
+*  rejected without allocation. */
+var MAX_EXPRESSION_SOURCE_LENGTH = 2048;
+/** A legal binding / identifier name. */
+var EXPRESSION_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Binding names an author may NOT use: `now` is auto-injected; the literal
+*  keywords lex as values, not identifiers, so binding to them is meaningless. */
+var RESERVED_BINDING_NAMES = new Set([
+	"now",
+	"true",
+	"false",
+	"null"
 ]);
 /**
-* MF remote descriptor — mirrors `UiContributionRemote` from
-* `capability-definition.ts`. Widget remotes expose a single
-* `'./widgets'` module whose default export is a
-* `Record<componentKey, Component>` map; `componentKey` (the widget
-* `stableId`) picks the entry the host mounts.
-*/
-var WidgetRemoteSchema = object({
-	remoteName: string(),
-	exposedModule: string(),
-	componentKey: string().optional()
-});
-/**
-* One widget declaration — a `UiContribution` (`kind:'remote'`) plus
-* widget-only metadata. The `UiContribution` core fields:
-*
-*  - `tab`     — where the widget hosts. A widget that runs on the
-*                dashboard declares `tab:'dashboard'`; a device-tab
-*                widget declares the target device-detail tab id.
-*  - `subTab`  — optional sub-tab within `tab`.
-*  - `label`   — operator-facing label.
-*  - `order`   — ordering within `(tab, subTab)`.
-*  - `kind`    — always `'remote'` for widgets.
-*  - `remote`  — the MF remote `{ remoteName, exposedModule, componentKey }`.
-*
-* Widget-only fields retained alongside the contribution core:
-*
-*  - `stableId`      — stable identity within the addon (the MF
-*                      `componentKey`; kept top-level so consumers have
-*                      a stable key without reaching into `remote`).
-*  - `description` / `icon` — picker metadata.
-*  - `bundle`        — entry filename inside the addon `dist/` dir; the
-*                      aggregator stamps a versioned `bundleUrl` from it.
-*  - `hosts`         — every host the widget supports (a widget can run
-*                      both on the dashboard and a device tab). `tab`
-*                      is the PRIMARY host; `hosts` is the full set the
-*                      picker filters on.
-*  - `requires`      — host-context requirements validated at mount.
-*  - `defaultSize` / `allowedSizes` / `defaultColumns` / `defaultRows`
-*                    — dashboard placement hints.
+* Tokenizer for the safe expression mini-language. Hand-rolled, single-pass,
+* zero-dependency. The grammar is deliberately boring: decimal numbers,
+* single/double-quoted strings with a tiny escape set, identifiers, the three
+* value keywords (`true`/`false`/`null`) and a fixed punctuator set. Anything
+* outside that — a bare `.`, `=`, `[`, `]`, `{`, `}`, `;`, backtick, `&`, `|` —
+* is a parse error with a source position, so member access / assignment /
+* template literals are lexically impossible.
 */
-var WidgetMetadataSchema = object({
-	/** Primary host tab — `'dashboard'`, `'device-tab'`, or a device-detail tab id. */
-	tab: string(),
-	/** Optional sub-tab within `tab`. */
-	subTab: string().optional(),
-	/** Operator-facing label. */
-	label: string(),
-	/** Ordering within `(tab, subTab)`, ascending. */
-	order: number().optional(),
-	/** Always `'remote'` — a widget is a Module Federation remote. */
-	kind: literal("remote"),
-	/** MF remote descriptor. */
-	remote: WidgetRemoteSchema,
-	/** Stable id within the addon — kebab-case. Equals `remote.componentKey`. */
-	stableId: string(),
-	description: string().optional(),
-	icon: string().optional(),
-	/**
-	* Bundle filename inside the addon's `dist/` dir served at
-	* `/api/addon-widgets/<addonId>/<bundle>`. With Module Federation
-	* this is always `'remoteEntry.js'` — the value is kept on the
-	* metadata so the static-file route can compute an mtime-based
-	* cache-buster URL without a separate filesystem stat.
-	*/
-	bundle: string(),
-	/** Every host the widget supports. The picker filters on this set. */
-	hosts: array(WidgetHostEnum).readonly(),
-	/** Required props the host must supply. Validated at `<WidgetSlot>` mount. */
-	requires: object({
-		deviceContext: boolean().default(false),
-		integrationContext: boolean().default(false)
-	}),
-	/**
-	* Loadable BEFORE authentication. The normal widget registry listing
-	* (`addon-widgets.listWidgets`) is auth-gated, so a pre-auth surface
-	* (the login page) cannot discover a widget through it. A widget that
-	* declares `preAuth: true` marks itself as safe to mount on a pre-auth
-	* screen — it is surfaced through the PUBLIC `auth.listLoginMethods`
-	* login-method contribution channel (see `login-method.cap.ts`) rather
-	* than the authenticated registry, and its bundle is served by the
-	* public `/api/addon-widgets/:addonId/*` static route. Defaults false.
-	*/
-	preAuth: boolean().optional().default(false),
-	/** Dashboard placement HINTS (operator can override per instance). */
-	defaultSize: WidgetSizeEnum.default("md"),
-	allowedSizes: array(WidgetSizeEnum).readonly().default([
-		"sm",
-		"md",
-		"lg"
-	]),
-	defaultColumns: number().int().min(1).max(12).default(6),
-	defaultRows: number().int().min(1).max(12).default(1)
-});
-var addonWidgetsSourceCapability = {
-	name: "addon-widgets-source",
-	scope: "system",
-	mode: "collection",
-	internal: true,
-	methods: { listWidgets: method(_void(), array(WidgetMetadataSchema).readonly()) }
-};
+var KEYWORDS = new Set([
+	"true",
+	"false",
+	"null"
+]);
+function isDigit(ch) {
+	return ch >= "0" && ch <= "9";
+}
+function isIdentStart(ch) {
+	return ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_";
+}
+function isIdentPart(ch) {
+	return isIdentStart(ch) || isDigit(ch);
+}
+function isWhitespace(ch) {
+	return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
+}
+/** Tokenize `source` into a flat token list ending with a single `eof` token.
+*  Throws `ExpressionParseError` on any illegal character or unterminated
+*  string. */
+function tokenize(source) {
+	if (source.length > 2048) throw new ExpressionParseError(`expression too long (${source.length} > ${MAX_EXPRESSION_SOURCE_LENGTH} chars)`, 0);
+	const tokens = [];
+	let i = 0;
+	const n = source.length;
+	while (i < n) {
+		const ch = source[i];
+		if (isWhitespace(ch)) {
+			i += 1;
+			continue;
+		}
+		if (isDigit(ch)) {
+			const start = i;
+			while (i < n && isDigit(source[i])) i += 1;
+			if (i < n && source[i] === ".") {
+				if (i + 1 >= n || !isDigit(source[i + 1])) throw new ExpressionParseError("malformed number: decimal point needs a digit", i);
+				i += 1;
+				while (i < n && isDigit(source[i])) i += 1;
+			}
+			const text = source.slice(start, i);
+			const value = Number(text);
+			if (!Number.isFinite(value)) throw new ExpressionParseError(`malformed number: '${text}'`, start);
+			tokens.push({
+				type: "number",
+				value,
+				pos: start
+			});
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			const quote = ch;
+			const start = i;
+			i += 1;
+			let out = "";
+			let closed = false;
+			while (i < n) {
+				const c = source[i];
+				if (c === "\\") {
+					const next = i + 1 < n ? source[i + 1] : "";
+					if (next === "\\" || next === "'" || next === "\"") {
+						out += next;
+						i += 2;
+						continue;
+					}
+					throw new ExpressionParseError(`invalid string escape: '\\${next}'`, i);
+				}
+				if (c === quote) {
+					closed = true;
+					i += 1;
+					break;
+				}
+				out += c;
+				i += 1;
+			}
+			if (!closed) throw new ExpressionParseError("unterminated string literal", start);
+			tokens.push({
+				type: "string",
+				value: out,
+				pos: start
+			});
+			continue;
+		}
+		if (isIdentStart(ch)) {
+			const start = i;
+			while (i < n && isIdentPart(source[i])) i += 1;
+			const text = source.slice(start, i);
+			if (KEYWORDS.has(text)) tokens.push({
+				type: "keyword",
+				keyword: keywordOf(text),
+				pos: start
+			});
+			else tokens.push({
+				type: "identifier",
+				name: text,
+				pos: start
+			});
+			continue;
+		}
+		const two = i + 1 < n ? source.slice(i, i + 2) : "";
+		if (two === "<=" || two === ">=" || two === "==" || two === "!=" || two === "&&" || two === "||") {
+			tokens.push({
+				type: "punct",
+				punct: two,
+				pos: i
+			});
+			i += 2;
+			continue;
+		}
+		if (isSinglePunct(ch)) {
+			tokens.push({
+				type: "punct",
+				punct: ch,
+				pos: i
+			});
+			i += 1;
+			continue;
+		}
+		throw new ExpressionParseError(`unexpected character '${ch}'`, i);
+	}
+	tokens.push({
+		type: "eof",
+		pos: n
+	});
+	return tokens;
+}
+function keywordOf(text) {
+	if (text === "true") return "true";
+	if (text === "false") return "false";
+	return "null";
+}
+function isSinglePunct(ch) {
+	return ch === "(" || ch === ")" || ch === "," || ch === "?" || ch === ":" || ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%" || ch === "!" || ch === "<" || ch === ">";
+}
 /**
-* `addon-widgets` — system-scoped singleton aggregator cap. Public-facing
-* surface that admin-ui consumes through `useAddonWidgetsListWidgets()`.
-*
-* The provider iterates every `addon-widgets-source` (collection)
-* provider and emits `EnrichedWidgetMetadata[]` enriched with versioned
-* `bundleUrl` strings pointing at
-* `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. The filesystem
-* `mtime` cache-buster lets the browser pick up addon rebuilds without
-* manual reload — same scheme used by `addon-pages`.
+* Pratt (precedence-climbing) parser for the safe expression mini-language.
 *
-* The hub-local builtin `addon-widgets-aggregator` (see
-* `@camstack/system/builtins/addon-widgets-aggregator`) registers the
-* provider. Splitting the public aggregator from the raw collection
-* keeps both ends in codegen — there's no hand-written wrapper.
-*/
-var EnrichedWidgetMetadataSchema = WidgetMetadataSchema.extend({
-	addonId: string(),
-	bundleUrl: string()
-});
-method(_void(), array(EnrichedWidgetMetadataSchema).readonly());
-/**
-* Alerts capability — collection-based internal alert system.
+* Precedence (low → high): ternary `?:` (right-assoc) → `||` → `&&` → equality
+* → relational → additive → multiplicative → unary `! -` → call / primary.
+* Calls are ONLY `IDENT '(' args? ')'` at primary position — the callee is a
+* string validated against the builtin table at parse time, so an unknown
+* function is rejected immediately (author feedback) and a persisted expression
+* that references a since-removed builtin degrades at read.
 *
-* Multiple providers can register. Each provider filters by EventBus category
-* and creates/updates alerts. The built-in Alert Center addon persists alerts
-* in the DB and serves them to the admin UI.
-*/
-var AlertSeveritySchema = _enum([
-	"info",
-	"success",
-	"warning",
-	"error"
-]);
-var AlertStatusSchema = _enum([
-	"active",
-	"in-progress",
-	"completed",
-	"failed",
-	"dismissed"
-]);
-var AlertSourceSchema = object({
-	type: string(),
-	id: string()
-});
-var AlertSchema = object({
-	id: string(),
-	category: string(),
-	severity: AlertSeveritySchema,
-	title: string(),
-	message: string(),
-	status: AlertStatusSchema,
-	progress: number().optional(),
-	read: boolean(),
-	createdAt: number(),
-	updatedAt: number(),
-	source: AlertSourceSchema.optional(),
-	metadata: record(string(), unknown()).optional()
-});
-method(AlertSchema, _void(), { kind: "mutation" }), method(object({
-	alertId: string(),
-	patch: AlertSchema.partial()
-}), _void(), { kind: "mutation" }), method(object({
-	unreadOnly: boolean().optional(),
-	limit: number().optional()
-}).optional(), array(AlertSchema).readonly()), method(_void(), number()), method(object({ alertId: string() }), _void(), { kind: "mutation" }), method(_void(), _void(), { kind: "mutation" }), method(object({ alertId: string() }), _void(), { kind: "mutation" });
-DeviceType.Camera, method(object({ deviceId: number() }), custom()), object({
-	deviceId: number(),
-	rms: number(),
-	dbfs: number()
-});
-/** Shared Zod schemas used across detection capabilities. */
-/**
-* Canonical frame-format enum mirrored on `FrameFormat` in
-* `packages/types/src/types/io.ts`. Kept inline (vs imported) so the
-* Zod runtime schema and TypeScript type stay in sync at the call site
-* — adding a new format requires changing both this enum and the
-* `FrameFormat` type alias together.
+* A node counter caps total AST size (`MAX_EXPRESSION_AST_NODES`) and call
+* arity is capped (`MAX_EXPRESSION_CALL_ARGS`) — both raise `ExpressionParseError`.
 */
-var FrameFormatSchema = _enum([
-	"jpeg",
-	"rgb",
-	"bgr",
-	"yuv420",
-	"gray"
-]);
-var FrameInputSchema = object({
-	data: custom(),
-	format: FrameFormatSchema,
-	width: number(),
-	height: number(),
-	timestamp: number()
-});
-var BoundingBoxSchema = object({
-	x: number(),
-	y: number(),
-	w: number(),
-	h: number()
-});
-object({
-	class: string(),
-	originalClass: string(),
-	score: number(),
-	bbox: BoundingBoxSchema
-});
-/**
-* `data` carries the raw f32le bytes of the PCM samples (4 bytes per
-* sample, little-endian IEEE 754).  `Uint8Array` is the wire-safe choice
-* because `@msgpack/msgpack` serialises it as a MsgPack `bin` type that
-* round-trips losslessly over the UDS transport.  `Float32Array` is NOT
-* preserved — the encoder serialises it as `bin` (its raw bytes) but
-* the decoder returns `Uint8Array`, so treating a `Float32Array` as the
-* wire type causes receivers to read bytes as sample values, producing
-* wildly wrong RMS/dBFS results (~+43 dBFS instead of ≤0).
-*
-* Callers that need float arithmetic reconstruct the view with:
-*   `new Float32Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength / 4)`
+/** Binary/logical operator precedence (higher binds tighter). */
+var BINARY_PRECEDENCE = {
+	"||": 1,
+	"&&": 2,
+	"==": 3,
+	"!=": 3,
+	"<": 4,
+	"<=": 4,
+	">": 4,
+	">=": 4,
+	"+": 5,
+	"-": 5,
+	"*": 6,
+	"/": 6,
+	"%": 6
+};
+function isLogicalOp(op) {
+	return op === "&&" || op === "||";
+}
+function isBinaryOp(op) {
+	return op === "+" || op === "-" || op === "*" || op === "/" || op === "%" || op === "==" || op === "!=" || op === "<" || op === "<=" || op === ">" || op === ">=";
+}
+var Parser = class {
+	tokens;
+	pos = 0;
+	nodeCount = 0;
+	identifiers = /* @__PURE__ */ new Set();
+	callees = /* @__PURE__ */ new Set();
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	parse() {
+		const ast = this.parseTernary();
+		const tok = this.peek();
+		if (tok.type !== "eof") throw new ExpressionParseError("unexpected trailing input", tok.pos);
+		return {
+			ast,
+			identifiers: this.identifiers,
+			callees: this.callees,
+			nodeCount: this.nodeCount
+		};
+	}
+	peek() {
+		return this.tokens[this.pos];
+	}
+	next() {
+		return this.tokens[this.pos++];
+	}
+	/** Consume a punctuator token, erroring if the next token isn't it. */
+	expectPunct(punct) {
+		const tok = this.peek();
+		if (tok.type !== "punct" || tok.punct !== punct) throw new ExpressionParseError(`expected '${punct}'`, tok.pos);
+		this.pos += 1;
+	}
+	matchPunct(punct) {
+		const tok = this.peek();
+		if (tok.type === "punct" && tok.punct === punct) {
+			this.pos += 1;
+			return true;
+		}
+		return false;
+	}
+	countNode() {
+		this.nodeCount += 1;
+		if (this.nodeCount > 256) throw new ExpressionParseError("expression too complex", this.peek().pos);
+	}
+	parseTernary() {
+		const test = this.parseBinary(1);
+		if (this.matchPunct("?")) {
+			const consequent = this.parseTernary();
+			this.expectPunct(":");
+			const alternate = this.parseTernary();
+			this.countNode();
+			return {
+				kind: "conditional",
+				test,
+				consequent,
+				alternate
+			};
+		}
+		return test;
+	}
+	parseBinary(minPrec) {
+		let left = this.parseUnary();
+		for (;;) {
+			const tok = this.peek();
+			if (tok.type !== "punct") break;
+			const prec = BINARY_PRECEDENCE[tok.punct];
+			if (prec === void 0 || prec < minPrec) break;
+			const op = tok.punct;
+			this.pos += 1;
+			const right = this.parseBinary(prec + 1);
+			this.countNode();
+			if (isLogicalOp(op)) left = {
+				kind: "logical",
+				op,
+				left,
+				right
+			};
+			else if (isBinaryOp(op)) left = {
+				kind: "binary",
+				op,
+				left,
+				right
+			};
+			else throw new ExpressionParseError(`unexpected operator '${op}'`, tok.pos);
+		}
+		return left;
+	}
+	parseUnary() {
+		const tok = this.peek();
+		if (tok.type === "punct" && (tok.punct === "!" || tok.punct === "-")) {
+			const op = tok.punct;
+			this.pos += 1;
+			const operand = this.parseUnary();
+			this.countNode();
+			return {
+				kind: "unary",
+				op,
+				operand
+			};
+		}
+		return this.parsePrimary();
+	}
+	parsePrimary() {
+		const tok = this.next();
+		switch (tok.type) {
+			case "number":
+				this.countNode();
+				return {
+					kind: "literal",
+					value: tok.value
+				};
+			case "string":
+				this.countNode();
+				return {
+					kind: "literal",
+					value: tok.value
+				};
+			case "keyword":
+				this.countNode();
+				return {
+					kind: "literal",
+					value: tok.keyword === "null" ? null : tok.keyword === "true"
+				};
+			case "identifier": {
+				const nextTok = this.peek();
+				if (nextTok.type === "punct" && nextTok.punct === "(") return this.parseCall(tok.name, tok.pos);
+				this.identifiers.add(tok.name);
+				this.countNode();
+				return {
+					kind: "identifier",
+					name: tok.name
+				};
+			}
+			case "punct":
+				if (tok.punct === "(") {
+					const inner = this.parseTernary();
+					this.expectPunct(")");
+					return inner;
+				}
+				throw new ExpressionParseError(`unexpected token '${tok.punct}'`, tok.pos);
+			case "eof": throw new ExpressionParseError("unexpected end of expression", tok.pos);
+		}
+	}
+	parseCall(callee, pos) {
+		if (!EXPRESSION_BUILTIN_NAMES.has(callee)) throw new ExpressionParseError(`unknown function '${callee}'`, pos);
+		this.expectPunct("(");
+		const args = [];
+		if (!this.matchPunct(")")) for (;;) {
+			args.push(this.parseTernary());
+			if (args.length > 16) throw new ExpressionParseError(`too many arguments to '${callee}'`, pos);
+			if (this.matchPunct(",")) continue;
+			this.expectPunct(")");
+			break;
+		}
+		this.callees.add(callee);
+		this.countNode();
+		return {
+			kind: "call",
+			callee,
+			args
+		};
+	}
+};
+/** Tokenize + parse `source` into a validated `ParsedExpression`. Throws
+*  `ExpressionParseError` on any lexical or grammatical failure. */
+function parseExpression(source) {
+	return new Parser(tokenize(source)).parse();
+}
+/**
+* LRU compile cache for parsed expressions (spec §2.4 "parse once … LRU keyed
+* by expr"). The cache stores BOTH successes and failures (negative caching),
+* so a corrupt persisted string costs exactly one tokenize+parse total — not
+* one per read on a hot resolve path.
+*
+* The cache is a module-level singleton: entries are pure, content-addressed
+* ASTs keyed by the raw source string, so sharing one instance across all
+* callers is safe and maximises hit rate.
+*/
+var cache = /* @__PURE__ */ new Map();
+function getCached(source) {
+	const hit = cache.get(source);
+	if (hit !== void 0) {
+		cache.delete(source);
+		cache.set(source, hit);
+		return hit;
+	}
+	let result;
+	try {
+		result = {
+			ok: true,
+			parsed: parseExpression(source)
+		};
+	} catch (err) {
+		result = {
+			ok: false,
+			error: err instanceof ExpressionParseError ? err.message : String(err)
+		};
+	}
+	cache.set(source, result);
+	if (cache.size > 256) {
+		const oldest = cache.keys().next().value;
+		if (oldest !== void 0) cache.delete(oldest);
+	}
+	return result;
+}
+/** Compile `source`, returning a discriminated result instead of throwing.
+*  Used by read paths that must degrade rather than raise. LRU/negative-cached. */
+function compileExpressionSafe(source) {
+	return getCached(source);
+}
+Object.freeze({});
+/**
+* Author-time validation. Returns `null` when the source is valid, else a
+* human-readable error message. Checks: the expression compiles; binding count
+* is within `MAX_EXPRESSION_BINDINGS`; every binding name is a legal identifier,
+* is not reserved (`now`/keywords) and does not shadow a builtin; and every
+* FREE identifier of the AST is covered by a binding or the injected `now`.
+*/
+function validateExpressionSource(src) {
+	const names = Object.keys(src.bindings);
+	if (names.length > 32) return `too many bindings (${names.length} > 32)`;
+	for (const name of names) {
+		if (!EXPRESSION_IDENTIFIER_RE.test(name)) return `invalid binding name '${name}'`;
+		if (RESERVED_BINDING_NAMES.has(name)) return `binding name '${name}' is reserved`;
+		if (EXPRESSION_BUILTIN_NAMES.has(name)) return `binding name '${name}' shadows a builtin function`;
+	}
+	const compiled = compileExpressionSafe(src.expr);
+	if (!compiled.ok) return compiled.error;
+	const bound = new Set(names);
+	for (const id of compiled.parsed.identifiers) {
+		if (id === "now") continue;
+		if (!bound.has(id)) return `expression references unbound identifier '${id}'`;
+	}
+	return null;
+}
+var ExpressionBindingSourceSchema = union([
+	object({
+		kind: literal("field").optional(),
+		sourceKey: string(),
+		cap: string(),
+		fieldPath: string()
+	}),
+	object({
+		kind: literal("literal"),
+		value: union([
+			string(),
+			number(),
+			boolean(),
+			_null()
+		])
+	}),
+	object({
+		kind: literal("global"),
+		sourceStableId: string(),
+		cap: string(),
+		fieldPath: string()
+	})
+]);
+object({
+	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+}).superRefine((src, ctx) => {
+	const err = validateExpressionSource(src);
+	if (err !== null) ctx.addIssue({
+		code: "custom",
+		message: err,
+		path: ["expr"]
+	});
+});
+/** How a leaf compares a device field to a value. Derived from the field's
+*  `kind` in `deviceManager.getWireableFields`, never hand-maintained. */
+var AutomationConditionOperatorSchema = _enum([
+	"eq",
+	"ne",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"contains",
+	"in"
+]);
+var AutomationConditionLeafSchema = object({
+	kind: literal("condition"),
+	deviceId: number().int().nonnegative(),
+	cap: string().min(1),
+	fieldPath: string().min(1),
+	operator: AutomationConditionOperatorSchema,
+	value: union([
+		string(),
+		number(),
+		boolean(),
+		array(union([string(), number()]))
+	])
+});
+/**
+* The expression leaf, declared as a plain object rather than an intersection
+* with {@link ExpressionSourceSchema}: a discriminated union has to be able to
+* read `kind` off each option, and an intersection hides it. The author-time
+* validation is the SAME function `ExpressionSourceSchema` runs, so the two
+* cannot drift — an expression that one accepts, the other accepts.
+*/
+var AutomationConditionExpressionSchema = object({
+	kind: literal("expression"),
+	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
+	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
+}).superRefine((src, ctx) => {
+	const err = validateExpressionSource(src);
+	if (err !== null) ctx.addIssue({
+		code: "custom",
+		message: err,
+		path: ["expr"]
+	});
+});
+var AutomationConditionSchema = lazy(() => discriminatedUnion("kind", [
+	object({
+		kind: literal("all"),
+		children: array(AutomationConditionSchema)
+	}),
+	object({
+		kind: literal("any"),
+		children: array(AutomationConditionSchema)
+	}),
+	object({
+		kind: literal("not"),
+		child: AutomationConditionSchema
+	}),
+	AutomationConditionLeafSchema,
+	AutomationConditionExpressionSchema
+]));
+/**
+* What starts a run.
+*
+* D8 compliance, and it is the reason `device-state` is not merely an event
+* subscription: the trigger evaluates against the **state mirror**, which is
+* reconciled, and an event only WAKES the evaluation. A dropped event therefore
+* DELAYS a trigger; it does not lose it. `schedule` uses `croner` — the one
+* already in the repo — because `setInterval(24h)` drifts and "at 23:30" does
+* not.
+*/
+var AutomationTriggerSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("device-state"),
+		deviceId: number().int().nonnegative(),
+		cap: string().min(1),
+		fieldPath: string().min(1),
+		/** Fire when the field takes this value. Omit to fire on any change. */
+		becomes: union([
+			string(),
+			number(),
+			boolean()
+		]).optional(),
+		/** Only on a CHANGE of value, not on every re-report. */
+		edge: boolean().optional(),
+		/** The condition must hold this long before the run starts. */
+		forMs: number().int().min(0).max(864e5).optional(),
+		/** Collapse a burst into one run. */
+		debounceMs: number().int().min(0).max(6e5).optional()
+	}),
+	object({
+		kind: literal("device-event"),
+		/** An `EventCategory` value. */
+		category: string().min(1),
+		deviceId: number().int().nonnegative().optional()
+	}),
+	object({
+		kind: literal("schedule"),
+		cron: string().min(1).max(120)
+	}),
+	object({ kind: literal("manual") })
+]);
+/**
+* One action step.
+*
+* `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.
+*/
+var AutomationActionSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("wait"),
+		seconds: number().min(0).max(300)
+	}),
+	object({
+		kind: literal("cap"),
+		deviceId: union([number().int(), object({ $var: string().min(1) })]),
+		cap: string().min(1),
+		method: string().min(1),
+		/** Values may carry `{{vars.x}}` slots, which SUBSTITUTE and do not
+		*  evaluate (§3.2.3). Anything beyond substitution is the expression leaf. */
+		args: record(string(), unknown()).optional()
+	}),
+	object({
+		kind: literal("code"),
+		/** Compiled into the automation's OWN block by esbuild — not a third
+		*  runtime, not a `vm`, and not dynamically evaluated. */
+		code: string().min(1).max(2e4)
+	})
+]);
+object({
+	triggers: array(AutomationTriggerSchema),
+	conditions: AutomationConditionSchema.optional(),
+	actions: array(AutomationActionSchema)
+});
+/**
+* `addon-pages` — system-scoped singleton aggregator cap. Public-facing
+* surface that admin-ui consumes through `useAddonPagesListPages()`.
+*
+* The provider iterates every `addon-pages-source` (collection) provider
+* and emits `AddonPageInfo[]` enriched with versioned `bundleUrl` strings
+* pointing at `/api/addon-pages/<addonId>/<bundle>?v=<mtime>`. The
+* filesystem `mtime` cache-buster lets the browser pick up addon
+* rebuilds without manual reload.
+*
+* The hub-local builtin `addon-pages-aggregator` (see
+* `@camstack/system/builtins/addon-pages-aggregator`) registers the
+* provider. Splitting the public aggregator from the raw collection
+* keeps both ends in codegen — there's no hand-written
+* `addon-pages.router.ts` wrapper anymore.
+*/
+var AddonPageDeclarationSchema$1 = object({
+	id: string(),
+	label: string(),
+	icon: string(),
+	path: string(),
+	remoteName: string(),
+	bundle: string(),
+	section: string().optional(),
+	sectionLabel: string().optional()
+});
+var AddonPageInfoSchema = object({
+	addonId: string(),
+	page: AddonPageDeclarationSchema$1,
+	bundleUrl: string()
+});
+method(_void(), array(AddonPageInfoSchema).readonly());
+/**
+* `addon-pages-source` — collection cap exposing per-provider raw page
+* declarations. Every addon that contributes a UI page registers a
+* provider here. The hub-side singleton aggregator (`addon-pages` cap,
+* see `addon-pages.cap.ts`) walks this collection, stamps versioned
+* `bundleUrl` values, and returns the enriched `AddonPageInfo[]` list
+* that admin-ui consumes.
+*
+* The split exists because the public listing has a different output
+* shape than the per-provider raw declarations, and we want both ends
+* to flow through codegen instead of relying on a hand-written wrapper.
+*/
+var AddonPageDeclarationSchema = object({
+	id: string(),
+	label: string(),
+	icon: string(),
+	path: string(),
+	/**
+	* Module Federation remote name — must match the `name` field on the
+	* page addon's `federation()` plugin config. Used by admin-ui's
+	* `<AddonPageLoader>` to call `loadRemote('<remoteName>/page')`.
+	* Conventionally `addon_<id>_page` (snake_case; MF names cannot
+	* contain hyphens).
+	*/
+	remoteName: string(),
+	/**
+	* Bundle filename inside the addon's `dist/` dir served at
+	* `/api/addon-pages/<addonId>/<bundle>`. With Module Federation this
+	* is always `'remoteEntry.js'`; the value is kept on the metadata so
+	* the static-file route can compute an mtime-based cache-buster URL
+	* without a separate filesystem stat.
+	*/
+	bundle: string(),
+	/**
+	* Sidebar section this page docks into. Well-known ids: `'detection'`,
+	* `'cluster'`, `'administration'` — the page renders inside that group.
+	* Any OTHER string creates (or joins) a custom section rendered after
+	* the built-in groups; its label comes from `sectionLabel` (first
+	* declaration wins), falling back to the id. Absent → the legacy
+	* "Addon Pages" group.
+	*/
+	section: string().optional(),
+	/** Display label for a CUSTOM `section` id (ignored for well-known ids). */
+	sectionLabel: string().optional()
+});
+method(_void(), array(AddonPageDeclarationSchema).readonly());
+var AddonHttpRouteSchema = object({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"DELETE",
+		"PATCH"
+	]),
+	path: string(),
+	access: _enum([
+		"public",
+		"authenticated",
+		"admin"
+	]).optional(),
+	description: string().optional()
+});
+/**
+* Cross-process route invocation envelope. The hub captures the
+* request as plain data, ships it to the worker via Moleculer, and
+* the worker runs the local handler against a capturing reply. The
+* envelope returned describes what the handler intended (status,
+* headers, body, or a redirect) so the hub can translate it back to
+* the Fastify reply that's actually wired to the socket.
+*/
+var InvokeRequestSchema = object({
+	method: string(),
+	path: string(),
+	params: record(string(), string()),
+	query: record(string(), string()),
+	body: unknown(),
+	headers: record(string(), string()),
+	user: object({
+		id: string(),
+		username: string(),
+		isAdmin: boolean()
+	}).optional(),
+	scopedToken: unknown().optional()
+});
+var InvokeReplyEnvelopeSchema = object({
+	status: number().int(),
+	headers: record(string(), string()),
+	/** When set, the hub MUST `reply.redirect(redirectUrl)` instead of
+	*  sending `body`. Status defaults to 302 when this is set unless
+	*  the handler called `reply.code(...)` explicitly. */
+	redirectUrl: string().nullable(),
+	/** JSON-serializable body. `undefined` is treated as "no body". */
+	body: unknown().optional(),
+	/** Set when the handler called `reply.type(mime)`. */
+	contentType: string().optional()
+});
+method(_void(), array(AddonHttpRouteSchema)), method(InvokeRequestSchema, InvokeReplyEnvelopeSchema, { kind: "mutation" });
+var ConfigTabDeclarationSchema = object({
+	id: string(),
+	label: string(),
+	icon: string(),
+	order: number().optional()
+});
+var ConfigSectionWithValuesSchema = object({
+	id: string(),
+	title: string(),
+	description: string().optional(),
+	style: _enum(["card", "accordion"]).optional(),
+	defaultCollapsed: boolean().optional(),
+	columns: union([
+		literal(1),
+		literal(2),
+		literal(3),
+		literal(4)
+	]).optional(),
+	tab: string().optional(),
+	location: _enum(["settings", "top-tab"]).optional(),
+	order: number().optional(),
+	fields: array(any())
+});
+var SettingsSchemaWithValuesSchema = object({
+	tabs: array(ConfigTabDeclarationSchema).optional(),
+	sections: array(ConfigSectionWithValuesSchema)
+});
+/** Patch object — keys are field names, values are the new field values. */
+var SettingsPatchSchema = record(string(), unknown());
+/** Standard success response for update operations. */
+var SettingsUpdateResultSchema = object({ success: literal(true) });
+method(object({
+	addonId: string(),
+	nodeId: string().optional(),
+	overlay: record(string(), unknown()).optional(),
+	cap: string().optional()
+}), SettingsSchemaWithValuesSchema.nullable()), method(object({
+	addonId: string(),
+	nodeId: string().optional(),
+	patch: SettingsPatchSchema
+}), SettingsUpdateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	addonId: string(),
+	deviceId: number(),
+	nodeId: string().optional()
+}), SettingsSchemaWithValuesSchema.nullable()), method(object({
+	addonId: string(),
+	deviceId: number(),
+	nodeId: string().optional(),
+	patch: SettingsPatchSchema
+}), SettingsUpdateResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+});
+/**
+* `addon-widgets-source` — collection cap exposing per-addon raw widget
+* declarations. Mirrors the addon-pages split: every addon shipping
+* widgets registers a provider on this collection cap; the hub-local
+* aggregator (`addon-widgets`, see `addon-widgets.cap.ts`) walks the
+* collection, stamps versioned `bundleUrl`s onto each declaration, and
+* exposes the public listing surface that admin-ui consumes.
+*
+* The split exists because the public listing has a different output
+* shape (flat enriched metadata with `addonId` + `bundleUrl`) than the
+* per-provider raw declarations. Both ends flow through codegen.
+*
+* Unified UI-contribution model (Task 10): a widget descriptor IS a
+* `UiContribution` with `kind:'remote'`. The host renders it through the
+* same `ContributionRenderer` / Module-Federation path as every other
+* contributed UI surface — no bespoke widget-rendering path. The widget-
+* only metadata (sizing hints, `requires`) lives as extra fields on the
+* descriptor; the `UiContribution` core (`tab` / `label` / `order` /
+* `kind` / `remote`) carries identity + placement + the MF remote.
+*/
+/** Where the widget makes sense to render — maps to a contribution `tab`. */
+var WidgetHostEnum = _enum([
+	"device-tab",
+	"dashboard",
+	"integration-detail"
+]);
+var WidgetSizeEnum = _enum([
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl"
+]);
+/**
+* MF remote descriptor — mirrors `UiContributionRemote` from
+* `capability-definition.ts`. Widget remotes expose a single
+* `'./widgets'` module whose default export is a
+* `Record<componentKey, Component>` map; `componentKey` (the widget
+* `stableId`) picks the entry the host mounts.
+*/
+var WidgetRemoteSchema = object({
+	remoteName: string(),
+	exposedModule: string(),
+	componentKey: string().optional()
+});
+/**
+* One widget declaration — a `UiContribution` (`kind:'remote'`) plus
+* widget-only metadata. The `UiContribution` core fields:
+*
+*  - `tab`     — where the widget hosts. A widget that runs on the
+*                dashboard declares `tab:'dashboard'`; a device-tab
+*                widget declares the target device-detail tab id.
+*  - `subTab`  — optional sub-tab within `tab`.
+*  - `label`   — operator-facing label.
+*  - `order`   — ordering within `(tab, subTab)`.
+*  - `kind`    — always `'remote'` for widgets.
+*  - `remote`  — the MF remote `{ remoteName, exposedModule, componentKey }`.
+*
+* Widget-only fields retained alongside the contribution core:
+*
+*  - `stableId`      — stable identity within the addon (the MF
+*                      `componentKey`; kept top-level so consumers have
+*                      a stable key without reaching into `remote`).
+*  - `description` / `icon` — picker metadata.
+*  - `bundle`        — entry filename inside the addon `dist/` dir; the
+*                      aggregator stamps a versioned `bundleUrl` from it.
+*  - `hosts`         — every host the widget supports (a widget can run
+*                      both on the dashboard and a device tab). `tab`
+*                      is the PRIMARY host; `hosts` is the full set the
+*                      picker filters on.
+*  - `requires`      — host-context requirements validated at mount.
+*  - `defaultSize` / `allowedSizes` / `defaultColumns` / `defaultRows`
+*                    — dashboard placement hints.
+*/
+var WidgetMetadataSchema = object({
+	/** Primary host tab — `'dashboard'`, `'device-tab'`, or a device-detail tab id. */
+	tab: string(),
+	/** Optional sub-tab within `tab`. */
+	subTab: string().optional(),
+	/** Operator-facing label. */
+	label: string(),
+	/** Ordering within `(tab, subTab)`, ascending. */
+	order: number().optional(),
+	/** Always `'remote'` — a widget is a Module Federation remote. */
+	kind: literal("remote"),
+	/** MF remote descriptor. */
+	remote: WidgetRemoteSchema,
+	/** Stable id within the addon — kebab-case. Equals `remote.componentKey`. */
+	stableId: string(),
+	description: string().optional(),
+	icon: string().optional(),
+	/**
+	* Bundle filename inside the addon's `dist/` dir served at
+	* `/api/addon-widgets/<addonId>/<bundle>`. With Module Federation
+	* this is always `'remoteEntry.js'` — the value is kept on the
+	* metadata so the static-file route can compute an mtime-based
+	* cache-buster URL without a separate filesystem stat.
+	*/
+	bundle: string(),
+	/** Every host the widget supports. The picker filters on this set. */
+	hosts: array(WidgetHostEnum).readonly(),
+	/** Required props the host must supply. Validated at `<WidgetSlot>` mount. */
+	requires: object({
+		deviceContext: boolean().default(false),
+		integrationContext: boolean().default(false)
+	}),
+	/**
+	* Loadable BEFORE authentication. The normal widget registry listing
+	* (`addon-widgets.listWidgets`) is auth-gated, so a pre-auth surface
+	* (the login page) cannot discover a widget through it. A widget that
+	* declares `preAuth: true` marks itself as safe to mount on a pre-auth
+	* screen — it is surfaced through the PUBLIC `auth.listLoginMethods`
+	* login-method contribution channel (see `login-method.cap.ts`) rather
+	* than the authenticated registry, and its bundle is served by the
+	* public `/api/addon-widgets/:addonId/*` static route. Defaults false.
+	*/
+	preAuth: boolean().optional().default(false),
+	/** Dashboard placement HINTS (operator can override per instance). */
+	defaultSize: WidgetSizeEnum.default("md"),
+	allowedSizes: array(WidgetSizeEnum).readonly().default([
+		"sm",
+		"md",
+		"lg"
+	]),
+	defaultColumns: number().int().min(1).max(12).default(6),
+	defaultRows: number().int().min(1).max(12).default(1)
+});
+var addonWidgetsSourceCapability = {
+	name: "addon-widgets-source",
+	scope: "system",
+	mode: "collection",
+	internal: true,
+	methods: { listWidgets: method(_void(), array(WidgetMetadataSchema).readonly()) }
+};
+/**
+* `addon-widgets` — system-scoped singleton aggregator cap. Public-facing
+* surface that admin-ui consumes through `useAddonWidgetsListWidgets()`.
+*
+* The provider iterates every `addon-widgets-source` (collection)
+* provider and emits `EnrichedWidgetMetadata[]` enriched with versioned
+* `bundleUrl` strings pointing at
+* `/api/addon-widgets/<addonId>/<bundle>?v=<mtime>`. The filesystem
+* `mtime` cache-buster lets the browser pick up addon rebuilds without
+* manual reload — same scheme used by `addon-pages`.
+*
+* The hub-local builtin `addon-widgets-aggregator` (see
+* `@camstack/system/builtins/addon-widgets-aggregator`) registers the
+* provider. Splitting the public aggregator from the raw collection
+* keeps both ends in codegen — there's no hand-written wrapper.
+*/
+var EnrichedWidgetMetadataSchema = WidgetMetadataSchema.extend({
+	addonId: string(),
+	bundleUrl: string()
+});
+method(_void(), array(EnrichedWidgetMetadataSchema).readonly());
+/**
+* Alerts capability — collection-based internal alert system.
+*
+* Multiple providers can register. Each provider filters by EventBus category
+* and creates/updates alerts. The built-in Alert Center addon persists alerts
+* in the DB and serves them to the admin UI.
+*/
+var AlertSeveritySchema = _enum([
+	"info",
+	"success",
+	"warning",
+	"error"
+]);
+var AlertStatusSchema = _enum([
+	"active",
+	"in-progress",
+	"completed",
+	"failed",
+	"dismissed"
+]);
+var AlertSourceSchema = object({
+	type: string(),
+	id: string()
+});
+var AlertSchema = object({
+	id: string(),
+	category: string(),
+	severity: AlertSeveritySchema,
+	title: string(),
+	message: string(),
+	status: AlertStatusSchema,
+	progress: number().optional(),
+	read: boolean(),
+	createdAt: number(),
+	updatedAt: number(),
+	source: AlertSourceSchema.optional(),
+	metadata: record(string(), unknown()).optional()
+});
+method(AlertSchema, _void(), { kind: "mutation" }), method(object({
+	alertId: string(),
+	patch: AlertSchema.partial()
+}), _void(), { kind: "mutation" }), method(object({
+	unreadOnly: boolean().optional(),
+	limit: number().optional()
+}).optional(), array(AlertSchema).readonly()), method(_void(), number()), method(object({ alertId: string() }), _void(), { kind: "mutation" }), method(_void(), _void(), { kind: "mutation" }), method(object({ alertId: string() }), _void(), { kind: "mutation" });
+DeviceType.Camera, method(object({ deviceId: number() }), custom()), object({
+	deviceId: number(),
+	rms: number(),
+	dbfs: number()
+});
+/** Shared Zod schemas used across detection capabilities. */
+/**
+* Canonical frame-format enum mirrored on `FrameFormat` in
+* `packages/types/src/types/io.ts`. Kept inline (vs imported) so the
+* Zod runtime schema and TypeScript type stay in sync at the call site
+* — adding a new format requires changing both this enum and the
+* `FrameFormat` type alias together.
+*/
+var FrameFormatSchema = _enum([
+	"jpeg",
+	"rgb",
+	"bgr",
+	"yuv420",
+	"gray"
+]);
+var FrameInputSchema = object({
+	data: custom(),
+	format: FrameFormatSchema,
+	width: number(),
+	height: number(),
+	timestamp: number()
+});
+var BoundingBoxSchema = object({
+	x: number(),
+	y: number(),
+	w: number(),
+	h: number()
+});
+object({
+	class: string(),
+	originalClass: string(),
+	score: number(),
+	bbox: BoundingBoxSchema
+});
+/**
+* `data` carries the raw f32le bytes of the PCM samples (4 bytes per
+* sample, little-endian IEEE 754).  `Uint8Array` is the wire-safe choice
+* because `@msgpack/msgpack` serialises it as a MsgPack `bin` type that
+* round-trips losslessly over the UDS transport.  `Float32Array` is NOT
+* preserved — the encoder serialises it as `bin` (its raw bytes) but
+* the decoder returns `Uint8Array`, so treating a `Float32Array` as the
+* wire type causes receivers to read bytes as sample values, producing
+* wildly wrong RMS/dBFS results (~+43 dBFS instead of ≤0).
+*
+* Callers that need float arithmetic reconstruct the view with:
+*   `new Float32Array(chunk.data.buffer, chunk.data.byteOffset, chunk.data.byteLength / 4)`
 */
 var AudioChunkInputSchema = object({
 	data: _instanceof(Uint8Array),
@@ -11900,6 +12772,15 @@ method(object({
 }), method(ReleaseInputSchema.extend({ addonId: string() }), _void(), {
 	kind: "mutation",
 	auth: "admin"
+}), method(AdoptInputSchema.extend({ addonId: string() }), object({ jobId: string() }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	addonId: string(),
+	integrationId: string().optional()
+}), array(AdoptionJobSchema).readonly(), { auth: "admin" }), method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(ResyncInputSchema, ResyncResultSchema, {
 	kind: "mutation",
 	auth: "admin"
@@ -12622,7 +13503,7 @@ DeviceType.Camera, method(object({
 * Why: pub/sub routing over the system event-bus loses fidelity
 * (callback shape, QoS guarantees, will/retain semantics) and adds
 * refcount bookkeeping that addons would rather own themselves. The
-* canonical consumer (`addon-export-ha-mqtt`) needs raw `mqtt.js`
+* canonical consumer needs raw `mqtt.js`
 * features anyway — give it the connection config, get out of the way.
 *
 * Consumer flow:
@@ -14779,6 +15660,65 @@ object({
 * Each provider returns a static descriptor; the core enumerates them
 * to validate the `integration=` query param and resolve the consent
 * label + the scopes baked into the issued token.
+*
+* ## Declaring one
+*
+* An OAuth client is integration-specific knowledge — who the client is, what
+* it may ask for, where it may be sent — so it is declared by the ADDON that
+* owns the integration, never by the kernel and never as a branch inside
+* `oauth2-routes.ts` ([D101](../../../../docs/decisions/adr-0101.md)). Three
+* steps, no others:
+*
+* 1. Add `{ "name": "oauth-integration" }` to the addon's `camstack.addons[]`
+*    manifest entry. This is also what tells the hub, at addon-LOAD time, that
+*    a descriptor is owed — see "the boot window" below.
+* 2. Return a provider from `onInitialize()`:
+*
+*    ```ts
+*    const provider: IOauthIntegrationProvider = {
+*      getDescriptor: async () => ({
+*        integrationId: 'my-thing',      // the `integration=` query param
+*        displayName: 'My Thing',
+*        requestedScopes: [ … ],         // see below
+*        allowedRedirectPrefixes: ['https://callback.example/'],
+*      }),
+*    }
+*    return [{ capability: oauthIntegrationCapability, provider }]
+*    ```
+*
+*    The descriptor must be **static** — it is read on the authorize path, so
+*    never put an await on network or disk behind it, and never register it
+*    behind one either (a provider is registered only once `onInitialize`
+*    RETURNS, so anything awaited before the return delays linking).
+* 3. Nothing else. There is no allow-list to join, no id to register with the
+*    core, and no per-integration branch anywhere: `/api/oauth2/authorize` and
+*    `/api/oauth2/integrations` are built from this collection alone.
+*
+* **Scopes.** `requestedScopes` is baked into every token this integration is
+* ever issued and the operator consents to it once. Derive it from the tRPC
+* paths the client calls **with that token**, against `METHOD_ACCESS_MAP`, and
+* prefer a narrow `capability:` scope to a `category:` one unless the client
+* genuinely needs a whole family. A category scope grants every future member
+* of that category too. `category:system [create]` has been rejected once and
+* should stay rejected: it hands `addons.installPackage` to an integration.
+*
+* What it does NOT cover: calls the ADDON makes over `ctx.api`, which run as
+* the addon and are not scope-checked. Alexa's descriptor is narrower than
+* Home Assistant's for exactly that reason — its Lambda posts directives and
+* the addon does the work, while the Home Assistant component calls tRPC
+* directly with the token. So `requestedScopes` describes the blast radius of
+* the GRANT, not the reach of the integration; do not widen one to describe the
+* other.
+*
+* **The boot window.** An addon registers its provider after its runner forks
+* and initialises, so between hub start and that moment this collection is
+* incomplete and an `integrationId` can be legitimately absent. The core does
+* not wait, poll or cache around this ([D3](../../../../docs/decisions/adr-0003.md)):
+* it compares the manifest declarers against the registered providers and
+* answers `503 temporarily_unavailable` (with `Retry-After` and the pending
+* addon ids) instead of `400 unknown integration`, and reports
+* `complete: false` on `GET /api/oauth2/integrations`. A client should retry
+* while the list is incomplete rather than conclude the hub cannot do OAuth.
 */
 var OauthIntegrationDescriptorSchema = object({
 	/** Stable id used as the `integration=` query param, e.g. 'export-alexa'. */
@@ -15162,8 +16102,26 @@ var TrackSchema = object({
 	/** Periodic snapshots at snapshotIntervalMs cadence (subject to
 	*  saveThumbnails policy). */
 	snapshots: array(TrackSnapshotSchema).readonly(),
-	/** Deduplicated zones the track has entered at least once. */
+	/** Deduplicated zones the track has entered at least once. Zone IDS. */
 	zonesVisited: array(string()).readonly(),
+	/**
+	* Human NAMES for {@link zonesVisited}, resolved at READ time against the
+	* `zones` capability.
+	*
+	* `zonesVisited` persists ids (`cfeec78c-8d69-…`), which no operator can type
+	* and no card can render — so every free-text search surface was structurally
+	* unable to answer "show me the tracks in Uscio", and did not fail loudly, it
+	* just returned nothing. Resolving here rather than in each client keeps ONE
+	* derivation and costs the clients no extra call (the `zones` cap is
+	* per-device, so a client-side resolve would be a per-camera fan-out on a
+	* surface built to avoid exactly that).
+	*
+	* Resolved, never invented: a zone deleted since the track was written has no
+	* name and is DROPPED, so this array can be shorter than `zonesVisited` — the
+	* two are not positionally aligned. Absent when the track visited no zone, or
+	* when the zone catalogue could not be read.
+	*/
+	zoneNames: array(string()).readonly().optional(),
 	/** Deduplicated set of detector classes observed for this track over its
 	*  life (a track may be reclassified, e.g. person→vehicle). Absent on
 	*  legacy rows written before class accumulation shipped. */
@@ -18435,6 +19393,37 @@ DeviceType.Camera, method(object({
 	lastCapturedAt: number().nullable(),
 	cacheAgeMs: number().nullable(),
 	etag: string().nullable()
+}))), systemMethod(object({ 
+/** The tiles a surface is actually rendering. One entry per (device,
+*  width) the caller will paint — the width is snapped to the server's
+*  ladder and becomes part of the link's SIGNED identity. */
+targets: array(object({
+	deviceId: number(),
+	/** Target width in px. Omit for the frame as captured — correct
+	*  for a full-bleed surface, wrong (and expensive) for a grid. */
+	width: number().int().positive().optional()
+})).min(1).max(200) }), array(object({
+	deviceId: number(),
+	/** Root-relative signed path, or null when the link plane is not
+	*  served (no data-plane facility). Present even for a device that has
+	*  never captured — the request is what triggers the first one (D94). */
+	url: string().nullable(),
+	/** Epoch ms of the frame this link serves. Null = never captured.
+	*  THE honest age: the tRPC path carried none before this. */
+	capturedAt: number().nullable(),
+	/** Age of that frame at the moment the answer was built. */
+	ageMs: number().nullable(),
+	/** Epoch ms after which `url` stops verifying. */
+	expiresAt: number().nullable(),
+	/** Ladder rung the bytes are at; null = the frame as captured. */
+	width: number().nullable(),
+	/** The device has never produced a frame. An empty state, not a
+	*  failure — and never a reason to withhold the link (D94). */
+	neverCaptured: boolean(),
+	/** A sleeping battery camera: the frame is deliberately stale and will
+	*  NOT refresh in the background. A surface should say so rather than
+	*  present it as current. */
+	sleeping: boolean()
 })));
 /**
 * `sso-bridge` — internal hub-only cap that lets SSO-style auth
@@ -20185,6 +21174,37 @@ DeviceType.Light, method(object({
 	mireds: number().int().optional(),
 	lastChangedAt: number()
 });
+var ConnectionTestOutcomeSchema = discriminatedUnion("outcome", [
+	object({
+		outcome: literal("validated"),
+		/** Round-trip of the sign-in, when the provider measured it. */
+		latencyMs: number().nonnegative().optional(),
+		/** Optional human detail worth showing next to the tick
+		*  ("3 devices visible on this account"). */
+		detail: string().optional()
+	}).strict(),
+	object({
+		outcome: literal("rejected"),
+		error: string()
+	}).strict(),
+	object({
+		outcome: literal("inconclusive"),
+		error: string()
+	}).strict()
+]);
+var ConnectionTestInputSchema = object({ 
+/** Candidate integration settings, exactly as the create form collected them. */
+settings: record(string(), unknown()) });
+/**
+* What the provider's test actually DOES, so the UI can say it in words before
+* the operator presses the button ("Signs in to the Dreo cloud"). Purely
+* descriptive — it never changes routing.
+*/
+var ConnectionTestDescriptorSchema = object({ label: string() });
+method(ConnectionTestInputSchema, ConnectionTestOutcomeSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), ConnectionTestDescriptorSchema, { auth: "admin" });
 object({
 	/** True when the upstream system considers the entity connected. */
 	connected: boolean(),
@@ -21086,15 +22106,57 @@ var AvailableIntegrationTypeSchema = object({
 	*  flow can import (e.g. HA areas). Drives the adopt modal's "import
 	*  locations" checkbox. Provider-declared in the addon manifest. */
 	supportsLocationImport: boolean(),
+	/**
+	* True when this integration DECLARES a pre-creation test (the
+	* `connection-test` cap, or a broker whose settings it stores). Drives the
+	* Test button: an integration that cannot be tested must say so up front
+	* rather than offering a button that always answers the same nonsense.
+	*/
+	canTest: boolean(),
 	existingInstances: array(object({
 		id: string(),
 		name: string()
 	})),
 	canAdd: boolean()
 });
+/**
+* Why a test could not be answered as a plain boolean.
+*
+* `success` alone collapsed four different situations into one red box, and the
+* one that mattered most — "nobody ever asked the remote anything" — looked
+* exactly like "the remote said no". The status is the discriminator:
+*
+*   - `validated`    — a provider-declared test ran and the remote ACCEPTED.
+*   - `rejected`     — a provider-declared test ran and the remote REFUSED.
+*                      The only status that blocks `integrations.create`.
+*   - `inconclusive` — a test IS declared but could not complete (timeout,
+*                      DNS, 5xx). Nothing was observed; not a failure.
+*   - `unsupported`  — this integration declares NO test. Nothing was
+*                      observed either; not a failure, and not a pass.
+*
+* `unsupported` and `inconclusive` both carry `success: false` so an older
+* client can never read them as a green tick, and both carry an `error` string
+* that SAYS the test did not run rather than inventing a failure.
+*/
+var TestConnectionStatusEnum = _enum([
+	"validated",
+	"rejected",
+	"inconclusive",
+	"unsupported"
+]);
 var TestConnectionResultSchema$1 = object({
+	/** True ONLY for `validated`. Never true for a test that did not run. */
 	success: boolean(),
-	error: string().optional()
+	error: string().optional(),
+	/** Optional for wire back-compat with clients built before the tri-state;
+	*  the server always sets it. */
+	status: TestConnectionStatusEnum.optional(),
+	/** Addon id whose declared test answered — `null` when none did. Lets the UI
+	*  attribute a result instead of blaming "the integration". */
+	testedBy: string().nullable().optional(),
+	latencyMs: number().nonnegative().optional(),
+	/** Human detail from a `validated` result ("3 devices on this account"). */
+	detail: string().optional()
 });
 var CreateIntegrationInputSchema = object({
 	addonId: string(),
@@ -24069,1208 +25131,579 @@ var TotpStatusSchema = object({
 method(_void(), array(UserSummarySchema), { auth: "admin" }), method(CreateUserInputSchema, UserSummarySchema, {
 	kind: "mutation",
 	auth: "admin",
-	access: "create"
-}), method(UpdateUserInputSchema, object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "delete"
-}), method(object({
-	id: string(),
-	newPassword: string().min(6)
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({
-	userId: string(),
-	scopes: array(TokenScopeSchema)
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({
-	username: string(),
-	password: string()
-}), UserSummarySchema.extend({ passwordHash: string() }).nullable(), {
-	kind: "mutation",
-	access: "view"
-}), method(_void(), array(ApiKeySummarySchema), { auth: "admin" }), method(CreateApiKeyInputSchema, CreateApiKeyResultSchema, {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "delete"
-}), method(object({ token: string() }), ApiKeySummarySchema.nullable(), {
-	kind: "mutation",
-	access: "view"
-}), method(CreateScopedTokenInputSchema, CreateScopedTokenResultSchema, {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "delete"
-}), method(object({ token: string() }), ScopedTokenSummarySchema.nullable(), { access: "view" }), method(object({ userId: string() }), array(ScopedTokenSummarySchema), { auth: "admin" }), method(object({ userId: string() }), TotpSetupResultSchema, {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({
-	userId: string(),
-	code: string()
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "create"
-}), method(object({ userId: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "delete"
-}), method(object({ userId: string() }), TotpStatusSchema, { auth: "admin" }), method(object({
-	userId: string(),
-	code: string()
-}), object({ valid: boolean() }), {
-	kind: "mutation",
-	access: "view"
-}), method(object({
-	integrationId: string(),
-	userId: string(),
-	username: string(),
-	scopes: array(TokenScopeSchema),
-	redirectUri: string(),
-	hubUrl: string(),
-	/** PKCE (RFC 7636) S256 challenge. Baked into the signed code; a code
-	*  that carries one can ONLY be exchanged with the matching verifier. */
-	codeChallenge: string().optional()
-}), object({ code: string() }), {
-	kind: "mutation",
-	access: "create"
-}), method(object({
-	code: string(),
-	redirectUri: string(),
-	/** PKCE verifier. REQUIRED when the code carries a challenge. */
-	codeVerifier: string().optional()
-}), object({
-	accessToken: string(),
-	refreshToken: string(),
-	expiresIn: number()
-}).nullable(), {
-	kind: "mutation",
-	access: "view"
-}), method(object({ refreshToken: string() }), object({
-	accessToken: string(),
-	refreshToken: string(),
-	expiresIn: number()
-}).nullable(), {
-	kind: "mutation",
-	access: "view"
-}), method(object({ token: string() }), object({
-	userId: string(),
-	username: string(),
-	scopes: array(TokenScopeSchema)
-}).nullable(), { access: "view" }), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
-	kind: "mutation",
-	auth: "admin",
-	access: "delete"
-});
-/**
-* Robot-vacuum cap. Models HA `vacuum.*` entities — anything with a
-* cleaning lifecycle plus a return-to-base / locate surface and an
-* optional fan-speed selector.
-*
-* State follows HA's canonical vacuum lifecycle: `idle` / `cleaning` /
-* `paused` / `returning` / `docked` / `error`. `batteryLevel`
-* (0..100) is nullable — some vacuums don't report a battery
-* percentage. `fanSpeed` is the current speed token (provider-verbatim,
-* e.g. `'standard'` / `'turbo'`) and `availableFanSpeeds` lists the
-* tokens the hardware accepts so the UI renders only supported choices.
-*
-* The `setFanSpeed` method takes the bare `speed` token — the provider
-* validates it against the vacuum's own list. `locate` triggers the
-* find-me chirp; `returnToBase` sends it home.
-*
-* Consumable / waste tanks: `cleanWater` / `dirtyWater` / `detergent` /
-* `dustBin` each carry a nullable `{ level (0..100 %), status ('ok' |
-* 'low' | 'full') }` reading. Native providers (e.g. Dreame, Roborock)
-* SHOULD populate whichever tanks the hardware has — leave a field `null`
-* only when the device has no such tank at all, and use a `TankStatus`
-* with both inner fields `null` when the tank exists but its level is
-* currently unknown. HA `vacuum.*` entities expose no per-tank telemetry,
-* so the HA provider leaves all four `null`.
-*/
-var VacuumStateSchema = _enum([
-	"idle",
-	"cleaning",
-	"paused",
-	"returning",
-	"docked",
-	"drying",
-	"error"
-]);
-/**
-* One consumable / waste tank on a robot vacuum (clean-water, dirty-water,
-* detergent or dust-bin). A tank can report a numeric fill `level` (0..100),
-* a discrete `status` (binary-style hardware), or both. Both `null` means the
-* level is currently unknown; the OWNING field being `null` means the
-* hardware has no such tank at all.
-*/
-var TankStatusSchema = object({
-	/** Numeric fill 0..100 when the hardware reports a percentage; null otherwise. */
-	level: number().min(0).max(100).nullable(),
-	/** Discrete state when the hardware is binary-mode; null otherwise. */
-	status: _enum([
-		"ok",
-		"low",
-		"full"
-	]).nullable()
-});
-object({
-	/** Lifecycle state of the vacuum. */
-	state: VacuumStateSchema,
-	/** 0..100 battery percentage. Null when the device has no battery
-	*  reading. */
-	batteryLevel: number().min(0).max(100).nullable(),
-	/** Current fan-speed token (provider-verbatim). Null when unknown or
-	*  the vacuum has no speed control. */
-	fanSpeed: string().nullable(),
-	/** Speed tokens the hardware accepts — drives the UI selector. */
-	availableFanSpeeds: array(string()),
-	/** Clean-water (mop) tank. Null when the hardware has no clean-water tank. */
-	cleanWater: TankStatusSchema.nullable(),
-	/** Dirty-water (recovery) tank. Null when the hardware has no dirty-water tank. */
-	dirtyWater: TankStatusSchema.nullable(),
-	/** Detergent tank. Null when the hardware has no detergent tank. */
-	detergent: TankStatusSchema.nullable(),
-	/** Dust bin. Null when the hardware has no dust bin. */
-	dustBin: TankStatusSchema.nullable(),
-	/** 0..100 cleaning-completion percentage of the current task, or null. */
-	progressPercent: number().min(0).max(100).nullable(),
-	/** Current error code (0 / null = no error). */
-	errorCode: number().nullable(),
-	/** Human label for {@link errorCode}, or null when none / undecodable. */
-	errorLabel: string().nullable(),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-DeviceType.Vacuum, method(object({ deviceId: number().int().nonnegative() }), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	access: "create"
+}), method(UpdateUserInputSchema, object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	auth: "admin",
+	access: "create"
+}), method(object({ id: string() }), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	auth: "admin",
+	access: "delete"
+}), method(object({
+	id: string(),
+	newPassword: string().min(6)
+}), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	auth: "admin",
+	access: "create"
+}), method(object({
+	userId: string(),
+	scopes: array(TokenScopeSchema)
+}), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
+	auth: "admin",
+	access: "create"
 }), method(object({
-	deviceId: number().int().nonnegative(),
-	speed: string().min(1)
-}), _void(), {
+	username: string(),
+	password: string()
+}), UserSummarySchema.extend({ passwordHash: string() }).nullable(), {
 	kind: "mutation",
-	auth: "admin"
-});
-object({
-	/** Lifecycle state of the valve. */
-	state: _enum([
-		"open",
-		"opening",
-		"closing",
-		"closed",
-		"stopped"
-	]),
-	/** 0 = fully closed, 100 = fully open. Null when the device has no
-	*  intermediate position surface. */
-	position: number().min(0).max(100).nullable(),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-DeviceType.Valve, method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	access: "view"
+}), method(_void(), array(ApiKeySummarySchema), { auth: "admin" }), method(CreateApiKeyInputSchema, CreateApiKeyResultSchema, {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	auth: "admin",
+	access: "create"
+}), method(object({ id: string() }), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	auth: "admin",
+	access: "delete"
+}), method(object({ token: string() }), ApiKeySummarySchema.nullable(), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number().int().nonnegative(),
-	position: number().min(0).max(100)
-}), _void(), {
+	access: "view"
+}), method(CreateScopedTokenInputSchema, CreateScopedTokenResultSchema, {
 	kind: "mutation",
-	auth: "admin"
-});
-object({
-	detected: boolean(),
-	/** Ms epoch of the last transition. 0 if never observed. */
-	lastChangedAt: number()
-});
-DeviceType.Sensor;
-object({
-	/** Current measured temperature. Null when not reported. */
-	currentTemp: number().nullable(),
-	/** Target temperature setpoint. Null when no setpoint surface. */
-	targetTemp: number().nullable(),
-	/** Active operation mode = HA `state` (`eco` / `electric` / `gas` /
-	*  `heat_pump` / `high_demand` / `performance` / `off`). Null when the
-	*  device reports an unknown state. */
-	operationMode: string().nullable(),
-	/** Available operation modes = HA `operation_list`. */
-	availableModes: array(string()),
-	/** Away mode (HA `away_mode` 'on'/'off' → bool). Null when the device
-	*  has no away surface. */
-	away: boolean().nullable(),
-	/** HA `min_temp` attribute. Null when not reported. */
-	minTemp: number().nullable(),
-	/** HA `max_temp` attribute. Null when not reported. */
-	maxTemp: number().nullable(),
-	/** Ms epoch when the slice was last updated. */
-	lastChangedAt: number()
-});
-DeviceType.WaterHeater, method(object({
-	deviceId: number().int().nonnegative(),
-	temp: number().finite()
-}), _void(), {
+	auth: "admin",
+	access: "create"
+}), method(object({ id: string() }), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number().int().nonnegative(),
-	mode: string().min(1)
-}), _void(), {
+	auth: "admin",
+	access: "delete"
+}), method(object({ token: string() }), ScopedTokenSummarySchema.nullable(), { access: "view" }), method(object({ userId: string() }), array(ScopedTokenSummarySchema), { auth: "admin" }), method(object({ userId: string() }), TotpSetupResultSchema, {
 	kind: "mutation",
-	auth: "admin"
+	auth: "admin",
+	access: "create"
 }), method(object({
-	deviceId: number().int().nonnegative(),
-	on: boolean()
-}), _void(), {
+	userId: string(),
+	code: string()
+}), object({ success: literal(true) }), {
 	kind: "mutation",
-	auth: "admin"
-});
-object({
-	/** Verbatim HA condition state (`sunny`, `cloudy`, `rainy`, …). Null
-	*  when no condition has been reported yet. */
-	condition: string().nullable(),
-	/** Current temperature in the reported unit. Null when not provided. */
-	temperature: number().nullable(),
-	/** Temperature unit string (e.g. `°C` / `°F`). Null when not provided. */
-	temperatureUnit: string().nullable(),
-	/** Relative humidity (0..100). Null when not provided. */
-	humidity: number().min(0).max(100).nullable(),
-	/** Barometric pressure in the reported unit. Null when not provided. */
-	pressure: number().nullable(),
-	/** Pressure unit string (e.g. `hPa` / `inHg`). Null when not provided. */
-	pressureUnit: string().nullable(),
-	/** Wind speed in the reported unit. Null when not provided. */
-	windSpeed: number().nullable(),
-	/** Wind-speed unit string (e.g. `km/h` / `mph`). Null when not provided. */
-	windSpeedUnit: string().nullable(),
-	/** Wind bearing in degrees (0..360, meteorological). Null when not provided. */
-	windBearing: number().nullable(),
-	/** Ms epoch when the slice was last updated. */
-	lastFetchedAt: number()
-});
-DeviceType.Weather;
-/**
-* Per-zone occupancy aggregation produced by the analytics frame
-* processor on every inference result. Covers the full combinatorial
-* matrix the operator UI needs: total objects everywhere, total
-* objects per zone, single class everywhere, single class per zone,
-* objects outside any zone.
-*
-* Counts are derived from the analytics tracker (tracked detections
-* with stable trackIds), not raw detector hits — this filters out
-* one-off detector flickers and gives counts that match what the user
-* sees on the live overlay.
-*
-* Overlap policy: a detection that intersects two zones counts in
-* BOTH zones' `byClass` and `totalObjects` (count-in-each). The
-* `frame` aggregate de-duplicates trivially since it's frame-wide.
-* `unzoned` counts only detections that landed in zero zones.
-*/
-var PerScopeBreakdownSchema = object({
-	/** Total tracked objects in this scope (frame / zone / unzoned). */
-	totalObjects: number().int().nonnegative(),
-	/** Per-class count. Keys are macro class names (e.g. `person`, `car`). */
-	byClass: record(string(), number().int().nonnegative())
-});
-var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
-	zoneId: string(),
-	zoneName: string(),
-	/** TrackIds of objects currently inside this zone — for cross-reference
-	*  with the per-track detail panel and live overlay. */
-	trackIds: array(string()).readonly()
-});
-/**
-* A parked ("stationary") object surfaced alongside occupancy — an object that
-* settled and stopped moving. It is NO LONGER a tracked object (the tracker was
-* told to forget it so it stops re-spawning tracks/events), but it IS still
-* physically present, so it keeps counting toward `frame` occupancy and is
-* listed here so the UI can show it in a dedicated "Stationary" section instead
-* of flooding the live event feed.
-*/
-var StationaryObjectSchema = object({
-	id: string(),
-	className: string(),
-	bbox: object({
-		x: number(),
-		y: number(),
-		w: number(),
-		h: number()
-	}),
-	frameWidth: number().int().nonnegative(),
-	frameHeight: number().int().nonnegative(),
-	/** When the source track was first seen. */
-	firstSeenAt: number().int(),
-	/** When the object was recognised as parked (promotion time). */
-	becameStationaryAt: number().int(),
-	/** Last frame a detection confirmed the object is still there. */
-	lastConfirmedAt: number().int(),
-	/** Enrichment label carried from the source track (identity / plate). */
-	label: string().optional(),
-	/** Native-resolution key-frame media key for the parked object's best image. */
-	keyFrameMediaKey: string().optional()
-});
-var CameraOccupancySnapshotSchema = object({
-	/** Frame timestamp of the inference result that produced this snapshot. */
-	ts: number().int(),
-	/** Frame width/height in pixels — let the UI normalize bbox coords. */
-	frameWidth: number().int().nonnegative(),
-	frameHeight: number().int().nonnegative(),
-	/** Per-zone breakdown — one entry per defined zone (user + onboard). */
-	zones: array(ZoneScopeBreakdownSchema).readonly(),
-	/** Frame-wide aggregate (everywhere, regardless of zone membership).
-	*  INCLUDES currently-confirmed stationary objects (they are still present). */
-	frame: PerScopeBreakdownSchema,
-	/** Detections that landed outside every zone. Empty when no zones defined. */
-	unzoned: PerScopeBreakdownSchema,
-	/** Parked objects on this camera (additive — absent on legacy snapshots).
-	*  Surfaced separately so the UI shows them in a dedicated section rather
-	*  than as repeated tracks/events. */
-	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
-});
-/**
-* Time-series resolution. The history methods return one bucket per
-* step over the requested range. Smaller resolutions cost more
-* memory + bandwidth; bound to discrete steps so caller cannot ask
-* for arbitrary fractional buckets.
-*/
-var HistoryResolutionEnum = _enum([
-	"minute",
-	"5min",
-	"hour"
-]);
-var HistoryRangeSchema = object({
-	/** Range start (epoch ms, inclusive). */
-	from: number().int(),
-	/** Range end (epoch ms, inclusive). Defaults to "now" at query time. */
-	to: number().int(),
-	resolution: HistoryResolutionEnum
-});
-var HistoryPointSchema = object({
-	/** Bucket midpoint (epoch ms). */
-	ts: number().int(),
-	/** Object count averaged over the bucket (rounded to nearest integer). */
-	count: number().int().nonnegative()
+	auth: "admin",
+	access: "create"
+}), method(object({ userId: string() }), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin",
+	access: "delete"
+}), method(object({ userId: string() }), TotpStatusSchema, { auth: "admin" }), method(object({
+	userId: string(),
+	code: string()
+}), object({ valid: boolean() }), {
+	kind: "mutation",
+	access: "view"
+}), method(object({
+	integrationId: string(),
+	userId: string(),
+	username: string(),
+	scopes: array(TokenScopeSchema),
+	redirectUri: string(),
+	hubUrl: string(),
+	/** PKCE (RFC 7636) S256 challenge. Baked into the signed code; a code
+	*  that carries one can ONLY be exchanged with the matching verifier. */
+	codeChallenge: string().optional()
+}), object({ code: string() }), {
+	kind: "mutation",
+	access: "create"
+}), method(object({
+	code: string(),
+	redirectUri: string(),
+	/** PKCE verifier. REQUIRED when the code carries a challenge. */
+	codeVerifier: string().optional()
+}), object({
+	accessToken: string(),
+	refreshToken: string(),
+	expiresIn: number()
+}).nullable(), {
+	kind: "mutation",
+	access: "view"
+}), method(object({ refreshToken: string() }), object({
+	accessToken: string(),
+	refreshToken: string(),
+	expiresIn: number()
+}).nullable(), {
+	kind: "mutation",
+	access: "view"
+}), method(object({ token: string() }), object({
+	userId: string(),
+	username: string(),
+	scopes: array(TokenScopeSchema)
+}).nullable(), { access: "view" }), method(_void(), array(OauthSessionSummarySchema), { auth: "admin" }), method(object({ id: string() }), object({ success: boolean() }), {
+	kind: "mutation",
+	auth: "admin",
+	access: "delete"
 });
-DeviceType.Camera, method(object({ deviceId: number() }), CameraOccupancySnapshotSchema.nullable()), method(object({
-	deviceId: number(),
-	zoneId: string(),
-	className: string().optional()
-}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly()), method(object({
-	deviceId: number(),
-	className: string().optional()
-}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly()), method(object({
-	deviceId: number(),
-	className: string().optional()
-}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly());
-/**
-* Stages a {@link ZoneRule} can apply to. Discriminator on the rules
-* cap so a single CRUD surface backs every consumer; each stage has
-* its own dev-state mirror slice (`motion-zone-rules`,
-* `detection-zone-rules`, …) so consumer addons subscribe independently.
-*
-* Extend the enum here when a new gating consumer comes online (audio
-* gating, alert filtering, …) — no other surface needs to change.
-*/
-var ZoneRuleStageEnum = _enum([
-	"motion",
-	"detection",
-	"package"
-]);
-/**
-* Zone rules capability — per-camera CRUD over the {@link ZoneRule}
-* arrays that decide how each pipeline stage uses the polygon zones.
-*
-* Hosted by `addon-pipeline-orchestrator` alongside the zones provider
-* so the operator has a single hub-side source of truth for both
-* geometry and behaviour. Per-stage rules are stored under the
-* `zoneRules.<stage>` key in the orchestrator's per-device store and
-* mirrored to the device-state slice `<stage>-zone-rules` on every
-* mutation; consumer addons (analytics, motion-wasm, pipeline-executor)
-* subscribe to that slice and refresh their gating without
-* round-tripping the cap.
-*
-* Sets are bulk-replace — the operator UI sends the new rule list
-* wholesale, so reordering / batch enable-toggle / drag-drop CRUD lives
-* naturally in the rule editor without per-rule mutation chatter.
-*/
-var zoneRulesCapability = {
-	name: "zone-rules",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: [DeviceType.Camera],
-	methods: {
-		/** Read the full rule list for a given stage (empty when no rules
-		*  are defined yet). */
-		listRules: method(object({
-			deviceId: number(),
-			stage: ZoneRuleStageEnum
-		}), array(ZoneRuleSchema).readonly()),
-		/** Bulk-replace the rule list for one stage. The provider validates
-		*  each entry against {@link ZoneRuleSchema} (zoneIds non-empty,
-		*  thresholds in range) and rejects the whole patch if any entry
-		*  is invalid — partial writes are a configuration footgun. */
-		setRules: method(object({
-			deviceId: number(),
-			stage: ZoneRuleStageEnum,
-			rules: array(ZoneRuleSchema).readonly()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	/**
-	* Runtime-state slice — every stage mirrored together so consumers
-	* see one reactive handle (`device.state.zoneRules.value`) instead
-	* of one per stage. Bulk-replace mutations on any stage write the full
-	* `{motion, detection, package}` shape, so subscribers always get the
-	* complete current set. Consumers that only care about one stage
-	* just read the matching property.
-	*
-	* `package` backs the package-drop detector — a package zone is a
-	* `ZoneRule` on the `'package'` stage referencing drawn polygons
-	* (see docs/superpowers/specs/2026-07-17-package-zones-design.md §3.1).
-	* The orchestrator provider writes this stage as a first-class slice
-	* (Phase 4): every mutation mirrors the full `{motion, detection,
-	* package}` shape, so consumers read the current package rules directly
-	* off `device.state.zoneRules.value.package`.
-	*/
-	runtimeState: object({
-		motion: array(ZoneRuleSchema).readonly(),
-		detection: array(ZoneRuleSchema).readonly(),
-		package: array(ZoneRuleSchema).readonly()
-	})
-};
 /**
-* Accessory device helpers — shared across drivers.
-*
-* Many vendor-specific drivers register accessory child devices on
-* top of a parent (Reolink: siren / floodlight / PIR / autotrack /
-* chime; ONVIF: relay outputs; future: Tapo Hub child devices). Each
-* driver picks the right `DeviceType` + `DeviceRole` explicitly when
-* spawning, builds a name derived from the parent, and produces a
-* stableId tied to the parent so boot-restore can reconstruct the
-* relationship.
+* Robot-vacuum cap. Models HA `vacuum.*` entities — anything with a
+* cleaning lifecycle plus a return-to-base / locate surface and an
+* optional fan-speed selector.
 *
-* Centralised `(kind → DeviceType)` mapping was dropped on purpose:
-* drivers may reasonably disagree on the right type for an accessory
-* (a Reolink PIR exposes a switch on/off + sensitivity, while a hypothetical
-* read-only motion-only sensor might be `DeviceType.Sensor`). Forcing
-* one canonical mapping was over-prescriptive and added a layer of
-* indirection without saving meaningful code at call sites — the
-* driver knows its own hardware best.
-*/
-/**
-* Subset of `DeviceRole` values that drivers register as child
-* accessories of a parent device. Sourced verbatim from `DeviceRole`
-* — `AccessoryKind` is the alias drivers use when building accessory
-* children, so the call site reads as
-* `accessoryStableId(parent, AccessoryKind.Siren)` rather than
-* `accessoryStableId(parent, DeviceRole.Siren)` (which would imply
-* any role works, including non-accessory ones like Doorbell).
-*/
-var AccessoryKind = {
-	Siren: DeviceRole.Siren,
-	Floodlight: DeviceRole.Floodlight,
-	Spotlight: DeviceRole.Spotlight,
-	PirSensor: DeviceRole.PirSensor,
-	Chime: DeviceRole.Chime,
-	Autotrack: DeviceRole.Autotrack,
-	Nightvision: DeviceRole.Nightvision,
-	PrivacyMask: DeviceRole.PrivacyMask
-};
-AccessoryKind.Siren, AccessoryKind.Floodlight, AccessoryKind.Spotlight, AccessoryKind.PirSensor, AccessoryKind.Chime, AccessoryKind.Autotrack, AccessoryKind.Nightvision, AccessoryKind.PrivacyMask;
-DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
-new Set(Object.values(DeviceType));
-/**
-* Heuristic check — `device.features?.includes(profile.when.hasFeature)`.
-*/
-function deviceMatchesProfile(features, profile) {
-	if (!features || features.length === 0) return false;
-	return features.includes(profile.when.hasFeature);
-}
-/**
-* Profile registry — order matters when multiple profiles match the
-* same device (first match wins). Today there's only one entry.
-*/
-var DEVICE_PROFILES = [{
-	id: "battery",
-	label: "Battery-operated camera",
-	when: { hasFeature: DeviceFeature.BatteryOperated },
-	defaults: {
-		audioMode: "disabled",
-		detectionMode: "on-motion"
-	},
-	settings: {}
-}];
-/**
-* Resolve the profile that matches a device's features, or `null` when
-* no profile matches. First-match-wins.
-*/
-function resolveDeviceProfile(features) {
-	for (const profile of DEVICE_PROFILES) if (deviceMatchesProfile(features, profile)) return profile;
-	return null;
-}
-/**
-* Error types for the safe expression engine. Two distinct classes so callers
-* can tell a compile-time (grammar) failure from a runtime (evaluation)
-* failure — both are non-fatal to the host: read paths degrade to "skip link".
-*/
-/** Thrown by the tokenizer / parser. Carries a 0-based source `position` when
-*  the failure is anchored to a character (author-facing inline feedback). */
-var ExpressionParseError = class extends Error {
-	position;
-	constructor(message, position) {
-		super(message);
-		this.name = "ExpressionParseError";
-		this.position = position;
-	}
-};
-/** Thrown by the evaluator (unknown identifier, type mismatch, non-finite
-*  result, unknown builtin, step-budget exceeded). */
-var ExpressionEvalError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "ExpressionEvalError";
-	}
-};
-/**
-* Frozen, null-prototype builtin function table for the expression engine
-* (spec §4 rule 4). The table is the SOLE surface of callable functions: the
-* parser rejects any callee not in it, and the evaluator gates each call on an
-* own-property check against it.
+* State follows HA's canonical vacuum lifecycle: `idle` / `cleaning` /
+* `paused` / `returning` / `docked` / `error`. `batteryLevel`
+* (0..100) is nullable — some vacuums don't report a battery
+* percentage. `fanSpeed` is the current speed token (provider-verbatim,
+* e.g. `'standard'` / `'turbo'`) and `availableFanSpeeds` lists the
+* tokens the hardware accepts so the UI renders only supported choices.
 *
-* Because the object has a NULL prototype AND is `Object.freeze`d:
-*  - it cannot be polluted (no `__proto__` / `constructor` write reaches it);
-*  - a lookup for `toString` / `hasOwnProperty` / `constructor` finds NOTHING
-*    (there is no `Object.prototype` in the chain), so those names are not
-*    callable — they are simply "unknown function" at parse time.
+* The `setFanSpeed` method takes the bare `speed` token — the provider
+* validates it against the vacuum's own list. `locate` triggers the
+* find-me chirp; `returnToBase` sends it home.
 *
-* Every numeric argument is validated as a finite number and every numeric
-* RESULT is re-checked finite, so `/0`, `sqrt(-1)` (→ NaN) and overflow
-* (`pow(10,400)` → Infinity) all raise `ExpressionEvalError` and fail the link
-* closed rather than emitting a garbage value.
+* Consumable / waste tanks: `cleanWater` / `dirtyWater` / `detergent` /
+* `dustBin` each carry a nullable `{ level (0..100 %), status ('ok' |
+* 'low' | 'full') }` reading. Native providers (e.g. Dreame, Roborock)
+* SHOULD populate whichever tanks the hardware has — leave a field `null`
+* only when the device has no such tank at all, and use a `TankStatus`
+* with both inner fields `null` when the tank exists but its level is
+* currently unknown. HA `vacuum.*` entities expose no per-tank telemetry,
+* so the HA provider leaves all four `null`.
 */
-function asFiniteNumber(value, name, index) {
-	if (typeof value !== "number" || !Number.isFinite(value)) throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a finite number`);
-	return value;
-}
-function asString$1(value, name, index) {
-	if (typeof value !== "string") throw new ExpressionEvalError(`${name}: argument ${index + 1} must be a string`);
-	return value;
-}
-function finiteResult(value, name) {
-	if (!Number.isFinite(value)) throw new ExpressionEvalError(`${name}: produced a non-finite result`);
-	return value;
-}
-function allFiniteNumbers(args, name) {
-	return args.map((a, idx) => asFiniteNumber(a, name, idx));
-}
-var INF = Number.POSITIVE_INFINITY;
-var table = {
-	min: {
-		minArgs: 1,
-		maxArgs: INF,
-		apply: (args) => finiteResult(Math.min(...allFiniteNumbers(args, "min")), "min")
-	},
-	max: {
-		minArgs: 1,
-		maxArgs: INF,
-		apply: (args) => finiteResult(Math.max(...allFiniteNumbers(args, "max")), "max")
-	},
-	abs: {
-		minArgs: 1,
-		maxArgs: 1,
-		apply: (args) => finiteResult(Math.abs(asFiniteNumber(args[0], "abs", 0)), "abs")
-	},
-	floor: {
-		minArgs: 1,
-		maxArgs: 1,
-		apply: (args) => finiteResult(Math.floor(asFiniteNumber(args[0], "floor", 0)), "floor")
-	},
-	ceil: {
-		minArgs: 1,
-		maxArgs: 1,
-		apply: (args) => finiteResult(Math.ceil(asFiniteNumber(args[0], "ceil", 0)), "ceil")
-	},
-	sqrt: {
-		minArgs: 1,
-		maxArgs: 1,
-		apply: (args) => finiteResult(Math.sqrt(asFiniteNumber(args[0], "sqrt", 0)), "sqrt")
-	},
-	round: {
-		minArgs: 1,
-		maxArgs: 2,
-		apply: (args) => {
-			const x = asFiniteNumber(args[0], "round", 0);
-			const digits = args.length > 1 ? Math.trunc(asFiniteNumber(args[1], "round", 1)) : 0;
-			if (digits < 0 || digits > 100) throw new ExpressionEvalError("round: digits must be between 0 and 100");
-			const factor = 10 ** digits;
-			return finiteResult(Math.round(x * factor) / factor, "round");
-		}
-	},
-	pow: {
-		minArgs: 2,
-		maxArgs: 2,
-		apply: (args) => finiteResult(asFiniteNumber(args[0], "pow", 0) ** asFiniteNumber(args[1], "pow", 1), "pow")
-	},
-	clamp: {
-		minArgs: 3,
-		maxArgs: 3,
-		apply: (args) => {
-			const x = asFiniteNumber(args[0], "clamp", 0);
-			const lo = asFiniteNumber(args[1], "clamp", 1);
-			const hi = asFiniteNumber(args[2], "clamp", 2);
-			if (lo > hi) throw new ExpressionEvalError("clamp: lower bound is greater than upper bound");
-			return finiteResult(Math.min(hi, Math.max(lo, x)), "clamp");
-		}
-	},
-	avg: {
-		minArgs: 1,
-		maxArgs: INF,
-		apply: (args) => {
-			const nums = allFiniteNumbers(args, "avg");
-			return finiteResult(nums.reduce((acc, v) => acc + v, 0) / nums.length, "avg");
-		}
-	},
-	sum: {
-		minArgs: 1,
-		maxArgs: INF,
-		apply: (args) => finiteResult(allFiniteNumbers(args, "sum").reduce((acc, v) => acc + v, 0), "sum")
-	},
-	coalesce: {
-		minArgs: 1,
-		maxArgs: INF,
-		apply: (args) => {
-			for (const a of args) if (a !== null) return a;
-			return null;
-		}
-	},
-	age: {
-		minArgs: 2,
-		maxArgs: 2,
-		apply: (args) => finiteResult(asFiniteNumber(args[0], "age", 0) - asFiniteNumber(args[1], "age", 1), "age")
-	},
-	convert: {
-		minArgs: 3,
-		maxArgs: 3,
-		apply: (args, hooks) => {
-			const x = asFiniteNumber(args[0], "convert", 0);
-			const from = asString$1(args[1], "convert", 1).trim();
-			const to = asString$1(args[2], "convert", 2).trim();
-			if (hooks.convert) {
-				const out = hooks.convert(x, from, to);
-				if (out === null) throw new ExpressionEvalError(`convert: cannot convert '${from}' to '${to}'`);
-				return finiteResult(out, "convert");
-			}
-			if (from === to) return x;
-			throw new ExpressionEvalError("convert: unit conversion table not installed");
-		}
-	}
-};
-Object.freeze(Object.assign(Object.create(null), table));
-/** The set of valid builtin names — used by the parser to reject unknown
-*  callees at parse time (immediate author feedback). */
-var EXPRESSION_BUILTIN_NAMES = new Set(Object.keys(table));
+var VacuumStateSchema = _enum([
+	"idle",
+	"cleaning",
+	"paused",
+	"returning",
+	"docked",
+	"drying",
+	"error"
+]);
+/**
+* One consumable / waste tank on a robot vacuum (clean-water, dirty-water,
+* detergent or dust-bin). A tank can report a numeric fill `level` (0..100),
+* a discrete `status` (binary-style hardware), or both. Both `null` means the
+* level is currently unknown; the OWNING field being `null` means the
+* hardware has no such tank at all.
+*/
+var TankStatusSchema = object({
+	/** Numeric fill 0..100 when the hardware reports a percentage; null otherwise. */
+	level: number().min(0).max(100).nullable(),
+	/** Discrete state when the hardware is binary-mode; null otherwise. */
+	status: _enum([
+		"ok",
+		"low",
+		"full"
+	]).nullable()
+});
+object({
+	/** Lifecycle state of the vacuum. */
+	state: VacuumStateSchema,
+	/** 0..100 battery percentage. Null when the device has no battery
+	*  reading. */
+	batteryLevel: number().min(0).max(100).nullable(),
+	/** Current fan-speed token (provider-verbatim). Null when unknown or
+	*  the vacuum has no speed control. */
+	fanSpeed: string().nullable(),
+	/** Speed tokens the hardware accepts — drives the UI selector. */
+	availableFanSpeeds: array(string()),
+	/** Clean-water (mop) tank. Null when the hardware has no clean-water tank. */
+	cleanWater: TankStatusSchema.nullable(),
+	/** Dirty-water (recovery) tank. Null when the hardware has no dirty-water tank. */
+	dirtyWater: TankStatusSchema.nullable(),
+	/** Detergent tank. Null when the hardware has no detergent tank. */
+	detergent: TankStatusSchema.nullable(),
+	/** Dust bin. Null when the hardware has no dust bin. */
+	dustBin: TankStatusSchema.nullable(),
+	/** 0..100 cleaning-completion percentage of the current task, or null. */
+	progressPercent: number().min(0).max(100).nullable(),
+	/** Current error code (0 / null = no error). */
+	errorCode: number().nullable(),
+	/** Human label for {@link errorCode}, or null when none / undecodable. */
+	errorLabel: string().nullable(),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+DeviceType.Vacuum, method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	speed: string().min(1)
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+object({
+	/** Lifecycle state of the valve. */
+	state: _enum([
+		"open",
+		"opening",
+		"closing",
+		"closed",
+		"stopped"
+	]),
+	/** 0 = fully closed, 100 = fully open. Null when the device has no
+	*  intermediate position surface. */
+	position: number().min(0).max(100).nullable(),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+DeviceType.Valve, method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceId: number().int().nonnegative() }), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	position: number().min(0).max(100)
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+object({
+	detected: boolean(),
+	/** Ms epoch of the last transition. 0 if never observed. */
+	lastChangedAt: number()
+});
+DeviceType.Sensor;
+object({
+	/** Current measured temperature. Null when not reported. */
+	currentTemp: number().nullable(),
+	/** Target temperature setpoint. Null when no setpoint surface. */
+	targetTemp: number().nullable(),
+	/** Active operation mode = HA `state` (`eco` / `electric` / `gas` /
+	*  `heat_pump` / `high_demand` / `performance` / `off`). Null when the
+	*  device reports an unknown state. */
+	operationMode: string().nullable(),
+	/** Available operation modes = HA `operation_list`. */
+	availableModes: array(string()),
+	/** Away mode (HA `away_mode` 'on'/'off' → bool). Null when the device
+	*  has no away surface. */
+	away: boolean().nullable(),
+	/** HA `min_temp` attribute. Null when not reported. */
+	minTemp: number().nullable(),
+	/** HA `max_temp` attribute. Null when not reported. */
+	maxTemp: number().nullable(),
+	/** Ms epoch when the slice was last updated. */
+	lastChangedAt: number()
+});
+DeviceType.WaterHeater, method(object({
+	deviceId: number().int().nonnegative(),
+	temp: number().finite()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	mode: string().min(1)
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number().int().nonnegative(),
+	on: boolean()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+});
+object({
+	/** Verbatim HA condition state (`sunny`, `cloudy`, `rainy`, …). Null
+	*  when no condition has been reported yet. */
+	condition: string().nullable(),
+	/** Current temperature in the reported unit. Null when not provided. */
+	temperature: number().nullable(),
+	/** Temperature unit string (e.g. `°C` / `°F`). Null when not provided. */
+	temperatureUnit: string().nullable(),
+	/** Relative humidity (0..100). Null when not provided. */
+	humidity: number().min(0).max(100).nullable(),
+	/** Barometric pressure in the reported unit. Null when not provided. */
+	pressure: number().nullable(),
+	/** Pressure unit string (e.g. `hPa` / `inHg`). Null when not provided. */
+	pressureUnit: string().nullable(),
+	/** Wind speed in the reported unit. Null when not provided. */
+	windSpeed: number().nullable(),
+	/** Wind-speed unit string (e.g. `km/h` / `mph`). Null when not provided. */
+	windSpeedUnit: string().nullable(),
+	/** Wind bearing in degrees (0..360, meteorological). Null when not provided. */
+	windBearing: number().nullable(),
+	/** Ms epoch when the slice was last updated. */
+	lastFetchedAt: number()
+});
+DeviceType.Weather;
 /**
-* Resource-bound constants for the safe expression engine.
+* Per-zone occupancy aggregation produced by the analytics frame
+* processor on every inference result. Covers the full combinatorial
+* matrix the operator UI needs: total objects everywhere, total
+* objects per zone, single class everywhere, single class per zone,
+* objects outside any zone.
 *
-* Every bound is defense-in-depth: the grammar is non-Turing-complete (no
-* loops, recursion, lambdas or member access — see `ast.ts`), so evaluation is
-* O(nodeCount) by construction. These caps merely put a hard ceiling on the
-* work a single author-supplied expression can request, so a hostile or
-* accidental pathological string can never spend unbounded CPU/memory.
+* Counts are derived from the analytics tracker (tracked detections
+* with stable trackIds), not raw detector hits — this filters out
+* one-off detector flickers and gives counts that match what the user
+* sees on the live overlay.
+*
+* Overlap policy: a detection that intersects two zones counts in
+* BOTH zones' `byClass` and `totalObjects` (count-in-each). The
+* `frame` aggregate de-duplicates trivially since it's frame-wide.
+* `unzoned` counts only detections that landed in zero zones.
 */
-/** Max source length (chars) — checked BEFORE tokenizing so a huge string is
-*  rejected without allocation. */
-var MAX_EXPRESSION_SOURCE_LENGTH = 2048;
-/** A legal binding / identifier name. */
-var EXPRESSION_IDENTIFIER_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-/** Binding names an author may NOT use: `now` is auto-injected; the literal
-*  keywords lex as values, not identifiers, so binding to them is meaningless. */
-var RESERVED_BINDING_NAMES = new Set([
-	"now",
-	"true",
-	"false",
-	"null"
-]);
+var PerScopeBreakdownSchema = object({
+	/** Total tracked objects in this scope (frame / zone / unzoned). */
+	totalObjects: number().int().nonnegative(),
+	/** Per-class count. Keys are macro class names (e.g. `person`, `car`). */
+	byClass: record(string(), number().int().nonnegative())
+});
+var ZoneScopeBreakdownSchema = PerScopeBreakdownSchema.extend({
+	zoneId: string(),
+	zoneName: string(),
+	/** TrackIds of objects currently inside this zone — for cross-reference
+	*  with the per-track detail panel and live overlay. */
+	trackIds: array(string()).readonly()
+});
 /**
-* Tokenizer for the safe expression mini-language. Hand-rolled, single-pass,
-* zero-dependency. The grammar is deliberately boring: decimal numbers,
-* single/double-quoted strings with a tiny escape set, identifiers, the three
-* value keywords (`true`/`false`/`null`) and a fixed punctuator set. Anything
-* outside that — a bare `.`, `=`, `[`, `]`, `{`, `}`, `;`, backtick, `&`, `|` —
-* is a parse error with a source position, so member access / assignment /
-* template literals are lexically impossible.
+* A parked ("stationary") object surfaced alongside occupancy — an object that
+* settled and stopped moving. It is NO LONGER a tracked object (the tracker was
+* told to forget it so it stops re-spawning tracks/events), but it IS still
+* physically present, so it keeps counting toward `frame` occupancy and is
+* listed here so the UI can show it in a dedicated "Stationary" section instead
+* of flooding the live event feed.
 */
-var KEYWORDS = new Set([
-	"true",
-	"false",
-	"null"
-]);
-function isDigit(ch) {
-	return ch >= "0" && ch <= "9";
-}
-function isIdentStart(ch) {
-	return ch >= "A" && ch <= "Z" || ch >= "a" && ch <= "z" || ch === "_";
-}
-function isIdentPart(ch) {
-	return isIdentStart(ch) || isDigit(ch);
-}
-function isWhitespace(ch) {
-	return ch === " " || ch === "	" || ch === "\n" || ch === "\r" || ch === "\f" || ch === "\v";
-}
-/** Tokenize `source` into a flat token list ending with a single `eof` token.
-*  Throws `ExpressionParseError` on any illegal character or unterminated
-*  string. */
-function tokenize(source) {
-	if (source.length > 2048) throw new ExpressionParseError(`expression too long (${source.length} > ${MAX_EXPRESSION_SOURCE_LENGTH} chars)`, 0);
-	const tokens = [];
-	let i = 0;
-	const n = source.length;
-	while (i < n) {
-		const ch = source[i];
-		if (isWhitespace(ch)) {
-			i += 1;
-			continue;
-		}
-		if (isDigit(ch)) {
-			const start = i;
-			while (i < n && isDigit(source[i])) i += 1;
-			if (i < n && source[i] === ".") {
-				if (i + 1 >= n || !isDigit(source[i + 1])) throw new ExpressionParseError("malformed number: decimal point needs a digit", i);
-				i += 1;
-				while (i < n && isDigit(source[i])) i += 1;
-			}
-			const text = source.slice(start, i);
-			const value = Number(text);
-			if (!Number.isFinite(value)) throw new ExpressionParseError(`malformed number: '${text}'`, start);
-			tokens.push({
-				type: "number",
-				value,
-				pos: start
-			});
-			continue;
-		}
-		if (ch === "'" || ch === "\"") {
-			const quote = ch;
-			const start = i;
-			i += 1;
-			let out = "";
-			let closed = false;
-			while (i < n) {
-				const c = source[i];
-				if (c === "\\") {
-					const next = i + 1 < n ? source[i + 1] : "";
-					if (next === "\\" || next === "'" || next === "\"") {
-						out += next;
-						i += 2;
-						continue;
-					}
-					throw new ExpressionParseError(`invalid string escape: '\\${next}'`, i);
-				}
-				if (c === quote) {
-					closed = true;
-					i += 1;
-					break;
-				}
-				out += c;
-				i += 1;
-			}
-			if (!closed) throw new ExpressionParseError("unterminated string literal", start);
-			tokens.push({
-				type: "string",
-				value: out,
-				pos: start
-			});
-			continue;
-		}
-		if (isIdentStart(ch)) {
-			const start = i;
-			while (i < n && isIdentPart(source[i])) i += 1;
-			const text = source.slice(start, i);
-			if (KEYWORDS.has(text)) tokens.push({
-				type: "keyword",
-				keyword: keywordOf(text),
-				pos: start
-			});
-			else tokens.push({
-				type: "identifier",
-				name: text,
-				pos: start
-			});
-			continue;
-		}
-		const two = i + 1 < n ? source.slice(i, i + 2) : "";
-		if (two === "<=" || two === ">=" || two === "==" || two === "!=" || two === "&&" || two === "||") {
-			tokens.push({
-				type: "punct",
-				punct: two,
-				pos: i
-			});
-			i += 2;
-			continue;
-		}
-		if (isSinglePunct(ch)) {
-			tokens.push({
-				type: "punct",
-				punct: ch,
-				pos: i
-			});
-			i += 1;
-			continue;
-		}
-		throw new ExpressionParseError(`unexpected character '${ch}'`, i);
-	}
-	tokens.push({
-		type: "eof",
-		pos: n
-	});
-	return tokens;
-}
-function keywordOf(text) {
-	if (text === "true") return "true";
-	if (text === "false") return "false";
-	return "null";
-}
-function isSinglePunct(ch) {
-	return ch === "(" || ch === ")" || ch === "," || ch === "?" || ch === ":" || ch === "+" || ch === "-" || ch === "*" || ch === "/" || ch === "%" || ch === "!" || ch === "<" || ch === ">";
-}
+var StationaryObjectSchema = object({
+	id: string(),
+	className: string(),
+	bbox: object({
+		x: number(),
+		y: number(),
+		w: number(),
+		h: number()
+	}),
+	frameWidth: number().int().nonnegative(),
+	frameHeight: number().int().nonnegative(),
+	/** When the source track was first seen. */
+	firstSeenAt: number().int(),
+	/** When the object was recognised as parked (promotion time). */
+	becameStationaryAt: number().int(),
+	/** Last frame a detection confirmed the object is still there. */
+	lastConfirmedAt: number().int(),
+	/** Enrichment label carried from the source track (identity / plate). */
+	label: string().optional(),
+	/** Native-resolution key-frame media key for the parked object's best image. */
+	keyFrameMediaKey: string().optional()
+});
+var CameraOccupancySnapshotSchema = object({
+	/** Frame timestamp of the inference result that produced this snapshot. */
+	ts: number().int(),
+	/** Frame width/height in pixels — let the UI normalize bbox coords. */
+	frameWidth: number().int().nonnegative(),
+	frameHeight: number().int().nonnegative(),
+	/** Per-zone breakdown — one entry per defined zone (user + onboard). */
+	zones: array(ZoneScopeBreakdownSchema).readonly(),
+	/** Frame-wide aggregate (everywhere, regardless of zone membership).
+	*  INCLUDES currently-confirmed stationary objects (they are still present). */
+	frame: PerScopeBreakdownSchema,
+	/** Detections that landed outside every zone. Empty when no zones defined. */
+	unzoned: PerScopeBreakdownSchema,
+	/** Parked objects on this camera (additive — absent on legacy snapshots).
+	*  Surfaced separately so the UI shows them in a dedicated section rather
+	*  than as repeated tracks/events. */
+	stationaryObjects: array(StationaryObjectSchema).readonly().optional()
+});
 /**
-* Pratt (precedence-climbing) parser for the safe expression mini-language.
-*
-* Precedence (low → high): ternary `?:` (right-assoc) → `||` → `&&` → equality
-* → relational → additive → multiplicative → unary `! -` → call / primary.
-* Calls are ONLY `IDENT '(' args? ')'` at primary position — the callee is a
-* string validated against the builtin table at parse time, so an unknown
-* function is rejected immediately (author feedback) and a persisted expression
-* that references a since-removed builtin degrades at read.
+* Time-series resolution. The history methods return one bucket per
+* step over the requested range. Smaller resolutions cost more
+* memory + bandwidth; bound to discrete steps so caller cannot ask
+* for arbitrary fractional buckets.
+*/
+var HistoryResolutionEnum = _enum([
+	"minute",
+	"5min",
+	"hour"
+]);
+var HistoryRangeSchema = object({
+	/** Range start (epoch ms, inclusive). */
+	from: number().int(),
+	/** Range end (epoch ms, inclusive). Defaults to "now" at query time. */
+	to: number().int(),
+	resolution: HistoryResolutionEnum
+});
+var HistoryPointSchema = object({
+	/** Bucket midpoint (epoch ms). */
+	ts: number().int(),
+	/** Object count averaged over the bucket (rounded to nearest integer). */
+	count: number().int().nonnegative()
+});
+DeviceType.Camera, method(object({ deviceId: number() }), CameraOccupancySnapshotSchema.nullable()), method(object({
+	deviceId: number(),
+	zoneId: string(),
+	className: string().optional()
+}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly()), method(object({
+	deviceId: number(),
+	className: string().optional()
+}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly()), method(object({
+	deviceId: number(),
+	className: string().optional()
+}).extend(HistoryRangeSchema.shape), array(HistoryPointSchema).readonly());
+/**
+* Stages a {@link ZoneRule} can apply to. Discriminator on the rules
+* cap so a single CRUD surface backs every consumer; each stage has
+* its own dev-state mirror slice (`motion-zone-rules`,
+* `detection-zone-rules`, …) so consumer addons subscribe independently.
 *
-* A node counter caps total AST size (`MAX_EXPRESSION_AST_NODES`) and call
-* arity is capped (`MAX_EXPRESSION_CALL_ARGS`) — both raise `ExpressionParseError`.
+* Extend the enum here when a new gating consumer comes online (audio
+* gating, alert filtering, …) — no other surface needs to change.
 */
-/** Binary/logical operator precedence (higher binds tighter). */
-var BINARY_PRECEDENCE = {
-	"||": 1,
-	"&&": 2,
-	"==": 3,
-	"!=": 3,
-	"<": 4,
-	"<=": 4,
-	">": 4,
-	">=": 4,
-	"+": 5,
-	"-": 5,
-	"*": 6,
-	"/": 6,
-	"%": 6
-};
-function isLogicalOp(op) {
-	return op === "&&" || op === "||";
-}
-function isBinaryOp(op) {
-	return op === "+" || op === "-" || op === "*" || op === "/" || op === "%" || op === "==" || op === "!=" || op === "<" || op === "<=" || op === ">" || op === ">=";
-}
-var Parser = class {
-	tokens;
-	pos = 0;
-	nodeCount = 0;
-	identifiers = /* @__PURE__ */ new Set();
-	callees = /* @__PURE__ */ new Set();
-	constructor(tokens) {
-		this.tokens = tokens;
-	}
-	parse() {
-		const ast = this.parseTernary();
-		const tok = this.peek();
-		if (tok.type !== "eof") throw new ExpressionParseError("unexpected trailing input", tok.pos);
-		return {
-			ast,
-			identifiers: this.identifiers,
-			callees: this.callees,
-			nodeCount: this.nodeCount
-		};
-	}
-	peek() {
-		return this.tokens[this.pos];
-	}
-	next() {
-		return this.tokens[this.pos++];
-	}
-	/** Consume a punctuator token, erroring if the next token isn't it. */
-	expectPunct(punct) {
-		const tok = this.peek();
-		if (tok.type !== "punct" || tok.punct !== punct) throw new ExpressionParseError(`expected '${punct}'`, tok.pos);
-		this.pos += 1;
-	}
-	matchPunct(punct) {
-		const tok = this.peek();
-		if (tok.type === "punct" && tok.punct === punct) {
-			this.pos += 1;
-			return true;
-		}
-		return false;
-	}
-	countNode() {
-		this.nodeCount += 1;
-		if (this.nodeCount > 256) throw new ExpressionParseError("expression too complex", this.peek().pos);
-	}
-	parseTernary() {
-		const test = this.parseBinary(1);
-		if (this.matchPunct("?")) {
-			const consequent = this.parseTernary();
-			this.expectPunct(":");
-			const alternate = this.parseTernary();
-			this.countNode();
-			return {
-				kind: "conditional",
-				test,
-				consequent,
-				alternate
-			};
-		}
-		return test;
-	}
-	parseBinary(minPrec) {
-		let left = this.parseUnary();
-		for (;;) {
-			const tok = this.peek();
-			if (tok.type !== "punct") break;
-			const prec = BINARY_PRECEDENCE[tok.punct];
-			if (prec === void 0 || prec < minPrec) break;
-			const op = tok.punct;
-			this.pos += 1;
-			const right = this.parseBinary(prec + 1);
-			this.countNode();
-			if (isLogicalOp(op)) left = {
-				kind: "logical",
-				op,
-				left,
-				right
-			};
-			else if (isBinaryOp(op)) left = {
-				kind: "binary",
-				op,
-				left,
-				right
-			};
-			else throw new ExpressionParseError(`unexpected operator '${op}'`, tok.pos);
-		}
-		return left;
-	}
-	parseUnary() {
-		const tok = this.peek();
-		if (tok.type === "punct" && (tok.punct === "!" || tok.punct === "-")) {
-			const op = tok.punct;
-			this.pos += 1;
-			const operand = this.parseUnary();
-			this.countNode();
-			return {
-				kind: "unary",
-				op,
-				operand
-			};
-		}
-		return this.parsePrimary();
-	}
-	parsePrimary() {
-		const tok = this.next();
-		switch (tok.type) {
-			case "number":
-				this.countNode();
-				return {
-					kind: "literal",
-					value: tok.value
-				};
-			case "string":
-				this.countNode();
-				return {
-					kind: "literal",
-					value: tok.value
-				};
-			case "keyword":
-				this.countNode();
-				return {
-					kind: "literal",
-					value: tok.keyword === "null" ? null : tok.keyword === "true"
-				};
-			case "identifier": {
-				const nextTok = this.peek();
-				if (nextTok.type === "punct" && nextTok.punct === "(") return this.parseCall(tok.name, tok.pos);
-				this.identifiers.add(tok.name);
-				this.countNode();
-				return {
-					kind: "identifier",
-					name: tok.name
-				};
-			}
-			case "punct":
-				if (tok.punct === "(") {
-					const inner = this.parseTernary();
-					this.expectPunct(")");
-					return inner;
-				}
-				throw new ExpressionParseError(`unexpected token '${tok.punct}'`, tok.pos);
-			case "eof": throw new ExpressionParseError("unexpected end of expression", tok.pos);
-		}
-	}
-	parseCall(callee, pos) {
-		if (!EXPRESSION_BUILTIN_NAMES.has(callee)) throw new ExpressionParseError(`unknown function '${callee}'`, pos);
-		this.expectPunct("(");
-		const args = [];
-		if (!this.matchPunct(")")) for (;;) {
-			args.push(this.parseTernary());
-			if (args.length > 16) throw new ExpressionParseError(`too many arguments to '${callee}'`, pos);
-			if (this.matchPunct(",")) continue;
-			this.expectPunct(")");
-			break;
-		}
-		this.callees.add(callee);
-		this.countNode();
-		return {
-			kind: "call",
-			callee,
-			args
-		};
-	}
+var ZoneRuleStageEnum = _enum([
+	"motion",
+	"detection",
+	"package"
+]);
+/**
+* Zone rules capability — per-camera CRUD over the {@link ZoneRule}
+* arrays that decide how each pipeline stage uses the polygon zones.
+*
+* Hosted by `addon-pipeline-orchestrator` alongside the zones provider
+* so the operator has a single hub-side source of truth for both
+* geometry and behaviour. Per-stage rules are stored under the
+* `zoneRules.<stage>` key in the orchestrator's per-device store and
+* mirrored to the device-state slice `<stage>-zone-rules` on every
+* mutation; consumer addons (analytics, motion-wasm, pipeline-executor)
+* subscribe to that slice and refresh their gating without
+* round-tripping the cap.
+*
+* Sets are bulk-replace — the operator UI sends the new rule list
+* wholesale, so reordering / batch enable-toggle / drag-drop CRUD lives
+* naturally in the rule editor without per-rule mutation chatter.
+*/
+var zoneRulesCapability = {
+	name: "zone-rules",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	methods: {
+		/** Read the full rule list for a given stage (empty when no rules
+		*  are defined yet). */
+		listRules: method(object({
+			deviceId: number(),
+			stage: ZoneRuleStageEnum
+		}), array(ZoneRuleSchema).readonly()),
+		/** Bulk-replace the rule list for one stage. The provider validates
+		*  each entry against {@link ZoneRuleSchema} (zoneIds non-empty,
+		*  thresholds in range) and rejects the whole patch if any entry
+		*  is invalid — partial writes are a configuration footgun. */
+		setRules: method(object({
+			deviceId: number(),
+			stage: ZoneRuleStageEnum,
+			rules: array(ZoneRuleSchema).readonly()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	/**
+	* Runtime-state slice — every stage mirrored together so consumers
+	* see one reactive handle (`device.state.zoneRules.value`) instead
+	* of one per stage. Bulk-replace mutations on any stage write the full
+	* `{motion, detection, package}` shape, so subscribers always get the
+	* complete current set. Consumers that only care about one stage
+	* just read the matching property.
+	*
+	* `package` backs the package-drop detector — a package zone is a
+	* `ZoneRule` on the `'package'` stage referencing drawn polygons
+	* (see docs/superpowers/specs/2026-07-17-package-zones-design.md §3.1).
+	* The orchestrator provider writes this stage as a first-class slice
+	* (Phase 4): every mutation mirrors the full `{motion, detection,
+	* package}` shape, so consumers read the current package rules directly
+	* off `device.state.zoneRules.value.package`.
+	*/
+	runtimeState: object({
+		motion: array(ZoneRuleSchema).readonly(),
+		detection: array(ZoneRuleSchema).readonly(),
+		package: array(ZoneRuleSchema).readonly()
+	})
 };
-/** Tokenize + parse `source` into a validated `ParsedExpression`. Throws
-*  `ExpressionParseError` on any lexical or grammatical failure. */
-function parseExpression(source) {
-	return new Parser(tokenize(source)).parse();
-}
 /**
-* LRU compile cache for parsed expressions (spec §2.4 "parse once … LRU keyed
-* by expr"). The cache stores BOTH successes and failures (negative caching),
-* so a corrupt persisted string costs exactly one tokenize+parse total — not
-* one per read on a hot resolve path.
+* Accessory device helpers — shared across drivers.
 *
-* The cache is a module-level singleton: entries are pure, content-addressed
-* ASTs keyed by the raw source string, so sharing one instance across all
-* callers is safe and maximises hit rate.
+* Many vendor-specific drivers register accessory child devices on
+* top of a parent (Reolink: siren / floodlight / PIR / autotrack /
+* chime; ONVIF: relay outputs; future: Tapo Hub child devices). Each
+* driver picks the right `DeviceType` + `DeviceRole` explicitly when
+* spawning, builds a name derived from the parent, and produces a
+* stableId tied to the parent so boot-restore can reconstruct the
+* relationship.
+*
+* Centralised `(kind → DeviceType)` mapping was dropped on purpose:
+* drivers may reasonably disagree on the right type for an accessory
+* (a Reolink PIR exposes a switch on/off + sensitivity, while a hypothetical
+* read-only motion-only sensor might be `DeviceType.Sensor`). Forcing
+* one canonical mapping was over-prescriptive and added a layer of
+* indirection without saving meaningful code at call sites — the
+* driver knows its own hardware best.
 */
-var cache = /* @__PURE__ */ new Map();
-function getCached(source) {
-	const hit = cache.get(source);
-	if (hit !== void 0) {
-		cache.delete(source);
-		cache.set(source, hit);
-		return hit;
-	}
-	let result;
-	try {
-		result = {
-			ok: true,
-			parsed: parseExpression(source)
-		};
-	} catch (err) {
-		result = {
-			ok: false,
-			error: err instanceof ExpressionParseError ? err.message : String(err)
-		};
-	}
-	cache.set(source, result);
-	if (cache.size > 256) {
-		const oldest = cache.keys().next().value;
-		if (oldest !== void 0) cache.delete(oldest);
-	}
-	return result;
-}
-/** Compile `source`, returning a discriminated result instead of throwing.
-*  Used by read paths that must degrade rather than raise. LRU/negative-cached. */
-function compileExpressionSafe(source) {
-	return getCached(source);
+/**
+* Subset of `DeviceRole` values that drivers register as child
+* accessories of a parent device. Sourced verbatim from `DeviceRole`
+* — `AccessoryKind` is the alias drivers use when building accessory
+* children, so the call site reads as
+* `accessoryStableId(parent, AccessoryKind.Siren)` rather than
+* `accessoryStableId(parent, DeviceRole.Siren)` (which would imply
+* any role works, including non-accessory ones like Doorbell).
+*/
+var AccessoryKind = {
+	Siren: DeviceRole.Siren,
+	Floodlight: DeviceRole.Floodlight,
+	Spotlight: DeviceRole.Spotlight,
+	PirSensor: DeviceRole.PirSensor,
+	Chime: DeviceRole.Chime,
+	Autotrack: DeviceRole.Autotrack,
+	Nightvision: DeviceRole.Nightvision,
+	PrivacyMask: DeviceRole.PrivacyMask
+};
+AccessoryKind.Siren, AccessoryKind.Floodlight, AccessoryKind.Spotlight, AccessoryKind.PirSensor, AccessoryKind.Chime, AccessoryKind.Autotrack, AccessoryKind.Nightvision, AccessoryKind.PrivacyMask;
+DeviceType.Cover, DeviceType.Valve, DeviceType.Humidifier, DeviceType.WaterHeater, DeviceType.Camera, DeviceType.Hub, DeviceType.Switch, DeviceType.Siren, DeviceType.Light, DeviceType.Fan, DeviceType.Sensor, DeviceType.Thermostat, DeviceType.Climate, DeviceType.Button, DeviceType.EventEmitter, DeviceType.Update, DeviceType.Generic, DeviceType.Notifier, DeviceType.Script, DeviceType.Automation, DeviceType.Lock, DeviceType.MediaPlayer, DeviceType.AlarmPanel, DeviceType.Control, DeviceType.Presence, DeviceType.Weather, DeviceType.Vacuum, DeviceType.LawnMower, DeviceType.Container, DeviceType.Image, DeviceType.PetFeeder;
+new Set(Object.values(DeviceType));
+/**
+* Heuristic check — `device.features?.includes(profile.when.hasFeature)`.
+*/
+function deviceMatchesProfile(features, profile) {
+	if (!features || features.length === 0) return false;
+	return features.includes(profile.when.hasFeature);
 }
-Object.freeze({});
 /**
-* Author-time validation. Returns `null` when the source is valid, else a
-* human-readable error message. Checks: the expression compiles; binding count
-* is within `MAX_EXPRESSION_BINDINGS`; every binding name is a legal identifier,
-* is not reserved (`now`/keywords) and does not shadow a builtin; and every
-* FREE identifier of the AST is covered by a binding or the injected `now`.
+* Profile registry — order matters when multiple profiles match the
+* same device (first match wins). Today there's only one entry.
 */
-function validateExpressionSource(src) {
-	const names = Object.keys(src.bindings);
-	if (names.length > 32) return `too many bindings (${names.length} > 32)`;
-	for (const name of names) {
-		if (!EXPRESSION_IDENTIFIER_RE.test(name)) return `invalid binding name '${name}'`;
-		if (RESERVED_BINDING_NAMES.has(name)) return `binding name '${name}' is reserved`;
-		if (EXPRESSION_BUILTIN_NAMES.has(name)) return `binding name '${name}' shadows a builtin function`;
-	}
-	const compiled = compileExpressionSafe(src.expr);
-	if (!compiled.ok) return compiled.error;
-	const bound = new Set(names);
-	for (const id of compiled.parsed.identifiers) {
-		if (id === "now") continue;
-		if (!bound.has(id)) return `expression references unbound identifier '${id}'`;
-	}
+var DEVICE_PROFILES = [{
+	id: "battery",
+	label: "Battery-operated camera",
+	when: { hasFeature: DeviceFeature.BatteryOperated },
+	defaults: {
+		audioMode: "disabled",
+		detectionMode: "on-motion"
+	},
+	settings: {}
+}];
+/**
+* Resolve the profile that matches a device's features, or `null` when
+* no profile matches. First-match-wins.
+*/
+function resolveDeviceProfile(features) {
+	for (const profile of DEVICE_PROFILES) if (deviceMatchesProfile(features, profile)) return profile;
 	return null;
 }
-var ExpressionBindingSourceSchema = union([
-	object({
-		kind: literal("field").optional(),
-		sourceKey: string(),
-		cap: string(),
-		fieldPath: string()
-	}),
-	object({
-		kind: literal("literal"),
-		value: union([
-			string(),
-			number(),
-			boolean(),
-			_null()
-		])
-	}),
-	object({
-		kind: literal("global"),
-		sourceStableId: string(),
-		cap: string(),
-		fieldPath: string()
-	})
-]);
-object({
-	expr: string().min(1).max(MAX_EXPRESSION_SOURCE_LENGTH),
-	bindings: record(string().regex(EXPRESSION_IDENTIFIER_RE), ExpressionBindingSourceSchema)
-}).superRefine((src, ctx) => {
-	const err = validateExpressionSource(src);
-	if (err !== null) ctx.addIssue({
-		code: "custom",
-		message: err,
-		path: ["expr"]
-	});
-});
 Object.freeze({
 	"accessories.setChildHidden": {
 		capName: "accessories",
@@ -26046,6 +26479,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"connectionTest.describeTest": {
+		capName: "connection-test",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"connectionTest.testSettings": {
+		capName: "connection-test",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"consumables.reset": {
 		capName: "consumables",
 		capScope: "device",
@@ -26436,6 +26881,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionCancelJob": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.adoptionListCandidateFilters": {
 		capName: "device-manager",
 		capScope: "system",
@@ -26448,6 +26899,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"deviceManager.adoptionListJobs": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"deviceManager.adoptionRefresh": {
 		capName: "device-manager",
 		capScope: "system",
@@ -26466,6 +26923,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"deviceManager.adoptionStartJob": {
+		capName: "device-manager",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"deviceManager.allocateDeviceId": {
 		capName: "device-manager",
 		capScope: "system",
@@ -29604,6 +30067,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"snapshot.getSnapshotLinks": {
+		capName: "snapshot",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"snapshot.getSnapshotOverview": {
 		capName: "snapshot",
 		capScope: "device",