@camstack/system 1.2.453 → 1.2.455

package/dist/{dist-DyjNaeIj.js → dist-DjQ8C-ku.js}

@@ -1,6 +1,6 @@
 let zod = require("zod");
 require("node:crypto");
-//#region ../types/dist/event-category-BvOFi6PY.mjs
+//#region ../types/dist/event-category-DOl51-Ij.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -79,9 +79,18 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	/**
 	* The node's one-shot runner boot check (D877): planned runners against the
 	* process service, `degraded` when any is failed, refused or missing. The
-	* alert centre turns it into one alert and a direct critical push.
+	* alert centre turns it into one critical alert.
 	*/
 	EventCategory["SystemRunnerCheck"] = "system.runner-check";
+	/**
+	* An alert EPISODE opened or closed, emitted by the alert centre for alerts
+	* of severity `critical` or `error` (`AlertEpisodePayload`). The alert
+	* centre sends no notification of its own: Notification Center turns this
+	* into the `alert-critical` / `alert-error` / `alert-critical-resolved`
+	* system-event kinds, and reconciles from the alerts store because a bus
+	* event may be dropped (D8, D11).
+	*/
+	EventCategory["AlertEpisode"] = "alert.episode";
 	EventCategory["AddonError"] = "addon.error";
 	EventCategory["AddonPageReady"] = "addon.page-ready";
 	EventCategory["AddonWidgetReady"] = "addon.widget-ready";
@@ -736,7 +745,7 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	return EventCategory;
 }({});
 //#endregion
-//#region ../types/dist/sleep-BegKjwUu.mjs
+//#region ../types/dist/sleep-BxjU_fJM.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -3248,6 +3257,12 @@ function normalizeAddonInitResult(result) {
 * core proxy and the kernel listener) to keep both off a kernel↔core import.
 */
 var DATAPLANE_SECRET_HEADER = "x-camstack-dataplane-secret";
