@camstack/addon-ai 0.4.123 → 0.4.124

package/dist/addon.js

@@ -5525,7 +5525,7 @@ function number(params) {
 	return /* @__PURE__ */ _coercedNumber(ZodNumber, params);
 }
 //#endregion
-//#region ../types/dist/sleep-D_4W7xuQ.mjs
+//#region ../types/dist/sleep-BaRu0bS5.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -9639,7 +9639,7 @@ var ModelFormatEntrySchema = object({
 	/** Multi-file payload (directory members or sibling files). */
 	files: array(string()).readonly().optional(),
 	/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
-	runtimes: array(_enum(["node", "python"])).readonly().optional()
+	runtimes: array(_enum(["python"])).readonly().optional()
 });
 /**
 * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -9720,10 +9720,17 @@ var ModelCatalogEntrySchema = object({
 	inputChannels: number$1().int().positive().optional(),
 	labels: array(LabelDefinitionSchema).readonly(),
 	inputLayout: _enum(["nchw", "nhwc"]).optional(),
+	/**
+	* `'scrfd'` applies InsightFace's SCRFD input contract, `(x - 127.5) / 128`
+	* (upstream `insightface/model_zoo/scrfd.py`), instead of the historical
+	* plain `/255`. Measured against COCO GT: 188 → 196 faces found on the
+	* `scrfd-2.5g` catalog entry (2026-09-26 model-replacement spike, §2.4-2).
+	*/
 	inputNormalization: _enum([
 		"zero-one",
 		"imagenet",
-		"none"
+		"none",
+		"scrfd"
 	]).optional(),
 	/**
 	* The model already applies softmax IN-GRAPH — its raw output is a
@@ -9825,7 +9832,8 @@ var ModelConvertMetadataSchema = object({
 	inputNormalization: _enum([
 		"zero-one",
 		"imagenet",
-		"none"
+		"none",
+		"scrfd"
 	]).optional(),
 	preprocessMode: _enum(["letterbox", "resize"]).optional(),
 	outputFormat: _enum([
@@ -17311,6 +17319,9 @@ var NcSystemEventKindSchema = _enum([
 	"device-battery-normal",
 	"device-consumable-low",
 	"device-consumable-normal",
+	"device-tank-low",
+	"device-tank-full",
+	"device-tank-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -17348,6 +17359,29 @@ var NC_LEGACY_SYSTEM_EVENT_KINDS = new Set([
 ]);
 NcSystemEventKindSchema.options.filter((kind) => !NC_LEGACY_SYSTEM_EVENT_KINDS.has(kind));
 /**
+* The panel's transitions, as ONE list.
+*
+* Named here rather than spelled out at each of the four sites that need them
+* (the emitter, the intake, the editor group, the combined-notification gate),
+* because a transition added to the enum and forgotten at one of them is an
+* alarm state nobody can be notified about. That is exactly what this list
+* failed to prevent while it held three: `alarm-arming` was the fourth.
+*
+* In LIFECYCLE order, which is the order an editor lists them in and the order
+* a person experiences them — not the order they were added.
+*/
+var NC_ALARM_SYSTEM_EVENT_KINDS = [
+	"alarm-arm-refused",
+	"alarm-check-failed",
+	"alarm-arming",
+	"alarm-armed",
+	"alarm-pending",
+	"alarm-triggered",
+	"alarm-rearmed",
+	"alarm-sensor-bypass",
+	"alarm-disarmed"
+];
+/**
 * One coherent system-event condition. `kinds` is the required opt-in safety
 * gate; the remaining lists are optional narrowing filters relevant to the
 * selected kinds.
@@ -17381,7 +17415,22 @@ var NcSystemEventConditionSchema = object({
 	*/
 	excludeDeviceIds: array(number$1().int()).min(1).optional(),
 	nodeIds: array(string().min(1)).min(1).optional(),
-	packageNames: array(string().min(1)).min(1).optional()
+	packageNames: array(string().min(1)).min(1).optional(),
+	/**
+	* At or below this remaining-life %, a consumable is LOW for THIS rule
+	* (D642). Absent = {@link NC_CONSUMABLE_LOW_PERCENT_DEFAULT}; at most
+	* {@link NC_CONSUMABLE_LOW_PERCENT_MAX}, so every episode can recover. Scoped to the
+	* consumable kinds (`systemEventFilterApplies`) and to the device-events
+	* family; ignored on every other kind.
+	*
+	* It is a property of the RULE because the operator decided so: a rule at
+	* 25 must be told about a filter at 20 %, a rule at 10 must not. The hub
+	* keeps one episode per (threshold, device, item) — its own hysteresis, its
+	* own reminder — and a rule hears only the episode judged at ITS threshold,
+	* exactly as an occupancy rule hears only the edge of its own count. A
+	* provider's own `replace` verdict is low at every threshold.
+	*/
+	consumableLowPercent: number$1().int().min(1).max(95).optional()
 });
 /** Hard ceiling on a window (24h). A snooze that could not expire would be an
 *  outage the operator asked for once and forgot. */
@@ -17399,6 +17448,25 @@ var NcScheduleSchema = object({
 	/** Active OUTSIDE the windows (e.g. "only outside business hours"). */
 	invert: boolean().optional()
 });
