@camstack/addon-pipeline 1.2.293 → 1.2.295

package/dist/{dist-C0Fr4hM5.mjs → dist-CuxSNLKW.mjs}

@@ -5360,7 +5360,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DU7mu4wb.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).
@@ -11327,7 +11327,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).
@@ -19852,6 +19852,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.
@@ -19918,6 +19941,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({
 	/**
@@ -20653,6 +20695,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()`. */
@@ -20881,6 +20933,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([
@@ -20972,6 +21046,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")
@@ -20984,7 +21065,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(),
@@ -21518,6 +21601,10 @@ method(object({}), object({ rules: array(NcRuleSchema) }), { auth: "admin" }), m
 }), object({ results: array(NcTestResultSchema) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({ rule: NcRuleInputSchema }), NcStateSummaryPreviewSchema, {
+	kind: "mutation",
+	auth: "admin",
+	access: "view"
 }), method(object({}), object({
 	catalog: array(NcConditionDescriptorSchema),
 	taxonomy: NcTaxonomySchema.optional()
@@ -21864,790 +21951,6 @@ var OauthIntegrationDescriptorSchema = object({
 });
 method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" });
 /**
-* Reference to the frame's retained NATIVE surface + the parent crop's placement
-* within the frame, so the executor can re-cut a leaf child ROI at native
-* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
-*/
-var NativeCropRefSchema = object({
-	/** Handle keying the retained native surface (node-pinned to its owner). */
-	handle: FrameHandleSchema,
-	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
-	cropFrameSpace: object({
-		x: number(),
-		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: _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,
-	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()
-});
-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.
-		*/
-		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")
-});
-DeviceType.Camera, method(object({ deviceId: number() }), array(ZoneSchema).readonly()), method(object({
-	deviceId: number(),
-	zone: ZoneSchema
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number(),
-	zoneId: string()
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	deviceId: number(),
-	zone: ZoneSchema
-}), _void(), {
-	kind: "mutation",
-	auth: "admin"
-}), object({ zones: array(ZoneSchema).readonly() });
-/**
 * pipeline-analytics — device-scoped wrapper cap. Refines raw
 * per-frame detections emitted by the pipeline runner into tracked
 * objects, per-kind event collections (motion / object / audio), and
@@ -23218,6 +22521,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
 });
@@ -24224,24 +23543,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`
@@ -24472,16 +23773,6 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 }), RetrainAssistResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), 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, {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
 	kind: "query",
 	auth: "admin"
@@ -24557,6 +23848,674 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	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.
+		*/
+		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.
+		*
+		* `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?
+		*/
+		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" }),
+		/**
+		* 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.
+		*
+		* 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.
+		*/
+		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" }),
+		/**
+		* 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({
+			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" }),
+		/**
+		* 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.
+		*/
+		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"
+		}),
+		/**
+		* 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)
+	}
+};
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -24582,6 +24541,66 @@ 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")
+});
+DeviceType.Camera, method(object({ deviceId: number() }), array(ZoneSchema).readonly()), method(object({
+	deviceId: number(),
+	zone: ZoneSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	zoneId: string()
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	zone: ZoneSchema
+}), _void(), {
+	kind: "mutation",
+	auth: "admin"
+}), object({ zones: array(ZoneSchema).readonly() });
+/**
 * A bounding box in NORMALIZED [0,1] frame coordinates for `getNativeCrop`. The
 * decode worker resolves it against the RETAINED native frame's real pixel dims,
 * so the caller supplies only the detection-res bbox divided by the detection
@@ -24768,7 +24787,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`).
@@ -33770,7 +33799,7 @@ var HardwareInfoSchema = object({
 	coral: CoralInfoSchema.nullable().optional()
 });
 var PlatformScoreSchema = object({
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: _enum([
 		"onnx",
@@ -33807,7 +33836,7 @@ var ModelRequirementSchema = object({
 });
 var ResolvedInferenceConfigSchema = object({
 	modelId: string(),
-	runtime: _enum(["node", "python"]),
+	runtime: literal("python"),
 	backend: string(),
 	format: ModelFormatSchema,
 	reason: string()
@@ -36534,6 +36563,92 @@ DeviceType.Camera, method(object({ deviceId: number() }), SceneMonitorStatusSche
 	kind: "mutation",
 	auth: "admin"
 });
+/**
+* Per-stage gating mode applied to the zones a rule references.
+*
+* - `include`: the rule contributes to a **whitelist** for its stage.
+*   When at least one `include` rule fires for a stage, only entities
+*   inside one of those zones pass that stage.
+* - `exclude`: the rule contributes to a **blacklist** for its stage.
+*   Entities inside one of those zones are dropped at that stage.
+*
+* `monitor`-style observation (count without filtering) is not a rule
+* mode — zones without any matching rule are observed naturally by
+* `zone-analytics` (live snapshot + history), so an "I just want to
+* count, not filter" use case needs no rule at all.
+*/
+var ZoneRuleModeEnum = _enum(["include", "exclude"]);
+/**
+* Per-consumer rule that references existing zones (geometry) and
+* defines how a specific pipeline stage should treat them. Each
+* consumer addon owns its own `ZoneRule[]` array in its per-device
+* settings:
+*
+* - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
+* - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
+* - future: notification rules, audio gating, etc.
+*
+* One rule applies to N zones (`zoneIds[]`) so the operator can
+* express "ignore motion in ALL of {garden, street}" with a single
+* rule. `classFilter` narrows the rule to specific object classes —
+* "drop person detections in the street, but keep cars" is one
+* `exclude` rule with `classFilter: ['person']`.
+*
+* `enabled` is a soft toggle — the operator can keep the rule
+* configured but inert without deleting it.
+*/
+var ZoneRuleSchema = object({
+	/** Stable rule id — survives edits, used by the UI for diffing. */
+	id: string(),
+	/** Optional human-readable label rendered in the rule editor. */
+	name: string().optional(),
+	/** Zones this rule targets. The rule's `mode` applies to ALL
+	*  listed zones (OR-set: a detection in any one of them counts).
+	*  At least one zone id required — a rule with no targets is a
+	*  configuration mistake and the form validator rejects it. */
+	zoneIds: array(string()).min(1).readonly(),
+	mode: ZoneRuleModeEnum,
+	/**
+	* Class names this rule applies to. Empty / undefined ⇒ rule
+	* applies to every class. Class strings match the `macroClass`
+	* field on detections (e.g. `person`, `car`, `dog`).
+	*/
+	classFilter: array(string()).readonly().optional(),
+	/**
+	* Minimum bbox/mask overlap (0–1) with any of the rule's zones
+	* required to consider an entity "in the zone". Defaults to the
+	* consumer's stage default when omitted. Kept for back-compat with
+	* existing per-rule overrides; new operators pick the value via
+	* `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
+	* set, the lower-level engine reads it as a 0–1 fraction.
+	*/
+	overlapThreshold: number().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();
 object({
 	/** Whether the script is currently executing. */
 	isRunning: boolean(),
@@ -43009,6 +43124,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",
@@ -43585,12 +43706,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",
@@ -47688,11 +47803,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"pipelineAnalytics.runReplayFrameProcessor": [{
-		name: "deviceId",
-		form: "single",
-		optional: false
-	}],
 	"pipelineAnalytics.saveRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",
@@ -48722,6 +48832,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;
 /**
 * WHICH WAY A BOOLEAN SENSOR MOVED — read off the one slice a sensor event
@@ -48796,7 +48998,183 @@ var DEVICE_EVENTS = [
 	"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], [...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];
+/** 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.
 *
@@ -49622,6 +50000,110 @@ function pickNativeLeaseOverride(view) {
 	}
 	return readNativeLeaseOverride(flat);
 }
+function snapshot(run) {
+	return {
+		runId: run.runId,
+		state: run.state,
+		startedAtMs: run.startedAtMs,
+		finishedAtMs: run.finishedAtMs,
+		progress: run.progress,
+		result: run.result,
+		error: run.error
+	};
+}
+var BackgroundRunRegistry = class {
+	opts;
+	runs = /* @__PURE__ */ new Map();
+	now;
+	constructor(opts) {
+		this.opts = opts;
+		this.now = opts.now ?? Date.now;
+	}
+	/** Runs still going. */
+	get runningCount() {
+		let n = 0;
+		for (const run of this.runs.values()) if (run.state === "running") n += 1;
+		return n;
+	}
+	/**
+	* Register and start `work`. Returns the `running` receipt immediately.
+	* Throws only for a refusal the caller must see (duplicate id, busy) — a
+	* failure of the work itself lands in `status`, never here.
+	*/
+	start(runId, work) {
+		const existing = this.runs.get(runId);
+		if (existing !== void 0 && existing.state === "running") throw new Error(`run '${runId}' is already running`);
+		if (this.runningCount >= this.opts.maxConcurrent) throw new Error(`busy: ${this.runningCount}/${this.opts.maxConcurrent} run(s) already in progress — wait for one to finish or abort it`);
+		const run = {
+			runId,
+			state: "running",
+			startedAtMs: this.now(),
+			finishedAtMs: null,
+			progress: null,
+			result: null,
+			error: null,
+			controller: new AbortController()
+		};
+		this.runs.delete(runId);
+		this.runs.set(runId, run);
+		const ctx = {
+			signal: run.controller.signal,
+			report: (progress) => {
+				run.progress = progress;
+			}
+		};
+		const settle = (patch) => {
+			if (patch.error !== void 0) {
+				run.state = "failed";
+				run.error = patch.error;
+			} else {
+				run.state = run.controller.signal.aborted ? "aborted" : "done";
+				run.result = patch.result ?? null;
+			}
+			run.finishedAtMs = this.now();
+			this.prune();
+			this.opts.onSettled?.(snapshot(run));
+		};
+		let pending;
+		try {
+			pending = work(ctx);
+		} catch (err) {
+			pending = Promise.reject(err);
+		}
+		pending.then((result) => settle({ result }), (err) => settle({ error: err instanceof Error ? err.message : String(err) }));
+		return snapshot(run);
+	}
+	status(runId) {
+		const run = this.runs.get(runId);
+		return run === void 0 ? null : snapshot(run);
+	}
+	/** Running runs first (newest start first), then finished ones (newest finish first). */
+	list() {
+		const all = [...this.runs.values()];
+		const running = all.filter((r) => r.state === "running").toSorted((a, b) => b.startedAtMs - a.startedAtMs);
+		const finished = all.filter((r) => r.state !== "running").toSorted((a, b) => (b.finishedAtMs ?? 0) - (a.finishedAtMs ?? 0));
+		return [...running, ...finished].map(snapshot);
+	}
+	/** Signal a running run to stop. `false` for an unknown or already finished run. */
+	abort(runId) {
+		const run = this.runs.get(runId);
+		if (run === void 0 || run.state !== "running") return false;
+		run.controller.abort();
+		return true;
+	}
+	/** Abort every running run (shutdown). */
+	abortAll() {
+		for (const run of this.runs.values()) if (run.state === "running") run.controller.abort();
+	}
+	prune() {
+		const finished = [...this.runs.values()].filter((r) => r.state !== "running").toSorted((a, b) => (a.finishedAtMs ?? 0) - (b.finishedAtMs ?? 0));
+		const excess = finished.length - this.opts.keepFinished;
+		for (let i = 0; i < excess; i++) {
+			const victim = finished[i];
+			if (victim !== void 0) this.runs.delete(victim.runId);
+		}
+	}
+};
 function hfModelUrl(repo, path) {
 	return `https://huggingface.co/${repo}/resolve/main/${path}`;
 }
@@ -50023,9 +50505,9 @@ var RingBuffer = class {
 };
 /**
 * DEVICE-POOL backend → model format — the SSOT for the multi-device inference
-* DESCRIPTOR path (Python per-device pools), distinct from {@link BACKEND_TO_FORMAT}
-* above which is the legacy NODE runtime map (where `coreml → onnx` because
-* onnxruntime-node's CoreML EP loads `.onnx`). Here a device pool runs the
+* DESCRIPTOR path (Python per-device pools),  distinct from the former BACKEND_TO_FORMAT,
+* which was the removed NODE runtime map (where `coreml → onnx` because
+* onnxruntime-node's CoreML EP loaded `.onnx`). A device pool runs the
 * backend NATIVELY, so `coreml → coreml` and `edgetpu → tflite`. Consumed by
 * `resolveDeviceEngine` (addon-pipeline) and the orchestrator's
 * `parseDeviceKey`/`getNodeInferenceDevices` — the previously-duplicated
@@ -50323,4 +50805,4 @@ function enumerateInferenceDevices(hw) {
 	return out;
 }
 //#endregion
-export { defaultDeviceFor as $, errMsg as $t, PoolMemoryWatchdog as A, literal as An, pickDetailCropConvention as At, VISIT_MERGE_GAP_MS as B, resolveCreateExportSubject as Bt, FailureCounters as C, selectAssignedProfileSlots as Cn, migrateLegacyDeviceSignalConfig as Ct, NativeLeaseAdmissionSchema as D, boolean as Dn, parseProcStatus as Dt, MOTION_CLOSE_AFTER_MS as E, array as En, overlayClusterStepSettings as Et, RECORDING_SOURCE_CAMSTACK_ADDON as F, string as Fn, recordingArchiveCapability as Ft, audioKindId as G, runtimeDevices as Gt, addonWidgetsSourceCapability as H, resolveLocationMode as Ht, RecordingConfigSchema as I, union as In, recordingCapability as It, clipExportFailure as J, streamBrokerCapability as Jt, batteryCapability as K, storageEvictableCapability as Kt, RecordingSignalStatusSchema as L, EventCategory as Ln, recordingExportCapability as Lt, RATE_CONTROL_TIGHT as M, object as Mn, pipelineExecutorCapability as Mt, RECORDING_EXPORT_MAX_READ_BYTES as N, preprocess as Nn, pipelineRunnerCapability as Nt, NativeLeaseSettingsSchema as O, discriminatedUnion as On, pickClusterStepModels as Ot, RECORDING_SOURCE_CAMSTACK as P, record as Pn, rankStreams as Pt, declareLogChannel as Q, webrtcSessionCapability as Qt, RingBuffer as R, recordingSignalCapability as Rt, ExportRecordSchema as S, parseProfileBrokerId as Sn, mayWriteToLocation as St, HF_BASE_URL as T, _enum as Tn, motionDetectionCapability as Tt, audioAnalysisCapability as U, resolvePoolMemoryPolicy as Ut, YAMNET_TO_MACRO as V, resolveEgressDecodeHwAccel as Vt, audioAnalyzerCapability as W, resolveRecordingProfiles as Wt, createHwAccelCache as X, supportedRuntimes as Xt, clipExportFailureOf as Y, stripRetiredBandPreBufferSec as Yt, createLogChannelsProvider as Z, videoclipsCapability as Zt, DEFAULT_NATIVE_LEASE_SETTINGS as _, isEvent as _n, loadContributionCapability as _t, CLIP_BROKER_PACED_RATES as a, BOOT_RECOVERY_BACKOFF_MS as an, egressTransportFromRequest as at, EVENT_PAD_MS as b, nodePin as bn, maskUrlCredentials as bt, CLIP_STREAM_TRANSPORT_HEADER as c, CamProfileSchema as cn, evaluateZoneRules as ct, DEFAULT_AUDIO_ANALYZER_CONFIG as d, audioChunkBytesPerSample as dn, exportSubjectOf as dt, AUDIO_PRESETS as en, deriveBatteryPresence as et, DEFAULT_CLUSTER_STEP_MODELS as f, createEvent as fn, failureContributionCapability as ft, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as g, hydrateSchema as gn, isFirstLevelMacroClass as gt, DEFAULT_EVENTS_BAND_BUFFER_SEC as h, expandAudioChunkToF32le as hn, inferModelProvider as ht, BatteryStatusSchema as i, isSoftwareDecode as in, egressTranscodeSharingKey as it, RATE_CONTROL_RELAXED as j, number as jn, pickNativeLeaseOverride as jt, OpsLogEntrySchema as k, lazy as kn, pickClusterStepSettings as kt, COCO_80_LABELS as l, DeviceFeature as ln, evictionPolicyForMode as lt, DEFAULT_DETAIL_CROP_CONVENTION as m, defineCustomActions as mn, hfModelUrl as mt, AUDIO_BACKEND_CHOICES as n, buildFfmpegArgs as nn, deriveRecordingMode as nt, CLIP_STILL_REASON_CODE_HEADER as o, BaseAddon as on, enumerateInferenceDevices as ot, DEFAULT_CLUSTER_STEP_SETTINGS as p, customAction as pn, gbToBytes as pt, cameraStreamsCapability as q, storageOccupancyCapability as qt, AUDIO_MACRO_LABELS as r, invocationFromEncodeProfile as rn, detectionPipelineCapability as rt, CLIP_STILL_REASON_HEADER as s, CAM_PROFILE_ORDER as sn, evaluateSensorEdge as st, APPLE_SA_TO_MACRO as t, Fmp4BoxSplitter as tn, deriveDetailCropRect as tt, COCO_TO_MACRO as u, DeviceType as un, evictionPolicyOfLocation as ut, DEVICE_BACKEND_TO_FORMAT as v, makeProfileBrokerId as vn, logChannelsCapability as vt, G711_SCALE_CORRECTION_DB as w, sleep as wn, modeMayWrite as wt, EncodeProfileSchema as x, parseJsonUnknown as xn, mayReadLocation as xt, EVENT_OWNER_TYPES as y, makeSourceBrokerId as yn, mapAudioLabelToMacro as yt, VIDEOCLIPS_MAX_OFFER_BYTES as z, resolveClusterStepModelId as zt };
+export { declareLogChannel as $, webrtcSessionCapability as $t, OpsLogEntrySchema as A, lazy as An, pickClusterStepSettings as At, VIDEOCLIPS_MAX_OFFER_BYTES as B, resolveClusterStepModelId as Bt, ExportRecordSchema as C, parseProfileBrokerId as Cn, mayWriteToLocation as Ct, MOTION_CLOSE_AFTER_MS as D, array as Dn, overlayClusterStepSettings as Dt, HF_BASE_URL as E, _enum as En, motionDetectionCapability as Et, RECORDING_SOURCE_CAMSTACK as F, record as Fn, rankStreams as Ft, audioAnalyzerCapability as G, resolveRecordingProfiles as Gt, YAMNET_TO_MACRO as H, resolveEgressDecodeHwAccel as Ht, RECORDING_SOURCE_CAMSTACK_ADDON as I, string as In, recordingArchiveCapability as It, cameraStreamsCapability as J, storageOccupancyCapability as Jt, audioKindId as K, runtimeDevices as Kt, RecordingConfigSchema as L, union as Ln, recordingCapability as Lt, RATE_CONTROL_RELAXED as M, number as Mn, pickNativeLeaseOverride as Mt, RATE_CONTROL_TIGHT as N, object as Nn, pipelineExecutorCapability as Nt, NativeLeaseAdmissionSchema as O, boolean as On, parseProcStatus as Ot, RECORDING_EXPORT_MAX_READ_BYTES as P, preprocess as Pn, pipelineRunnerCapability as Pt, createLogChannelsProvider as Q, videoclipsCapability as Qt, RecordingSignalStatusSchema as R, EventCategory as Rn, recordingExportCapability as Rt, EncodeProfileSchema as S, parseJsonUnknown as Sn, mayReadLocation as St, G711_SCALE_CORRECTION_DB as T, sleep as Tn, modeMayWrite as Tt, addonWidgetsSourceCapability as U, resolveLocationMode as Ut, VISIT_MERGE_GAP_MS as V, resolveCreateExportSubject as Vt, audioAnalysisCapability as W, resolvePoolMemoryPolicy as Wt, clipExportFailureOf as X, stripRetiredBandPreBufferSec as Xt, clipExportFailure as Y, streamBrokerCapability as Yt, createHwAccelCache as Z, supportedRuntimes as Zt, DEFAULT_FIRST_SIGHTING_FRESHNESS_MS as _, hydrateSchema as _n, isFirstLevelMacroClass as _t, BatteryStatusSchema as a, isSoftwareDecode as an, egressTranscodeSharingKey as at, EVENT_OWNER_TYPES as b, makeSourceBrokerId as bn, mapAudioLabelToMacro as bt, CLIP_STILL_REASON_HEADER as c, CAM_PROFILE_ORDER as cn, evaluateSensorEdge as ct, COCO_TO_MACRO as d, DeviceType as dn, evictionPolicyOfLocation as dt, errMsg as en, defaultDeviceFor as et, DEFAULT_AUDIO_ANALYZER_CONFIG as f, audioChunkBytesPerSample as fn, exportSubjectOf as ft, DEFAULT_EVENTS_BAND_BUFFER_SEC as g, expandAudioChunkToF32le as gn, inferModelProvider as gt, DEFAULT_DETAIL_CROP_CONVENTION as h, defineCustomActions as hn, hfModelUrl as ht, BackgroundRunRegistry as i, invocationFromEncodeProfile as in, detectionPipelineCapability as it, PoolMemoryWatchdog as j, literal as jn, pickDetailCropConvention as jt, NativeLeaseSettingsSchema as k, discriminatedUnion as kn, pickClusterStepModels as kt, CLIP_STREAM_TRANSPORT_HEADER as l, CamProfileSchema as ln, evaluateZoneRules as lt, DEFAULT_CLUSTER_STEP_SETTINGS as m, customAction as mn, gbToBytes as mt, AUDIO_BACKEND_CHOICES as n, Fmp4BoxSplitter as nn, deriveDetailCropRect as nt, CLIP_BROKER_PACED_RATES as o, BOOT_RECOVERY_BACKOFF_MS as on, egressTransportFromRequest as ot, DEFAULT_CLUSTER_STEP_MODELS as p, createEvent as pn, failureContributionCapability as pt, batteryCapability as q, storageEvictableCapability as qt, AUDIO_MACRO_LABELS as r, buildFfmpegArgs as rn, deriveRecordingMode as rt, CLIP_STILL_REASON_CODE_HEADER as s, BaseAddon as sn, enumerateInferenceDevices as st, APPLE_SA_TO_MACRO as t, AUDIO_PRESETS as tn, deriveBatteryPresence as tt, COCO_80_LABELS as u, DeviceFeature as un, evictionPolicyForMode as ut, DEFAULT_NATIVE_LEASE_SETTINGS as v, isEvent as vn, loadContributionCapability as vt, FailureCounters as w, selectAssignedProfileSlots as wn, migrateLegacyDeviceSignalConfig as wt, EVENT_PAD_MS as x, nodePin as xn, maskUrlCredentials as xt, DEVICE_BACKEND_TO_FORMAT as y, makeProfileBrokerId as yn, logChannelsCapability as yt, RingBuffer as z, recordingSignalCapability as zt };