@camstack/addon-osd-manager 0.1.137 → 0.1.139

package/dist/index.mjs

@@ -5359,7 +5359,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-D_4W7xuQ.mjs
+//#region ../types/dist/sleep-DU7mu4wb.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -16738,18 +16738,30 @@ var LlmErrorCodeSchema = _enum([
 	"budget-exceeded",
 	"adapter-error"
 ]);
-var LlmGenerateResultSchema = discriminatedUnion("ok", [object({
+var LlmGenerateOkSchema = object({
 	ok: literal(true),
 	text: string(),
 	model: string(),
 	usage: LlmUsageSchema,
 	truncated: boolean(),
 	latencyMs: number()
-}), object({
+});
+/**
+* WHO refused, on a `refusal`. `guardrail` = a safety filter in front of the
+* model rejected the request before it answered (Apple Foundation Models
+* refuses surveillance-framed prompts in 0.1 s); `model` = the model itself
+* declined. They are different faults: a guardrail refusal is a property of
+* the BACKEND, so the provider falls back to the next profile; a model refusal
+* is an answer. Absent on every other code, and on a refusal a wire cannot
+* attribute.
+*/
+var LlmRefusalSourceSchema = _enum(["guardrail", "model"]);
+var LlmGenerateResultSchema = discriminatedUnion("ok", [LlmGenerateOkSchema, object({
 	ok: literal(false),
 	code: LlmErrorCodeSchema,
 	message: string(),
-	retryAfterMs: number().optional()
+	retryAfterMs: number().optional(),
+	refusalSource: LlmRefusalSourceSchema.optional()
 })]);
 /**
 * `Uint8Array` is the sanctioned binary convention — superjson + the UDS
@@ -16979,6 +16991,77 @@ var LlmRuntimeDiskUsageSchema = object({
 	modelsBytes: number(),
 	freeBytes: number().optional()
 });
+var LlmRuntimeCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: array(LlmImageSchema).optional(),
+	runtime: ManagedRuntimeConfigSchema,
+	/** The managed profile's timeout, threaded by the hub provider. */
+	timeoutMs: number().int().positive().optional()
+});
+/**
+* Why Apple Foundation Models cannot run on a node that has it in principle.
+* The first three are Apple's own `UnavailableReason`s, verbatim; the rest are
+* ours: the OS predates the framework (macOS < 26), the helper binary is not
+* in the installed addon, or it crashed past the respawn bound.
+*/
+var AppleFmUnavailableReasonSchema = _enum([
+	"deviceNotEligible",
+	"appleIntelligenceNotEnabled",
+	"modelNotReady",
+	"osTooOld",
+	"helperMissing",
+	"helperCrashed"
+]);
+/**
+* Apple Foundation Models on ONE node — four states, never a boolean (D315).
+*
+*   - `available`            — the helper probed it; what it CAN do is reported
+*                              here (`imageInput`, `contextSize`, languages),
+*                              never typed by an operator.
+*   - `unavailable`          — a known absence, with the reason to act on.
+*   - `unsupported-platform` — not a Mac; there is nothing to enable.
+*   - `unknown`              — the probe did not answer (not yet run, timed
+*                              out, helper crashed mid-probe). A failed
+*                              measurement is NEVER `unavailable` (D393).
+*/
+var AppleFmAvailabilitySchema = discriminatedUnion("state", [
+	object({
+		state: literal("available"),
+		osVersion: string(),
+		/** Tokens, as the framework reports it. Read at runtime, never assumed. */
+		contextSize: number().int().positive(),
+		/** BCP-47-ish tags (`it-IT`) of the languages the model supports. */
+		languages: array(string()),
+		/** Whether prompts may carry images. `false` on a macOS 26 build. */
+		imageInput: boolean()
+	}),
+	object({
+		state: literal("unavailable"),
+		reason: AppleFmUnavailableReasonSchema,
+		osVersion: string().nullable(),
+		detail: string()
+	}),
+	object({
+		state: literal("unsupported-platform"),
+		platform: string()
+	}),
+	object({
+		state: literal("unknown"),
+		error: string()
+	})
+]);
+/**
+* A generation on the node's Apple Foundation Models helper. A separate verb
+* from `complete`, whose `runtime` is a llama.cpp config: overloading it would
+* drag a GGUF model reference into a backend that has none. `images` is part
+* of the contract so vision needs no cap change later; a node whose model has
+* no image input REFUSES them (`unavailable`), never drops them.
+*/
+var LlmRuntimeAppleCompleteInputSchema = LlmGenerateBaseInputSchema.extend({
+	images: array(LlmImageSchema).optional(),
+	/** The profile's timeout, threaded by the hub provider. */
+	timeoutMs: number().int().positive().optional()
+});
+var LlmRuntimeCancelInputSchema = object({ requestId: string() });
 var llmRuntimeCapability = {
 	name: "llm-runtime",
 	scope: "system",
@@ -16998,12 +17081,7 @@ var llmRuntimeCapability = {
 		* nothing; the public `llm` cap (which end users and non-admin sessions
 		* legitimately call for chat/generation) is untouched.
 		*/
-		complete: method(LlmGenerateBaseInputSchema.extend({
-			images: array(LlmImageSchema).optional(),
-			runtime: ManagedRuntimeConfigSchema,
-			/** The managed profile's timeout, threaded by the hub provider. */
-			timeoutMs: number().int().positive().optional()
-		}), LlmGenerateResultSchema, {
+		complete: method(LlmRuntimeCompleteInputSchema, LlmGenerateResultSchema, {
 			kind: "mutation",
 			auth: "admin",
 			timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
@@ -17028,7 +17106,28 @@ var llmRuntimeCapability = {
 			auth: "admin"
 		}),
 		listLocalModels: method(object({}), array(LlmNodeModelSchema), { auth: "admin" }),
-		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
+		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" }),
+		/**
+		* Stop a node-side generation started with a `requestId` — `complete` or
+		* `completeApple`. The hub's `llm.cancel` forwards here with the same
+		* nodePin the generation took; before this existed a cancelled
+		* managed-local generation kept running on the node to its own timeout.
+		* Idempotent: an unknown or finished id is a no-op.
+		*/
+		cancel: method(LlmRuntimeCancelInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* This node's Apple Foundation Models state, answered from a mirror the
+		* node refreshes in the background — it never waits on a probe.
+		*/
+		appleAvailability: method(object({}), AppleFmAvailabilitySchema, { auth: "admin" }),
+		completeApple: method(LlmRuntimeAppleCompleteInputSchema, LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin",
+			timeoutMs: AI_CAP_TRANSPORT_TIMEOUT_MS
+		})
 	}
 };
 /**
@@ -17047,7 +17146,8 @@ var LlmProfileKindSchema = _enum([
 	"openai",
 	"anthropic",
 	"google",
-	"managed-local"
+	"managed-local",
+	"apple-foundation"
 ]);
 var LlmProfileSchema = object({
 	id: string(),
@@ -17105,7 +17205,14 @@ var LlmProfileSchema = object({
 	toolsEnabled: boolean().default(false),
 	extraHeaders: record(string(), string()).optional(),
 	/** kind === 'managed-local' only (spec §4). */
-	runtime: ManagedRuntimeConfigSchema.optional()
+	runtime: ManagedRuntimeConfigSchema.optional(),
+	/**
+	* kind === 'apple-foundation' only: WHERE it runs — the only thing there is
+	* to configure (no key, no URL, no download; `model` is `apple-system`).
+	* `supportsVision` on such a row is stamped by the provider from the node's
+	* reported `imageInput`, never taken from the operator (D62).
+	*/
+	appleFoundation: object({ nodeId: string() }).optional()
 });
 /** ConfigUISchema tree passed through untyped on the wire (the
 *  notification-output `ConfigSchemaPassthrough` precedent at
@@ -17187,7 +17294,9 @@ var LlmRuntimeNodeSchema = object({
 	reachable: boolean(),
 	status: LlmRuntimeStatusSchema.optional(),
 	disk: LlmRuntimeDiskUsageSchema.optional(),
-	error: string().optional()
+	error: string().optional(),
+	/** Absent = the node did not answer the question (render as unknown). */
+	apple: AppleFmAvailabilitySchema.optional()
 });
 var GenerateVisionInputSchema = LlmGenerateBaseInputSchema.extend({ images: array(LlmImageSchema).min(1) });
 var ProfileRefInputSchema = object({
@@ -19631,6 +19740,16 @@ var NcCrossingSchema = _enum([
 	"exit",
 	"any"
 ]);
+/**
+* Which edge of a BOOLEAN sensor fires a device-event rule (D640).
+*  - `raised`  — the sensor went high: water detected, smoke, open, tampered.
+*  - `cleared` — it went back: dry, clear, closed.
+*  - absent    — both edges, which is what every rule authored before this did.
+*
+* There is no third member for "both": absence already says it, and a value
+* that means the same as absence is a second way to write one rule.
+*/
+var NcSensorTransitionSchema = _enum(["raised", "cleared"]);
 /** Admin-zone membership condition (zone IDs as stamped by the ZoneEngine). */
 var NcZoneConditionSchema = object({
 	ids: array(string().min(1)).min(1),
@@ -19820,6 +19939,20 @@ var NcConditionsSchema = object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number()).optional(),
+	/**
+	* Device EXCLUSION (D641) — "every device except these". Judged on the SAME
+	* subject ids {@link devices} is judged on (the camera, the sensor that
+	* fired, a linked set's sensor and row cameras), so a sensor fanned out per
+	* linked camera is excluded exactly where an include would have tested it.
+	* `min(1)`: an empty exclusion excludes nothing and is written as absent.
+	*
+	* Not for `system-event` rules — those carry their own
+	* `systemEvent.excludeDeviceIds` (D636), and the hub refuses this key there.
+	* Editors present the two lists as ONE field (All | Only these | All except
+	* these); the engine evaluates each independently, so a legacy rule
+	* carrying both still means "these, minus those".
+	*/
+	devicesExclude: array(number()).min(1).optional(),
 	/** Detector class names (any overlap with the record's class set). */
 	classes: array(string().min(1)).optional(),
 	/** Veto classes — any overlap fails the rule. */
@@ -19953,6 +20086,16 @@ var NcConditionsSchema = object({
 	*/
 	sensorKinds: array(string().min(1)).optional(),
 	/**
+	* DEVICE-EVENT only (D640). Fire on one edge of a boolean sensor —
+	* {@link NcSensorTransitionSchema}. Which field of the slice means "raised"
+	* is `@camstack/types` → `notification/sensor-raised.ts`. A reading the
+	* engine cannot place (a kind with no raise, an unreadable slice) PASSES:
+	* the condition fails open towards notifying, never towards silence. Editors
+	* offer it only when every chosen {@link sensorKinds} member has a raise
+	* (`sensorTransitionOffered`), and the hub refuses it on any other delivery.
+	*/
+	sensorTransition: NcSensorTransitionSchema.optional(),
+	/**
 	* PACKAGE-EVENT only. Which package phase fires the rule — `delivered`
 	* (a parked parcel appeared), `picked-up` (it departed), or `both`. Fails
 	* when the subject's phase does not match (a subject always carries a phase
@@ -20452,9 +20595,29 @@ var NcTestResultSchema = object({
 	className: string().optional(),
 	label: string().optional()
 });
-/** The five rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts`
-*  is the same union; the template-vars spec pins the two together. */
+/** The rule kinds, as data. `NcRuleKind` in `notification/rule-kinds.ts` is the
+*  same union; the template-vars spec pins the two together. `mixed` is DERIVED
+*  (a stored system rule whose kinds span families, D637) and never authored. */
 var NcRuleKindSchema = _enum([
+	"detection",
+	"sensor",
+	"occupancy",
+	"sound",
+	"device-events",
+	"system",
+	"alarm",
+	"mixed"
+]);
+/**
+* The kinds a SERVED template-variable descriptor may name: the five that
+* existed before D637, frozen. `getTemplateCatalog` ships `kinds` to every
+* installed viewer, and a viewer at `@camstack/types` 1.2.25x parses them with a
+* strict five-member enum — one `device-events` in one descriptor fails the
+* whole catalog parse. So the WIRE says `system`, and the MATCH widens it:
+* `templateVarKindApplies` reads a `system` descriptor as applying to every
+* system rule kind (`device-events`, `system`, `alarm`, `mixed`).
+*/
+var NcTemplateVarKindSchema = _enum([
 	"detection",
 	"sensor",
 	"occupancy",
@@ -20492,7 +20655,7 @@ var NcTemplateVarGroupSchema = _enum([
 *
 * `families` / `fields` / `kinds` / `deliveries` / `systemEventKinds` say WHERE
 * it has a value; absent = no restriction on that axis. `systemEventKinds` is
-* read only for a `system` rule. `dynamic` declares a FAMILY of names
+* read only for a system-event rule (any family, or `mixed`). `dynamic` declares a FAMILY of names
 * (`count_<class>`): the descriptor's `name` is the example member.
 */
 var NcTemplateVarDescriptorSchema = object({
@@ -20503,7 +20666,7 @@ var NcTemplateVarDescriptorSchema = object({
 	group: NcTemplateVarGroupSchema,
 	families: array(NcTemplateFamilySchema).min(1),
 	fields: array(NcTemplateFieldSchema).optional(),
-	kinds: array(NcRuleKindSchema).optional(),
+	kinds: array(NcTemplateVarKindSchema).optional(),
 	deliveries: array(NcDeliverySchema).optional(),
 	systemEventKinds: array(NcSystemEventKindSchema).optional(),
 	dynamic: object({
@@ -20551,6 +20714,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -20561,6 +20725,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -20759,6 +20924,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Restrict the rule to these devices; absent = all devices. A sensor event matches either the SENSOR that fired or the camera it is attributed to, so a rule may name either one."
 	},
+	{
+		id: "devicesExclude",
+		group: "scope",
+		label: "Excluded devices",
+		valueType: "deviceIdExcludeList",
+		operator: "notIn",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P1",
+		description: "Every device except these. Judged on the same device ids as Devices: a sensor event is excluded by the SENSOR that fired or by the camera it is attributed to."
+	},
 	{
 		id: "classes",
 		group: "class",
@@ -21015,6 +21195,33 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Raw device event-type tokens (e.g. doorbell press / press_long) from the event-emitter slice; absent on doorbell-pulse / passive sensors."
 	},
+	{
+		id: "sensorTransition",
+		group: "device",
+		label: "Notify when",
+		valueType: "sensorTransition",
+		options: [
+			{
+				value: "",
+				label: "It triggers and when it clears",
+				hint: "Every change: water detected, and back to dry."
+			},
+			{
+				value: "raised",
+				label: "Only when it triggers",
+				hint: "Water detected, smoke, a contact opening — never the return to normal."
+			},
+			{
+				value: "cleared",
+				label: "Only when it clears",
+				hint: "Back to dry, smoke gone, a contact closing — never the alert itself."
+			}
+		],
+		operator: "in",
+		appliesTo: ["device-event"],
+		phase: "P2",
+		description: "Fire on one edge of a boolean sensor. Offered only when every chosen sensor kind raises and clears; a reading that cannot be placed still notifies."
+	},
 	{
 		id: "packagePhase",
 		group: "package",
@@ -21198,6 +21405,28 @@ var NcHistoryFilterSchema = object({
 	limit: number().int().min(1).max(500).default(100)
 });
 /**
+* Every rule's last run, in one answer.
+*
+* A rule ABSENT from `runs` produced no delivery inside `horizonMs` — how far
+* back this answer looked, in ms before the hub's now. It is the outbox prune
+* window (7 days by default, operator-configurable), NARROWED when the read hit
+* its row bound: the answer never claims a window it did not read. `null` means
+* the operator keeps the outbox forever AND the read reached its end, so absent
+* means "never on record". A UI derives its "not in the last N days" from this
+* value, never from a constant — and only when the call ANSWERED (D315).
+*/
+var NcRuleLastRunsSchema = object({
+	runs: array(object({
+		ruleId: string(),
+		/** Fire time of the newest row (`createdAt`, epoch ms). */
+		lastAt: number(),
+		status: NcHistoryStatusSchema,
+		/** The camera/device of that row (a digest row files under its first camera). */
+		deviceId: number()
+	})),
+	horizonMs: number().nonnegative().nullable()
+});
+/**
 * What a snooze covers. Broader scopes win when several overlap, so one window
 * leaves ONE digest rather than a rule snooze and a whole-feed snooze both
 * summarising the same silence.
@@ -21378,6 +21607,14 @@ var NcAlarmModeCoverageSchema = object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: array(number().int()),
 	/**
+	* D641: the ids NOT covered although `allDevices` is true — every unscoped
+	* covering rule EXCLUDES them (`conditions.devicesExclude`) and no named rule
+	* covers them. Always `[]` when `allDevices` is false. Excluded by the rules,
+	* which is not the same as skipped by a switch: never in `skippedDevices`.
+	* Defaulted so an answer computed before this field parses as "none".
+	*/
+	allDevicesExcept: array(number().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -21601,6 +21838,15 @@ var notificationRulesCapability = {
 		*/
 		getHistory: method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }),
 		/**
+		* The newest delivery of every rule, in ONE bounded read of the outbox —
+		* the "Last run" column. Never a `getHistory` per rule. A rule with no
+		* delivery inside `horizonMs` is absent from `runs`; see
+		* {@link NcRuleLastRunsSchema} for what absent means. A store that cannot
+		* answer FAILS the call rather than answering "nothing ran". Admin-only,
+		* like `getHistory`, of which it is a projection.
+		*/
+		getRuleLastRuns: method(object({}), NcRuleLastRunsSchema, { auth: "admin" }),
+		/**
 		* Mint a fresh, externally-reachable URL for one artefact a history row
 		* named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
 		* signed-link mechanism the dispatcher uses to attach media to an
@@ -27529,7 +27775,11 @@ function buildDescriptor(capName, kind) {
 		icon: legacyIcon(t.iconId)
 	};
 }
-Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
+/**
+* Sensor / control cap name → static event-kind descriptor. A linked device
+* contributes one entry per bound cap present in this map.
+*/
+var EVENT_KIND_BY_CAP = Object.freeze(Object.fromEntries(Object.entries(CAP_TO_KIND).map(([capName, kind]) => [capName, buildDescriptor(capName, kind)])));
 /**
 * server-management — per-NODE singleton capability for a node's ROOT
 * package lifecycle (runtime-updatable node packages).
@@ -36549,6 +36799,29 @@ var RenameNodeResultSchema = object({
 	name: string()
 });
 /**
+* The cheap node list. A consumer's rule for a STORED node id (a rule's
+* `nodeIds`) that is missing from `nodes`, whatever `complete` says: render it
+* as a removable chip labelled unknown, never drop it (D49). Even a complete
+* list omits a node that joined and left between two history captures, so a
+* missing id means "not known to the hub", never "removed". Only the operator
+* removes it.
+*
+* `complete` changes only the WORDING: `false` = no history read has ever
+* answered, so the list may be missing offline nodes the hub does know (D315).
+*
+* `name` is the history row's name (≤ 30 s behind a rename), or the id when
+* the history has none.
+*/
+var NodeDirectorySchema = object({
+	nodes: array(object({
+		id: string(),
+		name: string(),
+		isHub: boolean(),
+		isOnline: boolean()
+	})).readonly(),
+	complete: boolean()
+});
+/**
 * `nodes` is a **hub-centric** cluster-management cap: the hub hosts
 * the single provider and every per-node method (`getNodeAddons`,
 * `restartProcess`, `restartNode`, `undeployAddon`, …) takes `nodeId`
@@ -36567,6 +36840,12 @@ var nodesCapability = {
 	nodeIdMode: "data",
 	methods: {
 		topology: method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }),
+		/**
+		* The cheap node list for pickers (D637): the hub's in-memory registry plus
+		* the durable node history, no per-node RPC. `complete: false` when the
+		* history could not be read.
+		*/
+		directory: method(_void(), NodeDirectorySchema, { auth: "admin" }),
 		deployAddon: method(NodeAddonInputSchema, SuccessSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -42861,6 +43140,42 @@ function readDeviceStateFrom(runtimeState) {
 	}
 }
 /**
+* LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
+* valutatore puro del suo FRONTE.
+*
+* Viveva dentro il builtin virtual-doorbell
+* (`@camstack/system` — `builtins/doorbell/trigger-engine.ts`) e i suoi
+* predicati erano privati al modulo. Il recorder ne ha bisogno per il trigger
+* `RecordingTriggers.sensorDeviceIds`: copiarla avrebbe creato la SECONDA
+* tabella, che diverge alla prima cap aggiunta e il cui sintomo — "il sensore
+* fa suonare il campanello ma non registra" — è esattamente D62. Quindi si
+* SPOSTA qui e il doorbell la ri-esporta.
+*
+* ⚠ NON è `DEVICE_STATE_READERS` (`catalogs/device-state-vocabulary.ts`), e le
+* due non vanno unificate: quella risponde a "qual è la PAROLA di stato per una
+* regola" (e include `presence`, `cover`, `alarm-panel`), questa a "qual è il
+* booleano il cui FRONTE conta". Vocabolari deliberatamente diversi.
+*/
+/**
+* Known binary / switch source caps → the boolean slice field whose
+* false→true rise counts as ACTIVE. Every entry is "fire on active".
+* Sensors whose "active" reading is not a plain boolean (presence's string
+* state, connectivity's connected flag) are deliberately excluded — a
+* reconnect is not a doorbell press, and it is not a recording either.
+*/
+var SOURCE_CAP_ACTIVE_FIELD = {
+	contact: "entryOpen",
+	binary: "on",
+	switch: "on",
+	motion: "detected",
+	flood: "flooded",
+	gas: "detected",
+	smoke: "detected",
+	"carbon-monoxide": "detected",
+	vibration: "detected",
+	tamper: "tampered"
+};
+/**
 * Accessory device helpers — shared across drivers.
 *
 * Many vendor-specific drivers register accessory child devices on
@@ -47067,12 +47382,30 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.appleAvailability": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"llmRuntime.cancel": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.complete": {
 		capName: "llm-runtime",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
+	"llmRuntime.completeApple": {
+		capName: "llm-runtime",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"llmRuntime.deleteModel": {
 		capName: "llm-runtime",
 		capScope: "system",
@@ -47745,6 +48078,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -47913,6 +48252,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.getRuleLastRuns": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.getTemplateCatalog": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -53509,6 +53854,51 @@ var NC_AUDIO_DEFAULTS = {
 	samplingSeconds: 10
 };
 new Set(["devices", "classes"]);
+/** Every filter, for the callers that must cover all four (guards, tests). */
+var NC_SYSTEM_EVENT_FILTER_KEYS = [
+	"deviceIds",
+	"deviceTypes",
+	"nodeIds",
+	"packageNames"
+];
+new Map(Object.entries({
+	"device-online": "device-events",
+	"device-offline": "device-events",
+	"device-disabled": "device-events",
+	"device-enabled": "device-events",
+	"device-battery-low": "device-events",
+	"device-battery-normal": "device-events",
+	"device-consumable-low": "device-events",
+	"device-consumable-normal": "device-events",
+	"stream-online": "device-events",
+	"stream-offline": "device-events",
+	"detection-blind": "device-events",
+	"node-online": "system",
+	"node-offline": "system",
+	"node-inference-unavailable": "system",
+	"addon-crash-loop": "system",
+	"addon-update-available": "system",
+	"addon-updated": "system",
+	"server-update-available": "system",
+	"server-updated": "system",
+	"wrapper-update-available": "system",
+	"backup-completed": "system",
+	"export-completed": "system",
+	"alarm-triggered": "alarm",
+	"alarm-armed": "alarm",
+	"alarm-disarmed": "alarm",
+	"alarm-arming": "alarm",
+	"alarm-arm-refused": "alarm",
+	"alarm-pending": "alarm",
+	"alarm-rearmed": "alarm",
+	"alarm-sensor-bypass": "alarm",
+	"alarm-check-failed": "alarm",
+	"camera-online": null,
+	"camera-offline": null,
+	"camera-disabled": null,
+	"camera-enabled": null
+}));
+[...NC_SYSTEM_EVENT_FILTER_KEYS];
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
 var WEEKDAY_TO_DAY = {
 	Sun: 0,
@@ -53570,6 +53960,39 @@ function isScheduleActive(schedule, atMs) {
 	}
 	return schedule.invert === true ? !inside : inside;
 }
+/**
+* WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
+* persists (D640 "a sensor rule fires on the raise, the clear, or both").
+*
+* A device-event rule over a flood sensor notified on BOTH edges: water
+* detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+* name one edge; this file answers, for one `SensorEvent`, which edge it is.
+*
+* NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+* already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+* (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+* table), and a sensor event names its kind, not its cap. So the table here is
+* DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+* Only kinds whose taxonomy category is `sensor` take part — a switch has an
+* `on` boolean too, but "it triggers / it clears" is not a sentence about a
+* light, and offering it there would be a knob with a misleading label.
+* `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+* absent from the source table, so it is absent here.
+*
+* `undefined` = never guessed: a kind with no raise (a doorbell press, a
+* button, a cover), or a slice whose field is missing or not a boolean. The
+* engine then does NOT filter — a flood alert must not go silent because one
+* read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+*
+* Pure, RN-safe: the viewer imports the support rule from here.
+*/
+/** Event kind → the boolean field of its cap slice that means "raised". */
+var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.entries(EVENT_KIND_BY_CAP).flatMap(([capName, descriptor]) => {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0 || descriptor.category !== "sensor") return [];
+	return [[descriptor.kind, field]];
+})));
+Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
 var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];

package/dist/{player-overlays-B_ERqzqj.mjs → player-overlays-Cxv7i44p.mjs}

@@ -1,5 +1,5 @@
 import { h as e, l as t, u as n, y as r } from "./_virtual_mf___mfe_internal__addon_osd_manager_page__loadShare__react__loadShare__.js-Bs1t18EM.mjs";
-import { o as i, s as a } from "./responsive-BOpuh3Lr.mjs";
+import { o as i, s as a } from "./responsive-BpLjT1Jf.mjs";
 import { n as o, r as s, t as c } from "./_virtual_mf___mfe_internal__addon_osd_manager_page__loadShare__react_mf_1_jsx_mf_2_runtime__loadShare__.js-DalfdIDw.mjs";
 var l = a("chevron-down", [["path", {
 	d: "m6 9 6 6 6-6",

package/dist/remoteEntry.js

@@ -1,2 +1,2 @@
-import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_osd_manager_page__remoteEntry_js-C-OUB_74.mjs";
+import { n as e, t } from "./virtual_mf-REMOTE_ENTRY_ID___mfe_internal__addon_osd_manager_page__remoteEntry_js-CJGlrZlS.mjs";
 export { t as get, e as init };