+/**
+* How a system-event rule of the `device-events` or `system` family speaks
+* (D647): at once, per event (`instant`, the only behaviour before D647), or
+* as a STATE SUMMARY at the end of each window of `schedule`.
+*/
+var NcSystemEventDeliveryModeSchema = _enum(["instant", "summary"]);
+/**
+* `summary`: the rule sends NOTHING per event. When a window of `schedule`
+* CLOSES, it sends one notification with the current state of its kinds
+* (low batteries, consumables to replace, devices offline, updates
+* available, ...), after its own filters. Nothing to report sends nothing.
+* The schedule is the ordinary `NcSchedule` (weekly windows, IANA timezone,
+* midnight crossing); the send time is each window's END. Refused on the
+* `alarm` family, which stays instant (`systemEventDeliveryProblems`).
+*/
+var NcSystemEventDeliverySchema = discriminatedUnion("mode", [object({ mode: literal("instant") }), object({
+	mode: literal("summary"),
+	schedule: NcScheduleSchema
+})]);
 /** Fuzzy plate matcher — OCR noise makes exact match useless (spec row 12/13). */
 var NcPlateMatcherSchema = object({
 	/**
@@ -17524,6 +17592,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),
@@ -17713,6 +17791,20 @@ var NcConditionsSchema = object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number$1()).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$1()).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. */
@@ -17846,6 +17938,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
@@ -18100,6 +18202,16 @@ var NcRuleInputSchema = object({
 	delivery: NcDeliverySchema,
 	conditions: NcConditionsSchema.default({}),
 	schedule: NcScheduleSchema.optional(),
+	/**
+	* A `device-events` / `system` rule's delivery (D647): absent or `instant`
+	* is a notification per event; `summary` is one state summary per closed
+	* window of its schedule. `.optional()` and never defaulted: absent must
+	* keep meaning what every rule authored before D647 meant, with no
+	* migration. Top-level rather than inside `conditions.systemEvent`, so a
+	* client that does not know it (an older viewer re-sending `conditions`
+	* whole) leaves it standing through the store's patch merge.
+	*/
+	systemEventDelivery: NcSystemEventDeliverySchema.optional(),
 	/** May be empty when `targetUsers` addresses at least one user — the
 	*  "at least one addressee" invariant is enforced by the provider, because
 	*  a cross-field refine here would break `NcRulePatchSchema.partial()`. */
@@ -18328,6 +18440,28 @@ var NcRuleSchema = NcRuleInputSchema.extend({
 	*/
 	disabledTargetIds: array(string()).default([])
 });
+/** One section of a previewed state summary. `unavailable` = its state could not be read. */
+var NcStateSummaryPreviewSectionSchema = object({
+	id: string(),
+	status: _enum(["read", "unavailable"]),
+	items: number$1().int().nonnegative(),
+	reason: string().optional()
+});
+/**
+* The summary a rule would send now. `empty` = nothing to report and every
+* section read: such a summary is NOT sent. `dropped` counts the open states
+* the rule's own filters (or a camera mute) left out, by reason.
+* `excludedGroups` names the kind groups selected that have no state to report
+* (backups & exports).
+*/
+var NcStateSummaryPreviewSchema = object({
+	empty: boolean(),
+	count: number$1().int().nonnegative(),
+	text: string(),
+	sections: array(NcStateSummaryPreviewSectionSchema),
+	dropped: record(string(), number$1().int().nonnegative()),
+	excludedGroups: array(string())
+});
 var NcTestResultSchema = object({
 	recordId: string(),
 	recordKind: _enum([
@@ -18345,9 +18479,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",
@@ -18385,7 +18539,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({
@@ -18396,9 +18550,16 @@ 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(),
+	/**
+	* Which system-event DELIVERY has a value for it (D647). Absent = an
+	* instant row only when the descriptor names `systemEventKinds` (a
+	* per-event fact: a summary row has no single device), and both otherwise.
+	* `['summary']` marks the state-summary vocabulary (`{{summaryText}}`, ...).
+	*/
+	systemEventDeliveries: array(NcSystemEventDeliveryModeSchema).optional(),
 	dynamic: object({
 		prefix: literal("count_"),
 		from: literal("classes")
@@ -18411,7 +18572,9 @@ var NcTemplatePreviewInputSchema = object({
 		field: NcTemplateFieldSchema,
 		kind: NcRuleKindSchema.optional(),
 		delivery: NcDeliverySchema.optional(),
-		systemEventKinds: array(NcSystemEventKindSchema).optional()
+		systemEventKinds: array(NcSystemEventKindSchema).optional(),
+		/** The rule's system-event delivery (D647); absent = instant. */
+		systemEventDelivery: NcSystemEventDeliveryModeSchema.optional()
 	}),
 	template: object({
 		title: string().max(500).optional(),
@@ -18444,6 +18607,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -18454,6 +18618,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -18604,6 +18769,28 @@ var NcHistoryFilterSchema = object({
 	limit: number$1().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$1(),
+		status: NcHistoryStatusSchema,
+		/** The camera/device of that row (a digest row files under its first camera). */
+		deviceId: number$1()
+	})),
+	horizonMs: number$1().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.
@@ -18784,6 +18971,14 @@ var NcAlarmModeCoverageSchema = object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: array(number$1().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$1().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -18913,13 +19108,17 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), object({ results: array(NcTestResultSchema) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ rule: NcRuleInputSchema }), NcStateSummaryPreviewSchema, {
+	kind: "mutation",
+	auth: "admin",
+	access: "view"
 }), method(object({}), object({
 	catalog: array(NcConditionDescriptorSchema),
 	taxonomy: NcTaxonomySchema.optional()
 })), method(object({}), object({ vars: array(NcTemplateVarDescriptorSchema) })), method(NcTemplatePreviewInputSchema, NcTemplatePreviewSchema, {
 	kind: "mutation",
 	access: "view"
-}), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
+}), method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }), method(object({}), NcRuleLastRunsSchema, { auth: "admin" }), method(object({ artifactId: string().min(1) }), object({ url: string().nullable() }), { auth: "admin" }), method(object({}), object({ snoozes: array(NcSnoozeSchema) }), { caller: "required" }), method(object({ snooze: NcSnoozeInputSchema }), object({ snooze: NcSnoozeSchema }), {
 	kind: "mutation",
 	caller: "required"
 }), method(object({ snoozeId: string() }), object({ success: literal(true) }), {
@@ -19259,606 +19458,6 @@ var OauthIntegrationDescriptorSchema = object({
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
-* Reference to the frame's retained NATIVE surface + the parent crop's placement
-* within the frame, so the executor can re-cut a leaf child ROI at native
-* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
-*/
-var NativeCropRefSchema = object({
-	/** Handle keying the retained native surface (node-pinned to its owner). */
-	handle: FrameHandleSchema,
-	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
-	cropFrameSpace: object({
-		x: number$1(),
-		y: number$1(),
-		w: number$1(),
-		h: number$1()
-	})
-});
-object({
-	crop: object({
-		left: number$1(),
-		top: number$1(),
-		width: number$1().positive(),
-		height: number$1().positive()
-	}).optional(),
-	content: object({
-		width: number$1().int().positive(),
-		height: number$1().int().positive()
-	}),
-	fit: _enum(["stretch", "contain"]),
-	format: _enum([
-		"rgb",
-		"gray",
-		"jpeg"
-	])
-});
-/**
-* Process-local frame identity. It is serializable so it can ride an in-process
-* capability call, but `registryId` deliberately prevents resolution in any
-* other process or execution group.
-*/
-var FrameRefSchema = object({
-	registryId: string().min(1),
-	id: string().min(1),
-	width: number$1().int().positive(),
-	height: number$1().int().positive(),
-	format: _enum(["rgb", "gray"]),
-	timestamp: number$1(),
-	capturedAt: number$1().optional()
-});
-var ModelFormatSchema$1 = _enum([
-	"onnx",
-	"coreml",
-	"openvino",
-	"tflite",
-	"pt",
-	"gguf"
-]);
-var PipelineSlotSchema = _enum([
-	"detector",
-	"cropper",
-	"classifier",
-	"refiner",
-	"audio-classifier"
-]);
-var PipelineEngineChoiceSchema = object({
-	runtime: _enum(["node", "python"]),
-	backend: string(),
-	format: ModelFormatSchema$1,
-	device: string().optional()
-});
-var AvailableEngineSchema = object({
-	engine: PipelineEngineChoiceSchema,
-	devices: array(object({
-		id: string(),
-		label: string(),
-		description: string().optional()
-	})).readonly(),
-	defaultDevice: string()
-});
-var PipelineDefaultStepSchema = lazy(() => object({
-	addonId: string(),
-	addonName: string(),
-	slot: PipelineSlotSchema,
-	inputClasses: array(string()).readonly(),
-	outputClasses: array(string()).readonly(),
-	enabled: boolean(),
-	modelId: string(),
-	children: array(PipelineDefaultStepSchema).readonly(),
-	group: string().optional(),
-	settings: record(string(), unknown()).optional()
-}));
-var PipelineTemplateStepSchema = lazy(() => object({
-	addonId: string(),
-	enabled: boolean(),
-	modelId: string(),
-	children: array(PipelineTemplateStepSchema).readonly(),
-	settings: record(string(), unknown()).optional()
-}));
-var PipelineTemplateSchema$1 = object({
-	id: string(),
-	name: string(),
-	createdAt: string(),
-	updatedAt: string(),
-	engine: PipelineEngineChoiceSchema,
-	steps: array(PipelineTemplateStepSchema).readonly()
-});
-var PipelineModelOptionSchema = object({
-	id: string(),
-	name: string(),
-	formats: record(string(), object({
-		downloaded: boolean(),
-		sizeMB: number$1()
-	})),
-	group: ModelVariantGroupSchema.optional(),
-	legacy: boolean().optional(),
-	provider: ModelProviderIdSchema.optional()
-});
-var ConfigFieldBridge = custom();
-var PipelineAddonSchemaSchema = object({
-	id: string(),
-	name: string(),
-	slot: PipelineSlotSchema,
-	inputClasses: array(string()).readonly(),
-	outputClasses: array(string()).readonly(),
-	childSlots: array(PipelineSlotSchema).readonly(),
-	models: array(PipelineModelOptionSchema).readonly(),
-	defaultModelId: string(),
-	defaultModelIdByFormat: record(string(), string()).optional(),
-	enabledByDefault: boolean().optional(),
-	backfillIntoExistingOverrides: boolean().optional(),
-	defaultConfidence: number$1(),
-	group: string().optional(),
-	configSchema: array(ConfigFieldBridge).readonly().optional()
-});
-var PipelineSlotSchemaSchema = object({
-	id: PipelineSlotSchema,
-	label: string(),
-	priority: number$1(),
-	parentSlot: PipelineSlotSchema.nullable(),
-	addons: array(PipelineAddonSchemaSchema).readonly()
-});
-var PipelineSchemaSchema = object({
-	availableEngines: array(AvailableEngineSchema).readonly(),
-	selectedEngine: PipelineEngineChoiceSchema,
-	slots: array(PipelineSlotSchemaSchema).readonly()
-});
-var EngineProvisioningSchema = object({
-	runtimeId: _enum([
-		"onnx",
-		"openvino",
-		"coreml",
-		"edgetpu"
-	]).nullable(),
-	device: string().nullable(),
-	state: _enum([
-		"idle",
-		"installing",
-		"verifying",
-		"ready",
-		"failed"
-	]),
-	progress: number$1().optional(),
-	error: string().optional(),
-	nextRetryAt: number$1().optional(),
-	/**
-	* Gate A (config-correctness gate at engine change): human-readable
-	* config issues surfaced EAGERLY when the node's engine changes — model
-	* substitutions ("chose X, running Y") and zero-build steps ("no model
-	* has a <format> build"). Additive/optional: informational only, never
-	* enforced here — `assertEngineReady` (readiness) still gates inference.
-	* Absent/empty when the node-default tree resolves cleanly.
-	*/
-	configIssues: array(string()).optional()
-});
-var PipelineStepInputSchema = lazy(() => object({
-	addonId: string(),
-	modelId: string().optional(),
-	enabled: boolean().default(true),
-	children: array(PipelineStepInputSchema).optional(),
-	settings: record(string(), unknown()).optional(),
-	jumpDeviceKey: string().optional()
-}));
-var ModelSubstitutionSchema = object({
-	addonId: string(),
-	chosen: string(),
-	running: string(),
-	format: string()
-});
-var PipelineValidationIssueSchema = object({
-	addonId: string(),
-	kind: _enum(["unknown-addon", "no-format-build"]),
-	detail: string()
-});
-var PipelineValidationResultSchema = object({
-	ok: boolean(),
-	issues: array(PipelineValidationIssueSchema).readonly(),
-	substitutions: array(ModelSubstitutionSchema).readonly(),
-	/** The node's `currentEngine.format` this validation ran against. */
-	format: string()
-});
-var ReferenceImageEntrySchema = object({
-	filename: string(),
-	stepIds: array(string()).readonly().optional()
-});
-var ReferenceImageBodySchema = object({
-	base64: string(),
-	filename: string()
-});
-var ReferenceAudioEntrySchema = object({
-	filename: string(),
-	sizeKb: number$1()
-});
-var ReferenceAudioBodySchema = object({ base64: string() });
-var AudioBackendSchema = object({
-	id: string(),
-	name: string(),
-	description: string(),
-	available: boolean(),
-	/**
-	* Raw classifier labels this backend can emit (e.g. YAMNet's
-	* 521-class set or Apple SoundAnalysis's 303-class set). Used by
-	* the benchmark UI to populate the `enabledMicroClasses` filter
-	* specific to the selected backend without a separate fetch.
-	*/
-	rawLabels: array(string()).readonly().optional()
-});
-var AudioCapabilitiesSchema = object({
-	activeBackend: string(),
-	availableBackends: array(AudioBackendSchema).readonly(),
-	sampleRate: number$1(),
-	chunkDurationMs: number$1()
-});
-var DownloadModelResultSchema = object({
-	filePath: string(),
-	sizeMB: number$1(),
-	durationMs: number$1()
-});
-/**
-* Wrapper carrying a single test run's result. Replaces the legacy
-* ad-hoc `{labels: [{className, originalClass, score}]}` shape with the
-* canonical `AudioResult` from the Phase 6 output rework: one
-* `AudioDetection` per class above `minScore`, top-N candidates in
-* `debug.alternateLabels['audio-classifier']`, per-source timings in
-* `debug.stepTimings`. The outer `success`/`error` fields stay so the
-* benchmark UI can still report a clean failure when the classifier
-* cap isn't available.
-*/
-var AudioTestResultSchema = object({
-	success: boolean(),
-	error: string().optional(),
-	frame: custom().optional()
-});
-var PipelineConfigBridge = custom();
-var ConfigUISchemaBridge = custom();
-var ConfigUISchemaNullableBridge = custom();
-var InferenceCapabilitiesBridge = custom();
-var ModelAvailabilityListBridge = custom();
-var PipelineRunResultBridge = custom();
-method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngineChoiceSchema), method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)), method(object({ nodeId: string() }), EngineProvisioningSchema), method(_void(), record(string(), object({
-	modelId: string(),
-	settings: record(string(), unknown()).readonly()
-}))), method(object({ steps: record(string(), object({
-	modelId: string(),
-	settings: record(string(), unknown()).readonly()
-})) }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ nodeId: string() }), object({
-	success: literal(true),
-	clearedDevices: number$1()
-}), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
-	/** `<backend>:<device>`, e.g. `openvino:gpu`. */
-	deviceKey: string(),
-	/**
-	* `failed` — the per-device restart budget is exhausted; no pool
-	* will be spawned until an operator re-arms it or the runner
-	* respawns. `backoff` — under budget, waiting out the backoff (or
-	* a cached pool observed dead and not yet condemned).
-	*/
-	state: _enum(["failed", "backoff"]),
-	/** Epoch ms of the death that produced this state. */
-	since: number$1(),
-	/** Pool deaths inside the current window. */
-	deaths: number$1(),
-	/** The last death's message. */
-	lastError: string()
-})).readonly() })), method(object({
-	nodeId: string(),
-	deviceKey: string()
-}), object({ rearmed: boolean() }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({ steps: array(PipelineStepInputSchema) }), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
-	name: string(),
-	steps: array(PipelineTemplateStepSchema).readonly(),
-	engine: PipelineEngineChoiceSchema
-}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
-	id: string(),
-	name: string().optional(),
-	steps: array(PipelineTemplateStepSchema).readonly().optional()
-}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
-	addonId: string(),
-	modelId: string(),
-	format: ModelFormatSchema$1
-}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
-	addonId: string(),
-	modelId: string(),
-	format: ModelFormatSchema$1
-}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
-	engine: PipelineEngineChoiceSchema.optional(),
-	steps: array(PipelineStepInputSchema).min(1),
-	frame: FrameInputSchema.optional(),
-	/**
-	* Process-local lazy frame. Valid only when caller and provider resolve
-	* in the same execution-group process; split/cross-node callers use
-	* `frame`/`image` inline compatibility instead.
-	*/
-	frameRef: FrameRefSchema.optional(),
-	/**
-	* CB5 shm passthrough — a `FrameHandle` naming the same ring slot
-	* the decoded pixels live in. One more member of the one-of
-	* frame/frameHandle/image/imageBase64/referenceImage group.
-	*/
-	frameHandle: FrameHandleSchema.optional(),
-	imageBase64: string().optional(),
-	/**
-	* Binary JPEG bytes — preferred over `imageBase64` on internal
-	* hops (hub → forked worker via Moleculer MsgPack) because it
-	* skips the 33% base64 overhead + the per-call base64 decode on
-	* the detection-pipeline worker. Callers can pass either; exactly
-	* one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
-	*/
-	image: _instanceof(Uint8Array).optional(),
-	referenceImage: string().optional(),
-	deviceId: number$1().optional(),
-	sessionId: string().optional(),
-	/**
-	* Execution plane. 'full' (default) runs the whole tree — benchmark,
-	* reference-image, and detail-subtree calls. 'frame' is the live
-	* per-frame dispatch: ONLY root-plane steps run; crop children
-	* (inputClasses ≠ null) are skipped and served per-track via
-	* pipelineRunner.runDetailSubtree (two-plane design).
-	*/
-	plane: _enum(["full", "frame"]).optional(),
-	/**
-	* Inference-device selector (Phase 2 multi-device). Format
-	* `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
-	* Omitted ⇒ the runner's default device (current single-engine
-	* behaviour). Selects WHICH device pool of the node runs the call.
-	*/
-	deviceKey: string().optional(),
-	/**
-	* Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
-	* when the parent crop was resolved from the frame's retained NATIVE
-	* surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
-	* child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
-	* resolution from that surface — the SAME quality path faces already
-	* had — instead of the downscaled parent tile. `handle` keys the native
-	* surface (node-pinned to its owner); `cropFrameSpace` is the parent
-	* crop's padded/clamped rectangle in FRAME-space pixels, used to compose
-	* the executor's crop-normalized child ROI back into frame-normalized
-	* coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
-	* of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
-	* (today's behaviour on the fallback path).
-	*/
-	nativeCropRef: NativeCropRefSchema.optional()
-}), PipelineRunResultBridge, { kind: "mutation" }), method(object({
-	engine: PipelineEngineChoiceSchema.optional(),
-	steps: array(PipelineStepInputSchema).min(1),
-	frames: array(FrameInputSchema).min(1).max(255),
-	deviceId: number$1().optional(),
-	sessionId: string().optional(),
-	/**
-	* Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
-	* the batch to the Python pool's bench preprocess cache
-	* (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
-	* preprocessed ONCE and every later inference is a pure-inference cache
-	* hit — the sustained-throughput run measures inference, not
-	* decode+preprocess+infer. Omitted/0 for live frames (all different →
-	* full preprocess every call, correct). Fresh per sustained run;
-	* released via `uncacheFrame`.
-	*/
-	frameId: number$1().int().nonnegative().optional(),
-	/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
-	deviceKey: string().optional()
-}), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }), method(object({
-	data: _instanceof(Uint8Array),
-	width: number$1().int().positive(),
-	height: number$1().int().positive(),
-	format: _enum([
-		"rgb",
-		"bgr",
-		"gray"
-	])
-}), object({
-	frameId: number$1(),
-	width: number$1(),
-	height: number$1()
-}), { kind: "mutation" }), method(object({
-	stepId: string(),
-	frameId: number$1().int()
-}), record(string(), unknown()), { kind: "mutation" }), method(object({ frameId: number$1().int() }), _void(), { kind: "mutation" }), method(_void(), object({
-	batchMode: string(),
-	windowMs: number$1(),
-	maxBatchSize: number$1(),
-	concurrency: number$1()
-})), method(_void(), array(object({
-	engineKey: string(),
-	engine: PipelineEngineChoiceSchema,
-	modelsLoaded: array(string()).readonly(),
-	inUseByCameras: array(number$1()).readonly(),
-	/**
-	* Origin of this resident factory.
-	*  - `runtime`       — main camera-serving engine (no idle TTL).
-	*  - `warm-override` — benchmark/test override held in the warm
-	*                      cache; auto-disposed after the idle TTL.
-	*  - `device-pool`   — a concurrent per-device pool (Phase 2
-	*                      multi-device, keyed by `deviceKey`) resolved
-	*                      via `resolveDeviceFactory`. Runs alongside the
-	*                      `runtime` engine on a DIFFERENT accelerator
-	*                      (NPU / iGPU / Coral) — this is how the
-	*                      Engines tab shows all pools running at once.
-	*/
-	kind: _enum([
-		"runtime",
-		"warm-override",
-		"device-pool"
-	]),
-	/** Native pid of the underlying Python pool (null when no pool). */
-	poolPid: number$1().nullable(),
-	/** ms since this factory was last used (null when not warm-tracked). */
-	idleMs: number$1().nullable(),
-	/** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
-	idleTtlMs: number$1().nullable()
-})).readonly()), method(object({ engine: PipelineEngineChoiceSchema }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	engine: PipelineEngineChoiceSchema,
-	force: boolean().optional()
-}), object({
-	success: boolean(),
-	reason: string().optional()
-}), {
-	kind: "mutation",
-	auth: "admin"
-}), method(_void(), array(ReferenceImageEntrySchema).readonly()), method(object({ filename: string() }), ReferenceImageBodySchema.nullable()), method(_void(), array(ReferenceAudioEntrySchema).readonly()), method(object({ filename: string() }), ReferenceAudioBodySchema.nullable()), method(_void(), AudioCapabilitiesSchema), method(object({
-	addonId: string(),
-	modelId: string(),
-	filename: string().optional(),
-	settings: record(string(), unknown()).optional()
-}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
-/**
-* Per-stage gating mode applied to the zones a rule references.
-*
-* - `include`: the rule contributes to a **whitelist** for its stage.
-*   When at least one `include` rule fires for a stage, only entities
-*   inside one of those zones pass that stage.
-* - `exclude`: the rule contributes to a **blacklist** for its stage.
-*   Entities inside one of those zones are dropped at that stage.
-*
-* `monitor`-style observation (count without filtering) is not a rule
-* mode — zones without any matching rule are observed naturally by
-* `zone-analytics` (live snapshot + history), so an "I just want to
-* count, not filter" use case needs no rule at all.
-*/
-var ZoneRuleModeEnum = _enum(["include", "exclude"]);
-/**
-* Per-consumer rule that references existing zones (geometry) and
-* defines how a specific pipeline stage should treat them. Each
-* consumer addon owns its own `ZoneRule[]` array in its per-device
-* settings:
-*
-* - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
-* - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
-* - future: notification rules, audio gating, etc.
-*
-* One rule applies to N zones (`zoneIds[]`) so the operator can
-* express "ignore motion in ALL of {garden, street}" with a single
-* rule. `classFilter` narrows the rule to specific object classes —
-* "drop person detections in the street, but keep cars" is one
-* `exclude` rule with `classFilter: ['person']`.
-*
-* `enabled` is a soft toggle — the operator can keep the rule
-* configured but inert without deleting it.
-*/
-var ZoneRuleSchema = object({
-	/** Stable rule id — survives edits, used by the UI for diffing. */
-	id: string(),
-	/** Optional human-readable label rendered in the rule editor. */
-	name: string().optional(),
-	/** Zones this rule targets. The rule's `mode` applies to ALL
-	*  listed zones (OR-set: a detection in any one of them counts).
-	*  At least one zone id required — a rule with no targets is a
-	*  configuration mistake and the form validator rejects it. */
-	zoneIds: array(string()).min(1).readonly(),
-	mode: ZoneRuleModeEnum,
-	/**
-	* Class names this rule applies to. Empty / undefined ⇒ rule
-	* applies to every class. Class strings match the `macroClass`
-	* field on detections (e.g. `person`, `car`, `dog`).
-	*/
-	classFilter: array(string()).readonly().optional(),
-	/**
-	* Minimum bbox/mask overlap (0–1) with any of the rule's zones
-	* required to consider an entity "in the zone". Defaults to the
-	* consumer's stage default when omitted. Kept for back-compat with
-	* existing per-rule overrides; new operators pick the value via
-	* `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
-	* set, the lower-level engine reads it as a 0–1 fraction.
-	*/
-	overlapThreshold: number$1().min(0).max(1).optional(),
-	/**
-	* Operator-friendly version of `overlapThreshold` — the percentage
-	* of the detection's bbox that must lie inside the zone for the
-	* rule to match. Documented default is 85%; the engine substitutes
-	* that when the field is omitted (kept optional so existing rules
-	* stored without it stay valid).
-	*
-	* When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
-	* rule, the engine prefers `bboxInclusionPct` because it's the
-	* field exposed in the UI. Internally both feed the same gate.
-	*/
-	bboxInclusionPct: number$1().min(0).max(100).optional(),
-	/**
-	* When `true` and a detection has a segmentation mask, use the
-	* mask for overlap instead of the bbox. Detection-stage only;
-	* motion rules ignore this field.
-	*/
-	preferMask: boolean().optional(),
-	/**
-	* Soft-toggle: `false` disables the rule without deleting it.
-	* Defaults to `true` so operators creating a rule via the UI
-	* see it active immediately.
-	*/
-	enabled: boolean().default(true)
-});
-array(ZoneRuleSchema).readonly();
-/**
-* Zone — pure geometry + identity. NO filtering behaviour.
-*
-* Zones describe **where** in the frame the operator wants to flag
-* something; consumer-owned {@link ZoneRule} arrays describe **how**
-* each pipeline stage uses them. Splitting the two means a single
-* polygon "Driveway" can simultaneously back a motion-exclude rule,
-* a detection-include rule on `['car']`, and an occupancy aggregate
-* — without three duplicated polygons.
-*
-* Owned by the orchestrator addon (provider) and mirrored into the
-* `zones` device-state slice on every mutation. Consumers
-* (motion-wasm, pipeline-executor, analytics, admin UI) read either
-* via `api.zones.listZones` (one-shot) or via `dev.state.zones` (live
-* mirror with `onChanged`).
-*
-* Coordinates are normalised fractions of the frame (0–1) so zones
-* survive resolution changes and stream profile switches.
-*
-* `kind` discriminates between full polygons (closed regions used
-* for intrusion / occupancy filters) and tripwires (open 2-point
-* line segments used for cross events). Onboard / firmware-reported
-* zones (Reolink, ONVIF) are out of scope for now — see the deferred
-* task list.
-*/
-var ZoneKindEnum = _enum(["polygon", "tripwire"]);
-/** Polygon vertex in fraction-of-frame coordinates (0–1). */
-var PolygonPointSchema = object({
-	x: number$1(),
-	y: number$1()
-});
-/** A camera detection zone — pure geometry/identity. */
-var ZoneSchema = object({
-	id: string(),
-	name: string(),
-	kind: ZoneKindEnum.default("polygon"),
-	/** Polygon vertices, fraction of frame (0–1). */
-	polygon: array(PolygonPointSchema).readonly(),
-	/** Visual color for UI rendering. */
-	color: string().default("#3b82f6")
-});
-DeviceType.Camera, method(object({ deviceId: number$1() }), array(ZoneSchema).readonly()), method(object({
-	deviceId: number$1(),
-	zone: ZoneSchema
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	zoneId: string()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	zone: ZoneSchema
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), object({ zones: array(ZoneSchema).readonly() });
-/**
 * pipeline-analytics — device-scoped wrapper cap. Refines raw
 * per-frame detections emitted by the pipeline runner into tracked
 * objects, per-kind event collections (motion / object / audio), and
@@ -20429,6 +20028,22 @@ var TrackSchema = object({
 	* omit it. Render nothing when absent.
 	*/
 	previewMissReason: string().optional(),
+	/**
+	* The ROOT model that produced this track — the `FrameResult.rootModelId` of
+	* the frame it was BORN on (D646). What a later replay compares against, so
+	* "the original model" is named rather than assumed. A birth fact: never
+	* rewritten by a later frame. **Absent ≠ unknown-model**: a row from before
+	* the column, and a track the camera's own detector produced, carry none.
+	*/
+	modelId: string().optional(),
+	/**
+	* Size (px) of the detection frame this track's `positions[].bbox` live in —
+	* the frame it was born on, else the camera's latest analysis frame at
+	* persist time. Divide a position by these to normalise it. Absent when the
+	* size was never known.
+	*/
+	frameWidth: number$1().optional(),
+	frameHeight: number$1().optional(),
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
@@ -21435,24 +21050,6 @@ var MediaReclaimStatusSchema = object({
 	finishedAtMs: number$1().nullable(),
 	error: string().nullable()
 });
-var ReplayFrameInputSchema = object({
-	timestamp: number$1(),
-	frame: PipelineRunResultBridge
-});
-var RunReplayFrameProcessorResultSchema = object({ tracks: array(object({
-	className: string(),
-	firstSeenMs: number$1(),
-	lastSeenMs: number$1(),
-	/** Bbox of the track's FIRST matched detection, pixel-space in the clip's
-	*  frame — a representative box for the diff's `(className, window, IoU)`
-	*  pairing (`replay-diff.ts`). A replay does not need the full per-frame
-	*  trajectory production's `Track.positions` keeps. */
-	bbox: BoundingBoxSchema,
-	/** How many of the input frames this track matched a real detection on
-	*  (never a coasted/extrapolated frame) — the replay's own signal for "how
-	*  solid is this track", cheaper than re-deriving it from a trajectory. */
-	framesMatched: number$1().int()
-})).readonly() });
 /**
 * The long-term series a camera produces. A closed union so a typo cannot
 * invent one, and the ONE declaration of it — the addon's `AnalyticsLtsSeries`
@@ -21666,108 +21263,570 @@ DeviceType.Camera, method(object({ deviceId: number$1() }), array(TrackSchema).r
 }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ frameId: string() }), object({
-	base64: string(),
-	width: number$1().int(),
-	height: number$1().int()
+}), method(object({ frameId: string() }), object({
+	base64: string(),
+	width: number$1().int(),
+	height: number$1().int()
+}), {
+	kind: "query",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	trackId: string(),
+	frameId: string(),
+	subject: RetrainAssistSubjectSchema,
+	/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
+	nodeId: string().optional()
+}), RetrainAssistResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
+	kind: "query",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	trackId: string(),
+	frameId: string(),
+	annotations: array(RetrainAnnotationDraftSchema)
+}), array(RetrainAnnotationSchema).readonly(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	trackId: string()
+}), RetrainTransitionResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	trackId: string()
+}), RetrainTransitionResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ deviceIds: array(number$1()).optional() }), object({ url: string() }), {
+	kind: "query",
+	auth: "admin"
+}), method(object({
+	/** Which of the three event tables owns the row. */
+	ownerType: EventOwnerTypeSchema,
+	/** The event's rowid in that table (D474: an event id is a number). */
+	eventId: number$1().int(),
+	kind: MediaFileKindEnum.optional(),
+	deviceId: number$1()
+}), array(MediaFileSchema).readonly()), method(object({
+	trackId: string(),
+	kinds: array(MediaFileKindEnum).optional(),
+	deviceId: number$1()
+}), array(MediaFileSchema).readonly()), method(object({
+	trackId: string(),
+	deviceId: number$1()
+}), array(MediaFileInfoSchema).readonly()), method(object({
+	ownerType: EventOwnerTypeSchema,
+	eventId: number$1().int(),
+	deviceId: number$1()
+}), array(MediaFileInfoSchema).readonly()), method(object({
+	deviceId: number$1(),
+	ownerKind: MediaPresenceOwnerKindSchema,
+	ownerIds: array(string()).max(5e3)
+}), array(string()).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({}), RebuildStatusSchema), object({
+	deviceId: number$1(),
+	timestamp: number$1(),
+	frameWidth: number$1(),
+	frameHeight: number$1(),
+	detections: array(OverlayDetectionSchema).readonly()
+}), object({
+	deviceId: number$1(),
+	trackId: string(),
+	className: string()
+}), object({
+	deviceId: number$1(),
+	trackId: string(),
+	className: string(),
+	durationMs: number$1()
+}), object({
+	deviceId: number$1(),
+	kind: EventKindSchema,
+	eventId: string(),
+	timestamp: number$1()
+});
+/**
+* Reference to the frame's retained NATIVE surface + the parent crop's placement
+* within the frame, so the executor can re-cut a leaf child ROI at native
+* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
+*/
+var NativeCropRefSchema = object({
+	/** Handle keying the retained native surface (node-pinned to its owner). */
+	handle: FrameHandleSchema,
+	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
+	cropFrameSpace: object({
+		x: number$1(),
+		y: number$1(),
+		w: number$1(),
+		h: number$1()
+	})
+});
+object({
+	crop: object({
+		left: number$1(),
+		top: number$1(),
+		width: number$1().positive(),
+		height: number$1().positive()
+	}).optional(),
+	content: object({
+		width: number$1().int().positive(),
+		height: number$1().int().positive()
+	}),
+	fit: _enum(["stretch", "contain"]),
+	format: _enum([
+		"rgb",
+		"gray",
+		"jpeg"
+	])
+});
+/**
+* Process-local frame identity. It is serializable so it can ride an in-process
+* capability call, but `registryId` deliberately prevents resolution in any
+* other process or execution group.
+*/
+var FrameRefSchema = object({
+	registryId: string().min(1),
+	id: string().min(1),
+	width: number$1().int().positive(),
+	height: number$1().int().positive(),
+	format: _enum(["rgb", "gray"]),
+	timestamp: number$1(),
+	capturedAt: number$1().optional()
+});
+var ModelFormatSchema$1 = _enum([
+	"onnx",
+	"coreml",
+	"openvino",
+	"tflite",
+	"pt",
+	"gguf"
+]);
+var PipelineSlotSchema = _enum([
+	"detector",
+	"cropper",
+	"classifier",
+	"refiner",
+	"audio-classifier"
+]);
+var PipelineEngineChoiceSchema = object({
+	runtime: literal("python"),
+	backend: string(),
+	format: ModelFormatSchema$1,
+	device: string().optional()
+});
+/**
+* One pool's resolved provisioning (`getEffectiveTuning`). `numWorkers` is the
+* knob that lifts a saturated pool (`inference-devices.md`); `concurrency` is
+* per-worker in-flight requests. `deviceKey` echoes the pool asked about —
+* `null` for the node-default pool.
+*/
+var EffectiveTuningSchema = object({
+	deviceKey: string().nullable(),
+	runtime: string(),
+	batchMode: string(),
+	windowMs: number$1(),
+	maxBatchSize: number$1(),
+	concurrency: number$1(),
+	numWorkers: number$1()
+});
+var AvailableEngineSchema = object({
+	engine: PipelineEngineChoiceSchema,
+	devices: array(object({
+		id: string(),
+		label: string(),
+		description: string().optional()
+	})).readonly(),
+	defaultDevice: string()
+});
+var PipelineDefaultStepSchema = lazy(() => object({
+	addonId: string(),
+	addonName: string(),
+	slot: PipelineSlotSchema,
+	inputClasses: array(string()).readonly(),
+	outputClasses: array(string()).readonly(),
+	enabled: boolean(),
+	modelId: string(),
+	children: array(PipelineDefaultStepSchema).readonly(),
+	group: string().optional(),
+	settings: record(string(), unknown()).optional()
+}));
+var PipelineTemplateStepSchema = lazy(() => object({
+	addonId: string(),
+	enabled: boolean(),
+	modelId: string(),
+	children: array(PipelineTemplateStepSchema).readonly(),
+	settings: record(string(), unknown()).optional()
+}));
+var PipelineTemplateSchema$1 = object({
+	id: string(),
+	name: string(),
+	createdAt: string(),
+	updatedAt: string(),
+	engine: PipelineEngineChoiceSchema,
+	steps: array(PipelineTemplateStepSchema).readonly()
+});
+var PipelineModelOptionSchema = object({
+	id: string(),
+	name: string(),
+	formats: record(string(), object({
+		downloaded: boolean(),
+		sizeMB: number$1()
+	})),
+	group: ModelVariantGroupSchema.optional(),
+	legacy: boolean().optional(),
+	provider: ModelProviderIdSchema.optional()
+});
+var ConfigFieldBridge = custom();
+var PipelineAddonSchemaSchema = object({
+	id: string(),
+	name: string(),
+	slot: PipelineSlotSchema,
+	inputClasses: array(string()).readonly(),
+	outputClasses: array(string()).readonly(),
+	childSlots: array(PipelineSlotSchema).readonly(),
+	models: array(PipelineModelOptionSchema).readonly(),
+	defaultModelId: string(),
+	defaultModelIdByFormat: record(string(), string()).optional(),
+	enabledByDefault: boolean().optional(),
+	backfillIntoExistingOverrides: boolean().optional(),
+	defaultConfidence: number$1(),
+	group: string().optional(),
+	configSchema: array(ConfigFieldBridge).readonly().optional()
+});
+var PipelineSlotSchemaSchema = object({
+	id: PipelineSlotSchema,
+	label: string(),
+	priority: number$1(),
+	parentSlot: PipelineSlotSchema.nullable(),
+	addons: array(PipelineAddonSchemaSchema).readonly()
+});
+var PipelineSchemaSchema = object({
+	availableEngines: array(AvailableEngineSchema).readonly(),
+	selectedEngine: PipelineEngineChoiceSchema,
+	slots: array(PipelineSlotSchemaSchema).readonly()
+});
+var EngineProvisioningSchema = object({
+	runtimeId: _enum([
+		"onnx",
+		"openvino",
+		"coreml",
+		"edgetpu"
+	]).nullable(),
+	device: string().nullable(),
+	state: _enum([
+		"idle",
+		"installing",
+		"verifying",
+		"ready",
+		"failed"
+	]),
+	progress: number$1().optional(),
+	error: string().optional(),
+	nextRetryAt: number$1().optional(),
+	/**
+	* Gate A (config-correctness gate at engine change): human-readable
+	* config issues surfaced EAGERLY when the node's engine changes — model
+	* substitutions ("chose X, running Y") and zero-build steps ("no model
+	* has a <format> build"). Additive/optional: informational only, never
+	* enforced here — `assertEngineReady` (readiness) still gates inference.
+	* Absent/empty when the node-default tree resolves cleanly.
+	*/
+	configIssues: array(string()).optional()
+});
+var PipelineStepInputSchema = lazy(() => object({
+	addonId: string(),
+	modelId: string().optional(),
+	enabled: boolean().default(true),
+	children: array(PipelineStepInputSchema).optional(),
+	settings: record(string(), unknown()).optional(),
+	jumpDeviceKey: string().optional()
+}));
+var ModelSubstitutionSchema = object({
+	addonId: string(),
+	chosen: string(),
+	running: string(),
+	format: string()
+});
+var PipelineValidationIssueSchema = object({
+	addonId: string(),
+	kind: _enum([
+		"unknown-addon",
+		"no-format-build",
+		"unknown-device"
+	]),
+	detail: string()
+});
+var PipelineValidationResultSchema = object({
+	ok: boolean(),
+	issues: array(PipelineValidationIssueSchema).readonly(),
+	substitutions: array(ModelSubstitutionSchema).readonly(),
+	/** The node's `currentEngine.format` this validation ran against. */
+	format: string()
+});
+var ReferenceImageEntrySchema = object({
+	filename: string(),
+	stepIds: array(string()).readonly().optional()
+});
+var ReferenceImageBodySchema = object({
+	base64: string(),
+	filename: string()
+});
+var ReferenceAudioEntrySchema = object({
+	filename: string(),
+	sizeKb: number$1()
+});
+var ReferenceAudioBodySchema = object({ base64: string() });
+var AudioBackendSchema = object({
+	id: string(),
+	name: string(),
+	description: string(),
+	available: boolean(),
+	/**
+	* Raw classifier labels this backend can emit (e.g. YAMNet's
+	* 521-class set or Apple SoundAnalysis's 303-class set). Used by
+	* the benchmark UI to populate the `enabledMicroClasses` filter
+	* specific to the selected backend without a separate fetch.
+	*/
+	rawLabels: array(string()).readonly().optional()
+});
+var AudioCapabilitiesSchema = object({
+	activeBackend: string(),
+	availableBackends: array(AudioBackendSchema).readonly(),
+	sampleRate: number$1(),
+	chunkDurationMs: number$1()
+});
+var DownloadModelResultSchema = object({
+	filePath: string(),
+	sizeMB: number$1(),
+	durationMs: number$1()
+});
+/**
+* Wrapper carrying a single test run's result. Replaces the legacy
+* ad-hoc `{labels: [{className, originalClass, score}]}` shape with the
+* canonical `AudioResult` from the Phase 6 output rework: one
+* `AudioDetection` per class above `minScore`, top-N candidates in
+* `debug.alternateLabels['audio-classifier']`, per-source timings in
+* `debug.stepTimings`. The outer `success`/`error` fields stay so the
+* benchmark UI can still report a clean failure when the classifier
+* cap isn't available.
+*/
+var AudioTestResultSchema = object({
+	success: boolean(),
+	error: string().optional(),
+	frame: custom().optional()
+});
+var PipelineConfigBridge = custom();
+var ConfigUISchemaBridge = custom();
+var ConfigUISchemaNullableBridge = custom();
+var InferenceCapabilitiesBridge = custom();
+var ModelAvailabilityListBridge = custom();
+var PipelineRunResultBridge = custom();
+method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngineChoiceSchema), method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)), method(object({ nodeId: string() }), EngineProvisioningSchema), method(_void(), record(string(), object({
+	modelId: string(),
+	settings: record(string(), unknown()).readonly()
+}))), method(object({ steps: record(string(), object({
+	modelId: string(),
+	settings: record(string(), unknown()).readonly()
+})) }), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ nodeId: string() }), object({
+	success: literal(true),
+	clearedDevices: number$1()
 }), {
-	kind: "query",
-	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	trackId: string(),
-	frameId: string(),
-	subject: RetrainAssistSubjectSchema,
-	/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
-	nodeId: string().optional()
-}), RetrainAssistResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	source: DetectionSourceSchema,
-	zones: array(ZoneSchema).readonly().optional(),
-	detectionRules: array(ZoneRuleSchema).readonly().optional(),
-	zoneMembershipMinOverlap: number$1().min(0).max(1).optional(),
-	frames: array(ReplayFrameInputSchema).min(1)
-}), RunReplayFrameProcessorResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
-	kind: "query",
-	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	trackId: string(),
-	frameId: string(),
-	annotations: array(RetrainAnnotationDraftSchema)
-}), array(RetrainAnnotationSchema).readonly(), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	trackId: string()
-}), RetrainTransitionResultSchema, {
+}), method(object({ nodeId: string() }), object({ unhealthy: array(object({
+	/** `<backend>:<device>`, e.g. `openvino:gpu`. */
+	deviceKey: string(),
+	/**
+	* `failed` — the per-device restart budget is exhausted; no pool
+	* will be spawned until an operator re-arms it or the runner
+	* respawns. `backoff` — under budget, waiting out the backoff (or
+	* a cached pool observed dead and not yet condemned).
+	*/
+	state: _enum(["failed", "backoff"]),
+	/** Epoch ms of the death that produced this state. */
+	since: number$1(),
+	/** Pool deaths inside the current window. */
+	deaths: number$1(),
+	/** The last death's message. */
+	lastError: string()
+})).readonly() })), method(object({
+	nodeId: string(),
+	deviceKey: string()
+}), object({ rearmed: boolean() }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	deviceId: number$1(),
-	trackId: string()
-}), RetrainTransitionResultSchema, {
+}), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
+	steps: array(PipelineStepInputSchema),
+	deviceKey: string().optional()
+}), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
+	name: string(),
+	steps: array(PipelineTemplateStepSchema).readonly(),
+	engine: PipelineEngineChoiceSchema
+}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
+	id: string(),
+	name: string().optional(),
+	steps: array(PipelineTemplateStepSchema).readonly().optional()
+}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
+	addonId: string(),
+	modelId: string(),
+	format: ModelFormatSchema$1
+}), DownloadModelResultSchema, { kind: "mutation" }), method(object({
+	addonId: string(),
+	modelId: string(),
+	format: ModelFormatSchema$1
+}), object({ success: literal(true) }), { kind: "mutation" }), method(object({
+	steps: array(PipelineStepInputSchema).min(1),
+	frame: FrameInputSchema.optional(),
+	/**
+	* Process-local lazy frame. Valid only when caller and provider resolve
+	* in the same execution-group process; split/cross-node callers use
+	* `frame`/`image` inline compatibility instead.
+	*/
+	frameRef: FrameRefSchema.optional(),
+	/**
+	* CB5 shm passthrough — a `FrameHandle` naming the same ring slot
+	* the decoded pixels live in. One more member of the one-of
+	* frame/frameHandle/image/imageBase64/referenceImage group.
+	*/
+	frameHandle: FrameHandleSchema.optional(),
+	imageBase64: string().optional(),
+	/**
+	* Binary JPEG bytes — preferred over `imageBase64` on internal
+	* hops (hub → forked worker via Moleculer MsgPack) because it
+	* skips the 33% base64 overhead + the per-call base64 decode on
+	* the detection-pipeline worker. Callers can pass either; exactly
+	* one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
+	*/
+	image: _instanceof(Uint8Array).optional(),
+	referenceImage: string().optional(),
+	deviceId: number$1().optional(),
+	sessionId: string().optional(),
+	/**
+	* Execution plane. 'full' (default) runs the whole tree — benchmark,
+	* reference-image, and detail-subtree calls. 'frame' is the live
+	* per-frame dispatch: ONLY root-plane steps run; crop children
+	* (inputClasses ≠ null) are skipped and served per-track via
+	* pipelineRunner.runDetailSubtree (two-plane design).
+	*/
+	plane: _enum(["full", "frame"]).optional(),
+	/**
+	* Inference-device selector (Phase 2 multi-device). Format
+	* `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
+	* Omitted ⇒ the runner's default device (current single-engine
+	* behaviour). Selects WHICH device pool of the node runs the call.
+	*/
+	deviceKey: string().optional(),
+	/**
+	* Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+	* when the parent crop was resolved from the frame's retained NATIVE
+	* surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+	* child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+	* resolution from that surface — the SAME quality path faces already
+	* had — instead of the downscaled parent tile. `handle` keys the native
+	* surface (node-pinned to its owner); `cropFrameSpace` is the parent
+	* crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+	* the executor's crop-normalized child ROI back into frame-normalized
+	* coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+	* of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+	* (today's behaviour on the fallback path).
+	*/
+	nativeCropRef: NativeCropRefSchema.optional(),
+	/**
+	* Offline REPLAY of stored media for `deviceId` (D56, D646): the
+	* camera's zone gate and overrides apply as live, every executing
+	* step runs EXACTLY the model it names on the `deviceKey` pool it
+	* names or the call refuses (`model-not-servable` /
+	* `device-not-servable`), and nothing reaches the camera's live
+	* trace stream. Absent ⇒ unchanged behaviour.
+	*/
+	replay: literal(true).optional()
+}), PipelineRunResultBridge, { kind: "mutation" }), method(object({
+	steps: array(PipelineStepInputSchema).min(1),
+	frames: array(FrameInputSchema).min(1).max(255),
+	deviceId: number$1().optional(),
+	sessionId: string().optional(),
+	/**
+	* Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
+	* the batch to the Python pool's bench preprocess cache
+	* (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
+	* preprocessed ONCE and every later inference is a pure-inference cache
+	* hit — the sustained-throughput run measures inference, not
+	* decode+preprocess+infer. Omitted/0 for live frames (all different →
+	* full preprocess every call, correct). Fresh per sustained run;
+	* released via `uncacheFrame`.
+	*/
+	frameId: number$1().int().nonnegative().optional(),
+	/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+	deviceKey: string().optional()
+}), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }), method(object({
+	data: _instanceof(Uint8Array),
+	width: number$1().int().positive(),
+	height: number$1().int().positive(),
+	format: _enum([
+		"rgb",
+		"bgr",
+		"gray"
+	])
+}), object({
+	frameId: number$1(),
+	width: number$1(),
+	height: number$1()
+}), { kind: "mutation" }), method(object({
+	stepId: string(),
+	frameId: number$1().int()
+}), record(string(), unknown()), { kind: "mutation" }), method(object({ frameId: number$1().int() }), _void(), { kind: "mutation" }), method(object({ deviceKey: string().optional() }), EffectiveTuningSchema), method(_void(), array(object({
+	engineKey: string(),
+	engine: PipelineEngineChoiceSchema,
+	modelsLoaded: array(string()).readonly(),
+	inUseByCameras: array(number$1()).readonly(),
+	/**
+	* Origin of this resident factory.
+	*  - `runtime`       — main camera-serving engine (no idle TTL).
+	*  - `device-pool`   — a concurrent per-device pool (Phase 2
+	*                      multi-device, keyed by `deviceKey`) resolved
+	*                      via `resolveDeviceFactory`. Runs alongside the
+	*                      `runtime` engine on a DIFFERENT accelerator
+	*                      (NPU / iGPU / Coral) — this is how the
+	*                      Engines tab shows all pools running at once.
+	*/
+	kind: _enum(["runtime", "device-pool"]),
+	/** Native pid of the underlying Python pool (null when no pool). */
+	poolPid: number$1().nullable(),
+	/** ms since this factory was last used (null when not warm-tracked). */
+	idleMs: number$1().nullable(),
+	/** Idle TTL after which the factory self-evicts (null when not applicable). */
+	idleTtlMs: number$1().nullable()
+})).readonly()), method(object({ engine: PipelineEngineChoiceSchema }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({ deviceIds: array(number$1()).optional() }), object({ url: string() }), {
-	kind: "query",
-	auth: "admin"
 }), method(object({
-	/** Which of the three event tables owns the row. */
-	ownerType: EventOwnerTypeSchema,
-	/** The event's rowid in that table (D474: an event id is a number). */
-	eventId: number$1().int(),
-	kind: MediaFileKindEnum.optional(),
-	deviceId: number$1()
-}), array(MediaFileSchema).readonly()), method(object({
-	trackId: string(),
-	kinds: array(MediaFileKindEnum).optional(),
-	deviceId: number$1()
-}), array(MediaFileSchema).readonly()), method(object({
-	trackId: string(),
-	deviceId: number$1()
-}), array(MediaFileInfoSchema).readonly()), method(object({
-	ownerType: EventOwnerTypeSchema,
-	eventId: number$1().int(),
-	deviceId: number$1()
-}), array(MediaFileInfoSchema).readonly()), method(object({
-	deviceId: number$1(),
-	ownerKind: MediaPresenceOwnerKindSchema,
-	ownerIds: array(string()).max(5e3)
-}), array(string()).readonly()), method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()), method(object({}), WipeObjectEmbeddingsResultSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+	engine: PipelineEngineChoiceSchema,
+	force: boolean().optional()
+}), object({
+	success: boolean(),
+	reason: string().optional()
+}), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({}), RebuildStatusSchema), object({
-	deviceId: number$1(),
-	timestamp: number$1(),
-	frameWidth: number$1(),
-	frameHeight: number$1(),
-	detections: array(OverlayDetectionSchema).readonly()
-}), object({
-	deviceId: number$1(),
-	trackId: string(),
-	className: string()
-}), object({
-	deviceId: number$1(),
-	trackId: string(),
-	className: string(),
-	durationMs: number$1()
-}), object({
-	deviceId: number$1(),
-	kind: EventKindSchema,
-	eventId: string(),
-	timestamp: number$1()
-});
+}), method(_void(), array(ReferenceImageEntrySchema).readonly()), method(object({ filename: string() }), ReferenceImageBodySchema.nullable()), method(_void(), array(ReferenceAudioEntrySchema).readonly()), method(object({ filename: string() }), ReferenceAudioBodySchema.nullable()), method(_void(), AudioCapabilitiesSchema), method(object({
+	addonId: string(),
+	modelId: string(),
+	filename: string().optional(),
+	settings: record(string(), unknown()).optional()
+}), AudioTestResultSchema, { kind: "mutation" }), method(_void(), ConfigUISchemaNullableBridge);
 object({
 	activeCameras: number$1(),
 	throttledCameras: number$1(),
@@ -21793,6 +21852,66 @@ var CameraMetricsSchema = object({
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: number$1() });
 /**
+* Zone — pure geometry + identity. NO filtering behaviour.
+*
+* Zones describe **where** in the frame the operator wants to flag
+* something; consumer-owned {@link ZoneRule} arrays describe **how**
+* each pipeline stage uses them. Splitting the two means a single
+* polygon "Driveway" can simultaneously back a motion-exclude rule,
+* a detection-include rule on `['car']`, and an occupancy aggregate
+* — without three duplicated polygons.
+*
+* Owned by the orchestrator addon (provider) and mirrored into the
+* `zones` device-state slice on every mutation. Consumers
+* (motion-wasm, pipeline-executor, analytics, admin UI) read either
+* via `api.zones.listZones` (one-shot) or via `dev.state.zones` (live
+* mirror with `onChanged`).
+*
+* Coordinates are normalised fractions of the frame (0–1) so zones
+* survive resolution changes and stream profile switches.
+*
+* `kind` discriminates between full polygons (closed regions used
+* for intrusion / occupancy filters) and tripwires (open 2-point
+* line segments used for cross events). Onboard / firmware-reported
+* zones (Reolink, ONVIF) are out of scope for now — see the deferred
+* task list.
+*/
+var ZoneKindEnum = _enum(["polygon", "tripwire"]);
+/** Polygon vertex in fraction-of-frame coordinates (0–1). */
+var PolygonPointSchema = object({
+	x: number$1(),
+	y: number$1()
+});
+/** A camera detection zone — pure geometry/identity. */
+var ZoneSchema = object({
+	id: string(),
+	name: string(),
+	kind: ZoneKindEnum.default("polygon"),
+	/** Polygon vertices, fraction of frame (0–1). */
+	polygon: array(PolygonPointSchema).readonly(),
+	/** Visual color for UI rendering. */
+	color: string().default("#3b82f6")
+});
+DeviceType.Camera, method(object({ deviceId: number$1() }), array(ZoneSchema).readonly()), method(object({
+	deviceId: number$1(),
+	zone: ZoneSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	zoneId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number$1(),
+	zone: ZoneSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), object({ zones: array(ZoneSchema).readonly() });
+/**
 * A bounding box in NORMALIZED [0,1] frame coordinates for `getNativeCrop`. The
 * decode worker resolves it against the RETAINED native frame's real pixel dims,
 * so the caller supplies only the detection-res bbox divided by the detection
@@ -21979,7 +22098,17 @@ var DetailResultSchema = object({
 	/** Face short side (px) measured on the NATIVE crop surface. The `bbox`
 	*  above is detection-frame px (≈6× smaller on a 4K camera) — min-face-size
 	*  consumers MUST prefer this when present (2026-07-22 native-gate fix). */
-	nativeFaceShortSidePx: number$1().optional()
+	nativeFaceShortSidePx: number$1().optional(),
+	/**
+	* The five facial landmarks of a `face` detail, in the SAME frame space as
+	* `bbox` (D644). Additive and optional: post-analysis stores them beside the
+	* face's source frame so a future alignment can be re-derived exactly; a
+	* runner that predates the field sends none and the face is stored without.
+	*/
+	landmarks: array(object({
+		x: number$1(),
+		y: number$1()
+	})).optional()
 });
 /**
 * Why an executing node REFUSED a stateless step run (`runStatelessStep`).
@@ -23365,7 +23494,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).
@@ -29508,7 +29641,30 @@ var RenameNodeResultSchema = object({
 	nodeId: string(),
 	name: string()
 });
-method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
+/**
+* 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()
+});
+method(_void(), array(TopologyNodeSchema).readonly(), { auth: "admin" }), method(_void(), NodeDirectorySchema, { auth: "admin" }), method(NodeAddonInputSchema, SuccessSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(NodeAddonInputSchema, SuccessSchema, {
@@ -30277,7 +30433,7 @@ var HardwareInfoSchema = object({
 	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = object({
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: _enum([
 		"onnx",
@@ -30314,7 +30470,7 @@ var ModelRequirementSchema = object({
 });
 var ResolvedInferenceConfigSchema = object({
 	modelId: string(),
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: ModelFormatSchema,
 	reason: string()
@@ -32521,6 +32677,92 @@ DeviceType.Camera, method(object({ deviceId: number$1() }), SceneMonitorStatusSc
 	kind: "mutation",
 	auth: "admin"
 });
+/**
+* Per-stage gating mode applied to the zones a rule references.
+*
+* - `include`: the rule contributes to a **whitelist** for its stage.
+*   When at least one `include` rule fires for a stage, only entities
+*   inside one of those zones pass that stage.
+* - `exclude`: the rule contributes to a **blacklist** for its stage.
+*   Entities inside one of those zones are dropped at that stage.
+*
+* `monitor`-style observation (count without filtering) is not a rule
+* mode — zones without any matching rule are observed naturally by
+* `zone-analytics` (live snapshot + history), so an "I just want to
+* count, not filter" use case needs no rule at all.
+*/
+var ZoneRuleModeEnum = _enum(["include", "exclude"]);
+/**
+* Per-consumer rule that references existing zones (geometry) and
+* defines how a specific pipeline stage should treat them. Each
+* consumer addon owns its own `ZoneRule[]` array in its per-device
+* settings:
+*
+* - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
+* - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
+* - future: notification rules, audio gating, etc.
+*
+* One rule applies to N zones (`zoneIds[]`) so the operator can
+* express "ignore motion in ALL of {garden, street}" with a single
+* rule. `classFilter` narrows the rule to specific object classes —
+* "drop person detections in the street, but keep cars" is one
+* `exclude` rule with `classFilter: ['person']`.
+*
+* `enabled` is a soft toggle — the operator can keep the rule
+* configured but inert without deleting it.
+*/
+var ZoneRuleSchema = object({
+	/** Stable rule id — survives edits, used by the UI for diffing. */
+	id: string(),
+	/** Optional human-readable label rendered in the rule editor. */
+	name: string().optional(),
+	/** Zones this rule targets. The rule's `mode` applies to ALL
+	*  listed zones (OR-set: a detection in any one of them counts).
+	*  At least one zone id required — a rule with no targets is a
+	*  configuration mistake and the form validator rejects it. */
+	zoneIds: array(string()).min(1).readonly(),
+	mode: ZoneRuleModeEnum,
+	/**
+	* Class names this rule applies to. Empty / undefined ⇒ rule
+	* applies to every class. Class strings match the `macroClass`
+	* field on detections (e.g. `person`, `car`, `dog`).
+	*/
+	classFilter: array(string()).readonly().optional(),
+	/**
+	* Minimum bbox/mask overlap (0–1) with any of the rule's zones
+	* required to consider an entity "in the zone". Defaults to the
+	* consumer's stage default when omitted. Kept for back-compat with
+	* existing per-rule overrides; new operators pick the value via
+	* `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
+	* set, the lower-level engine reads it as a 0–1 fraction.
+	*/
+	overlapThreshold: number$1().min(0).max(1).optional(),
+	/**
+	* Operator-friendly version of `overlapThreshold` — the percentage
+	* of the detection's bbox that must lie inside the zone for the
+	* rule to match. Documented default is 85%; the engine substitutes
+	* that when the field is omitted (kept optional so existing rules
+	* stored without it stay valid).
+	*
+	* When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
+	* rule, the engine prefers `bboxInclusionPct` because it's the
+	* field exposed in the UI. Internally both feed the same gate.
+	*/
+	bboxInclusionPct: number$1().min(0).max(100).optional(),
+	/**
+	* When `true` and a detection has a segmentation mask, use the
+	* mask for overlap instead of the bbox. Detection-stage only;
+	* motion rules ignore this field.
+	*/
+	preferMask: boolean().optional(),
+	/**
+	* Soft-toggle: `false` disables the rule without deleting it.
+	* Defaults to `true` so operators creating a rule via the UI
+	* see it active immediately.
+	*/
+	enabled: boolean().default(true)
+});
+array(ZoneRuleSchema).readonly();
 object({
 	/** Whether the script is currently executing. */
 	isRunning: boolean(),
@@ -33902,6 +34144,42 @@ DeviceType.Camera, method(object({
 	package: array(ZoneRuleSchema).readonly()
 });
 /**
+* 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
@@ -38633,6 +38911,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"nodes.directory": {
+		capName: "nodes",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"nodes.executeQuery": {
 		capName: "nodes",
 		capScope: "system",
@@ -38801,6 +39085,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",
@@ -38825,6 +39115,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"notificationRules.previewStateSummary": {
+		capName: "notification-rules",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"notificationRules.previewTemplate": {
 		capName: "notification-rules",
 		capScope: "system",
@@ -39401,12 +39697,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineAnalytics.runReplayFrameProcessor": {
-		capName: "pipeline-analytics",
-		capScope: "device",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineAnalytics.saveRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -43504,11 +43794,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"pipelineAnalytics.runReplayFrameProcessor": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineAnalytics.saveRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",
@@ -44397,11 +44682,232 @@ var NC_AUDIO_DEFAULTS = {
 	samplingSeconds: 10
 };
 new Set(["devices", "classes"]);
+/**
+* WHICH narrowing filter speaks about WHICH system-event kind — one predicate,
+* consumed by the rule ENGINE and by every rule EDITOR.
+*
+* ── The failure this file exists for ───────────────────────────────────────
+* `NcSystemEventConditionSchema` carries four optional narrowing lists
+* (`deviceIds`, `deviceTypes`, `nodeIds`, `packageNames`) beside a required
+* `kinds` gate. They are not four filters over one vocabulary: each belongs to
+* a FAMILY of kinds and is meaningless outside it. A node going away has no
+* device type; a completed export has no package; `stream-offline` deliberately
+* carries no device type at all (a stream belongs to a camera by construction).
+*
+* The engine applied all four to every kind, so a filter from one family failed
+* a kind from another family CLOSED. The operator's live rule "Eventi di
+* sistema" selected eleven kinds and set `deviceTypes: ['camera']` — the only
+* way to say "only my cameras" about the two liveness kinds — and NINE of the
+* eleven silently stopped being deliverable. Four days of history contained
+* `device-online` and `device-offline` and nothing else, across a window in
+* which agents were restarted and addons were updated.
+*
+* Both editors already computed this scoping, to decide which filter boxes to
+* render; the cap's own docblock already promised it ("Narrow a `device-*` kind
+* to these device TYPES"). Only the engine disagreed, and it disagreed in the
+* destructive direction. So the rule is stated ONCE, here, and the engine and
+* the editors are readers of it rather than three independent authors.
+*
+* ── The direction ─────────────────────────────────────────────────────────
+* Out of family ⇒ the filter is IGNORED, never fail-closed. An editor that
+* hides a box has already told the operator this filter does not speak about
+* these kinds, so honouring it as an exclusion contradicts the only
+* explanation the operator was ever given. Inside its family the filter still
+* narrows, and still fails CLOSED on a subject that cannot produce the identity
+* it tests (a device the mirror cannot name is not evidence of a camera).
+*/
+/**
+* Every filter, for the callers that must cover all of them (guards, tests).
+*
+* `consumableLowPercent` (D642) is not a list but it is a filter in exactly
+* this sense: it belongs to a family of kinds (the consumable pair) and the
+* engine consults it only there. It differs in one way the readers must know —
+* its ABSENCE is not "no narrowing" but the default threshold, because a
+* consumable episode is always judged at SOME threshold.
+*/
+var NC_SYSTEM_EVENT_FILTER_KEYS = [
+	"deviceIds",
+	"deviceTypes",
+	"nodeIds",
+	"packageNames",
+	"consumableLowPercent"
+];
+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",
+	"device-tank-low": "device-events",
+	"device-tank-full": "device-events",
+	"device-tank-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];
+var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
+	{
+		id: "device-state",
+		family: "device-events",
+		label: "Device state",
+		kinds: [
+			"device-offline",
+			"device-online",
+			"device-disabled",
+			"device-enabled"
+		]
+	},
+	{
+		id: "streams",
+		family: "device-events",
+		label: "Streams",
+		kinds: ["stream-offline", "stream-online"]
+	},
+	{
+		id: "battery",
+		family: "device-events",
+		label: "Battery",
+		kinds: ["device-battery-low", "device-battery-normal"]
+	},
+	{
+		id: "consumables",
+		family: "device-events",
+		label: "Consumables",
+		kinds: ["device-consumable-low", "device-consumable-normal"]
+	},
+	{
+		id: "tanks",
+		family: "device-events",
+		label: "Tanks",
+		kinds: [
+			"device-tank-low",
+			"device-tank-full",
+			"device-tank-normal"
+		]
+	},
+	{
+		id: "detection-blind",
+		family: "device-events",
+		label: "Detecting nothing",
+		kinds: ["detection-blind"]
+	},
+	{
+		id: "nodes",
+		family: "system",
+		label: "Nodes",
+		kinds: [
+			"node-offline",
+			"node-online",
+			"node-inference-unavailable"
+		]
+	},
+	{
+		id: "addons",
+		family: "system",
+		label: "Addons",
+		kinds: [
+			"addon-crash-loop",
+			"addon-update-available",
+			"addon-updated"
+		]
+	},
+	{
+		id: "updates",
+		family: "system",
+		label: "Server & container updates",
+		kinds: [
+			"server-update-available",
+			"server-updated",
+			"wrapper-update-available"
+		]
+	},
+	{
+		id: "backups-exports",
+		family: "system",
+		label: "Backups & exports",
+		kinds: ["backup-completed", "export-completed"]
+	},
+	{
+		id: "alarm",
+		family: "alarm",
+		label: "Alarm",
+		kinds: NC_ALARM_SYSTEM_EVENT_KINDS
+	}
+];
+function systemEventKindsOfFamily(family) {
+	return NC_SYSTEM_EVENT_KIND_GROUP_SPECS.filter((g) => g.family === family).flatMap((g) => g.kinds);
+}
 NC_AUDIO_DEFAULTS.hitPercent, NC_AUDIO_DEFAULTS.samplingSeconds;
+/**
+* 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"];
 var CONSUMABLE = ["device-consumable-low", "device-consumable-normal"];
+var TANK = [
+	"device-tank-low",
+	"device-tank-full",
+	"device-tank-normal"
+];
 var UPDATES = [
 	"addon-update-available",
 	"server-update-available",
@@ -44427,12 +44933,189 @@ var DEVICE_EVENTS = [
 	"device-enabled",
 	...BATTERY,
 	...CONSUMABLE,
+	...TANK,
 	"stream-online",
 	"stream-offline",
 	"detection-blind",
 	...ALARM
 ];
-[...DEVICE_EVENTS], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...COMBINED_ALARM], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_BODY_ONLY], [...RULE_TEXT], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...DEVICE_EVENTS], [...RULE_TEXT], [...BATTERY, ...CONSUMABLE], [...RULE_TEXT], [...CONSUMABLE], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...UPDATES], [...RULE_TEXT], [...PACKAGE_UPDATES], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT], [...RULE_TEXT];
+/** Every kind a summary may speak about — the two summarisable families. */
+var SUMMARISABLE = [...systemEventKindsOfFamily("device-events"), ...systemEventKindsOfFamily("system")];
+/** One per summary SECTION (`NC_STATE_SUMMARY_SECTIONS` in the notification
+*  centre): the section's lines, offered when one of its kinds is selected. */
+var STATE_SUMMARY_SECTION_VARS = [
+	{
+		name: "summaryDevices",
+		label: "Summary: devices offline / switched off",
+		example: "Garage — offline since 07:12",
+		kinds: [
+			"device-offline",
+			"device-online",
+			"device-disabled",
+			"device-enabled"
+		]
+	},
+	{
+		name: "summaryStreams",
+		label: "Summary: streams offline",
+		example: "Ingresso (high) — since 06:40",
+		kinds: ["stream-offline", "stream-online"]
+	},
+	{
+		name: "summaryBattery",
+		label: "Summary: low batteries",
+		example: "Sensore porta — 8 %",
+		kinds: BATTERY
+	},
+	{
+		name: "summaryConsumables",
+		label: "Summary: consumables",
+		example: "Robot — filter 10 %",
+		kinds: CONSUMABLE
+	},
+	{
+		name: "summaryTanks",
+		label: "Summary: tanks",
+		example: "Robot — clean water low",
+		kinds: TANK
+	},
+	{
+		name: "summaryDetection",
+		label: "Summary: cameras detecting nothing",
+		example: "Ingresso — since 05:10",
+		kinds: ["detection-blind"]
+	},
+	{
+		name: "summaryNodes",
+		label: "Summary: nodes",
+		example: "little-unraid — offline since 03:00",
+		kinds: [
+			"node-offline",
+			"node-online",
+			"node-inference-unavailable"
+		]
+	},
+	{
+		name: "summaryAddons",
+		label: "Summary: addons",
+		example: "@camstack/addon-recorder 1.2.3 → 1.2.4",
+		kinds: [
+			"addon-crash-loop",
+			"addon-update-available",
+			"addon-updated"
+		]
+	},
+	{
+		name: "summaryUpdates",
+		label: "Summary: server & container updates",
+		example: "server 1.2.377 → 1.2.378",
+		kinds: [
+			"server-update-available",
+			"server-updated",
+			"wrapper-update-available"
+		]
+	}
+];
+var STATE_SUMMARY_VARS = [
+	{
+		name: "summaryText",
+		label: "Summary: every section",
+		description: "One block per section with something to report, one line per item.",
+		example: "Batterie scariche: Sensore porta — 8 %",
+		group: "system",
+		families: ["rule"],
+		fields: [...RULE_TEXT],
+		kinds: ["system"],
+		systemEventKinds: [...SUMMARISABLE],
+		systemEventDeliveries: ["summary"]
+	},
+	{
+		name: "summaryCount",
+		label: "Summary: items reported",
+		example: "3",
+		group: "system",
+		families: ["rule"],
+		fields: [...RULE_TEXT],
+		kinds: ["system"],
+		systemEventKinds: [...SUMMARISABLE],
+		systemEventDeliveries: ["summary"]
+	},
+	...STATE_SUMMARY_SECTION_VARS.map((v) => ({
+		name: v.name,
+		label: v.label,
+		example: v.example,
+		group: "system",
+		families: ["rule"],
+		fields: [...RULE_TEXT],
+		kinds: ["system"],
+		systemEventKinds: [...v.kinds],
+		systemEventDeliveries: ["summary"]
+	}))
+];
+[
+	[...DEVICE_EVENTS],
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	([...RULE_TEXT], [...PACKAGE_UPDATES]),
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	([...RULE_TEXT], [...COMBINED_ALARM]),
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_BODY_ONLY],
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...DEVICE_EVENTS]),
+	([...RULE_TEXT], [...DEVICE_EVENTS]),
+	([...RULE_TEXT], [...BATTERY, ...CONSUMABLE]),
+	([...RULE_TEXT], [...CONSUMABLE]),
+	([...RULE_TEXT], [...TANK]),
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...UPDATES]),
+	([...RULE_TEXT], [...UPDATES]),
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	([...RULE_TEXT], [...UPDATES]),
+	([...RULE_TEXT], [...PACKAGE_UPDATES]),
+	([...RULE_TEXT], [...PACKAGE_UPDATES]),
+	([...RULE_TEXT], [...UPDATES]),
+	([...RULE_TEXT], [...UPDATES]),
+	([...RULE_TEXT], [...PACKAGE_UPDATES]),
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
+	...STATE_SUMMARY_VARS
+];
 /**
 * TimelapseRule — the STANDALONE scheduled timelapse producer's rule model.
 *