@camstack/addon-osd-manager 0.1.138 → 0.1.140

package/dist/index.mjs

@@ -5359,7 +5359,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-D_4W7xuQ.mjs
+//#region ../types/dist/sleep-BaRu0bS5.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -9526,7 +9526,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).
@@ -9607,10 +9607,17 @@ var ModelCatalogEntrySchema = object({
 	inputChannels: number().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
@@ -9712,7 +9719,8 @@ var ModelConvertMetadataSchema = object({
 	inputNormalization: _enum([
 		"zero-one",
 		"imagenet",
-		"none"
+		"none",
+		"scrfd"
 	]).optional(),
 	preprocessMode: _enum(["letterbox", "resize"]).optional(),
 	outputFormat: _enum([
@@ -19527,6 +19535,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",
@@ -19564,6 +19575,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.
@@ -19597,7 +19631,22 @@ var NcSystemEventConditionSchema = object({
 	*/
 	excludeDeviceIds: array(number().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().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. */
@@ -19615,6 +19664,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({
 	/**
@@ -19740,6 +19808,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),
@@ -19929,6 +20007,20 @@ var NcConditionsSchema = object({
 	scene: NcSceneConditionSchema.optional(),
 	/** Device scope — absent = all devices. */
 	devices: array(number()).optional(),
+	/**
+	* Device EXCLUSION (D641) — "every device except these". Judged on the SAME
+	* subject ids {@link devices} is judged on (the camera, the sensor that
+	* fired, a linked set's sensor and row cameras), so a sensor fanned out per
+	* linked camera is excluded exactly where an include would have tested it.
+	* `min(1)`: an empty exclusion excludes nothing and is written as absent.
+	*
+	* Not for `system-event` rules — those carry their own
+	* `systemEvent.excludeDeviceIds` (D636), and the hub refuses this key there.
+	* Editors present the two lists as ONE field (All | Only these | All except
+	* these); the engine evaluates each independently, so a legacy rule
+	* carrying both still means "these, minus those".
+	*/
+	devicesExclude: array(number()).min(1).optional(),
 	/** Detector class names (any overlap with the record's class set). */
 	classes: array(string().min(1)).optional(),
 	/** Veto classes — any overlap fails the rule. */
@@ -20062,6 +20154,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
@@ -20316,6 +20418,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()`. */
@@ -20544,6 +20656,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().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().int().nonnegative(),
+	text: string(),
+	sections: array(NcStateSummaryPreviewSectionSchema),
+	dropped: record(string(), number().int().nonnegative()),
+	excludedGroups: array(string())
+});
 var NcTestResultSchema = object({
 	recordId: string(),
 	recordKind: _enum([
@@ -20635,6 +20769,13 @@ var NcTemplateVarDescriptorSchema = object({
 	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")
@@ -20647,7 +20788,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(),
@@ -20680,6 +20823,7 @@ var NcConditionDescriptorSchema = object({
 	/** Editor widget the UI renders — never hardcode per-condition forms. */
 	valueType: _enum([
 		"deviceIdList",
+		"deviceIdExcludeList",
 		"stringList",
 		"number01",
 		"number",
@@ -20690,6 +20834,7 @@ var NcConditionDescriptorSchema = object({
 		"plateMatcher",
 		"packagePhase",
 		"crossingSelect",
+		"sensorTransition",
 		"polygonDraw",
 		"occupancy",
 		"audio",
@@ -20823,6 +20968,18 @@ var NC_CONDITION_CATALOG = [
 				value: "device-consumable-normal",
 				label: "Consumable replaced"
 			},
+			{
+				value: "device-tank-low",
+				label: "Tank low (water, detergent)"
+			},
+			{
+				value: "device-tank-full",
+				label: "Tank full (dirty water, dust)"
+			},
+			{
+				value: "device-tank-normal",
+				label: "Tank back to normal"
+			},
 			{
 				value: "export-completed",
 				label: "Export completed"
@@ -20888,6 +21045,21 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Restrict the rule to these devices; absent = all devices. A sensor event matches either the SENSOR that fired or the camera it is attributed to, so a rule may name either one."
 	},
+	{
+		id: "devicesExclude",
+		group: "scope",
+		label: "Excluded devices",
+		valueType: "deviceIdExcludeList",
+		operator: "notIn",
+		appliesTo: [
+			"immediate",
+			"track-end",
+			"device-event",
+			"package-event"
+		],
+		phase: "P1",
+		description: "Every device except these. Judged on the same device ids as Devices: a sensor event is excluded by the SENSOR that fired or by the camera it is attributed to."
+	},
 	{
 		id: "classes",
 		group: "class",
@@ -21144,6 +21316,33 @@ var NC_CONDITION_CATALOG = [
 		phase: "P1",
 		description: "Raw device event-type tokens (e.g. doorbell press / press_long) from the event-emitter slice; absent on doorbell-pulse / passive sensors."
 	},
+	{
+		id: "sensorTransition",
+		group: "device",
+		label: "Notify when",
+		valueType: "sensorTransition",
+		options: [
+			{
+				value: "",
+				label: "It triggers and when it clears",
+				hint: "Every change: water detected, and back to dry."
+			},
+			{
+				value: "raised",
+				label: "Only when it triggers",
+				hint: "Water detected, smoke, a contact opening — never the return to normal."
+			},
+			{
+				value: "cleared",
+				label: "Only when it clears",
+				hint: "Back to dry, smoke gone, a contact closing — never the alert itself."
+			}
+		],
+		operator: "in",
+		appliesTo: ["device-event"],
+		phase: "P2",
+		description: "Fire on one edge of a boolean sensor. Offered only when every chosen sensor kind raises and clears; a reading that cannot be placed still notifies."
+	},
 	{
 		id: "packagePhase",
 		group: "package",
@@ -21327,6 +21526,28 @@ var NcHistoryFilterSchema = object({
 	limit: number().int().min(1).max(500).default(100)
 });
 /**
+* Every rule's last run, in one answer.
+*
+* A rule ABSENT from `runs` produced no delivery inside `horizonMs` — how far
+* back this answer looked, in ms before the hub's now. It is the outbox prune
+* window (7 days by default, operator-configurable), NARROWED when the read hit
+* its row bound: the answer never claims a window it did not read. `null` means
+* the operator keeps the outbox forever AND the read reached its end, so absent
+* means "never on record". A UI derives its "not in the last N days" from this
+* value, never from a constant — and only when the call ANSWERED (D315).
+*/
+var NcRuleLastRunsSchema = object({
+	runs: array(object({
+		ruleId: string(),
+		/** Fire time of the newest row (`createdAt`, epoch ms). */
+		lastAt: number(),
+		status: NcHistoryStatusSchema,
+		/** The camera/device of that row (a digest row files under its first camera). */
+		deviceId: number()
+	})),
+	horizonMs: number().nonnegative().nullable()
+});
+/**
 * What a snooze covers. Broader scopes win when several overlap, so one window
 * leaves ONE digest rather than a rule snooze and a whole-feed snooze both
 * summarising the same silence.
@@ -21507,6 +21728,14 @@ var NcAlarmModeCoverageSchema = object({
 	/** Ids named by the covering rules. A SUBSET when `allDevices` is true. */
 	deviceIds: array(number().int()),
 	/**
+	* D641: the ids NOT covered although `allDevices` is true — every unscoped
+	* covering rule EXCLUDES them (`conditions.devicesExclude`) and no named rule
+	* covers them. Always `[]` when `allDevices` is false. Excluded by the rules,
+	* which is not the same as skipped by a switch: never in `skippedDevices`.
+	* Defaulted so an answer computed before this field parses as "none".
+	*/
+	allDevicesExcept: array(number().int()).default([]),
+	/**
 	* Devices this mode NAMES but cannot actually arm, each with the switch that
 	* excludes it.
 	*
@@ -21694,6 +21923,17 @@ var notificationRulesCapability = {
 			auth: "admin"
 		}),
 		/**
+		* The STATE SUMMARY a system rule would send now (D647) — for a saved rule
+		* or an unsaved draft. Pure: sends nothing, stamps nothing. A MUTATION
+		* only for transport (a whole rule does not belong in a GET URL). Admin,
+		* like `testRule`: it names devices and nodes across the installation.
+		*/
+		previewStateSummary: method(object({ rule: NcRuleInputSchema }), NcStateSummaryPreviewSchema, {
+			kind: "mutation",
+			auth: "admin",
+			access: "view"
+		}),
+		/**
 		* The machine-readable condition surface a rule editor renders from, plus
 		* the picker VOCABULARY those conditions draw on.
 		*
@@ -21730,6 +21970,15 @@ var notificationRulesCapability = {
 		*/
 		getHistory: method(object({ filter: NcHistoryFilterSchema.default({ limit: 100 }) }), object({ entries: array(NcHistoryEntrySchema) }), { auth: "admin" }),
 		/**
+		* The newest delivery of every rule, in ONE bounded read of the outbox —
+		* the "Last run" column. Never a `getHistory` per rule. A rule with no
+		* delivery inside `horizonMs` is absent from `runs`; see
+		* {@link NcRuleLastRunsSchema} for what absent means. A store that cannot
+		* answer FAILS the call rather than answering "nothing ran". Admin-only,
+		* like `getHistory`, of which it is a projection.
+		*/
+		getRuleLastRuns: method(object({}), NcRuleLastRunsSchema, { auth: "admin" }),
+		/**
 		* Mint a fresh, externally-reachable URL for one artefact a history row
 		* named in {@link NcHistoryEntrySchema.shape.artifactIds} — the SAME
 		* signed-link mechanism the dispatcher uses to attach media to an
@@ -22145,1019 +22394,195 @@ var oauthIntegrationCapability = {
 getDescriptor: 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.
+* 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
+* persisted media. Owns the post-detection domain end-to-end:
+*
+*   runner emits PipelineInferenceResult
+*     ↓ (event bus)
+*   pipeline-analytics subscriber
+*     ↓ SORT tracker + zone engine + state analyzer + event emitter
+*   → three DB collections (one per kind), one FS media tree, one
+*     unified event emitter (FrameTracked + TrackStarted/Ended +
+*     DetectionEvent on bus)
+*
+* Pure subscriber model. No `processFrame` cap method — the runner
+* already publishes the raw frame on the bus. The cap surface is
+* only QUERIES + per-device settings, bound on/off via
+* `device-manager.setWrapperActive`. `defaultActive: true` because
+* every camera with a detection pipeline wants its raw detections
+* refined; operators opt out per-device via BindingsTab when needed.
+*
+* Replaces the legacy `analysis-pipeline`, `analysis-data-persistence`
+* (per-device surface) and `track-trail` caps — see P11 cleanup.
 */
-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(),
-		y: number(),
-		w: number(),
-		h: number()
-	})
-});
-object({
-	crop: object({
-		left: number(),
-		top: number(),
-		width: number().positive(),
-		height: number().positive()
-	}).optional(),
-	content: object({
-		width: number().int().positive(),
-		height: number().int().positive()
-	}),
-	fit: _enum(["stretch", "contain"]),
-	format: _enum([
-		"rgb",
-		"gray",
-		"jpeg"
-	])
-});
+var TrackStateSchema = _enum([
+	"new",
+	"entered",
+	"left",
+	"moving",
+	"idle"
+]);
+var EventKindSchema = _enum([
+	"motion",
+	"object",
+	"audio"
+]);
 /**
-* 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.
+* Spatial filter for `listTracks` — the rect + polygon variants of the shared
+* MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
+* of the camera frame (top-left origin), matching the drawing-plane editor.
 */
-var FrameRefSchema = object({
-	registryId: string().min(1),
-	id: string().min(1),
-	width: number().int().positive(),
-	height: number().int().positive(),
-	format: _enum(["rgb", "gray"]),
-	timestamp: number(),
-	capturedAt: number().optional()
-});
-var ModelFormatSchema$1 = _enum([
-	"onnx",
-	"coreml",
-	"openvino",
-	"tflite",
-	"pt",
-	"gguf"
+var TrackZoneFilterSchema = discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
+/** Closed icon vocabulary so clients render a known glyph per kind. */
+var EventKindIconSchema = _enum([
+	"motion",
+	"audio",
+	"person",
+	"vehicle",
+	"animal",
+	"door",
+	"pir",
+	"smoke",
+	"water",
+	"button",
+	"package",
+	"generic"
 ]);
-var PipelineSlotSchema = _enum([
-	"detector",
-	"cropper",
-	"classifier",
-	"refiner",
-	"audio-classifier"
+var EventKindCategorySchema = _enum([
+	"motion",
+	"audio",
+	"detection",
+	"sensor",
+	"control",
+	"custom",
+	"package"
 ]);
-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()
-	})),
-	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(),
-	group: string().optional(),
-	configSchema: array(ConfigFieldBridge).readonly().optional()
-});
-var PipelineSlotSchemaSchema = object({
-	id: PipelineSlotSchema,
+/** Taxonomy level — macro (timeline lane) vs sub (events-page leaf). */
+var EventKindLevelSchema = _enum(["macro", "sub"]);
+var EventKindDescriptorSchema = object({
+	/** Stable kind id (e.g. 'motion', 'vehicle', 'car', 'lock'). */
+	kind: string(),
+	/** i18n key resolved on the UI side; `label` is the English fallback. */
+	labelKey: string(),
+	/** English fallback label (kept for clients that don't translate). */
 	label: string(),
-	priority: number(),
-	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().optional(),
-	error: string().optional(),
-	nextRetryAt: number().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()
+	/** Hex color for timeline/legend rendering. */
+	color: string(),
+	/** Dictionary id → lucide component on the UI side. */
+	iconId: string(),
+	/** Legacy closed-vocab glyph — fallback for `iconId`. */
+	icon: EventKindIconSchema,
+	category: EventKindCategorySchema,
+	/** Macro parent for this kind ('car' → 'vehicle'); null for a macro. */
+	parentKind: string().nullable(),
+	/** Derived from `parentKind`, explicit for the client tree. */
+	level: EventKindLevelSchema,
+	/** Which cap + device contributes this kind. For built-ins the camera
+	*  itself; for sensor kinds the LINKED source device. */
+	source: object({
+		capName: string(),
+		deviceId: number()
+	})
 });
-var ReferenceAudioEntrySchema = object({
-	filename: string(),
-	sizeKb: number()
+/** One camera's event vocabulary, as returned by `listEventKindsBatch`. */
+var EventKindsForDeviceSchema = object({
+	deviceId: number(),
+	kinds: array(EventKindDescriptorSchema).readonly()
 });
-var ReferenceAudioBodySchema = object({ base64: string() });
-var AudioBackendSchema = object({
+var SensorEventSchema = object({
 	id: string(),
-	name: string(),
-	description: string(),
-	available: boolean(),
+	/** The CAMERA the event is attributed to (a sensor linked to N cameras
+	*  yields N rows, one per camera). */
+	deviceId: number(),
+	/** The linked sensor device whose state changed. */
+	sourceDeviceId: number(),
+	/** Event kind id — matches an `EventKindDescriptor.kind`. */
+	kind: string(),
+	/** Snapshot of the sensor cap's runtime-state slice at the change. */
+	value: record(string(), unknown()).nullable(),
+	timestamp: number()
+});
+/**
+* One stored sighting on a track's trajectory.
+*
+* The array these live in is returned in TIME order (D399) — it is APPENDED in
+* arrival order, and the two detector passes interleave, so a consumer must not
+* assume the two are the same on a row written by an older build.
+*/
+var TrackPositionSchema = object({
+	x: number(),
+	y: number(),
+	timestamp: number(),
+	bbox: BoundingBoxSchema,
 	/**
-	* 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.
+	* Which detector pass measured this box (D399): `frame` is the full-frame
+	* pass on the analysis raster, `recovery` is the native-resolution
+	* small-subject second pass (D377/D378). Both write into one array, and until
+	* this field existed the only way to tell them apart was that full-frame boxes
+	* are exact multiples of 1.2 while recovery boxes are full-precision floats.
+	* Absent on rows written before D399.
 	*/
-	rawLabels: array(string()).readonly().optional()
+	source: _enum(["frame", "recovery"]).optional(),
+	/** Detection score of this box, so a position can be weighed and not only
+	*  plotted. Absent on rows written before D399. */
+	score: number().optional()
 });
-var AudioCapabilitiesSchema = object({
-	activeBackend: string(),
-	availableBackends: array(AudioBackendSchema).readonly(),
-	sampleRate: number(),
-	chunkDurationMs: number()
+var TrackSnapshotSchema = object({
+	timestamp: number(),
+	position: TrackPositionSchema,
+	/** The snapshot's media row id (D482); resolve via `listTrackMedia({ trackId })`. */
+	mediaId: number().int()
 });
-var DownloadModelResultSchema = object({
-	filePath: string(),
-	sizeMB: number(),
-	durationMs: number()
+/**
+* Normalized 0..1 trajectory envelope (min/max over every position bbox,
+* divided by the track's detection-frame dims), computed at persist time.
+* Absent when the frame dims were unknown when the track was persisted
+* (legacy rows / dims-less sources) and on active (in-RAM) tracks.
+*/
+var TrackEnvelopeSchema = object({
+	minX: number(),
+	minY: number(),
+	maxX: number(),
+	maxY: number()
 });
 /**
-* 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.
+* Row projection for track list queries. `full` (default) returns the
+* complete Track including the frame-rate `positions[]` history and the
+* `snapshots[]` references — megabytes across a page of tracks. `slim`
+* keeps every scalar the list surfaces actually render (ids, class(es),
+* label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
+* zonesVisited, bestEventId, envelope, hasFace, hasEmbeddedFace, hasRider) and returns `positions` /
+* `snapshots` as EMPTY arrays — detail views re-fetch the full row via
+* `getTrack`. Mirrors the event-store `projection` convention
+* (`getObjectEvents` et al.).
 */
-var AudioTestResultSchema = object({
-	success: boolean(),
-	error: string().optional(),
-	frame: custom().optional()
+var TrackProjectionSchema = _enum(["full", "slim"]);
+/**
+* One audio-classification label heard on the track's camera while the
+* track was alive, aggregated per label. An "episode" is one persisted
+* audio event (the confident-classification path: score ≥ the device's
+* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
+* one 32 ms inference chunk, so counts stay human-scaled.
+*/
+var TrackAudioLabelSchema = object({
+	label: string(),
+	/** Highest classification score observed across the label's episodes. */
+	peakScore: number(),
+	/** Number of coalesced audio-event episodes carrying this label. */
+	count: number(),
+	firstAt: number(),
+	lastAt: number()
 });
-var PipelineConfigBridge = custom();
-var ConfigUISchemaBridge = custom();
-var ConfigUISchemaNullableBridge = custom();
-var InferenceCapabilitiesBridge = custom();
-var ModelAvailabilityListBridge = custom();
-var PipelineRunResultBridge = custom();
 /**
-* Pipeline executor — detection engine + configuration + inference API.
+* How a track was produced. `pipeline` (default / absent) = the spatial
+* detection+tracking pipeline. Every OTHER value is a SYNTHETIC projection —
+* no positions, a single snapshot, and no bbox trajectory at all:
 *
-* Merged from: pipeline-executor, pipeline-config, inference, detection-config.
-* Implemented by the detection-pipeline addon.
-*
-* Per-device surface (DeviceSettingsContribution + the "is detection
-* enabled for this camera?" toggle) lives on the paired
-* `detection-pipeline` cap (device-scoped, singleton, wrapper
-* defaultActive) — same split pattern used by stream-broker /
-* camera-streams and audio-analyzer / audio-analysis.
-*/
-var pipelineExecutorCapability = {
-	name: "pipeline-executor",
-	scope: "system",
-	mode: "singleton",
-	methods: {
-		getAvailableEngines: method(_void(), array(PipelineEngineChoiceSchema)),
-		getSelectedEngine: method(_void(), PipelineEngineChoiceSchema),
-		getDefaultSteps: method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)),
-		/**
-		* Per-node detection-engine provisioning snapshot. Returns the live
-		* state of the lazy runtime-provisioning machine on `nodeId`
-		* (idle / installing / verifying / ready / failed). The UI pairs this
-		* one-shot query with the `pipeline.engine-provisioning` live event
-		* (emitted on every transition) to drive a per-node "engine ready?"
-		* indicator without polling. Phase 2.
-		*/
-		getEngineProvisioning: method(object({ nodeId: string() }), EngineProvisioningSchema),
-		getVideoPipelineSteps: method(_void(), record(string(), object({
-			modelId: string(),
-			settings: record(string(), unknown()).readonly()
-		}))),
-		setVideoPipelineSteps: method(object({ steps: record(string(), object({
-			modelId: string(),
-			settings: record(string(), unknown()).readonly()
-		})) }), object({ success: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Clear THIS node's executor-side PER-DEVICE settings stores (the
-		* per-camera step overrides the object-detection root reads via
-		* `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
-		* generated cap-router strips it (default `nodeIdMode: 'routing'`) and
-		* dispatches to that node, so the provider method runs ON the target
-		* node and receives no `nodeId`.
-		*
-		* This is the slimmed executor leg of the orchestrator's
-		* `resetNodePipelineDefaults` flow (which owns the real reset: node
-		* addonDefaults pins + per-camera orchestrator overrides). The legacy
-		* `resetToDefault` — which reset a persisted global step-tree seed
-		* nothing in the live per-camera path read — was removed together with
-		* that seed.
-		*/
-		clearDeviceOverrides: method(object({ nodeId: string() }), object({
-			success: literal(true),
-			clearedDevices: number()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Which of THIS node's inference devices the executor currently refuses,
-		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
-		*
-		* The channel that did not exist. Pool health was known only inside the
-		* detection addon and was an input to no routing decision anywhere: the
-		* per-dispatch capability gate is keyed on model FORMAT and so can never
-		* separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
-		* eligibility probe (`platformProbe.getCapabilities`) answers about
-		* HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
-		* Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
-		* balancer went on handing that dead pool cameras by rotation for 31 hours:
-		* ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
-		*
-		* Read semantics the caller depends on, and which the provider guarantees:
-		* this is a synchronous read of in-memory state. It never probes hardware,
-		* never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
-		* nothing is refused", which is what re-admits a device. A read that FAILS
-		* (node offline, version skew) must therefore be distinguishable from an
-		* empty answer, and it is: it rejects.
-		*/
-		getInferenceDeviceHealth: 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(),
-			/** Pool deaths inside the current window. */
-			deaths: number(),
-			/** The last death's message. */
-			lastError: string()
-		})).readonly() })),
-		/**
-		* Re-arm a terminally `failed` inference device on `nodeId`: forget its
-		* restart budget so the next dispatch builds a fresh pool.
-		*
-		* The terminal state is deliberate (the abort it bounds is deterministic —
-		* an automatic probation would just respawn Python forever, more slowly),
-		* and a terminal state an operator cannot leave is a silent fault. This is
-		* the way out. `rearmed:false` means there was nothing to forget.
-		*/
-		rearmInferenceDevice: method(object({
-			nodeId: string(),
-			deviceKey: string()
-		}), object({ rearmed: boolean() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		getSchema: method(_void(), PipelineSchemaSchema),
-		getGlobalSteps: method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()),
-		getGlobalPipelineConfig: method(_void(), PipelineConfigBridge),
-		getOrchestratorConfigSchema: method(_void(), ConfigUISchemaBridge),
-		/**
-		* Gate B (pre-init config-correctness gate). PURE COMPUTE against this
-		* node's `currentEngine.format` — resolves `steps` the same way the
-		* runtime dispatch path would, and reports what WOULD happen without
-		* touching any node-global state. Called by the orchestrator at attach
-		* time (`attachOn`), node-pinned to the TARGET node, so config problems
-		* surface BEFORE `pipelineRunner.attachCamera` rather than at the first
-		* per-frame resolve. `ok` is false iff `issues` is non-empty (both
-		* `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
-		* is informational (a degraded-but-loadable model swap) and never
-		* affects `ok`. Never throws.
-		*/
-		validatePipeline: method(object({ steps: array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
-		listTemplates: method(_void(), array(PipelineTemplateSchema$1).readonly()),
-		saveTemplate: method(object({
-			name: string(),
-			steps: array(PipelineTemplateStepSchema).readonly(),
-			engine: PipelineEngineChoiceSchema
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		updateTemplate: method(object({
-			id: string(),
-			name: string().optional(),
-			steps: array(PipelineTemplateStepSchema).readonly().optional()
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		deleteTemplate: method(object({ id: string() }), _void(), { kind: "mutation" }),
-		getCapabilities: method(_void(), InferenceCapabilitiesBridge),
-		getAddonModels: method(object({ addonId: string() }), ModelAvailabilityListBridge),
-		downloadModel: method(object({
-			addonId: string(),
-			modelId: string(),
-			format: ModelFormatSchema$1
-		}), DownloadModelResultSchema, { kind: "mutation" }),
-		deleteModel: method(object({
-			addonId: string(),
-			modelId: string(),
-			format: ModelFormatSchema$1
-		}), object({ success: literal(true) }), { kind: "mutation" }),
-		/**
-		* Stateless single-frame execution. Callers (runner, benchmark) pass
-		* the complete `engine` + `steps` tree; the executor holds no state
-		* about cameras or saved pipelines.
-		*
-		* `engine` is optional during the migration window to preserve the
-		* legacy call shape used by existing benchmark code; once all
-		* callers pass it explicitly we make it required.
-		*
-		* Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
-		* `referenceImage` must be provided:
-		*  - `frame`: runtime dispatch path (runner → decoded broker frame).
-		*    Carries the raw buffer, dimensions, and format; the executor
-		*    uses it directly without base64 round-tripping.
-		*  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
-		*    decoded frame. Both runner and executor are hub-local processes
-		*    sharing `/dev/shm`, so the executor maps the named segment and
-		*    reads the pixels back zero-copy — eliminating the ~1.2MB
-		*    re-serialisation over UDS/MsgPack the `frame` path pays per call.
-		*    High-risk: the FrameRing is a latest-wins seqlock with no
-		*    refcount, so a recycled slot yields a null read; the executor
-		*    then degrades to an empty result and the runner ships pixels via
-		*    `frame` as the fallback (queue-depth gated on the runner side).
-		*  - `imageBase64`: one-shot test path (benchmark ImageTab).
-		*  - `referenceImage`: named file from the reference-image store.
-		*/
-		runPipeline: 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().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" }),
-		/**
-		* Batched run — N raw frames packed into one cap call. The provider
-		* routes the batch through `SharedInferencePool.inferBatch`
-		* (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
-		* envelope cost is amortised N:1 vs N concurrent `runPipeline`
-		* calls. Single root step + uniform model assumed; trees with crop
-		* children fall back to sequential execution.
-		*
-		* Used by `scripts/bench-batch-style.mts` for batch benchmarking —
-		* N frames in one call to amortise per-call IPC overhead.
-		*/
-		runPipelineBatch: method(object({
-			engine: PipelineEngineChoiceSchema.optional(),
-			steps: array(PipelineStepInputSchema).min(1),
-			frames: array(FrameInputSchema).min(1).max(255),
-			deviceId: number().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().int().nonnegative().optional(),
-			/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
-			deviceKey: string().optional()
-		}), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
-		/**
-		* Cache a raw frame inside the Python inference pool's memory.
-		* Returns a numeric `frameId` that `inferCached` references —
-		* subsequent calls send only 5 bytes through the pipe instead of
-		* 1.2MB raw data, eliminating the pipe transfer bottleneck.
-		*/
-		cacheFrameInPool: method(object({
-			data: _instanceof(Uint8Array),
-			width: number().int().positive(),
-			height: number().int().positive(),
-			format: _enum([
-				"rgb",
-				"bgr",
-				"gray"
-			])
-		}), object({
-			frameId: number(),
-			width: number(),
-			height: number()
-		}), { kind: "mutation" }),
-		/**
-		* Run inference on a previously cached frame. Sends only 5 bytes
-		* (model_idx + frameId) through the IPC pipe — eliminates the
-		* ~35ms per-call overhead of transferring 1.2MB raw data.
-		*/
-		inferCached: method(object({
-			stepId: string(),
-			frameId: number().int()
-		}), record(string(), unknown()), { kind: "mutation" }),
-		/**
-		* Release a cached frame from the Python pool's memory.
-		*/
-		uncacheFrame: method(object({ frameId: number().int() }), _void(), { kind: "mutation" }),
-		/** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
-		getEffectiveTuning: method(_void(), object({
-			batchMode: string(),
-			windowMs: number(),
-			maxBatchSize: number(),
-			concurrency: number()
-		})),
-		/**
-		* List every EngineFactory currently loaded in this executor's RAM,
-		* with the models resident and a coarse "in use" marker derived from
-		* ongoing inference activity. Used by the Pipeline page Engines tab.
-		*/
-		listLoadedEngines: method(_void(), array(object({
-			engineKey: string(),
-			engine: PipelineEngineChoiceSchema,
-			modelsLoaded: array(string()).readonly(),
-			inUseByCameras: array(number()).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().nullable(),
-			/** ms since this factory was last used (null when not warm-tracked). */
-			idleMs: number().nullable(),
-			/** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
-			idleTtlMs: number().nullable()
-		})).readonly()),
-		/** Warm up an engine without running a frame. No-op if already loaded. */
-		spinEngine: method(object({ engine: PipelineEngineChoiceSchema }), object({ success: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
-		* Unload an engine from RAM. `force:true` unloads even when cameras
-		* are actively using it (they re-spin on next frame). Default is
-		* gated — returns `{success:false, reason}` when in use.
-		*/
-		killEngine: method(object({
-			engine: PipelineEngineChoiceSchema,
-			force: boolean().optional()
-		}), object({
-			success: boolean(),
-			reason: string().optional()
-		}), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		listReferenceImages: method(_void(), array(ReferenceImageEntrySchema).readonly()),
-		getReferenceImage: method(object({ filename: string() }), ReferenceImageBodySchema.nullable()),
-		getReferenceAudioFiles: method(_void(), array(ReferenceAudioEntrySchema).readonly()),
-		getReferenceAudio: method(object({ filename: string() }), ReferenceAudioBodySchema.nullable()),
-		getAudioCapabilities: method(_void(), AudioCapabilitiesSchema),
-		runAudioTest: method(object({
-			addonId: string(),
-			modelId: string(),
-			filename: string().optional(),
-			settings: record(string(), unknown()).optional()
-		}), AudioTestResultSchema, { kind: "mutation" }),
-		getDetectionConfigSchema: 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().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().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(),
-	y: number()
-});
-/** 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")
-});
-/**
-* Zones capability — per-camera CRUD over polygon detection zones.
-*
-* Provider lives in `addon-pipeline-orchestrator` (hub-only). Persists
-* to per-device settings and mirrors into the `zones` device-state
-* slice on every mutation, so downstream consumers can subscribe via
-* `dev.state.zones.onChanged`.
-*
-* The cap surface only handles geometry + identity; filtering
-* behaviour (per-class, include/exclude, threshold) lives in the
-* consumer addons' rule arrays — see `ZoneRuleSchema` exported from
-* `capabilities/schemas/zone-rule.js`.
-*/
-var zonesCapability = {
-	name: "zones",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: [DeviceType.Camera],
-	methods: {
-		listZones: method(object({ deviceId: number() }), array(ZoneSchema).readonly()),
-		addZone: method(object({
-			deviceId: number(),
-			zone: ZoneSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		removeZone: method(object({
-			deviceId: number(),
-			zoneId: string()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		updateZone: method(object({
-			deviceId: number(),
-			zone: ZoneSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	/**
-	* Runtime-state slice — the live zone catalogue mirrored by the
-	* orchestrator on every CRUD mutation. Consumers read via
-	* `device.state.zones.value` / `.watch(...)` without round-tripping
-	* the cap, and the codegen DeviceProxy auto-wires the reactive
-	* handle. Slice shape is `{ zones: Zone[] }` so future extensions
-	* (e.g. zone groupings) can sit alongside the polygon list.
-	*/
-	runtimeState: object({ zones: array(ZoneSchema).readonly() }),
-	/**
-	* Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored"
-};
-/**
-* 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
-* persisted media. Owns the post-detection domain end-to-end:
-*
-*   runner emits PipelineInferenceResult
-*     ↓ (event bus)
-*   pipeline-analytics subscriber
-*     ↓ SORT tracker + zone engine + state analyzer + event emitter
-*   → three DB collections (one per kind), one FS media tree, one
-*     unified event emitter (FrameTracked + TrackStarted/Ended +
-*     DetectionEvent on bus)
-*
-* Pure subscriber model. No `processFrame` cap method — the runner
-* already publishes the raw frame on the bus. The cap surface is
-* only QUERIES + per-device settings, bound on/off via
-* `device-manager.setWrapperActive`. `defaultActive: true` because
-* every camera with a detection pipeline wants its raw detections
-* refined; operators opt out per-device via BindingsTab when needed.
-*
-* Replaces the legacy `analysis-pipeline`, `analysis-data-persistence`
-* (per-device surface) and `track-trail` caps — see P11 cleanup.
-*/
-var TrackStateSchema = _enum([
-	"new",
-	"entered",
-	"left",
-	"moving",
-	"idle"
-]);
-var EventKindSchema = _enum([
-	"motion",
-	"object",
-	"audio"
-]);
-/**
-* Spatial filter for `listTracks` — the rect + polygon variants of the shared
-* MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
-* of the camera frame (top-left origin), matching the drawing-plane editor.
-*/
-var TrackZoneFilterSchema = discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
-/** Closed icon vocabulary so clients render a known glyph per kind. */
-var EventKindIconSchema = _enum([
-	"motion",
-	"audio",
-	"person",
-	"vehicle",
-	"animal",
-	"door",
-	"pir",
-	"smoke",
-	"water",
-	"button",
-	"package",
-	"generic"
-]);
-var EventKindCategorySchema = _enum([
-	"motion",
-	"audio",
-	"detection",
-	"sensor",
-	"control",
-	"custom",
-	"package"
-]);
-/** Taxonomy level — macro (timeline lane) vs sub (events-page leaf). */
-var EventKindLevelSchema = _enum(["macro", "sub"]);
-var EventKindDescriptorSchema = object({
-	/** Stable kind id (e.g. 'motion', 'vehicle', 'car', 'lock'). */
-	kind: string(),
-	/** i18n key resolved on the UI side; `label` is the English fallback. */
-	labelKey: string(),
-	/** English fallback label (kept for clients that don't translate). */
-	label: string(),
-	/** Hex color for timeline/legend rendering. */
-	color: string(),
-	/** Dictionary id → lucide component on the UI side. */
-	iconId: string(),
-	/** Legacy closed-vocab glyph — fallback for `iconId`. */
-	icon: EventKindIconSchema,
-	category: EventKindCategorySchema,
-	/** Macro parent for this kind ('car' → 'vehicle'); null for a macro. */
-	parentKind: string().nullable(),
-	/** Derived from `parentKind`, explicit for the client tree. */
-	level: EventKindLevelSchema,
-	/** Which cap + device contributes this kind. For built-ins the camera
-	*  itself; for sensor kinds the LINKED source device. */
-	source: object({
-		capName: string(),
-		deviceId: number()
-	})
-});
-/** One camera's event vocabulary, as returned by `listEventKindsBatch`. */
-var EventKindsForDeviceSchema = object({
-	deviceId: number(),
-	kinds: array(EventKindDescriptorSchema).readonly()
-});
-var SensorEventSchema = object({
-	id: string(),
-	/** The CAMERA the event is attributed to (a sensor linked to N cameras
-	*  yields N rows, one per camera). */
-	deviceId: number(),
-	/** The linked sensor device whose state changed. */
-	sourceDeviceId: number(),
-	/** Event kind id — matches an `EventKindDescriptor.kind`. */
-	kind: string(),
-	/** Snapshot of the sensor cap's runtime-state slice at the change. */
-	value: record(string(), unknown()).nullable(),
-	timestamp: number()
-});
-/**
-* One stored sighting on a track's trajectory.
-*
-* The array these live in is returned in TIME order (D399) — it is APPENDED in
-* arrival order, and the two detector passes interleave, so a consumer must not
-* assume the two are the same on a row written by an older build.
-*/
-var TrackPositionSchema = object({
-	x: number(),
-	y: number(),
-	timestamp: number(),
-	bbox: BoundingBoxSchema,
-	/**
-	* Which detector pass measured this box (D399): `frame` is the full-frame
-	* pass on the analysis raster, `recovery` is the native-resolution
-	* small-subject second pass (D377/D378). Both write into one array, and until
-	* this field existed the only way to tell them apart was that full-frame boxes
-	* are exact multiples of 1.2 while recovery boxes are full-precision floats.
-	* Absent on rows written before D399.
-	*/
-	source: _enum(["frame", "recovery"]).optional(),
-	/** Detection score of this box, so a position can be weighed and not only
-	*  plotted. Absent on rows written before D399. */
-	score: number().optional()
-});
-var TrackSnapshotSchema = object({
-	timestamp: number(),
-	position: TrackPositionSchema,
-	/** The snapshot's media row id (D482); resolve via `listTrackMedia({ trackId })`. */
-	mediaId: number().int()
-});
-/**
-* Normalized 0..1 trajectory envelope (min/max over every position bbox,
-* divided by the track's detection-frame dims), computed at persist time.
-* Absent when the frame dims were unknown when the track was persisted
-* (legacy rows / dims-less sources) and on active (in-RAM) tracks.
-*/
-var TrackEnvelopeSchema = object({
-	minX: number(),
-	minY: number(),
-	maxX: number(),
-	maxY: number()
-});
-/**
-* Row projection for track list queries. `full` (default) returns the
-* complete Track including the frame-rate `positions[]` history and the
-* `snapshots[]` references — megabytes across a page of tracks. `slim`
-* keeps every scalar the list surfaces actually render (ids, class(es),
-* label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
-* zonesVisited, bestEventId, envelope, hasFace, hasEmbeddedFace, hasRider) and returns `positions` /
-* `snapshots` as EMPTY arrays — detail views re-fetch the full row via
-* `getTrack`. Mirrors the event-store `projection` convention
-* (`getObjectEvents` et al.).
-*/
-var TrackProjectionSchema = _enum(["full", "slim"]);
-/**
-* One audio-classification label heard on the track's camera while the
-* track was alive, aggregated per label. An "episode" is one persisted
-* audio event (the confident-classification path: score ≥ the device's
-* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
-* one 32 ms inference chunk, so counts stay human-scaled.
-*/
-var TrackAudioLabelSchema = object({
-	label: string(),
-	/** Highest classification score observed across the label's episodes. */
-	peakScore: number(),
-	/** Number of coalesced audio-event episodes carrying this label. */
-	count: number(),
-	firstAt: number(),
-	lastAt: number()
-});
-/**
-* How a track was produced. `pipeline` (default / absent) = the spatial
-* detection+tracking pipeline. Every OTHER value is a SYNTHETIC projection —
-* no positions, a single snapshot, and no bbox trajectory at all:
-*
-*  - `sensor` — a linked sensor/control device state change.
-*  - `audio` — an audio event on the camera itself that was anomalous for
-*    THAT camera, loud, and heard while nothing visual was happening (D62).
+*  - `sensor` — a linked sensor/control device state change.
+*  - `audio` — an audio event on the camera itself that was anomalous for
+*    THAT camera, loud, and heard while nothing visual was happening (D62).
 *
 *  - `onboard` — the CAMERA's own firmware, paired with a decoded frame in
 *    that frame's pixel space. A real root detector and a SPATIAL one: its
@@ -23539,6 +22964,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().optional(),
+	frameHeight: number().optional(),
 	...TrackFlagFields,
 	...TrackRetrainFields
 });
@@ -24545,24 +23986,6 @@ var MediaReclaimStatusSchema = object({
 	finishedAtMs: number().nullable(),
 	error: string().nullable()
 });
-var ReplayFrameInputSchema = object({
-	timestamp: number(),
-	frame: PipelineRunResultBridge
-});
-var RunReplayFrameProcessorResultSchema = object({ tracks: array(object({
-	className: string(),
-	firstSeenMs: number(),
-	lastSeenMs: number(),
-	/** 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().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`
@@ -25151,392 +24574,1034 @@ var pipelineAnalyticsCapability = {
 		* VERBATIM under `tracks/<deviceId>/<trackId>/…`. No crop is derived and no
 		* model is run: a training set's pixels must be the pixels the pipeline saw.
 		*/
-		getTrainingExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+		getTrainingExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* The staging worklist for one camera, or for every camera that has one.
+		*
+		* Fetched ON DEMAND, over the staging set only — the page never scans
+		* history, because making the working set small is the entire purpose of
+		* the mark. Each row carries how many frames the dataset already holds from
+		* the track and how many subjects were annotated on them, so
+		* `frameCount: 0` reads as "still to work" without a second call per track.
+		*
+		* `auth: 'admin'`, unlike the viewer-level mark itself: marking a track is
+		* curation you do while looking at it, but building the training set the
+		* fleet's models are fine-tuned on is not.
+		*/
+		listRetrainStaging: method(object({
+			/** Empty ⇒ every camera that has staging tracks. A LIST, not a single
+			*  `deviceId`, deliberately: `deviceId` would make this device-bound and
+			*  route it at one camera's owner, and "every camera" would stop being
+			*  expressible at all. */
+			deviceIds: array(number()).optional(),
+			limit: number().int().min(1).max(500).optional()
+		}), array(RetrainTrackSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* What a track can contribute, and what it already has.
+		*
+		* `candidates` are the track's whole, unannotated frames — index rows only,
+		* so this is cheap. `copies` are the frames already inside the dataset, and
+		* a candidate whose copy exists is marked `copied: true`: selecting it again
+		* is free and CANNOT fail, whatever became of the original.
+		*
+		* A crop, a thumbnail and `fullFrameBoxed` are never candidates. The last
+		* one matters most: it has the model's own rectangle burned into the pixels,
+		* and a detector trained on it learns to find a green line.
+		*/
+		listRetrainFrames: method(object({ trackId: string() }), RetrainFrameListSchema, {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* COPY-ON-SELECT — the write that makes `trained` safe to evict.
+		*
+		* Selecting a frame copies its bytes into retrain storage immediately: not
+		* a reference, not a lease. Once the copy exists the dataset no longer
+		* depends on the track's media, which is exactly what lets D81 hand a
+		* `trained` track back to retention.
+		*
+		* The order inside is load-bearing and is pinned by a test: an EXISTING
+		* copy is returned without touching the source, so an original that
+		* evaporated blocks the selection of THAT ORIGINAL and never the copy
+		* already taken. Every refusal comes back named — a dropped selection is
+		* never silent, on the wire or in the log.
+		*/
+		selectRetrainFrames: method(object({
+			deviceId: number(),
+			trackId: string(),
+			mediaIds: array(number().int()).min(1)
+		}), RetrainFrameSelectionSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Un-select a frame: its annotations go first, then the copy and its blob.
+		*  Deliberately destructive and deliberately explicit — it is the only way
+		*  a frame leaves the dataset before export. */
+		deselectRetrainFrame: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string()
+		}), object({
+			removed: boolean(),
+			removedAnnotations: number().int()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* The pixels of ONE copied frame, base64.
+		*
+		* Through the cap rather than a data plane because it is genuinely one
+		* frame at a time, on demand, at human speed — the shape D9/D18 permit
+		* (what they forbid is frames crossing a boundary at frame RATE). The
+		* annotation canvas needs the image and its exact dimensions in the same
+		* answer: a canvas that places a normalised box against a size it guessed
+		* draws every box in the wrong place.
+		*/
+		getRetrainFrameImage: method(object({ frameId: string() }), object({
+			base64: string(),
+			width: number().int(),
+			height: number().int()
+		}), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Ask the pipeline what it sees, as a PROPOSAL.
+		*
+		* Runs through `pipelineRunner.runStatelessStep` on the COPIED frame, and
+		* every box comes back as a draft with `source: 'assist'` plus the model and
+		* score that produced it. The operator confirms, edits, adds and deletes;
+		* nothing is stored until `saveRetrainAnnotations`.
+		*
+		* For packages the request is `rfdetr-package` on the ZONE CROP at 0.35 —
+		* never the whole frame, where a package detector at that threshold proposes
+		* furniture. A package request with no zone is REFUSED rather than widened,
+		* because the silent widening would look like a bad model for as long as
+		* nobody checked which rectangle it ran on.
+		*/
+		proposeRetrainAnnotations: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string(),
+			subject: RetrainAssistSubjectSchema,
+			/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
+			nodeId: string().optional()
+		}), RetrainAssistResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Every annotation on a track, oldest first. */
+		listRetrainAnnotations: method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
+		/**
+		* Replace EVERY annotation on one frame with the supplied set.
+		*
+		* Whole-frame replacement, not per-box upsert: the unit of ground truth is
+		* the frame, and "the operator deleted a box" must be the same durable
+		* outcome as "the operator never drew it". A per-box patch would let a frame
+		* keep a box the operator removed on a surface that only knew about the
+		* boxes it sent.
+		*
+		* Refuses a macro class typed into `label` or `subLabel` — the tiers are
+		* separate and the guard is at the WRITE, because a mixed taxonomy cannot
+		* be un-mixed by reading it.
+		*/
+		saveRetrainAnnotations: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string(),
+			annotations: array(RetrainAnnotationDraftSchema)
+		}), array(RetrainAnnotationSchema).readonly(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Finish with a track: `staging → trained`. **The only writer of that
+		* state** — D81 shipped the column with it deliberately unreachable.
+		*
+		* Refuses a track the dataset holds no copies from. `trained` un-pins the
+		* track's media, so completing without a copy is a delete order for material
+		* nothing ever extracted anything from; that refusal IS the safety argument
+		* of D81, expressed as a precondition.
+		*/
+		completeRetrainTrack: method(object({
+			deviceId: number(),
+			trackId: string()
+		}), RetrainTransitionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* The deliberate return: `trained → staging`, for the rare case.
+		*
+		* The generic `setTrackFlags` toggle refuses this in both directions by
+		* design (D81) — re-staging from a checkbox is how the same material gets
+		* annotated twice under two ground truths. Doing it here means the operator
+		* is looking at the annotations that already exist while they decide, and
+		* those annotations are LEFT ALONE: "put this back" must not be a
+		* destructive act wearing a navigational name.
+		*/
+		restageRetrainTrack: method(object({
+			deviceId: number(),
+			trackId: string()
+		}), RetrainTransitionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Where to download the ANNOTATED dataset.
+		*
+		* The sibling of `getTrainingExportUrl` and deliberately not the same
+		* archive: that one streams a marked track's stored media verbatim, this one
+		* streams the retrain COPIES plus an `annotations.json` carrying, for every
+		* subject, the canonical full-frame box AND the geometry derived for each
+		* model shape (letterboxed root / zone-cropped package / subject-cropped
+		* classifier). Derived at export, never stored — one box in, three shapes
+		* out, so two crops of the same subject can never end up in one feature
+		* space (D52).
+		*/
+		getRetrainExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
 			kind: "query",
 			auth: "admin"
 		}),
 		/**
-		* The staging worklist for one camera, or for every camera that has one.
+		* The media an EVENT owns.
 		*
-		* Fetched ON DEMAND, over the staging set only — the page never scans
-		* history, because making the working set small is the entire purpose of
-		* the mark. Each row carries how many frames the dataset already holds from
-		* the track and how many subjects were annotated on them, so
-		* `frameCount: 0` reads as "still to work" without a second call per track.
+		* `ownerType` is REQUIRED, and that is the whole correction (D482). An
+		* event is a row in ONE of three tables, and since D474 each numbers from
+		* 1 independently: `motion:101314` and `object:101314` both exist. This
+		* method took a bare `eventId` and the provider probed motion → object →
+		* audio, stopping at the first hit — so on the live hub, where object
+		* events own no media of their own and 299 883 of 300 559 media rows are
+		* motion-owned, EVERY object event resolved to its motion namesake. A
+		* track from 17:34 on camera 615 was served a snapshot from 22:35 eleven
+		* days earlier, silently.
 		*
-		* `auth: 'admin'`, unlike the viewer-level mark itself: marking a track is
-		* curation you do while looking at it, but building the training set the
-		* fleet's models are fine-tuned on is not.
+		* D476 had already disambiguated the KEY (`motion:` vs `object:`); this is
+		* the API catching up to it. Naming the table is not a "qualification" of
+		* the ambiguity — a listing BY OWNER has no address to make surrogate: the
+		* owner IS (table, id), and half of it is not a question.
 		*/
-		listRetrainStaging: method(object({
-			/** Empty ⇒ every camera that has staging tracks. A LIST, not a single
-			*  `deviceId`, deliberately: `deviceId` would make this device-bound and
-			*  route it at one camera's owner, and "every camera" would stop being
-			*  expressible at all. */
-			deviceIds: array(number()).optional(),
-			limit: number().int().min(1).max(500).optional()
-		}), array(RetrainTrackSchema).readonly(), {
-			kind: "query",
-			auth: "admin"
-		}),
+		getEventMedia: 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().int(),
+			kind: MediaFileKindEnum.optional(),
+			deviceId: number()
+		}), array(MediaFileSchema).readonly()),
+		/** All media rows owned by a track. `kinds` narrows to a kind subset so a
+		*  client can fetch the SMALL display variants on open and pull the
+		*  multi-MB native variants only on demand (mirrors `getEventMedia.kind`).
+		*  Absent ⇒ every kind (back-compat). */
+		getTrackMedia: method(object({
+			trackId: string(),
+			kinds: array(MediaFileKindEnum).optional(),
+			deviceId: number()
+		}), array(MediaFileSchema).readonly()),
 		/**
-		* What a track can contribute, and what it already has.
+		* What media a track HAS, without any of it.
 		*
-		* `candidates` are the track's whole, unannotated frames — index rows only,
-		* so this is cheap. `copies` are the frames already inside the dataset, and
-		* a candidate whose copy exists is marked `copied: true`: selecting it again
-		* is free and CANNOT fail, whatever became of the original.
+		* The detail view needs the shape of a track's media to build its strip —
+		* which kinds exist, in what order, at what size — and then wants each tile
+		* fetched as an image, not as base64 inside this response. Measured: the
+		* full `getTrackMedia` is 5.3-7.7 MB and blocks the view; this manifest is
+		* ~2 KB.
 		*
-		* A crop, a thumbnail and `fullFrameBoxed` are never candidates. The last
-		* one matters most: it has the model's own rectangle burned into the pixels,
-		* and a detector trained on it learns to find a green line.
+		* It also restores a fact a `kinds` filter destroys: filtering
+		* `getTrackMedia` drops whole ROWS, taking `kind` and `sizeBytes` with
+		* them, so a client that fetched only the small variants could no longer
+		* tell a full-resolution variant existed — and the affordance that opens it
+		* would silently disappear.
 		*/
-		listRetrainFrames: method(object({ trackId: string() }), RetrainFrameListSchema, {
-			kind: "query",
-			auth: "admin"
-		}),
+		listTrackMedia: method(object({
+			trackId: string(),
+			deviceId: number()
+		}), array(MediaFileInfoSchema).readonly()),
 		/**
-		* COPY-ON-SELECT — the write that makes `trained` safe to evict.
+		* What media an EVENT has, without any of it — the twin `getEventMedia`
+		* never had.
 		*
-		* Selecting a frame copies its bytes into retrain storage immediately: not
-		* a reference, not a lease. Once the copy exists the dataset no longer
-		* depends on the track's media, which is exactly what lets D81 hand a
-		* `trained` track back to retention.
+		* `listTrackMedia` above got this treatment because a track's media is
+		* 5-8 MB. An event's is worse per row, not better: an old-style event owns
+		* a `crop` AND a native-resolution `fullFrameBoxed`, and the track DETAIL
+		* modal — the one surface that legitimately shows the big kinds — unions
+		* both listings to build its filmstrip. It then renders every tile from
+		* the `event-media` plane by key and throws the bytes away. Measured on
+		* the live hub: one event's `fullFrameBoxed` is 2 824 077 B, base64'd to
+		* ~3.8 MB, allocated whole in hub-main's heap, for a list of keys.
 		*
-		* The order inside is load-bearing and is pinned by a test: an EXISTING
-		* copy is returned without touching the source, so an original that
-		* evaporated blocks the selection of THAT ORIGINAL and never the copy
-		* already taken. Every refusal comes back named — a dropped selection is
-		* never silent, on the wire or in the log.
+		* Same `deviceId` authorization subject as `getEventMedia`, the same
+		* REQUIRED `ownerType` (read that method's docblock for the night-time
+		* thumbnail this closes — D482), and the same rows: this is a projection
+		* of that method, never a different question.
 		*/
-		selectRetrainFrames: method(object({
+		listEventMedia: method(object({
+			ownerType: EventOwnerTypeSchema,
+			eventId: number().int(),
+			deviceId: number()
+		}), array(MediaFileInfoSchema).readonly()),
+		/**
+		* Which of `ownerIds` hold at least ONE media row — an INDEX read, never a
+		* blob read, and the LICENCE `videoclips` needs to publish a `thumbnail`.
+		*
+		* The event-media URL is stamped from a template for every event in the
+		* system, so "the plane is up" was being served as "there are bytes": 64 of
+		* one camera's 179 clips pointed at a 404 (device 3836, 2026-08-17). This
+		* is the question that turns the stamp into a claim.
+		*
+		* It is on the WIRE because the clip source is registered by the addon that
+		* owns the FOOTAGE, not by this one (D560) — the probe used to be an
+		* in-process `MediaStore` read. One call per OWNER KIND, never one per
+		* owner: that N+1 is what `MediaStore.ownersWithMedia` was written to
+		* prevent, and crossing a process boundary makes it worse, not better.
+		* `ownerIds` is bounded at the same 5 000 the annotation fetch is bounded
+		* at, so one pathological camera-day cannot mint an unbounded request.
+		*
+		* THROWS rather than answering partially. A probe that quietly
+		* under-reports reads as "these owners have nothing" and the caller drops
+		* thumbnails that exist — the opposite failure to the one above, and
+		* equally invisible.
+		*
+		* `deviceId` is the authorization subject, exactly as on `getEventMedia`.
+		*/
+		ownersWithMedia: method(object({
 			deviceId: number(),
-			trackId: string(),
-			mediaIds: array(number().int()).min(1)
-		}), RetrainFrameSelectionSchema, {
+			ownerKind: MediaPresenceOwnerKindSchema,
+			ownerIds: array(string()).max(5e3)
+		}), array(string()).readonly()),
+		/**
+		* Search object events by text query using CLIP cosine similarity.
+		* Encodes `text` via the `embedding-encoder` cap, queries the
+		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
+		* embeddings by cosine similarity, and joins winners to their
+		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
+		* `minScore`, sorted descending by score.
+		*/
+		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
+		wipeObjectEmbeddings: method(object({}), WipeObjectEmbeddingsResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Un-select a frame: its annotations go first, then the copy and its blob.
-		*  Deliberately destructive and deliberately explicit — it is the only way
-		*  a frame leaves the dataset before export. */
-		deselectRetrainFrame: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string()
-		}), object({
-			removed: boolean(),
-			removedAnnotations: number().int()
-		}), {
+		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		getObjectEmbeddingRebuildStatus: method(object({}), RebuildStatusSchema)
+	},
+	events: {
 		/**
-		* The pixels of ONE copied frame, base64.
-		*
-		* Through the cap rather than a data plane because it is genuinely one
-		* frame at a time, on demand, at human speed — the shape D9/D18 permit
-		* (what they forbid is frames crossing a boundary at frame RATE). The
-		* annotation canvas needs the image and its exact dimensions in the same
-		* answer: a canvas that places a normalised box against a size it guessed
-		* draws every box in the wrong place.
+		* Enriched frame emitted after refinement — the live-overlay source of
+		* truth (two-plane re-injection). Carries the frame's detections in the
+		* `ObjectDetection` wire shape: first-level roots (with track info +
+		* enrichment labels) plus synthesized `kind:'detail'` face/plate entries
+		* re-projected from per-track detail state, so stream overlays render
+		* boxes + recognized names without querying full Track state.
 		*/
-		getRetrainFrameImage: method(object({ frameId: string() }), object({
-			base64: string(),
-			width: number().int(),
-			height: number().int()
-		}), {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* Ask the pipeline what it sees, as a PROPOSAL.
-		*
-		* Runs through `pipelineRunner.runStatelessStep` on the COPIED frame, and
-		* every box comes back as a draft with `source: 'assist'` plus the model and
-		* score that produced it. The operator confirms, edits, adds and deletes;
-		* nothing is stored until `saveRetrainAnnotations`.
-		*
-		* For packages the request is `rfdetr-package` on the ZONE CROP at 0.35 —
-		* never the whole frame, where a package detector at that threshold proposes
-		* furniture. A package request with no zone is REFUSED rather than widened,
-		* because the silent widening would look like a bad model for as long as
-		* nobody checked which rectangle it ran on.
+		onFrameTracked: { data: object({
+			deviceId: number(),
+			timestamp: number(),
+			frameWidth: number(),
+			frameHeight: number(),
+			detections: array(OverlayDetectionSchema).readonly()
+		}) },
+		/** Track entered active state (first-seen). */
+		onTrackStarted: { data: object({
+			deviceId: number(),
+			trackId: string(),
+			className: string()
+		}) },
+		/** Track expired (TTL reached after last detection). */
+		onTrackEnded: { data: object({
+			deviceId: number(),
+			trackId: string(),
+			className: string(),
+			durationMs: number()
+		}) },
+		/** Canonical "something happened at device X" event, per-kind. */
+		onDetectionEvent: { data: object({
+			deviceId: number(),
+			kind: EventKindSchema,
+			eventId: string(),
+			timestamp: number()
+		}) }
+	}
+};
+/**
+* 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(),
+		y: number(),
+		w: number(),
+		h: number()
+	})
+});
+object({
+	crop: object({
+		left: number(),
+		top: number(),
+		width: number().positive(),
+		height: number().positive()
+	}).optional(),
+	content: object({
+		width: number().int().positive(),
+		height: number().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().int().positive(),
+	height: number().int().positive(),
+	format: _enum(["rgb", "gray"]),
+	timestamp: number(),
+	capturedAt: number().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(),
+	maxBatchSize: number(),
+	concurrency: number(),
+	numWorkers: number()
+});
+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()
+	})),
+	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(),
+	group: string().optional(),
+	configSchema: array(ConfigFieldBridge).readonly().optional()
+});
+var PipelineSlotSchemaSchema = object({
+	id: PipelineSlotSchema,
+	label: string(),
+	priority: number(),
+	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().optional(),
+	error: string().optional(),
+	nextRetryAt: number().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()
+});
+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(),
+	chunkDurationMs: number()
+});
+var DownloadModelResultSchema = object({
+	filePath: string(),
+	sizeMB: number(),
+	durationMs: number()
+});
+/**
+* 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();
+/**
+* Pipeline executor — detection engine + configuration + inference API.
+*
+* Merged from: pipeline-executor, pipeline-config, inference, detection-config.
+* Implemented by the detection-pipeline addon.
+*
+* Per-device surface (DeviceSettingsContribution + the "is detection
+* enabled for this camera?" toggle) lives on the paired
+* `detection-pipeline` cap (device-scoped, singleton, wrapper
+* defaultActive) — same split pattern used by stream-broker /
+* camera-streams and audio-analyzer / audio-analysis.
+*/
+var pipelineExecutorCapability = {
+	name: "pipeline-executor",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		getAvailableEngines: method(_void(), array(PipelineEngineChoiceSchema)),
+		getSelectedEngine: method(_void(), PipelineEngineChoiceSchema),
+		getDefaultSteps: method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)),
+		/**
+		* Per-node detection-engine provisioning snapshot. Returns the live
+		* state of the lazy runtime-provisioning machine on `nodeId`
+		* (idle / installing / verifying / ready / failed). The UI pairs this
+		* one-shot query with the `pipeline.engine-provisioning` live event
+		* (emitted on every transition) to drive a per-node "engine ready?"
+		* indicator without polling. Phase 2.
 		*/
-		proposeRetrainAnnotations: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string(),
-			subject: RetrainAssistSubjectSchema,
-			/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
-			nodeId: string().optional()
-		}), RetrainAssistResultSchema, {
+		getEngineProvisioning: method(object({ nodeId: string() }), EngineProvisioningSchema),
+		getVideoPipelineSteps: method(_void(), record(string(), object({
+			modelId: string(),
+			settings: record(string(), unknown()).readonly()
+		}))),
+		setVideoPipelineSteps: method(object({ steps: record(string(), object({
+			modelId: string(),
+			settings: record(string(), unknown()).readonly()
+		})) }), object({ success: literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
 		/**
-		* The FrameProcessor pass of a replay run — see the `Replay` section
-		* above this capability's definition for why this is not the
-		* `processFrame` method this file's header says pipeline-analytics does
-		* not have.
+		* Clear THIS node's executor-side PER-DEVICE settings stores (the
+		* per-camera step overrides the object-detection root reads via
+		* `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+		* generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+		* dispatches to that node, so the provider method runs ON the target
+		* node and receives no `nodeId`.
 		*
-		* Constructs a FRESH `FrameProcessor` for `(deviceId, source)`, feeds it
-		* `frames` IN THE ORDER GIVEN (the caller is responsible for time
-		* ordering — this method does not sort), and returns the tracks it
-		* produced. Zero persistence: no `TrackStore`, no event bus, no media
-		* capture. `zones` / `detectionRules` are the run's OWN zone set —
-		* typically the camera's real zones plus an ephemeral overlay
-		* (`addon-benchmark`'s `replay-plan.ts`), never read from or written to
-		* the `zones` capability by this method itself.
+		* This is the slimmed executor leg of the orchestrator's
+		* `resetNodePipelineDefaults` flow (which owns the real reset: node
+		* addonDefaults pins + per-camera orchestrator overrides). The legacy
+		* `resetToDefault` — which reset a persisted global step-tree seed
+		* nothing in the live per-camera path read — was removed together with
+		* that seed.
 		*/
-		runReplayFrameProcessor: method(object({
-			deviceId: number(),
-			source: DetectionSourceSchema,
-			zones: array(ZoneSchema).readonly().optional(),
-			detectionRules: array(ZoneRuleSchema).readonly().optional(),
-			zoneMembershipMinOverlap: number().min(0).max(1).optional(),
-			frames: array(ReplayFrameInputSchema).min(1)
-		}), RunReplayFrameProcessorResultSchema, {
+		clearDeviceOverrides: method(object({ nodeId: string() }), object({
+			success: literal(true),
+			clearedDevices: number()
+		}), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Every annotation on a track, oldest first. */
-		listRetrainAnnotations: method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
-			kind: "query",
-			auth: "admin"
-		}),
 		/**
-		* Replace EVERY annotation on one frame with the supplied set.
+		* Which of THIS node's inference devices the executor currently refuses,
+		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
 		*
-		* Whole-frame replacement, not per-box upsert: the unit of ground truth is
-		* the frame, and "the operator deleted a box" must be the same durable
-		* outcome as "the operator never drew it". A per-box patch would let a frame
-		* keep a box the operator removed on a surface that only knew about the
-		* boxes it sent.
+		* The channel that did not exist. Pool health was known only inside the
+		* detection addon and was an input to no routing decision anywhere: the
+		* per-dispatch capability gate is keyed on model FORMAT and so can never
+		* separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
+		* eligibility probe (`platformProbe.getCapabilities`) answers about
+		* HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
+		* Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
+		* balancer went on handing that dead pool cameras by rotation for 31 hours:
+		* ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
 		*
-		* Refuses a macro class typed into `label` or `subLabel` — the tiers are
-		* separate and the guard is at the WRITE, because a mixed taxonomy cannot
-		* be un-mixed by reading it.
+		* Read semantics the caller depends on, and which the provider guarantees:
+		* this is a synchronous read of in-memory state. It never probes hardware,
+		* never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
+		* nothing is refused", which is what re-admits a device. A read that FAILS
+		* (node offline, version skew) must therefore be distinguishable from an
+		* empty answer, and it is: it rejects.
 		*/
-		saveRetrainAnnotations: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string(),
-			annotations: array(RetrainAnnotationDraftSchema)
-		}), array(RetrainAnnotationSchema).readonly(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
+		getInferenceDeviceHealth: 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(),
+			/** Pool deaths inside the current window. */
+			deaths: number(),
+			/** The last death's message. */
+			lastError: string()
+		})).readonly() })),
 		/**
-		* Finish with a track: `staging → trained`. **The only writer of that
-		* state** — D81 shipped the column with it deliberately unreachable.
+		* Re-arm a terminally `failed` inference device on `nodeId`: forget its
+		* restart budget so the next dispatch builds a fresh pool.
 		*
-		* Refuses a track the dataset holds no copies from. `trained` un-pins the
-		* track's media, so completing without a copy is a delete order for material
-		* nothing ever extracted anything from; that refusal IS the safety argument
-		* of D81, expressed as a precondition.
+		* The terminal state is deliberate (the abort it bounds is deterministic —
+		* an automatic probation would just respawn Python forever, more slowly),
+		* and a terminal state an operator cannot leave is a silent fault. This is
+		* the way out. `rearmed:false` means there was nothing to forget.
 		*/
-		completeRetrainTrack: method(object({
-			deviceId: number(),
-			trackId: string()
-		}), RetrainTransitionResultSchema, {
+		rearmInferenceDevice: method(object({
+			nodeId: string(),
+			deviceKey: string()
+		}), object({ rearmed: boolean() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		getSchema: method(_void(), PipelineSchemaSchema),
+		getGlobalSteps: method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()),
+		getGlobalPipelineConfig: method(_void(), PipelineConfigBridge),
+		getOrchestratorConfigSchema: method(_void(), ConfigUISchemaBridge),
 		/**
-		* The deliberate return: `trained → staging`, for the rare case.
+		* Gate B (pre-init config-correctness gate). PURE COMPUTE against this
+		* node's `currentEngine.format` — resolves `steps` the same way the
+		* runtime dispatch path would, and reports what WOULD happen without
+		* touching any node-global state. Called by the orchestrator at attach
+		* time (`attachOn`), node-pinned to the TARGET node, so config problems
+		* surface BEFORE `pipelineRunner.attachCamera` rather than at the first
+		* per-frame resolve. `ok` is false iff `issues` is non-empty (both
+		* `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
+		* is informational (a degraded-but-loadable model swap) and never
+		* affects `ok`. Never throws.
 		*
-		* The generic `setTrackFlags` toggle refuses this in both directions by
-		* design (D81) — re-staging from a checkbox is how the same material gets
-		* annotated twice under two ground truths. Doing it here means the operator
-		* is looking at the annotations that already exist while they decide, and
-		* those annotations are LEFT ALONE: "put this back" must not be a
-		* destructive act wearing a navigational name.
+		* `deviceKey` validates against THAT device pool's format instead of the
+		* node default (D646) — the cheap question a pinned replay asks before it
+		* reads any media: can this (node, deviceKey) run exactly this model?
 		*/
-		restageRetrainTrack: method(object({
-			deviceId: number(),
-			trackId: string()
-		}), RetrainTransitionResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
+		validatePipeline: method(object({
+			steps: array(PipelineStepInputSchema),
+			deviceKey: string().optional()
+		}), PipelineValidationResultSchema),
+		listTemplates: method(_void(), array(PipelineTemplateSchema$1).readonly()),
+		saveTemplate: method(object({
+			name: string(),
+			steps: array(PipelineTemplateStepSchema).readonly(),
+			engine: PipelineEngineChoiceSchema
+		}), PipelineTemplateSchema$1, { kind: "mutation" }),
+		updateTemplate: method(object({
+			id: string(),
+			name: string().optional(),
+			steps: array(PipelineTemplateStepSchema).readonly().optional()
+		}), PipelineTemplateSchema$1, { kind: "mutation" }),
+		deleteTemplate: method(object({ id: string() }), _void(), { kind: "mutation" }),
+		getCapabilities: method(_void(), InferenceCapabilitiesBridge),
+		getAddonModels: method(object({ addonId: string() }), ModelAvailabilityListBridge),
+		downloadModel: method(object({
+			addonId: string(),
+			modelId: string(),
+			format: ModelFormatSchema$1
+		}), DownloadModelResultSchema, { kind: "mutation" }),
+		deleteModel: method(object({
+			addonId: string(),
+			modelId: string(),
+			format: ModelFormatSchema$1
+		}), object({ success: literal(true) }), { kind: "mutation" }),
 		/**
-		* Where to download the ANNOTATED dataset.
+		* Stateless single-frame execution. Callers (runner, benchmark) pass
+		* the complete `steps` tree; the executor holds no state about cameras
+		* or saved pipelines. WHICH pool answers is the node's own engine, or the
+		* `deviceKey` pool when one is named.
 		*
-		* The sibling of `getTrainingExportUrl` and deliberately not the same
-		* archive: that one streams a marked track's stored media verbatim, this one
-		* streams the retrain COPIES plus an `annotations.json` carrying, for every
-		* subject, the canonical full-frame box AND the geometry derived for each
-		* model shape (letterboxed root / zone-cropped package / subject-cropped
-		* classifier). Derived at export, never stored — one box in, three shapes
-		* out, so two crops of the same subject can never end up in one feature
-		* space (D52).
+		* There is no `engine` field (D646). It existed for the benchmark and was
+		* honoured by swapping the SHARED provider's engine, factory and executor
+		* for the duration of the call, on a node serving live cameras. A caller
+		* that still sends the key has it stripped here and changes nothing.
+		*
+		* Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
+		* `referenceImage` must be provided:
+		*  - `frame`: runtime dispatch path (runner → decoded broker frame).
+		*    Carries the raw buffer, dimensions, and format; the executor
+		*    uses it directly without base64 round-tripping.
+		*  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
+		*    decoded frame. Both runner and executor are hub-local processes
+		*    sharing `/dev/shm`, so the executor maps the named segment and
+		*    reads the pixels back zero-copy — eliminating the ~1.2MB
+		*    re-serialisation over UDS/MsgPack the `frame` path pays per call.
+		*    High-risk: the FrameRing is a latest-wins seqlock with no
+		*    refcount, so a recycled slot yields a null read; the executor
+		*    then degrades to an empty result and the runner ships pixels via
+		*    `frame` as the fallback (queue-depth gated on the runner side).
+		*  - `imageBase64`: one-shot test path (benchmark ImageTab).
+		*  - `referenceImage`: named file from the reference-image store.
 		*/
-		getRetrainExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
-			kind: "query",
-			auth: "admin"
-		}),
+		runPipeline: 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().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" }),
 		/**
-		* The media an EVENT owns.
-		*
-		* `ownerType` is REQUIRED, and that is the whole correction (D482). An
-		* event is a row in ONE of three tables, and since D474 each numbers from
-		* 1 independently: `motion:101314` and `object:101314` both exist. This
-		* method took a bare `eventId` and the provider probed motion → object →
-		* audio, stopping at the first hit — so on the live hub, where object
-		* events own no media of their own and 299 883 of 300 559 media rows are
-		* motion-owned, EVERY object event resolved to its motion namesake. A
-		* track from 17:34 on camera 615 was served a snapshot from 22:35 eleven
-		* days earlier, silently.
+		* Batched run — N raw frames packed into one cap call. The provider
+		* routes the batch through `SharedInferencePool.inferBatch`
+		* (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
+		* envelope cost is amortised N:1 vs N concurrent `runPipeline`
+		* calls. Single root step + uniform model assumed; trees with crop
+		* children fall back to sequential execution.
 		*
-		* D476 had already disambiguated the KEY (`motion:` vs `object:`); this is
-		* the API catching up to it. Naming the table is not a "qualification" of
-		* the ambiguity — a listing BY OWNER has no address to make surrogate: the
-		* owner IS (table, id), and half of it is not a question.
+		* Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+		* N frames in one call to amortise per-call IPC overhead.
 		*/
-		getEventMedia: 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().int(),
-			kind: MediaFileKindEnum.optional(),
-			deviceId: number()
-		}), array(MediaFileSchema).readonly()),
-		/** All media rows owned by a track. `kinds` narrows to a kind subset so a
-		*  client can fetch the SMALL display variants on open and pull the
-		*  multi-MB native variants only on demand (mirrors `getEventMedia.kind`).
-		*  Absent ⇒ every kind (back-compat). */
-		getTrackMedia: method(object({
-			trackId: string(),
-			kinds: array(MediaFileKindEnum).optional(),
-			deviceId: number()
-		}), array(MediaFileSchema).readonly()),
+		runPipelineBatch: method(object({
+			steps: array(PipelineStepInputSchema).min(1),
+			frames: array(FrameInputSchema).min(1).max(255),
+			deviceId: number().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().int().nonnegative().optional(),
+			/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+			deviceKey: string().optional()
+		}), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
 		/**
-		* What media a track HAS, without any of it.
-		*
-		* The detail view needs the shape of a track's media to build its strip —
-		* which kinds exist, in what order, at what size — and then wants each tile
-		* fetched as an image, not as base64 inside this response. Measured: the
-		* full `getTrackMedia` is 5.3-7.7 MB and blocks the view; this manifest is
-		* ~2 KB.
-		*
-		* It also restores a fact a `kinds` filter destroys: filtering
-		* `getTrackMedia` drops whole ROWS, taking `kind` and `sizeBytes` with
-		* them, so a client that fetched only the small variants could no longer
-		* tell a full-resolution variant existed — and the affordance that opens it
-		* would silently disappear.
+		* Cache a raw frame inside the Python inference pool's memory.
+		* Returns a numeric `frameId` that `inferCached` references —
+		* subsequent calls send only 5 bytes through the pipe instead of
+		* 1.2MB raw data, eliminating the pipe transfer bottleneck.
 		*/
-		listTrackMedia: method(object({
-			trackId: string(),
-			deviceId: number()
-		}), array(MediaFileInfoSchema).readonly()),
+		cacheFrameInPool: method(object({
+			data: _instanceof(Uint8Array),
+			width: number().int().positive(),
+			height: number().int().positive(),
+			format: _enum([
+				"rgb",
+				"bgr",
+				"gray"
+			])
+		}), object({
+			frameId: number(),
+			width: number(),
+			height: number()
+		}), { kind: "mutation" }),
 		/**
-		* What media an EVENT has, without any of it — the twin `getEventMedia`
-		* never had.
-		*
-		* `listTrackMedia` above got this treatment because a track's media is
-		* 5-8 MB. An event's is worse per row, not better: an old-style event owns
-		* a `crop` AND a native-resolution `fullFrameBoxed`, and the track DETAIL
-		* modal — the one surface that legitimately shows the big kinds — unions
-		* both listings to build its filmstrip. It then renders every tile from
-		* the `event-media` plane by key and throws the bytes away. Measured on
-		* the live hub: one event's `fullFrameBoxed` is 2 824 077 B, base64'd to
-		* ~3.8 MB, allocated whole in hub-main's heap, for a list of keys.
-		*
-		* Same `deviceId` authorization subject as `getEventMedia`, the same
-		* REQUIRED `ownerType` (read that method's docblock for the night-time
-		* thumbnail this closes — D482), and the same rows: this is a projection
-		* of that method, never a different question.
+		* Run inference on a previously cached frame. Sends only 5 bytes
+		* (model_idx + frameId) through the IPC pipe — eliminates the
+		* ~35ms per-call overhead of transferring 1.2MB raw data.
 		*/
-		listEventMedia: method(object({
-			ownerType: EventOwnerTypeSchema,
-			eventId: number().int(),
-			deviceId: number()
-		}), array(MediaFileInfoSchema).readonly()),
+		inferCached: method(object({
+			stepId: string(),
+			frameId: number().int()
+		}), record(string(), unknown()), { kind: "mutation" }),
 		/**
-		* Which of `ownerIds` hold at least ONE media row — an INDEX read, never a
-		* blob read, and the LICENCE `videoclips` needs to publish a `thumbnail`.
-		*
-		* The event-media URL is stamped from a template for every event in the
-		* system, so "the plane is up" was being served as "there are bytes": 64 of
-		* one camera's 179 clips pointed at a 404 (device 3836, 2026-08-17). This
-		* is the question that turns the stamp into a claim.
-		*
-		* It is on the WIRE because the clip source is registered by the addon that
-		* owns the FOOTAGE, not by this one (D560) — the probe used to be an
-		* in-process `MediaStore` read. One call per OWNER KIND, never one per
-		* owner: that N+1 is what `MediaStore.ownersWithMedia` was written to
-		* prevent, and crossing a process boundary makes it worse, not better.
-		* `ownerIds` is bounded at the same 5 000 the annotation fetch is bounded
-		* at, so one pathological camera-day cannot mint an unbounded request.
-		*
-		* THROWS rather than answering partially. A probe that quietly
-		* under-reports reads as "these owners have nothing" and the caller drops
-		* thumbnails that exist — the opposite failure to the one above, and
-		* equally invisible.
-		*
-		* `deviceId` is the authorization subject, exactly as on `getEventMedia`.
+		* Release a cached frame from the Python pool's memory.
 		*/
-		ownersWithMedia: method(object({
-			deviceId: number(),
-			ownerKind: MediaPresenceOwnerKindSchema,
-			ownerIds: array(string()).max(5e3)
-		}), array(string()).readonly()),
+		uncacheFrame: method(object({ frameId: number().int() }), _void(), { kind: "mutation" }),
 		/**
-		* Search object events by text query using CLIP cosine similarity.
-		* Encodes `text` via the `embedding-encoder` cap, queries the
-		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
-		* embeddings by cosine similarity, and joins winners to their
-		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
-		* `minScore`, sorted descending by score.
+		* The effective provisioning of ONE pool of this node (operator override →
+		* the pool's own runtime row). `deviceKey` names the device pool; absent is
+		* the node-default pool. It answered only for the node default until
+		* D646, so a benchmark on `openvino:npu` recorded the onnx pool's tuning
+		* beside an NPU measurement.
 		*/
-		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
-		wipeObjectEmbeddings: method(object({}), WipeObjectEmbeddingsResultSchema, {
+		getEffectiveTuning: method(object({ deviceKey: string().optional() }), EffectiveTuningSchema),
+		/**
+		* List every EngineFactory currently loaded in this executor's RAM,
+		* with the models resident and a coarse "in use" marker derived from
+		* ongoing inference activity. Used by the Pipeline page Engines tab.
+		*/
+		listLoadedEngines: method(_void(), array(object({
+			engineKey: string(),
+			engine: PipelineEngineChoiceSchema,
+			modelsLoaded: array(string()).readonly(),
+			inUseByCameras: array(number()).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().nullable(),
+			/** ms since this factory was last used (null when not warm-tracked). */
+			idleMs: number().nullable(),
+			/** Idle TTL after which the factory self-evicts (null when not applicable). */
+			idleTtlMs: number().nullable()
+		})).readonly()),
+		/** Warm up an engine without running a frame. No-op if already loaded. */
+		spinEngine: method(object({ engine: PipelineEngineChoiceSchema }), object({ success: literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+		/**
+		* Unload an engine from RAM. `force:true` unloads even when cameras
+		* are actively using it (they re-spin on next frame). Default is
+		* gated — returns `{success:false, reason}` when in use.
+		*/
+		killEngine: method(object({
+			engine: PipelineEngineChoiceSchema,
+			force: boolean().optional()
+		}), object({
+			success: boolean(),
+			reason: string().optional()
+		}), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		getObjectEmbeddingRebuildStatus: method(object({}), RebuildStatusSchema)
-	},
-	events: {
-		/**
-		* Enriched frame emitted after refinement — the live-overlay source of
-		* truth (two-plane re-injection). Carries the frame's detections in the
-		* `ObjectDetection` wire shape: first-level roots (with track info +
-		* enrichment labels) plus synthesized `kind:'detail'` face/plate entries
-		* re-projected from per-track detail state, so stream overlays render
-		* boxes + recognized names without querying full Track state.
-		*/
-		onFrameTracked: { data: object({
-			deviceId: number(),
-			timestamp: number(),
-			frameWidth: number(),
-			frameHeight: number(),
-			detections: array(OverlayDetectionSchema).readonly()
-		}) },
-		/** Track entered active state (first-seen). */
-		onTrackStarted: { data: object({
-			deviceId: number(),
-			trackId: string(),
-			className: string()
-		}) },
-		/** Track expired (TTL reached after last detection). */
-		onTrackEnded: { data: object({
-			deviceId: number(),
-			trackId: string(),
-			className: string(),
-			durationMs: number()
-		}) },
-		/** Canonical "something happened at device X" event, per-kind. */
-		onDetectionEvent: { data: object({
-			deviceId: number(),
-			kind: EventKindSchema,
-			eventId: string(),
-			timestamp: number()
-		}) }
+		listReferenceImages: method(_void(), array(ReferenceImageEntrySchema).readonly()),
+		getReferenceImage: method(object({ filename: string() }), ReferenceImageBodySchema.nullable()),
+		getReferenceAudioFiles: method(_void(), array(ReferenceAudioEntrySchema).readonly()),
+		getReferenceAudio: method(object({ filename: string() }), ReferenceAudioBodySchema.nullable()),
+		getAudioCapabilities: method(_void(), AudioCapabilitiesSchema),
+		runAudioTest: method(object({
+			addonId: string(),
+			modelId: string(),
+			filename: string().optional(),
+			settings: record(string(), unknown()).optional()
+		}), AudioTestResultSchema, { kind: "mutation" }),
+		getDetectionConfigSchema: method(_void(), ConfigUISchemaNullableBridge)
 	}
 };
 object({
@@ -25564,6 +25629,106 @@ var CameraMetricsSchema = object({
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: number() });
 /**
+* 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(),
+	y: number()
+});
+/** 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")
+});
+/**
+* Zones capability — per-camera CRUD over polygon detection zones.
+*
+* Provider lives in `addon-pipeline-orchestrator` (hub-only). Persists
+* to per-device settings and mirrors into the `zones` device-state
+* slice on every mutation, so downstream consumers can subscribe via
+* `dev.state.zones.onChanged`.
+*
+* The cap surface only handles geometry + identity; filtering
+* behaviour (per-class, include/exclude, threshold) lives in the
+* consumer addons' rule arrays — see `ZoneRuleSchema` exported from
+* `capabilities/schemas/zone-rule.js`.
+*/
+var zonesCapability = {
+	name: "zones",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	methods: {
+		listZones: method(object({ deviceId: number() }), array(ZoneSchema).readonly()),
+		addZone: method(object({
+			deviceId: number(),
+			zone: ZoneSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		removeZone: method(object({
+			deviceId: number(),
+			zoneId: string()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		updateZone: method(object({
+			deviceId: number(),
+			zone: ZoneSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	/**
+	* Runtime-state slice — the live zone catalogue mirrored by the
+	* orchestrator on every CRUD mutation. Consumers read via
+	* `device.state.zones.value` / `.watch(...)` without round-tripping
+	* the cap, and the codegen DeviceProxy auto-wires the reactive
+	* handle. Slice shape is `{ zones: Zone[] }` so future extensions
+	* (e.g. zone groupings) can sit alongside the polygon list.
+	*/
+	runtimeState: object({ zones: array(ZoneSchema).readonly() }),
+	/**
+	* Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored"
+};
+/**
 * 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
@@ -25750,7 +25915,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().optional()
+	nativeFaceShortSidePx: number().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(),
+		y: number()
+	})).optional()
 });
 /**
 * Why an executing node REFUSED a stateless step run (`runStatelessStep`).
@@ -27658,7 +27833,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).
@@ -32890,12 +33069,20 @@ reset: method(object({
 	},
 	runtimeState: ConsumablesStatusSchema.extend({ lastFetchedAt: number() }),
 	/**
-	* Runtime-state durability: **session** — the authority is the appliance; the provider re-reads the whole item array on connect.
+	* Runtime-state durability: **restored** — nothing else holds the value
+	* (D642). A consumable can often be read only in a device's wake window (the
+	* Dreame mower's CMS counters answer only while it charges), so a restart
+	* that wiped the slice left the panel empty and the alerts blind until the
+	* next wake — 2026-09-26, mower 503 idle with `items: []`. A restored item is
+	* the previous observation, not a claim about now; the provider overwrites it
+	* the moment it reads the device again.
 	*
 	* See `RuntimeStateDurability`. Enforced by
 	* `scripts/check-runtime-state-durability.ts`.
 	*/
-	durability: "session"
+	durability: "restored",
+	/** Clocks, not content: a re-read that changed no item costs no commit. */
+	volatileStateFields: ["lastChangedAt", "lastFetchedAt"]
 };
 /**
 * Door / window / opening / garage / valve contact sensor. Boolean
@@ -37768,7 +37955,7 @@ var HardwareInfoSchema = object({
 	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = object({
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: _enum([
 		"onnx",
@@ -37805,7 +37992,7 @@ var ModelRequirementSchema = object({
 });
 var ResolvedInferenceConfigSchema = object({
 	modelId: string(),
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: ModelFormatSchema,
 	reason: string()
@@ -40812,6 +40999,92 @@ var sceneMonitorCapability = {
 	durability: "session"
 };
 /**
+* 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().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().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();
+/**
 * Script-runner cap. Models HA `script.*` entities on
 * `DeviceType.Script`. A Script is a pre-recorded action sequence
 * that can be invoked imperatively — optionally with a variables
@@ -43019,6 +43292,42 @@ function readDeviceStateFrom(runtimeState) {
 	}
 }
 /**
+* LA tabella "quale booleano di questo tipo di device conta come ALTO", e il
+* valutatore puro del suo FRONTE.
+*
+* Viveva dentro il builtin virtual-doorbell
+* (`@camstack/system` — `builtins/doorbell/trigger-engine.ts`) e i suoi
+* predicati erano privati al modulo. Il recorder ne ha bisogno per il trigger
+* `RecordingTriggers.sensorDeviceIds`: copiarla avrebbe creato la SECONDA
+* tabella, che diverge alla prima cap aggiunta e il cui sintomo — "il sensore
+* fa suonare il campanello ma non registra" — è esattamente D62. Quindi si
+* SPOSTA qui e il doorbell la ri-esporta.
+*
+* ⚠ NON è `DEVICE_STATE_READERS` (`catalogs/device-state-vocabulary.ts`), e le
+* due non vanno unificate: quella risponde a "qual è la PAROLA di stato per una
+* regola" (e include `presence`, `cover`, `alarm-panel`), questa a "qual è il
+* booleano il cui FRONTE conta". Vocabolari deliberatamente diversi.
+*/
+/**
+* Known binary / switch source caps → the boolean slice field whose
+* false→true rise counts as ACTIVE. Every entry is "fire on active".
+* Sensors whose "active" reading is not a plain boolean (presence's string
+* state, connectivity's connected flag) are deliberately excluded — a
+* reconnect is not a doorbell press, and it is not a recording either.
+*/
+var SOURCE_CAP_ACTIVE_FIELD = {
+	contact: "entryOpen",
+	binary: "on",
+	switch: "on",
+	motion: "detected",
+	flood: "flooded",
+	gas: "detected",
+	smoke: "detected",
+	"carbon-monoxide": "detected",
+	vibration: "detected",
+	tamper: "tampered"
+};
+/**
 * Accessory device helpers — shared across drivers.
 *
 * Many vendor-specific drivers register accessory child devices on
@@ -48095,6 +48404,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",
@@ -48119,6 +48434,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",
@@ -48695,12 +49016,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",
@@ -52798,11 +53113,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"pipelineAnalytics.runReplayFrameProcessor": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineAnalytics.saveRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",
@@ -53691,12 +54001,55 @@ var NC_AUDIO_DEFAULTS = {
 	samplingSeconds: 10
 };
 new Set(["devices", "classes"]);
-/** Every filter, for the callers that must cover all four (guards, tests). */
+/**
+* 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"
+	"packageNames",
+	"consumableLowPercent"
 ];
 new Map(Object.entries({
 	"device-online": "device-events",
@@ -53707,6 +54060,9 @@ new Map(Object.entries({
 	"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",
@@ -53736,6 +54092,98 @@ new Map(Object.entries({
 	"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;
 var WEEKDAY_TO_DAY = {
 	Sun: 0,
@@ -53746,18 +54194,38 @@ var WEEKDAY_TO_DAY = {
 	Fri: 5,
 	Sat: 6
 };
-/** Resolve (weekday, minute-of-day) of `atMs` in the schedule's timezone.
-*  An invalid/unknown IANA name falls back to the host timezone. */
-function localDayMinute(atMs, timezone) {
-	const d = new Date(atMs);
-	if (timezone !== void 0) try {
-		const parts = new Intl.DateTimeFormat("en-US", {
+/**
+* One formatter per timezone, built once (D647 review I4). Constructing an
+* `Intl.DateTimeFormat` is the expensive part of this function, and a caller
+* that asks about many instants — a window scan — used to build one per
+* instant. `null` = an invalid IANA name (the host timezone is used).
+*/
+var FORMATTERS = /* @__PURE__ */ new Map();
+function formatterFor(timezone) {
+	const held = FORMATTERS.get(timezone);
+	if (held !== void 0) return held;
+	let made;
+	try {
+		made = new Intl.DateTimeFormat("en-US", {
 			timeZone: timezone,
 			weekday: "short",
 			hour: "numeric",
 			minute: "numeric",
 			hourCycle: "h23"
-		}).formatToParts(d);
+		});
+	} catch {
+		made = null;
+	}
+	FORMATTERS.set(timezone, made);
+	return made;
+}
+/** Resolve (weekday, minute-of-day) of `atMs` in the schedule's timezone.
+*  An invalid/unknown IANA name falls back to the host timezone. */
+function localDayMinute(atMs, timezone) {
+	const d = new Date(atMs);
+	const formatter = timezone !== void 0 ? formatterFor(timezone) : null;
+	if (formatter !== null) try {
+		const parts = formatter.formatToParts(d);
 		let weekday;
 		let hour;
 		let minute;
@@ -53797,10 +54265,48 @@ function isScheduleActive(schedule, atMs) {
 	}
 	return schedule.invert === true ? !inside : inside;
 }
+/**
+* WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
+* persists (D640 "a sensor rule fires on the raise, the clear, or both").
+*
+* A device-event rule over a flood sensor notified on BOTH edges: water
+* detected, and back to dry. `NcConditions.sensorTransition` lets the rule
+* name one edge; this file answers, for one `SensorEvent`, which edge it is.
+*
+* NOT A SECOND TABLE. The "which boolean of this cap counts as HIGH" question
+* already has one answer, `SOURCE_CAP_ACTIVE_FIELD`
+* (`catalogs/sensor-active-state.ts`, the doorbell's and the recorder's edge
+* table), and a sensor event names its kind, not its cap. So the table here is
+* DERIVED: event kind → cap (`EVENT_KIND_BY_CAP`) → that cap's active field.
+* Only kinds whose taxonomy category is `sensor` take part — a switch has an
+* `on` boolean too, but "it triggers / it clears" is not a sentence about a
+* light, and offering it there would be a knob with a misleading label.
+* `presence` is a WORD (`home` / `not_home` / a zone), not a boolean, and is
+* absent from the source table, so it is absent here.
+*
+* `undefined` = never guessed: a kind with no raise (a doorbell press, a
+* button, a cover), or a slice whose field is missing or not a boolean. The
+* engine then does NOT filter — a flood alert must not go silent because one
+* read came back unreadable (the same stance as the alarm's `sensorEdgeOf`).
+*
+* Pure, RN-safe: the viewer imports the support rule from here.
+*/
+/** Event kind → the boolean field of its cap slice that means "raised". */
+var NC_SENSOR_RAISED_FIELD_BY_KIND = Object.freeze(Object.fromEntries(Object.entries(EVENT_KIND_BY_CAP).flatMap(([capName, descriptor]) => {
+	const field = SOURCE_CAP_ACTIVE_FIELD[capName];
+	if (field === void 0 || descriptor.category !== "sensor") return [];
+	return [[descriptor.kind, field]];
+})));
+Object.freeze(Object.keys(NC_SENSOR_RAISED_FIELD_BY_KIND));
 var RULE_BODY_ONLY = ["body"];
 var RULE_TEXT = ["title", "body"];
 var BATTERY = ["device-battery-low", "device-battery-normal"];
 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",
@@ -53826,12 +54332,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.
 *