+/**
+* The share-view scope kinds a `csv_*` share token can carry. The hub mints
+* and validates them (`share-token.service.ts` builds its enum from this
+* list); a data plane names the kinds it ACCEPTS in `share`.
+*/
+var SHARE_VIEW_KINDS = ["grid-view", "events-view"];
 /** The wire shape of {@link PeerBytesTicket} — see the type for what it is. */
 var PeerBytesTicketSchema = zod.z.object({
 	/** `http://127.0.0.1:<port>/<token>`. One `GET` takes it. */
@@ -10383,6 +10398,235 @@ function scopesAllowDeviceCap(scopes, access) {
 function scopesAllowAddon(scopes, addonId, access) {
 	return scopes.some((s) => s.type === "addon" && s.target === addonId && s.access.includes(access));
 }
+/**
+* Zod schemas for persisted record types.
+*
+* These schemas serve as the single source of truth for types that are
+* stored in the settings-store backend and retrieved via tRPC. They
+* replace the manual TypeScript interfaces with schema-derived types,
+* enabling runtime validation when reading from the backend.
+*
+* Convention: each schema is named `<Type>Schema`, the inferred TS type
+* keeps the original name for backward compatibility.
+*/
+/**
+* Auth model (v2 — 2026-05-12 caps-only):
+*
+* Two principals:
+*   - `isAdmin: true`  — full bypass. Admin scope set is ignored.
+*   - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
+*
+* No role enum. There used to be `viewer / agent / scoped` and earlier
+* `super_admin` — collapsed onto the single boolean because every
+* non-admin caller is governed by the same scope-check rules; the
+* distinction was only ever used to route role-specific procedures
+* which we no longer have. CLI / webhook integrations are `cst_*` tokens
+* with `isAdmin: false` + an explicit scope list.
+*/
+/** Per-method access flavour. Materialised on every cap method via codegen. */
+var MethodAccessSchema = zod.z.enum([
+	"view",
+	"create",
+	"delete"
+]);
+/**
+* A single scope grant. Three forms — checked in matcher with OR
+* semantics; the first match decides whether the call passes:
+*
+*   - `category` — broadest. `target: 'device' | 'system'` selects every
+*     cap with the matching `scope` declaration. New caps inherit grants
+*     automatically — adding a device cap to the codebase makes it
+*     reachable to every user with `category:device [...]` without a
+*     re-grant. Use this for "family viewer" / "operator" tiers.
+*
+*   - `addon` — every cap that ships inside a given addon id. Niche;
+*     useful when an integration needs to interact with one specific
+*     addon's surface regardless of how many caps it exports.
+*
+*   - `capability` — the most precise form. Single cap name. Use for
+*     integration tokens where you want to grant `addons.installPackage`
+*     and nothing else.
+*
+* `access` is REQUIRED with min 1 element. `admin` bypass is the
+* "give me everything" escape; there is no wildcard scope.
+*/
+var AllowedProviderSchema = zod.z.union([zod.z.literal("*"), zod.z.array(zod.z.string())]);
+var AllowedDevicesSchema = zod.z.record(zod.z.string(), zod.z.union([zod.z.literal("*"), zod.z.array(zod.z.string())]));
+var CapScopeSchema = zod.z.enum(["device", "system"]);
+/**
+* DeviceSelector (scope model v3 — 2026-08-12).
+*
+* A `device` grant no longer carries a frozen list of deviceIds. It carries
+* a SELECTOR the matcher resolves against the live fleet, so the grant can be
+* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
+* AFTER the grant was minted — no re-grant, no re-login.
+*
+*   - `all`       — every device in the deployment. The broad viewer/operator
+*     lever without a `category` grant (a `category` grant also covers device
+*     caps that carry no deviceId; `all` is specifically the device set).
+*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
+*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
+*     is NOT covered until the grant is edited.
+*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
+*     DYNAMIC. A device that changes type, or a new device of the type,
+*     re-resolves on the next request.
+*   - `locations` — every device whose operator-assigned `location` label is
+*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
+*     null/unset location matches NO `locations` selector.
+*/
+var DeviceSelectorSchema = zod.z.discriminatedUnion("kind", [
+	zod.z.object({ kind: zod.z.literal("all") }),
+	zod.z.object({
+		kind: zod.z.literal("ids"),
+		ids: zod.z.array(zod.z.number().int()).min(1)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("types"),
+		types: zod.z.array(zod.z.enum(DeviceType)).min(1)
+	}),
+	zod.z.object({
+		kind: zod.z.literal("locations"),
+		locations: zod.z.array(zod.z.string().min(1)).min(1)
+	})
+]);
+var DeviceTokenScopeSchema = zod.z.object({
+	type: zod.z.literal("device"),
+	/** The device SET this grant covers — resolved against the live fleet. */
+	selector: DeviceSelectorSchema,
+	access: zod.z.array(MethodAccessSchema).min(1),
+	/**
+	* Whether a grant on a PARENT device transparently covers its accessory
+	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
+	* Direction is parent → children ONLY.
+	*
+	* Absent → the matcher DERIVES it from the access flavour: `view`
+	* inherits (a camera viewer sees the camera's accessories), `create` /
+	* `delete` do NOT (actuating/removing a child is an explicit act the
+	* operator must grant on the child, not inherit from the parent). Set it
+	* explicitly to override that default per grant.
+	*/
+	includeLinked: zod.z.boolean().optional()
+});
+/**
+* v2 → v3 lazy migration. A pre-v3 `device` grant carried
+* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
+* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
+* EVERY parse path — stored records AND the JWT-carried scope arrays
+* normalised at the request boundary ({@link normalizeTokenScopes} in
+* `device-selector.ts`). Chosen over a one-time DB migration because a
+* migration cannot reach a JWT already in a client's hands; parse-time
+* migration covers both without a flag day. No cast — the raw object is read
+* through `Reflect.get` (its static type is `unknown`).
+*/
+function migrateLegacyTokenScope(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
+	if (Reflect.get(raw, "type") !== "device") return raw;
+	if (Reflect.get(raw, "selector") !== void 0) return raw;
+	const targets = Reflect.get(raw, "targets");
+	if (!Array.isArray(targets)) return raw;
+	return {
+		type: "device",
+		selector: {
+			kind: "ids",
+			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
+		},
+		access: Reflect.get(raw, "access")
+	};
+}
+var TokenScopeSchema = zod.z.preprocess(migrateLegacyTokenScope, zod.z.discriminatedUnion("type", [
+	zod.z.object({
+		type: zod.z.literal("category"),
+		target: CapScopeSchema,
+		access: zod.z.array(MethodAccessSchema).min(1)
+	}),
+	zod.z.object({
+		type: zod.z.literal("capability"),
+		target: zod.z.string(),
+		access: zod.z.array(MethodAccessSchema).min(1)
+	}),
+	zod.z.object({
+		type: zod.z.literal("addon"),
+		target: zod.z.string(),
+		access: zod.z.array(MethodAccessSchema).min(1)
+	}),
+	DeviceTokenScopeSchema
+]));
+var UserRecordSchema = zod.z.object({
+	id: zod.z.string(),
+	username: zod.z.string(),
+	passwordHash: zod.z.string(),
+	/**
+	* Admin bypass. When true, the middleware skips the scope-access
+	* check entirely. There is no other axis of privilege; the legacy
+	* role enum collapsed onto this boolean in v2.
+	*/
+	isAdmin: zod.z.boolean().default(false),
+	allowedProviders: AllowedProviderSchema,
+	allowedDevices: AllowedDevicesSchema,
+	/**
+	* Scopes granted to this user. Admins bypass; their `scopes` is
+	* ignored. Non-admins without scopes are locked out of every
+	* protected call.
+	*/
+	scopes: zod.z.array(TokenScopeSchema).default([]),
+	createdAt: zod.z.number(),
+	updatedAt: zod.z.number()
+});
+var ApiKeyRecordSchema = zod.z.object({
+	id: zod.z.string(),
+	label: zod.z.string(),
+	isAdmin: zod.z.boolean().default(false),
+	allowedProviders: AllowedProviderSchema,
+	allowedDevices: AllowedDevicesSchema,
+	tokenHash: zod.z.string(),
+	tokenPrefix: zod.z.string(),
+	createdAt: zod.z.number(),
+	lastUsedAt: zod.z.number().optional()
+});
+var ScopedTokenSchema = zod.z.object({
+	id: zod.z.string(),
+	userId: zod.z.string(),
+	name: zod.z.string(),
+	tokenHash: zod.z.string(),
+	tokenPrefix: zod.z.string(),
+	scopes: zod.z.array(TokenScopeSchema),
+	expiresAt: zod.z.number().nullish(),
+	lastUsedAt: zod.z.number().nullish(),
+	createdAt: zod.z.number()
+});
+/** What a share-view grant lets its holder see. */
+var ShareViewGrantSchema = zod.z.object({
+	kind: zod.z.enum(SHARE_VIEW_KINDS),
+	deviceIds: zod.z.array(zod.z.number().int().nonnegative()).min(1).max(64),
+	/** Talk-back, opt-in at mint time; absent means off. */
+	talk: zod.z.boolean().optional()
+});
+var ShareViewScopeSchema = zod.z.object({
+	type: zod.z.literal("share-view"),
+	grant: ShareViewGrantSchema
+});
+var AddonRoutesScopeSchema = zod.z.object({
+	type: zod.z.literal("addon-routes"),
+	access: zod.z.array(MethodAccessSchema).min(1)
+});
+var CredentialScopeSchema = zod.z.union([
+	zod.z.literal("*"),
+	ShareViewScopeSchema,
+	AddonRoutesScopeSchema,
+	TokenScopeSchema
+]);
+/**
+* The claims of a unified token (`auth.mintToken`). It carries no `exp`: its
+* row (looked up by `jti` on every verify, for revocation) holds the ONE
+* expiry, so a share link can be extended and a JWT clock can never disagree
+* with the row.
+*/
+var CredentialTokenClaimsSchema = zod.z.object({
+	kind: zod.z.literal("credential"),
+	sub: zod.z.string().min(1),
+	jti: zod.z.string().min(16),
+	scopes: zod.z.array(CredentialScopeSchema).min(1)
+});
 zod.z.enum(["new-session", "step-up"]);
 /** The languages the hub's app landing pages are written in (D858). */
 var AppPageLangSchema = zod.z.enum(["en", "it"]);
@@ -11267,7 +11511,14 @@ var AlertSeveritySchema = zod.z.enum([
 ]);
 var AlertActionSchema = zod.z.object({
 	label: zod.z.string(),
-	href: zod.z.string().optional()
+	href: zod.z.string().optional(),
+	/**
+	* How `href` is followed. Absent / `app`: an admin-ui route (client-side).
+	* `server`: a route the HUB serves (an addon HTTP route such as an OAuth
+	* start) — the browser must leave the SPA with a full navigation, because
+	* the SPA has no such route and would bounce to the home page.
+	*/
+	navigation: zod.z.enum(["app", "server"]).optional()
 });
 var AlertStatusSchema = zod.z.enum([
 	"active",
@@ -44526,6 +44777,9 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"server-updated",
 	"export-completed",
 	"backup-completed",
+	"alert-critical",
+	"alert-error",
+	"alert-critical-resolved",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -46793,202 +47047,6 @@ var notificationRulesCapability = {
 	}
 };
 /**
-* Zod schemas for persisted record types.
-*
-* These schemas serve as the single source of truth for types that are
-* stored in the settings-store backend and retrieved via tRPC. They
-* replace the manual TypeScript interfaces with schema-derived types,
-* enabling runtime validation when reading from the backend.
-*
-* Convention: each schema is named `<Type>Schema`, the inferred TS type
-* keeps the original name for backward compatibility.
-*/
-/**
-* Auth model (v2 — 2026-05-12 caps-only):
-*
-* Two principals:
-*   - `isAdmin: true`  — full bypass. Admin scope set is ignored.
-*   - `isAdmin: false` — every call gated by `scopes` (see TokenScope).
-*
-* No role enum. There used to be `viewer / agent / scoped` and earlier
-* `super_admin` — collapsed onto the single boolean because every
-* non-admin caller is governed by the same scope-check rules; the
-* distinction was only ever used to route role-specific procedures
-* which we no longer have. CLI / webhook integrations are `cst_*` tokens
-* with `isAdmin: false` + an explicit scope list.
-*/
-/** Per-method access flavour. Materialised on every cap method via codegen. */
-var MethodAccessSchema = zod.z.enum([
-	"view",
-	"create",
-	"delete"
-]);
-/**
-* A single scope grant. Three forms — checked in matcher with OR
-* semantics; the first match decides whether the call passes:
-*
-*   - `category` — broadest. `target: 'device' | 'system'` selects every
-*     cap with the matching `scope` declaration. New caps inherit grants
-*     automatically — adding a device cap to the codebase makes it
-*     reachable to every user with `category:device [...]` without a
-*     re-grant. Use this for "family viewer" / "operator" tiers.
-*
-*   - `addon` — every cap that ships inside a given addon id. Niche;
-*     useful when an integration needs to interact with one specific
-*     addon's surface regardless of how many caps it exports.
-*
-*   - `capability` — the most precise form. Single cap name. Use for
-*     integration tokens where you want to grant `addons.installPackage`
-*     and nothing else.
-*
-* `access` is REQUIRED with min 1 element. `admin` bypass is the
-* "give me everything" escape; there is no wildcard scope.
-*/
-var AllowedProviderSchema = zod.z.union([zod.z.literal("*"), zod.z.array(zod.z.string())]);
-var AllowedDevicesSchema = zod.z.record(zod.z.string(), zod.z.union([zod.z.literal("*"), zod.z.array(zod.z.string())]));
-var CapScopeSchema = zod.z.enum(["device", "system"]);
-/**
-* DeviceSelector (scope model v3 — 2026-08-12).
-*
-* A `device` grant no longer carries a frozen list of deviceIds. It carries
-* a SELECTOR the matcher resolves against the live fleet, so the grant can be
-* DYNAMIC: a `types:['camera']` selector automatically covers a camera added
-* AFTER the grant was minted — no re-grant, no re-login.
-*
-*   - `all`       — every device in the deployment. The broad viewer/operator
-*     lever without a `category` grant (a `category` grant also covers device
-*     caps that carry no deviceId; `all` is specifically the device set).
-*   - `ids`       — an explicit deviceId list. This is what a v2 `device:[…]`
-*     grant migrates to (see {@link TokenScopeSchema}); STATIC — a new camera
-*     is NOT covered until the grant is edited.
-*   - `types`     — every device of a `DeviceType` (e.g. every `camera`).
-*     DYNAMIC. A device that changes type, or a new device of the type,
-*     re-resolves on the next request.
-*   - `locations` — every device whose operator-assigned `location` label is
-*     in the set (e.g. "Garden", "Front door"). DYNAMIC. A device with a
-*     null/unset location matches NO `locations` selector.
-*/
-var DeviceSelectorSchema = zod.z.discriminatedUnion("kind", [
-	zod.z.object({ kind: zod.z.literal("all") }),
-	zod.z.object({
-		kind: zod.z.literal("ids"),
-		ids: zod.z.array(zod.z.number().int()).min(1)
-	}),
-	zod.z.object({
-		kind: zod.z.literal("types"),
-		types: zod.z.array(zod.z.enum(DeviceType)).min(1)
-	}),
-	zod.z.object({
-		kind: zod.z.literal("locations"),
-		locations: zod.z.array(zod.z.string().min(1)).min(1)
-	})
-]);
-var DeviceTokenScopeSchema = zod.z.object({
-	type: zod.z.literal("device"),
-	/** The device SET this grant covers — resolved against the live fleet. */
-	selector: DeviceSelectorSchema,
-	access: zod.z.array(MethodAccessSchema).min(1),
-	/**
-	* Whether a grant on a PARENT device transparently covers its accessory
-	* CHILDREN (siren / floodlight / PIR) via the persisted-parentage walk.
-	* Direction is parent → children ONLY.
-	*
-	* Absent → the matcher DERIVES it from the access flavour: `view`
-	* inherits (a camera viewer sees the camera's accessories), `create` /
-	* `delete` do NOT (actuating/removing a child is an explicit act the
-	* operator must grant on the child, not inherit from the parent). Set it
-	* explicitly to override that default per grant.
-	*/
-	includeLinked: zod.z.boolean().optional()
-});
-/**
-* v2 → v3 lazy migration. A pre-v3 `device` grant carried
-* `targets: string[]` (stringified deviceIds); it rewrites to the equivalent
-* `selector: {kind:'ids', ids}`. Applied as a `preprocess` so it runs on
-* EVERY parse path — stored records AND the JWT-carried scope arrays
-* normalised at the request boundary ({@link normalizeTokenScopes} in
-* `device-selector.ts`). Chosen over a one-time DB migration because a
-* migration cannot reach a JWT already in a client's hands; parse-time
-* migration covers both without a flag day. No cast — the raw object is read
-* through `Reflect.get` (its static type is `unknown`).
-*/
-function migrateLegacyTokenScope(raw) {
-	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return raw;
-	if (Reflect.get(raw, "type") !== "device") return raw;
-	if (Reflect.get(raw, "selector") !== void 0) return raw;
-	const targets = Reflect.get(raw, "targets");
-	if (!Array.isArray(targets)) return raw;
-	return {
-		type: "device",
-		selector: {
-			kind: "ids",
-			ids: targets.map((t) => typeof t === "string" ? Number(t) : t).filter((n) => typeof n === "number" && Number.isInteger(n))
-		},
-		access: Reflect.get(raw, "access")
-	};
-}
-var TokenScopeSchema = zod.z.preprocess(migrateLegacyTokenScope, zod.z.discriminatedUnion("type", [
-	zod.z.object({
-		type: zod.z.literal("category"),
-		target: CapScopeSchema,
-		access: zod.z.array(MethodAccessSchema).min(1)
-	}),
-	zod.z.object({
-		type: zod.z.literal("capability"),
-		target: zod.z.string(),
-		access: zod.z.array(MethodAccessSchema).min(1)
-	}),
-	zod.z.object({
-		type: zod.z.literal("addon"),
-		target: zod.z.string(),
-		access: zod.z.array(MethodAccessSchema).min(1)
-	}),
-	DeviceTokenScopeSchema
-]));
-var UserRecordSchema = zod.z.object({
-	id: zod.z.string(),
-	username: zod.z.string(),
-	passwordHash: zod.z.string(),
-	/**
-	* Admin bypass. When true, the middleware skips the scope-access
-	* check entirely. There is no other axis of privilege; the legacy
-	* role enum collapsed onto this boolean in v2.
-	*/
-	isAdmin: zod.z.boolean().default(false),
-	allowedProviders: AllowedProviderSchema,
-	allowedDevices: AllowedDevicesSchema,
-	/**
-	* Scopes granted to this user. Admins bypass; their `scopes` is
-	* ignored. Non-admins without scopes are locked out of every
-	* protected call.
-	*/
-	scopes: zod.z.array(TokenScopeSchema).default([]),
-	createdAt: zod.z.number(),
-	updatedAt: zod.z.number()
-});
-var ApiKeyRecordSchema = zod.z.object({
-	id: zod.z.string(),
-	label: zod.z.string(),
-	isAdmin: zod.z.boolean().default(false),
-	allowedProviders: AllowedProviderSchema,
-	allowedDevices: AllowedDevicesSchema,
-	tokenHash: zod.z.string(),
-	tokenPrefix: zod.z.string(),
-	createdAt: zod.z.number(),
-	lastUsedAt: zod.z.number().optional()
-});
-var ScopedTokenSchema = zod.z.object({
-	id: zod.z.string(),
-	userId: zod.z.string(),
-	name: zod.z.string(),
-	tokenHash: zod.z.string(),
-	tokenPrefix: zod.z.string(),
-	scopes: zod.z.array(TokenScopeSchema),
-	expiresAt: zod.z.number().nullish(),
-	lastUsedAt: zod.z.number().nullish(),
-	createdAt: zod.z.number()
-});
-/**
 * `oauth-integration` — a collection cap by which an addon declares
 * itself a linkable OAuth client of the hub's core `/oauth2/*` server.
 * Each provider returns a static descriptor; the core enumerates them
@@ -55883,6 +55941,18 @@ var storageMigrationCapability = {
 		*/
 		movers: method(zod.z.object({}), zod.z.array(StorageMigrationMoverSchema).readonly(), { auth: "admin" }),
 		/**
+		* May a mover that touches these locations run NOW? One claim per physical
+		* root is owned by the storage orchestrator: a single-location repoint holds
+		* it while it carries its subtree, and a mover (`relocateMedia`,
+		* `relocateFootage`, a migration move) asks here AFTER registering its job and
+		* cancels itself on `clear: false`. The repoint, in turn, refuses while a
+		* registered mover touches its root. Asked, never polled (D3).
+		*/
+		moverClearance: method(zod.z.object({ locationIds: zod.z.array(zod.z.string()).readonly() }), zod.z.object({
+			clear: zod.z.boolean(),
+			repointLocationId: zod.z.string().optional()
+		}), { auth: "admin" }),
+		/**
 		* What each class's SOURCE still holds, from the archive — never from the
 		* resident index (D295). Only classes with something left (or something
 		* unknown) are listed, so an empty list means there is nothing to drain and
@@ -61103,6 +61173,11 @@ onStatusChanged: { data: zod.z.object({
 *
 * `kind: 'poll'` — cloud REST APIs typically have no push channel; the
 * provider refreshes the slice on an interval and eagerly after commands.
+*
+* UNKNOWN IS NOT OFF. Every field the appliance reports separately is
+* nullable: `null` means "not known right now" (the appliance has not said,
+* the link is down, or the description does not carry it) and is never
+* rendered or exported as `false` / `0`. `availability` says why.
 */
 var DishwasherStateSchema = zod.z.enum([
 	"idle",
@@ -61112,43 +61187,155 @@ var DishwasherStateSchema = zod.z.enum([
 	"error",
 	"unavailable"
 ]);
+/**
+* The appliance's own operation state, uncollapsed. `state` above is the coarse
+* view for compact surfaces; this is what the appliance said.
+*/
+var DishwasherOperationStateSchema = zod.z.enum([
+	"Inactive",
+	"Ready",
+	"DelayedStart",
+	"Run",
+	"Pause",
+	"ActionRequired",
+	"Finished",
+	"Error",
+	"Aborting"
+]);
+/**
+* Why fields may be `null`:
+*  - `available`           — the link is up and the description is loaded;
+*  - `offline`             — the local link is down (values are unknown, not last-known);
+*  - `description-missing` — the link is up but the appliance's description could not
+*                            be loaded, so its values cannot be decoded.
+*/
+var DishwasherAvailabilitySchema = zod.z.enum([
+	"available",
+	"offline",
+	"description-missing"
+]);
 var DishwasherConsumableLevelSchema = zod.z.enum([
 	"ok",
 	"low",
 	"empty"
 ]);
 var DishwasherStatusSchema = zod.z.object({
+	availability: DishwasherAvailabilitySchema,
+	/** Coarse state for compact surfaces; `unavailable` whenever the appliance state is not known. */
 	state: DishwasherStateSchema,
-	/** Active program id/name, or null when none selected / unknown. */
+	/** The appliance's operation state as reported; null when not known. */
+	operationState: DishwasherOperationStateSchema.nullable(),
+	/** Feature key of the ACTIVE (running) program, or null when none runs / not known. */
 	program: zod.z.string().nullable(),
-	/** Program tokens the hardware accepts — drives the UI selector. */
+	/** Feature key of the SELECTED program (what Start would run), or null when none / not known. */
+	selectedProgram: zod.z.string().nullable(),
+	/** Feature keys of the programs the appliance currently offers — drives the UI selector. */
 	availablePrograms: zod.z.array(zod.z.string()),
-	/** Minutes remaining on the active cycle, or null when not running. */
-	remainingMinutes: zod.z.number().int().nonnegative().nullable(),
+	/** Seconds remaining on the active cycle, or null when not running / not known. */
+	remainingSeconds: zod.z.number().int().nonnegative().nullable(),
+	/** Seconds the delayed start is set to (time until the cycle starts), or null. */
+	delayedStartSeconds: zod.z.number().int().nonnegative().nullable(),
 	/** Cycle completion 0..100, or null when not applicable. */
 	progressPercent: zod.z.number().min(0).max(100).nullable(),
-	/** True when the door is reported open. */
-	doorOpen: zod.z.boolean(),
-	/** True when remote start is allowed (door closed, power on, etc.). */
-	remoteStartAllowed: zod.z.boolean(),
-	/** Main power / switched-on state. */
-	powerOn: zod.z.boolean(),
+	/** True when the door is reported open; null when the door state is not known. */
+	doorOpen: zod.z.boolean().nullable(),
+	/** True when the door is latched (locked) during a cycle; null when not reported. */
+	doorLocked: zod.z.boolean().nullable(),
+	/** True when remote start is allowed (door closed, power on, etc.); null when not known. */
+	remoteStartAllowed: zod.z.boolean().nullable(),
+	/** True when the appliance accepts remote control now; null when not known. */
+	remoteControlActive: zod.z.boolean().nullable(),
+	/** True while somebody operates the appliance at its panel; null when not reported. */
+	localControlActive: zod.z.boolean().nullable(),
+	/** Main power / switched-on state; null when not known. */
+	powerOn: zod.z.boolean().nullable(),
+	/** The raw power state (`On`, `Off`, `Standby`, …); null when not known. */
+	powerState: zod.z.string().nullable(),
 	saltLevel: DishwasherConsumableLevelSchema.nullable(),
 	rinseAidLevel: DishwasherConsumableLevelSchema.nullable(),
-	halfLoad: zod.z.boolean(),
-	hygienePlus: zod.z.boolean(),
+	/** Option states: null when the appliance does not expose the option or has not said. */
+	halfLoad: zod.z.boolean().nullable(),
+	hygienePlus: zod.z.boolean().nullable(),
 	/** Extra dry option when the appliance exposes it. */
-	extraDry: zod.z.boolean(),
+	extraDry: zod.z.boolean().nullable(),
 	/** Intensive zone (lower basket) when the appliance exposes it. */
-	intensiveZone: zod.z.boolean(),
+	intensiveZone: zod.z.boolean().nullable(),
 	/** VarioSpeed / VarioSpeed+ when the appliance exposes it. */
-	varioSpeedPlus: zod.z.boolean(),
-	/** Child lock (controls disabled on the appliance). */
-	childLock: zod.z.boolean(),
+	varioSpeedPlus: zod.z.boolean().nullable(),
+	/** Child lock (controls disabled on the appliance); null when not known. */
+	childLock: zod.z.boolean().nullable(),
+	/** Feature keys of the events currently raised (salt low, rinse aid low, program finished, …). */
+	activeEvents: zod.z.array(zod.z.string()),
+	/** Numeric error code when the appliance reports one; null otherwise. */
 	errorCode: zod.z.number().nullable(),
+	/** Name of the raised alert-level event while the appliance is in error; null otherwise. */
 	errorLabel: zod.z.string().nullable(),
+	/** Ms epoch of the last value received from the appliance; 0 = never. */
 	lastFetchedAt: zod.z.number()
 });
+var DeviceIdSchema = zod.z.number().int().nonnegative();
+/** A value a program option or setting can take. */
+var DishwasherValueSchema = zod.z.union([
+	zod.z.boolean(),
+	zod.z.string(),
+	zod.z.number()
+]);
+var DishwasherAccessSchema = zod.z.enum([
+	"none",
+	"read",
+	"readWrite",
+	"writeOnly",
+	"readStatic"
+]);
+/**
+* One option or setting the appliance declares, with the constraints its description
+* gives. A `readWrite` descriptor that is `available` is what `setOption` accepts.
+*/
+var DishwasherOptionDescriptorSchema = zod.z.object({
+	/** Feature key (`Dishcare.Dishwasher.Option.ExtraDry`). */
+	key: zod.z.string(),
+	/** Last segment of the key, for display. */
+	name: zod.z.string(),
+	type: zod.z.enum([
+		"boolean",
+		"number",
+		"enum",
+		"string"
+	]),
+	access: DishwasherAccessSchema,
+	/** The appliance reports this entity as currently available. */
+	available: zod.z.boolean(),
+	/** Unit the description declares for a number; null when it declares none. */
+	unit: zod.z.string().nullable(),
+	min: zod.z.number().nullable(),
+	max: zod.z.number().nullable(),
+	step: zod.z.number().nullable(),
+	/** Allowed members of an enum; null for other types. */
+	enumValues: zod.z.array(zod.z.string()).nullable(),
+	defaultValue: DishwasherValueSchema.nullable()
+});
+var DishwasherProgramSchema = zod.z.object({
+	/** Feature key (`Dishcare.Dishwasher.Program.Eco50`) — what `setProgram` / `start` take. */
+	key: zod.z.string(),
+	name: zod.z.string(),
+	/** The appliance currently offers this program. */
+	available: zod.z.boolean(),
+	/** The options this program lists, with the program-level access / availability / default. */
+	options: zod.z.array(DishwasherOptionDescriptorSchema)
+});
+var DishwasherOptionsSchema = zod.z.object({
+	availability: DishwasherAvailabilitySchema,
+	/** What the appliance can be told to do, from the commands its description declares. */
+	supportsStart: zod.z.boolean(),
+	supportsPause: zod.z.boolean(),
+	supportsResume: zod.z.boolean(),
+	supportsStop: zod.z.boolean(),
+	supportsPower: zod.z.boolean(),
+	/** Every program the description lists, with its options. */
+	programs: zod.z.array(DishwasherProgramSchema),
+	/** Every option and setting entity the description lists (programs reference these by key). */
+	options: zod.z.array(DishwasherOptionDescriptorSchema)
+});
 var dishwasherCapability = {
 	name: "dishwasher",
 	scope: "device",
@@ -61156,86 +61343,102 @@ var dishwasherCapability = {
 	mode: "singleton",
 	deviceTypes: [DeviceType.Dishwasher],
 	methods: {
-		start: method(zod.z.object({ deviceId: zod.z.number().int().nonnegative() }), zod.z.void(), {
+		/**
+		* Start a program. Without `program` the selected one starts. `options` are
+		* option feature keys; each is checked against the program's constraints.
+		*/
+		start: method(zod.z.object({
+			deviceId: DeviceIdSchema,
+			program: zod.z.string().min(1).optional(),
+			options: zod.z.record(zod.z.string(), DishwasherValueSchema).optional()
+		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		pause: method(zod.z.object({ deviceId: zod.z.number().int().nonnegative() }), zod.z.void(), {
+		pause: method(zod.z.object({ deviceId: DeviceIdSchema }), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
-		stop: method(zod.z.object({ deviceId: zod.z.number().int().nonnegative() }), zod.z.void(), {
+		resume: method(zod.z.object({ deviceId: DeviceIdSchema }), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
+		stop: method(zod.z.object({ deviceId: DeviceIdSchema }), zod.z.void(), {
+			kind: "mutation",
+			auth: "protected"
+		}),
+		/** Select (not start) a program; refused when the appliance does not offer it. */
 		setProgram: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			program: zod.z.string().min(1)
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setPower: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setHalfLoad: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setHygienePlus: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setExtraDry: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setIntensiveZone: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setVarioSpeedPlus: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
 		setChildLock: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			on: zod.z.boolean()
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
 		}),
+		/**
+		* Write any option or setting by feature key. Refused when the description does
+		* not list it, it is not writable or not available now, or the value is outside
+		* its declared range / members.
+		*/
 		setOption: method(zod.z.object({
-			deviceId: zod.z.number().int().nonnegative(),
+			deviceId: DeviceIdSchema,
 			key: zod.z.string().min(1),
-			value: zod.z.union([
-				zod.z.boolean(),
-				zod.z.string(),
-				zod.z.number()
-			])
+			value: DishwasherValueSchema
 		}), zod.z.void(), {
 			kind: "mutation",
 			auth: "protected"
-		})
+		}),
+		/** What this appliance can do, from its own description — the UI is derived from it. */
+		getOptions: method(zod.z.object({ deviceId: DeviceIdSchema }), DishwasherOptionsSchema, { auth: "protected" })
 	},
 	status: {
 		schema: DishwasherStatusSchema,
@@ -77092,6 +77295,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"dishwasher.getOptions": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"dishwasher.getStatus": {
 		capName: "dishwasher",
 		capScope: "device",
@@ -77104,6 +77313,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"dishwasher.resume": {
+		capName: "dishwasher",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"dishwasher.setChildLock": {
 		capName: "dishwasher",
 		capScope: "device",
@@ -81604,6 +81819,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"storageMigration.moverClearance": {
+		capName: "storage-migration",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"storageMigration.movers": {
 		capName: "storage-migration",
 		capScope: "system",
@@ -84068,6 +84289,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"dishwasher.getOptions": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"dishwasher.getStatus": [{
 		name: "deviceId",
 		form: "single",
@@ -84078,6 +84304,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"dishwasher.resume": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"dishwasher.setChildLock": [{
 		name: "deviceId",
 		form: "single",
@@ -86754,6 +86985,9 @@ new Map(Object.entries({
 	"wrapper-update-available": "system",
 	"backup-completed": "system",
 	"export-completed": "system",
+	"alert-critical": "system",
+	"alert-error": "system",
+	"alert-critical-resolved": "system",
 	"storage-location-low": "system",
 	"storage-location-critical": "system",
 	"storage-location-ok": "system",
@@ -86878,6 +87112,16 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 			"storage-location-ok"
 		]
 	},
+	{
+		id: "alerts",
+		family: "system",
+		label: "Alerts",
+		kinds: [
+			"alert-critical",
+			"alert-error",
+			"alert-critical-resolved"
+		]
+	},
 	{
 		id: "alarm",
 		family: "alarm",
@@ -86922,6 +87166,63 @@ var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.ent
 	return [[descriptor.kind, field]];
 })));
 Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
+zod.z.object({
+	phase: zod.z.enum(["raised", "resolved"]),
+	episodeId: zod.z.string().min(1),
+	alertId: zod.z.string().min(1),
+	severity: AlertSeveritySchema,
+	category: zod.z.string(),
+	title: zod.z.string(),
+	message: zod.z.string(),
+	sourceType: zod.z.string().optional(),
+	sourceId: zod.z.string().optional(),
+	nodeId: zod.z.string().optional(),
+	/** The alert's own action link (where the operator acts on it), when it has one. */
+	actionUrl: zod.z.string().optional(),
+	at: zod.z.number()
+});
+/** An episode is closed once its alert is completed or dismissed. */
+function isAlertEpisodeOpen(status) {
+	return status !== "completed" && status !== "dismissed";
+}
+/** Only these severities are ever announced. */
+function isAlertEpisodeSeverity(severity) {
+	return severity === "critical" || severity === "error";
+}
+function alertEpisodeId(alert) {
+	const minted = alert.metadata?.["episodeId"];
+	return typeof minted === "string" && minted.length > 0 ? minted : `${alert.id}@${String(alert.createdAt)}`;
+}
+/** The node an alert is about, from the places emitters put it. */
+function alertNodeId(alert) {
+	const direct = alert.metadata?.["nodeId"];
+	if (typeof direct === "string") return direct;
+	const runner = alert.metadata?.["runner"];
+	if (typeof runner === "object" && runner !== null && "nodeId" in runner) {
+		const id = runner.nodeId;
+		if (typeof id === "string") return id;
+	}
+	return alert.source?.type === "node" ? alert.source.id : void 0;
+}
+function alertEpisodePayload(alert, phase, at) {
+	const nodeId = alertNodeId(alert);
+	return {
+		phase,
+		episodeId: alertEpisodeId(alert),
+		alertId: alert.id,
+		severity: alert.severity,
+		category: alert.category,
+		title: alert.title,
+		message: alert.message,
+		...alert.source !== void 0 ? {
+			sourceType: alert.source.type,
+			sourceId: alert.source.id
+		} : {},
+		...nodeId !== void 0 ? { nodeId } : {},
+		...alert.action?.href !== void 0 ? { actionUrl: alert.action.href } : {},
+		at
+	};
+}
 var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];
@@ -86931,6 +87232,11 @@ var TANK = [
 	"device-tank-full",
 	"device-tank-normal"
 ];
+var ALERT_EPISODE = [
+	"alert-critical",
+	"alert-error",
+	"alert-critical-resolved"
+];
 var UPDATES = [
 	"addon-update-available",
 	"server-update-available",
@@ -87123,14 +87429,14 @@ var STATE_SUMMARY_VARS = [
 	([...RULE_TEXT], [...CONSUMABLE]),
 	([...RULE_TEXT], [...TANK]),
 	[...RULE_TEXT],
-	([...RULE_TEXT], [...UPDATES]),
-	([...RULE_TEXT], [...UPDATES]),
-	[...RULE_TEXT],
+	([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
+	([...RULE_TEXT], [...UPDATES, ...ALERT_EPISODE]),
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
+	([...RULE_TEXT], [...ALERT_EPISODE]),
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
@@ -87148,7 +87454,11 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
-	[...RULE_TEXT],
+	([...RULE_TEXT], [...ALERT_EPISODE]),
+	([...RULE_TEXT], [...ALERT_EPISODE]),
+	([...RULE_TEXT], [...ALERT_EPISODE]),
+	([...RULE_TEXT], [...ALERT_EPISODE]),
+	([...RULE_TEXT], [...ALERT_EPISODE]),
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
@@ -88185,6 +88495,12 @@ Object.defineProperty(exports, "CoreBlockSchema", {
 		return CoreBlockSchema;
 	}
 });
+Object.defineProperty(exports, "CredentialTokenClaimsSchema", {
+	enumerable: true,
+	get: function() {
+		return CredentialTokenClaimsSchema;
+	}
+});
 Object.defineProperty(exports, "DATABASE_SNAPSHOT_PARTIAL_SUFFIX", {
 	enumerable: true,
 	get: function() {
@@ -88665,6 +88981,18 @@ Object.defineProperty(exports, "addonWidgetsCapability", {
 		return addonWidgetsCapability;
 	}
 });
+Object.defineProperty(exports, "alertEpisodeId", {
+	enumerable: true,
+	get: function() {
+		return alertEpisodeId;
+	}
+});
+Object.defineProperty(exports, "alertEpisodePayload", {
+	enumerable: true,
+	get: function() {
+		return alertEpisodePayload;
+	}
+});
 Object.defineProperty(exports, "alertsCapability", {
 	enumerable: true,
 	get: function() {
@@ -89151,6 +89479,18 @@ Object.defineProperty(exports, "interpolate", {
 		return interpolate;
 	}
 });
+Object.defineProperty(exports, "isAlertEpisodeOpen", {
+	enumerable: true,
+	get: function() {
+		return isAlertEpisodeOpen;
+	}
+});
+Object.defineProperty(exports, "isAlertEpisodeSeverity", {
+	enumerable: true,
+	get: function() {
+		return isAlertEpisodeSeverity;
+	}
+});
 Object.defineProperty(exports, "isAppLinkBase", {
 	enumerable: true,
 	get: function() {