@camstack/addon-osd-manager 0.1.21 → 0.1.23

package/dist/index.js

@@ -6633,7 +6633,7 @@ function method(input, output, options) {
 		input,
 		output,
 		kind: options?.kind ?? "query",
-		auth: options?.auth ?? "protected",
+		...options?.auth !== void 0 ? { auth: options.auth } : {},
 		...options?.access !== void 0 ? { access: options.access } : {},
 		...options?.caller !== void 0 ? { caller: options.caller } : {},
 		timeoutMs: options?.timeoutMs
@@ -6663,8 +6663,17 @@ var adminUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(_void(), StaticDirOutputSchema$1),
-		getVersion: method(_void(), VersionOutputSchema$1)
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — both methods were reachable on the AppRouter
+		* by ANY authenticated session at the default `auth: 'protected'`, and
+		* `getStaticDir` leaks a hub filesystem path. The only caller is
+		* `main.ts`'s static-file bootstrap, via `capRegistry.getSingletonForNode`
+		* — never tRPC — so `auth: 'admin'` costs it nothing. The actual admin-ui
+		* SPA assets are served as plain static files, unaffected by this gate.
+		*/
+		getStaticDir: method(_void(), StaticDirOutputSchema$1, { auth: "admin" }),
+		getVersion: method(_void(), VersionOutputSchema$1, { auth: "admin" })
 	}
 };
 var DeviceType = /* @__PURE__ */ function(DeviceType) {
@@ -7000,8 +7009,23 @@ var viewerUiCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
-		getStaticDir: method(_void(), StaticDirOutputSchema),
-		getVersion: method(_void(), VersionOutputSchema)
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — both methods were reachable on the AppRouter
+		* by ANY authenticated session at the default `auth: 'protected'`, and
+		* `getStaticDir` leaks a hub filesystem path.
+		*
+		* ⚠ Checked before gating: the VIEWER app IS used by a non-admin user
+		* (`roberta`), but it never calls `viewerUi.*` over tRPC. The static SPA
+		* it loads is served by the plain `GET /viewer/*` Fastify route in
+		* `main.ts`, which reads `staticDir`/`indexPath` from a module-level
+		* cache populated ONCE at boot via `capRegistry.getSingletonForNode`
+		* (in-process, not tRPC) — the cap's tRPC procedure is never on that
+		* request path. `auth: 'admin'` here does not block a single viewer
+		* user from loading the app.
+		*/
+		getStaticDir: method(_void(), StaticDirOutputSchema, { auth: "admin" }),
+		getVersion: method(_void(), VersionOutputSchema, { auth: "admin" })
 	}
 };
 /**
@@ -7676,24 +7700,6 @@ var RecordingRetentionSchema = object({
 	maxSizeGb: number().min(0).optional()
 });
 /**
-* Scrub-thumbnail fidelity preset — the single per-camera selector bundling the
-* sprite tile RESOLUTION + JPEG QUALITY the recorder packs timeline-scrub
-* previews at. Five graduated steps; absent on a config = `standard` (the
-* shipped default, matching `sheet-geometry`/`sheet-composer`).
-*
-* Existing sheets are IMMUTABLE — a changed preset applies to NEW windows only.
-* Each window's index sidecar carries its own tile dims, so a camera whose
-* preset changed over time renders every historical window at the dims it was
-* written with.
-*/
-var ScrubThumbnailPresetSchema = _enum([
-	"minimal",
-	"low",
-	"standard",
-	"high",
-	"max"
-]);
-/**
 * The full per-camera recording intent — the wire shape of a RecordingTarget.
 *
 * `bands` is the ONLY authored recording intent: what to record, when, and on
@@ -7701,7 +7707,11 @@ var ScrubThumbnailPresetSchema = _enum([
 * other field is a storage knob (profiles, segment length, retention, scrub).
 *
 * STRICT on purpose: the legacy authoring surface (`schedule`/`schedules`/
-* `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30.
+* `triggers`/`preBufferSec`/`postBufferSec`/`rules`) was retired 2026-07-30,
+* and `scrubThumbnails` — a five-step fidelity knob for a sprite tier that was
+* deleted on 2026-07-24 and had ZERO consumers in the recorder — on 2026-08-25
+* (D62: a switch that writes a store nobody reads is worse than no switch).
+* Stored rows keep loading: the READ schema is `.strip()` (config-store.ts).
 * A stale caller must fail loudly — silently stripping its legacy intent would
 * persist a band-less config, i.e. silently stop recording the camera.
 */
@@ -7724,14 +7734,7 @@ var RecordingConfigSchema = object({
 	* "off" is the absence of a covering band, never a band value.
 	*/
 	bands: array(RecordingBandSchema).default([]),
-	retention: RecordingRetentionSchema.optional(),
-	/**
-	* Per-camera scrub-thumbnail fidelity preset (resolution + JPEG quality for
-	* timeline-scrub sprite previews). Absent = `standard`. Applies to NEW
-	* windows only — existing sheets are immutable, and each window's index
-	* carries its own tile dims so mixed-preset history renders correctly.
-	*/
-	scrubThumbnails: ScrubThumbnailPresetSchema.optional()
+	retention: RecordingRetentionSchema.optional()
 }).strict();
 /**
 * Entity-relocation job state (storage entity-routing spec, Phase 4).
@@ -7807,10 +7810,11 @@ var RelocateFootageInputSchema = object({
 * `RecordingConfig.enabled` or camera wrapper bindings. */
 var StorageMigrationLeaseInputSchema = object({ leaseId: string().min(1) });
 var StorageMigrationFootageMoveInputSchema = RelocateFootageInputSchema.extend({ leaseId: string().min(1) });
-var StorageMigrationMediaMoveInputSchema = object({
+var RelocateMediaInputSchema = object({
 	toLocationId: string(),
 	throttleMbps: number().min(1).max(1e3).optional()
-}).extend({ leaseId: string().min(1) });
+});
+var StorageMigrationMediaMoveInputSchema = RelocateMediaInputSchema.extend({ leaseId: string().min(1) });
 /** The independently selectable logical storage classes. `recordings`
 * encompasses the high and mid segment profiles; `recordingsLow` is low
 * segments; `eventMedia` is post-analysis blobs. */
@@ -8105,7 +8109,26 @@ var LabelDefinitionSchema = object({
 	description: string().optional(),
 	icon: string().optional()
 });
-var ClassMapDefinitionSchema = object({
+/**
+* Wire schema for a per-model CATALOG classMap override
+* (`ModelCatalogEntry.classMap` / `ModelConvertMetadata.classMap`) —
+* restricted to {@link CLASS_MAP_MACRO_TARGETS}, the only macros the
+* detection pipeline executor actually routes.
+*
+* This is deliberately a DIFFERENT, narrower shape than the general-purpose
+* `ClassMapDefinition` interface above (e.g. `IDetectionAddon.getClassMap()`
+* and the audio `YAMNET_TO_MACRO` catalog both use macro targets outside this
+* enum) — the two used to share the name `ClassMapDefinition`/
+* `ClassMapDefinitionSchema`, which made the schema-type-twin guard
+* (`scripts/check-schema-type-twins.ts`) flag them as a duplicated shape. They
+* are not: it is two different concepts colliding on a name. Keep this type
+* under its own name rather than reusing `ClassMapDefinition` — reusing it
+* would either narrow every `ClassMapDefinition` consumer to the four
+* detection macros (breaking `YAMNET_TO_MACRO`) or drop the validation this
+* schema exists for (see the "rejects a classMap whose target is not a
+* detection macro" test in `model-catalog-schema.test.ts`).
+*/
+var DetectionCatalogClassMapSchema = object({
 	mapping: record(string(), _enum([
 		"person",
 		"vehicle",
@@ -8310,7 +8333,7 @@ var ModelCatalogEntrySchema = object({
 	* applies (Frigate / COCO public catalog). Set on a custom model whose raw
 	* labels already ARE the CamStack macros (Scrypted identity map).
 	*/
-	classMap: ClassMapDefinitionSchema.optional()
+	classMap: DetectionCatalogClassMapSchema.optional()
 });
 var ConvertTargetSchema = discriminatedUnion("format", [object({
 	format: literal("openvino"),
@@ -8340,7 +8363,7 @@ var ModelConvertMetadataSchema = object({
 		"segmentation"
 	]),
 	faceAlignment: boolean().optional(),
-	classMap: ClassMapDefinitionSchema.optional()
+	classMap: DetectionCatalogClassMapSchema.optional()
 });
 var ConvertResultSchema = object({
 	entry: ModelCatalogEntrySchema,
@@ -9213,7 +9236,18 @@ var addonPagesSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listPages: method(_void(), array(AddonPageDeclarationSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the `addon-pages-aggregator` builtin, reads it via
+	* `ctx.capabilities.getCollection('addon-pages-source')` — LOCAL-PROCESS
+	* only, never tRPC (per `ctx.capabilities` seeing only the local
+	* process). The public, enriched listing admin-ui actually consumes is
+	* the separate `addon-pages` cap, unaffected by this change.
+	*/
+listPages: method(_void(), array(AddonPageDeclarationSchema).readonly(), { auth: "admin" }) }
 };
 var AddonHttpRouteSchema = object({
 	method: _enum([
@@ -9510,7 +9544,20 @@ var addonWidgetsSourceCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listWidgets: method(_void(), array(WidgetMetadataSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the `addon-widgets-aggregator` builtin, reads it via
+	* `ctx.capabilities.getCollection('addon-widgets-source')` — LOCAL-PROCESS
+	* only, never tRPC. The public, enriched listing admin-ui actually
+	* consumes is the separate `addon-widgets` cap (`listWidgets` there is
+	* gated separately, and a `preAuth: true` widget is surfaced through the
+	* PUBLIC `auth.listLoginMethods` contribution channel instead) —
+	* neither is affected by this change.
+	*/
+listWidgets: method(_void(), array(WidgetMetadataSchema).readonly(), { auth: "admin" }) }
 };
 /**
 * `addon-widgets` — system-scoped singleton aggregator cap. Public-facing
@@ -11674,7 +11721,17 @@ var customModelRegistryCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { listModels: method(_void(), array(CustomModelDescriptorSchema).readonly()) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — this was reachable on the AppRouter by ANY
+	* authenticated session at the default `auth: 'protected'`. The only
+	* consumer, the detection-pipeline's model resolution
+	* (`addon-pipeline/src/detection-pipeline/provider.ts`), calls
+	* `ctx.api.customModelRegistry.listModels.query()` — UDS/Moleculer,
+	* never tRPC — so `auth: 'admin'` costs it nothing.
+	*/
+listModels: method(_void(), array(CustomModelDescriptorSchema).readonly(), { auth: "admin" }) }
 };
 /**
 * Query filter for settings-store collections.
@@ -11798,11 +11855,26 @@ var settingsStoreCapability = {
 			key: string(),
 			value: unknown()
 		}), _void(), { kind: "mutation" }),
-		/** Get all entries matching an optional filter. */
+		/**
+		* Rows matching a filter.
+		*
+		* `columns` is a SQL-level projection: the engine SELECTs only those
+		* columns (plus the primary key) instead of the whole row. It is the only
+		* way to stop paying disk for a column that is discarded — a heavy JSON
+		* column dominates the row, and dropping it in JS after the read pays every
+		* byte first. Measured on the live `pipeline-analytics:tracks` table: a
+		* 501-row page is 4.6 MB whole and 0.11 MB projected, same index, same
+		* plan.
+		*
+		* The engine REFUSES a column it cannot serve rather than omitting it —
+		* see `SettingsQueryInput.columns` for why a projection may not be
+		* forgiving the way a predicate is.
+		*/
 		query: method(object({
 			namespace: string().optional(),
 			collection: string(),
-			filter: QueryFilterSchema.optional()
+			filter: QueryFilterSchema.optional(),
+			columns: array(string()).readonly().optional()
 		}), array(SettingsRecordSchema).readonly()),
 		/** Insert a new record. */
 		insert: method(object({
@@ -11928,6 +12000,23 @@ var EngineInfoSchema = object({
 * go through `settings-store`; they never see this cap, and an engine
 * never sees a caller.
 *
+* ⚠ **`internal: true` DOES NOT gate the mount, and until 2026-08-26 this
+* comment claimed otherwise.** `resolveCapMount` never reads the field, so this
+* cap was live on the AppRouter with every method at the default
+* `auth: 'protected'` — i.e. readable by ANY authenticated session, admin or
+* not. Verified against the live hub: `dataStoreProvider.query` returned raw
+* settings rows including a provider credential, bypassing the secret redaction
+* that `deviceManager.listAll` and friends go through.
+*
+* Every method is now `auth: 'admin'` EXPLICITLY, including the five reads —
+* they had no options object at all, which is exactly how they kept the
+* permissive default while the mutations looked deliberate. The explicit
+* annotation is the fix that works today; making `internal` mean something at
+* mount time is the systemic one, and it is not free: 22 caps declare it, only
+* 4 are `mount: 'skip'`, and forcing admin on all of them would change the auth
+* of surfaces the viewer and admin-ui call as non-admin users. That decision is
+* the operator's, not a side effect of this file.
+*
 * Design notes:
 *   - **Stateless dispatch.** Every method carries its own
 *     `namespace` + `collection`, so an engine keeps no per-caller state
@@ -11949,64 +12038,105 @@ var dataStoreProviderCapability = {
 	internal: true,
 	methods: {
 		/** Self-description — how the orchestrator picks a registrant. */
-		getEngineInfo: method(_void(), EngineInfoSchema),
+		getEngineInfo: method(_void(), EngineInfoSchema, { auth: "admin" }),
 		/** Get a single value by key from a collection. */
 		get: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string()
-		}), unknown()),
+		}), unknown(), { auth: "admin" }),
 		/** Set a value by key in a collection (upsert). */
 		set: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string(),
 			value: unknown()
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Get all entries matching an optional filter. */
 		query: method(object({
 			namespace: string().optional(),
 			collection: string(),
-			filter: QueryFilterSchema.optional()
-		}), array(SettingsRecordSchema).readonly()),
+			filter: QueryFilterSchema.optional(),
+			/**
+			* SQL-level column projection — MUST mirror `settings-store.query`.
+			*
+			* ⚠ An earlier version of this comment blamed Zod stripping, and that
+			* was wrong — corrected 2026-08-26 after the hop map
+			* (`docs/design/2026-08-26-mappa-hop-argomenti.md`) traced the path.
+			* There is **no Zod parse at all** between the door and the engine: the
+			* dispatcher forwards the payload verbatim and UDS carries it whole. A
+			* field declared here reaches `SqliteSettingsBackend` either way.
+			*
+			* What actually lost `columns` was the THIRD declaration of this shape:
+			* `SettingsQueryInput` in `interfaces/storage.ts`, a hand-written TS
+			* interface the engine destructures from. The field existed on both
+			* schemas and the engine still never read it, because nothing checks a
+			* registered provider against `InferProvider<cap>` —
+			* `ProviderRegistration.provider` is typed `object`.
+			*
+			* It is declared here anyway, and must stay in step with
+			* `settings-store.query`: a caller reading only the cap definitions has
+			* to be able to see that this call carries a projection.
+			* `data-door-schema-parity.spec.ts` keeps the two aligned.
+			*/
+			columns: array(string()).readonly().optional()
+		}), array(SettingsRecordSchema).readonly(), { auth: "admin" }),
 		/** Insert a new record. */
 		insert: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			record: SettingsRecordSchema
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Update an existing record by ID. */
 		update: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			id: string(),
 			data: record(string(), unknown())
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete a record by key/ID. */
 		delete: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			key: string()
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Delete every record matching `filter`, in one statement. */
 		deleteWhere: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: MutationFilterSchema
-		}), object({ deleted: number().int() }), { kind: "mutation" }),
+		}), object({ deleted: number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Apply `data` to every record matching `filter`, in one statement. */
 		updateWhere: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: MutationFilterSchema,
 			data: record(string(), unknown())
-		}), object({ updated: number().int() }), { kind: "mutation" }),
+		}), object({ updated: number().int() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Count entries in a collection, optionally filtered. */
 		count: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			filter: QueryFilterSchema.optional()
-		}), number()),
+		}), number(), { auth: "admin" }),
 		/** Grouped counts per ((field-origin)/bucketSize) bucket, filtered. */
 		histogram: method(object({
 			namespace: string().optional(),
@@ -12018,19 +12148,22 @@ var dataStoreProviderCapability = {
 		}), array(object({
 			bucket: number().int(),
 			count: number().int()
-		})).readonly()),
+		})).readonly(), { auth: "admin" }),
 		/** Check if a collection is empty. */
 		isEmpty: method(object({
 			namespace: string().optional(),
 			collection: string()
-		}), boolean()),
+		}), boolean(), { auth: "admin" }),
 		/** Declare a typed (SQL-backed) collection with columns + indexes. */
 		declareCollection: method(object({
 			namespace: string().optional(),
 			collection: string(),
 			columns: array(CollectionColumnSchema).readonly(),
 			indexes: array(CollectionIndexSchema).readonly().optional()
-		}), _void(), { kind: "mutation" })
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /**
@@ -13830,13 +13963,20 @@ var embeddingEncoderCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — every method below was reachable on the
+		* AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`. Consumers reach the encoder via `ctx.api` from
+		* `addon-post-analysis`, never tRPC.
+		*/
 		encode: method(object({
 			crop: _instanceof(Uint8Array),
 			width: number(),
 			height: number()
-		}), EmbeddingResultSchema),
-		encodeText: method(object({ text: string() }), EmbeddingResultSchema),
-		getInfo: method(_void(), EmbeddingInfoSchema)
+		}), EmbeddingResultSchema, { auth: "admin" }),
+		encodeText: method(object({ text: string() }), EmbeddingResultSchema, { auth: "admin" }),
+		getInfo: method(_void(), EmbeddingInfoSchema, { auth: "admin" })
 	}
 };
 /**
@@ -14145,12 +14285,28 @@ var llmRuntimeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
+		/**
+		* `complete`, `status`, `listLocalModels` and `getDiskUsage` had NO
+		* `auth` override — `internal: true` did not gate the mount (see the
+		* 2026-08-26 note on `data-store-provider`), so they were reachable on
+		* the AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`, inconsistent with the rest of this cap (already
+		* `auth: 'admin'`) and with this file's own docblock: "the operator
+		* reaches this only through the `llm` cap's methods." The sole caller,
+		* `addon-ai`'s `runtime-client.ts`, reaches every method here via
+		* `ctx.api` + `nodePin` — never tRPC — so `auth: 'admin'` costs it
+		* nothing; the public `llm` cap (which end users and non-admin sessions
+		* legitimately call for chat/generation) is untouched.
+		*/
 		complete: method(LlmGenerateBaseInputSchema.extend({
 			images: array(LlmImageSchema).optional(),
 			runtime: ManagedRuntimeConfigSchema,
 			/** The managed profile's timeout, threaded by the hub provider. */
 			timeoutMs: number().int().positive().optional()
-		}), LlmGenerateResultSchema, { kind: "mutation" }),
+		}), LlmGenerateResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		ensureStarted: method(object({ runtime: ManagedRuntimeConfigSchema }), LlmRuntimeStatusSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -14159,7 +14315,7 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		status: method(object({}), LlmRuntimeStatusSchema),
+		status: method(object({}), LlmRuntimeStatusSchema, { auth: "admin" }),
 		installModel: method(object({ model: ManagedModelRefSchema }), _void(), {
 			kind: "mutation",
 			auth: "admin"
@@ -14168,8 +14324,8 @@ var llmRuntimeCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listLocalModels: method(object({}), array(LlmNodeModelSchema)),
-		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema)
+		listLocalModels: method(object({}), array(LlmNodeModelSchema), { auth: "admin" }),
+		getDiskUsage: method(object({}), LlmRuntimeDiskUsageSchema, { auth: "admin" })
 	}
 };
 /**
@@ -18435,210 +18591,1044 @@ var oauthIntegrationCapability = {
 	scope: "system",
 	mode: "collection",
 	internal: true,
-	methods: { getDescriptor: method(_void(), OauthIntegrationDescriptorSchema) }
+	methods: { 
+	/**
+	* `internal: true` did not gate the mount (see the 2026-08-26 note on
+	* `data-store-provider`) — `getDescriptor` was reachable on the AppRouter
+	* by ANY authenticated session at the default `auth: 'protected'`. The
+	* real caller is `/api/oauth2/authorize` and `/api/oauth2/integrations`
+	* (`oauth2-routes.ts`), which resolve the provider directly off the
+	* capability registry — never through tRPC. `auth: 'admin'` closes the
+	* tRPC surface without touching that path.
+	*/
+getDescriptor: method(_void(), OauthIntegrationDescriptorSchema, { auth: "admin" }) }
 };
 /**
-* pipeline-analytics — device-scoped wrapper cap. Refines raw
-* per-frame detections emitted by the pipeline runner into tracked
-* objects, per-kind event collections (motion / object / audio), and
-* persisted media. Owns the post-detection domain end-to-end:
-*
-*   runner emits PipelineInferenceResult
-*     ↓ (event bus)
-*   pipeline-analytics subscriber
-*     ↓ SORT tracker + zone engine + state analyzer + event emitter
-*   → three DB collections (one per kind), one FS media tree, one
-*     unified event emitter (FrameTracked + TrackStarted/Ended +
-*     DetectionEvent on bus)
-*
-* Pure subscriber model. No `processFrame` cap method — the runner
-* already publishes the raw frame on the bus. The cap surface is
-* only QUERIES + per-device settings, bound on/off via
-* `device-manager.setWrapperActive`. `defaultActive: true` because
-* every camera with a detection pipeline wants its raw detections
-* refined; operators opt out per-device via BindingsTab when needed.
-*
-* Replaces the legacy `analysis-pipeline`, `analysis-data-persistence`
-* (per-device surface) and `track-trail` caps — see P11 cleanup.
+* 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 TrackStateSchema = _enum([
-	"new",
-	"entered",
-	"left",
-	"moving",
-	"idle"
-]);
-var EventKindSchema = _enum([
-	"motion",
-	"object",
-	"audio"
-]);
+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"
+	])
+});
 /**
-* Spatial filter for `listTracks` — the rect + polygon variants of the shared
-* MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
-* of the camera frame (top-left origin), matching the drawing-plane editor.
+* 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 TrackZoneFilterSchema = discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
-/** Closed icon vocabulary so clients render a known glyph per kind. */
-var EventKindIconSchema = _enum([
-	"motion",
-	"audio",
-	"person",
-	"vehicle",
-	"animal",
-	"door",
-	"pir",
-	"smoke",
-	"water",
-	"button",
-	"package",
-	"generic"
+var 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 EventKindCategorySchema = _enum([
-	"motion",
-	"audio",
-	"detection",
-	"sensor",
-	"control",
-	"custom",
-	"package"
+var PipelineSlotSchema = _enum([
+	"detector",
+	"cropper",
+	"classifier",
+	"refiner",
+	"audio-classifier"
 ]);
-/** Taxonomy level — macro (timeline lane) vs sub (events-page leaf). */
-var EventKindLevelSchema = _enum(["macro", "sub"]);
-var EventKindDescriptorSchema = object({
-	/** Stable kind id (e.g. 'motion', 'vehicle', 'car', 'lock'). */
-	kind: string(),
-	/** i18n key resolved on the UI side; `label` is the English fallback. */
-	labelKey: string(),
-	/** English fallback label (kept for clients that don't translate). */
-	label: string(),
-	/** Hex color for timeline/legend rendering. */
-	color: string(),
-	/** Dictionary id → lucide component on the UI side. */
-	iconId: string(),
-	/** Legacy closed-vocab glyph — fallback for `iconId`. */
-	icon: EventKindIconSchema,
-	category: EventKindCategorySchema,
-	/** Macro parent for this kind ('car' → 'vehicle'); null for a macro. */
-	parentKind: string().nullable(),
-	/** Derived from `parentKind`, explicit for the client tree. */
-	level: EventKindLevelSchema,
-	/** Which cap + device contributes this kind. For built-ins the camera
-	*  itself; for sensor kinds the LINKED source device. */
-	source: object({
-		capName: string(),
-		deviceId: number()
-	})
+var PipelineEngineChoiceSchema = object({
+	runtime: _enum(["node", "python"]),
+	backend: string(),
+	format: ModelFormatSchema$1,
+	device: string().optional()
 });
-/** One camera's event vocabulary, as returned by `listEventKindsBatch`. */
-var EventKindsForDeviceSchema = object({
-	deviceId: number(),
-	kinds: array(EventKindDescriptorSchema).readonly()
+var AvailableEngineSchema = object({
+	engine: PipelineEngineChoiceSchema,
+	devices: array(object({
+		id: string(),
+		label: string(),
+		description: string().optional()
+	})).readonly(),
+	defaultDevice: string()
 });
-var SensorEventSchema = object({
+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(),
-	/** The CAMERA the event is attributed to (a sensor linked to N cameras
-	*  yields N rows, one per camera). */
-	deviceId: number(),
-	/** The linked sensor device whose state changed. */
-	sourceDeviceId: number(),
-	/** Event kind id — matches an `EventKindDescriptor.kind`. */
-	kind: string(),
-	/** Snapshot of the sensor cap's runtime-state slice at the change. */
-	value: record(string(), unknown()).nullable(),
-	timestamp: number()
-});
-var TrackPositionSchema = object({
-	x: number(),
-	y: number(),
-	timestamp: number(),
-	bbox: BoundingBoxSchema
+	name: string(),
+	createdAt: string(),
+	updatedAt: string(),
+	engine: PipelineEngineChoiceSchema,
+	steps: array(PipelineTemplateStepSchema).readonly()
 });
-var TrackSnapshotSchema = object({
-	timestamp: number(),
-	position: TrackPositionSchema,
-	/** MediaStore key; resolve via `getTrackMedia({ trackId })`. */
-	mediaKey: string()
+var PipelineModelOptionSchema = object({
+	id: string(),
+	name: string(),
+	formats: record(string(), object({
+		downloaded: boolean(),
+		sizeMB: number()
+	})),
+	group: ModelVariantGroupSchema.optional(),
+	legacy: boolean().optional(),
+	provider: ModelProviderIdSchema.optional()
 });
-/**
-* Normalized 0..1 trajectory envelope (min/max over every position bbox,
-* divided by the track's detection-frame dims), computed at persist time.
-* Absent when the frame dims were unknown when the track was persisted
-* (legacy rows / dims-less sources) and on active (in-RAM) tracks.
-*/
-var TrackEnvelopeSchema = object({
-	minX: number(),
-	minY: number(),
-	maxX: number(),
-	maxY: number()
+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()
 });
-/**
-* Row projection for track list queries. `full` (default) returns the
-* complete Track including the frame-rate `positions[]` history and the
-* `snapshots[]` references — megabytes across a page of tracks. `slim`
-* keeps every scalar the list surfaces actually render (ids, class(es),
-* label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
-* zonesVisited, bestEventId, envelope, hasFace, hasEmbeddedFace, hasRider) and returns `positions` /
-* `snapshots` as EMPTY arrays — detail views re-fetch the full row via
-* `getTrack`. Mirrors the event-store `projection` convention
-* (`getObjectEvents` et al.).
-*/
-var TrackProjectionSchema = _enum(["full", "slim"]);
-/**
-* One audio-classification label heard on the track's camera while the
-* track was alive, aggregated per label. An "episode" is one persisted
-* audio event (the confident-classification path: score ≥ the device's
-* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
-* one 32 ms inference chunk, so counts stay human-scaled.
-*/
-var TrackAudioLabelSchema = object({
+var PipelineSlotSchemaSchema = object({
+	id: PipelineSlotSchema,
 	label: string(),
-	/** Highest classification score observed across the label's episodes. */
-	peakScore: number(),
-	/** Number of coalesced audio-event episodes carrying this label. */
-	count: number(),
-	firstAt: number(),
-	lastAt: number()
+	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()
 });
 /**
-* How a track was produced. `pipeline` (default / absent) = the spatial
-* detection+tracking pipeline. Every OTHER value is a SYNTHETIC projection —
-* no positions, a single snapshot, and no bbox trajectory at all:
-*
-*  - `sensor` — a linked sensor/control device state change.
-*  - `audio` — an audio event on the camera itself that was anomalous for
-*    THAT camera, loud, and heard while nothing visual was happening (D62).
-*
-* The spatial subsystems (tracker association, occupancy count, re-id /
-* embedding, resurrection) MUST skip every synthetic source. Test for that
-* with `isSpatialTrack`, which allow-lists `pipeline` — a `!== 'sensor'`
-* check silently readmits every source added after it was written.
+* 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 TrackSourceSchema = _enum([
-	"pipeline",
-	"sensor",
-	"audio"
-]);
+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();
 /**
-* Where a track sits in the RETRAIN lifecycle (D81).
+* Pipeline executor — detection engine + configuration + inference API.
 *
-*  - `none` — never marked, or un-marked. Evictable.
-*  - `staging` — the operator wants this track as training material and has not
-*    finished with it. **This is the only state retention holds**: the track and
-*    everything it owns (object events, crops, keyframes, CLIP vector) survive
-*    the device's age window.
-*  - `trained` — the retrain page has taken what it needed. The frames it chose
-*    were COPIED into the retrain dataset at selection time, so the dataset no
-*    longer depends on the track's media and the track becomes EVICTABLE again.
-*    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
-*    a deliberate action of the retrain page, not a side effect of a checkbox.
+* Merged from: pipeline-executor, pipeline-config, inference, detection-config.
+* Implemented by the detection-pipeline addon.
 *
-* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
-* the store's filter language has only positive equality and `whereIn` — no
-* negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
-* would make the entire pre-column history immortal in one deploy.
+* 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 RetrainStatusSchema = _enum([
+var pipelineExecutorCapability = {
+	name: "pipeline-executor",
+	scope: "system",
+	mode: "singleton",
+	methods: {
+		getAvailableEngines: method(_void(), array(PipelineEngineChoiceSchema)),
+		getSelectedEngine: method(_void(), PipelineEngineChoiceSchema),
+		getDefaultSteps: method(PipelineEngineChoiceSchema, array(PipelineDefaultStepSchema)),
+		/**
+		* Per-node detection-engine provisioning snapshot. Returns the live
+		* state of the lazy runtime-provisioning machine on `nodeId`
+		* (idle / installing / verifying / ready / failed). The UI pairs this
+		* one-shot query with the `pipeline.engine-provisioning` live event
+		* (emitted on every transition) to drive a per-node "engine ready?"
+		* indicator without polling. Phase 2.
+		*/
+		getEngineProvisioning: method(object({ nodeId: string() }), EngineProvisioningSchema),
+		getVideoPipelineSteps: method(_void(), record(string(), object({
+			modelId: string(),
+			settings: record(string(), unknown()).readonly()
+		}))),
+		setVideoPipelineSteps: method(object({ steps: record(string(), object({
+			modelId: string(),
+			settings: record(string(), unknown()).readonly()
+		})) }), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Clear THIS node's executor-side PER-DEVICE settings stores (the
+		* per-camera step overrides the object-detection root reads via
+		* `applyDeviceOverridesToTree`). `nodeId` is the ROUTING key — the
+		* generated cap-router strips it (default `nodeIdMode: 'routing'`) and
+		* dispatches to that node, so the provider method runs ON the target
+		* node and receives no `nodeId`.
+		*
+		* This is the slimmed executor leg of the orchestrator's
+		* `resetNodePipelineDefaults` flow (which owns the real reset: node
+		* addonDefaults pins + per-camera orchestrator overrides). The legacy
+		* `resetToDefault` — which reset a persisted global step-tree seed
+		* nothing in the live per-camera path read — was removed together with
+		* that seed.
+		*/
+		clearDeviceOverrides: method(object({ nodeId: string() }), object({
+			success: literal(true),
+			clearedDevices: number()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Which of THIS node's inference devices the executor currently refuses,
+		* and why. `nodeId` is the ROUTING key (stripped by the generated router).
+		*
+		* The channel that did not exist. Pool health was known only inside the
+		* detection addon and was an input to no routing decision anywhere: the
+		* per-dispatch capability gate is keyed on model FORMAT and so can never
+		* separate `openvino:gpu` from `openvino:npu`, and the orchestrator's live
+		* eligibility probe (`platformProbe.getCapabilities`) answers about
+		* HARDWARE — which was present throughout. So when the hub's `openvino:gpu`
+		* Python worker was SIGABRT'd by the Intel GPU plugin on 2026-08-25, the
+		* balancer went on handing that dead pool cameras by rotation for 31 hours:
+		* ~370 000 `PoolWorker[w0]: not initialized` lines, every frame lost.
+		*
+		* Read semantics the caller depends on, and which the provider guarantees:
+		* this is a synchronous read of in-memory state. It never probes hardware,
+		* never spawns a pool and never throws — an EMPTY `unhealthy` means "asked,
+		* nothing is refused", which is what re-admits a device. A read that FAILS
+		* (node offline, version skew) must therefore be distinguishable from an
+		* empty answer, and it is: it rejects.
+		*/
+		getInferenceDeviceHealth: method(object({ nodeId: string() }), object({ unhealthy: array(object({
+			/** `<backend>:<device>`, e.g. `openvino:gpu`. */
+			deviceKey: string(),
+			/**
+			* `failed` — the per-device restart budget is exhausted; no pool
+			* will be spawned until an operator re-arms it or the runner
+			* respawns. `backoff` — under budget, waiting out the backoff (or
+			* a cached pool observed dead and not yet condemned).
+			*/
+			state: _enum(["failed", "backoff"]),
+			/** Epoch ms of the death that produced this state. */
+			since: number(),
+			/** Pool deaths inside the current window. */
+			deaths: number(),
+			/** The last death's message. */
+			lastError: string()
+		})).readonly() })),
+		/**
+		* Re-arm a terminally `failed` inference device on `nodeId`: forget its
+		* restart budget so the next dispatch builds a fresh pool.
+		*
+		* The terminal state is deliberate (the abort it bounds is deterministic —
+		* an automatic probation would just respawn Python forever, more slowly),
+		* and a terminal state an operator cannot leave is a silent fault. This is
+		* the way out. `rearmed:false` means there was nothing to forget.
+		*/
+		rearmInferenceDevice: method(object({
+			nodeId: string(),
+			deviceKey: string()
+		}), object({ rearmed: boolean() }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getSchema: method(_void(), PipelineSchemaSchema),
+		getGlobalSteps: method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()),
+		getGlobalPipelineConfig: method(_void(), PipelineConfigBridge),
+		getOrchestratorConfigSchema: method(_void(), ConfigUISchemaBridge),
+		/**
+		* Gate B (pre-init config-correctness gate). PURE COMPUTE against this
+		* node's `currentEngine.format` — resolves `steps` the same way the
+		* runtime dispatch path would, and reports what WOULD happen without
+		* touching any node-global state. Called by the orchestrator at attach
+		* time (`attachOn`), node-pinned to the TARGET node, so config problems
+		* surface BEFORE `pipelineRunner.attachCamera` rather than at the first
+		* per-frame resolve. `ok` is false iff `issues` is non-empty (both
+		* `unknown-addon` and `no-format-build` are HARD issues); `substitutions`
+		* is informational (a degraded-but-loadable model swap) and never
+		* affects `ok`. Never throws.
+		*/
+		validatePipeline: method(object({ steps: array(PipelineStepInputSchema) }), PipelineValidationResultSchema),
+		listTemplates: method(_void(), array(PipelineTemplateSchema$1).readonly()),
+		saveTemplate: method(object({
+			name: string(),
+			steps: array(PipelineTemplateStepSchema).readonly(),
+			engine: PipelineEngineChoiceSchema
+		}), PipelineTemplateSchema$1, { kind: "mutation" }),
+		updateTemplate: method(object({
+			id: string(),
+			name: string().optional(),
+			steps: array(PipelineTemplateStepSchema).readonly().optional()
+		}), PipelineTemplateSchema$1, { kind: "mutation" }),
+		deleteTemplate: method(object({ id: string() }), _void(), { kind: "mutation" }),
+		getCapabilities: method(_void(), InferenceCapabilitiesBridge),
+		getAddonModels: method(object({ addonId: string() }), ModelAvailabilityListBridge),
+		downloadModel: method(object({
+			addonId: string(),
+			modelId: string(),
+			format: ModelFormatSchema$1
+		}), DownloadModelResultSchema, { kind: "mutation" }),
+		deleteModel: method(object({
+			addonId: string(),
+			modelId: string(),
+			format: ModelFormatSchema$1
+		}), object({ success: literal(true) }), { kind: "mutation" }),
+		/**
+		* Stateless single-frame execution. Callers (runner, benchmark) pass
+		* the complete `engine` + `steps` tree; the executor holds no state
+		* about cameras or saved pipelines.
+		*
+		* `engine` is optional during the migration window to preserve the
+		* legacy call shape used by existing benchmark code; once all
+		* callers pass it explicitly we make it required.
+		*
+		* Exactly one of `frame`, `frameRef`, `frameHandle`, `imageBase64`,
+		* `referenceImage` must be provided:
+		*  - `frame`: runtime dispatch path (runner → decoded broker frame).
+		*    Carries the raw buffer, dimensions, and format; the executor
+		*    uses it directly without base64 round-tripping.
+		*  - `frameHandle` (CB5): a zero-pixel shm `FrameHandle` for the SAME
+		*    decoded frame. Both runner and executor are hub-local processes
+		*    sharing `/dev/shm`, so the executor maps the named segment and
+		*    reads the pixels back zero-copy — eliminating the ~1.2MB
+		*    re-serialisation over UDS/MsgPack the `frame` path pays per call.
+		*    High-risk: the FrameRing is a latest-wins seqlock with no
+		*    refcount, so a recycled slot yields a null read; the executor
+		*    then degrades to an empty result and the runner ships pixels via
+		*    `frame` as the fallback (queue-depth gated on the runner side).
+		*  - `imageBase64`: one-shot test path (benchmark ImageTab).
+		*  - `referenceImage`: named file from the reference-image store.
+		*/
+		runPipeline: method(object({
+			engine: PipelineEngineChoiceSchema.optional(),
+			steps: array(PipelineStepInputSchema).min(1),
+			frame: FrameInputSchema.optional(),
+			/**
+			* Process-local lazy frame. Valid only when caller and provider resolve
+			* in the same execution-group process; split/cross-node callers use
+			* `frame`/`image` inline compatibility instead.
+			*/
+			frameRef: FrameRefSchema.optional(),
+			/**
+			* CB5 shm passthrough — a `FrameHandle` naming the same ring slot
+			* the decoded pixels live in. One more member of the one-of
+			* frame/frameHandle/image/imageBase64/referenceImage group.
+			*/
+			frameHandle: FrameHandleSchema.optional(),
+			imageBase64: string().optional(),
+			/**
+			* Binary JPEG bytes — preferred over `imageBase64` on internal
+			* hops (hub → forked worker via Moleculer MsgPack) because it
+			* skips the 33% base64 overhead + the per-call base64 decode on
+			* the detection-pipeline worker. Callers can pass either; exactly
+			* one of `frame`/`image`/`imageBase64`/`referenceImage` is required.
+			*/
+			image: _instanceof(Uint8Array).optional(),
+			referenceImage: string().optional(),
+			deviceId: number().optional(),
+			sessionId: string().optional(),
+			/**
+			* Execution plane. 'full' (default) runs the whole tree — benchmark,
+			* reference-image, and detail-subtree calls. 'frame' is the live
+			* per-frame dispatch: ONLY root-plane steps run; crop children
+			* (inputClasses ≠ null) are skipped and served per-track via
+			* pipelineRunner.runDetailSubtree (two-plane design).
+			*/
+			plane: _enum(["full", "frame"]).optional(),
+			/**
+			* Inference-device selector (Phase 2 multi-device). Format
+			* `<backend>:<device>` (e.g. `openvino:gpu`, `edgetpu:usb`, `cpu`).
+			* Omitted ⇒ the runner's default device (current single-engine
+			* behaviour). Selects WHICH device pool of the node runs the call.
+			*/
+			deviceKey: string().optional(),
+			/**
+			* Two-plane NATIVE child-crop reference. Set by `runDetailSubtree` ONLY
+			* when the parent crop was resolved from the frame's retained NATIVE
+			* surface (a frameHandle HIT). Lets the executor re-cut a LEAF crop
+			* child's ROI (plate-ocr, face-embedding, leaf classifiers) at native
+			* resolution from that surface — the SAME quality path faces already
+			* had — instead of the downscaled parent tile. `handle` keys the native
+			* surface (node-pinned to its owner); `cropFrameSpace` is the parent
+			* crop's padded/clamped rectangle in FRAME-space pixels, used to compose
+			* the executor's crop-normalized child ROI back into frame-normalized
+			* coordinates. Auxiliary to the image source (`image`/`frame`/…), NOT one
+			* of the mutually-exclusive image inputs. Absent ⇒ tile-crop children
+			* (today's behaviour on the fallback path).
+			*/
+			nativeCropRef: NativeCropRefSchema.optional()
+		}), PipelineRunResultBridge, { kind: "mutation" }),
+		/**
+		* Batched run — N raw frames packed into one cap call. The provider
+		* routes the batch through `SharedInferencePool.inferBatch`
+		* (`MSG_INFER_BATCH = 0x03`) so the IPC framing and JSON response
+		* envelope cost is amortised N:1 vs N concurrent `runPipeline`
+		* calls. Single root step + uniform model assumed; trees with crop
+		* children fall back to sequential execution.
+		*
+		* Used by `scripts/bench-batch-style.mts` for batch benchmarking —
+		* N frames in one call to amortise per-call IPC overhead.
+		*/
+		runPipelineBatch: method(object({
+			engine: PipelineEngineChoiceSchema.optional(),
+			steps: array(PipelineStepInputSchema).min(1),
+			frames: array(FrameInputSchema).min(1).max(255),
+			deviceId: number().optional(),
+			sessionId: string().optional(),
+			/**
+			* Pure-inference benchmark hint. A NONZERO uint32 pins every frame in
+			* the batch to the Python pool's bench preprocess cache
+			* (`_bench_frame_id`) so a REPEATED benchmark frame is decoded +
+			* preprocessed ONCE and every later inference is a pure-inference cache
+			* hit — the sustained-throughput run measures inference, not
+			* decode+preprocess+infer. Omitted/0 for live frames (all different →
+			* full preprocess every call, correct). Fresh per sustained run;
+			* released via `uncacheFrame`.
+			*/
+			frameId: number().int().nonnegative().optional(),
+			/** Inference-device selector (Phase 2 multi-device); see runPipeline. */
+			deviceKey: string().optional()
+		}), object({ results: array(PipelineRunResultBridge).readonly() }), { kind: "mutation" }),
+		/**
+		* Cache a raw frame inside the Python inference pool's memory.
+		* Returns a numeric `frameId` that `inferCached` references —
+		* subsequent calls send only 5 bytes through the pipe instead of
+		* 1.2MB raw data, eliminating the pipe transfer bottleneck.
+		*/
+		cacheFrameInPool: method(object({
+			data: _instanceof(Uint8Array),
+			width: number().int().positive(),
+			height: number().int().positive(),
+			format: _enum([
+				"rgb",
+				"bgr",
+				"gray"
+			])
+		}), object({
+			frameId: number(),
+			width: number(),
+			height: number()
+		}), { kind: "mutation" }),
+		/**
+		* Run inference on a previously cached frame. Sends only 5 bytes
+		* (model_idx + frameId) through the IPC pipe — eliminates the
+		* ~35ms per-call overhead of transferring 1.2MB raw data.
+		*/
+		inferCached: method(object({
+			stepId: string(),
+			frameId: number().int()
+		}), record(string(), unknown()), { kind: "mutation" }),
+		/**
+		* Release a cached frame from the Python pool's memory.
+		*/
+		uncacheFrame: method(object({ frameId: number().int() }), _void(), { kind: "mutation" }),
+		/** Returns the effective pool tuning (resolved from user overrides + backend defaults). */
+		getEffectiveTuning: method(_void(), object({
+			batchMode: string(),
+			windowMs: number(),
+			maxBatchSize: number(),
+			concurrency: number()
+		})),
+		/**
+		* List every EngineFactory currently loaded in this executor's RAM,
+		* with the models resident and a coarse "in use" marker derived from
+		* ongoing inference activity. Used by the Pipeline page Engines tab.
+		*/
+		listLoadedEngines: method(_void(), array(object({
+			engineKey: string(),
+			engine: PipelineEngineChoiceSchema,
+			modelsLoaded: array(string()).readonly(),
+			inUseByCameras: array(number()).readonly(),
+			/**
+			* Origin of this resident factory.
+			*  - `runtime`       — main camera-serving engine (no idle TTL).
+			*  - `warm-override` — benchmark/test override held in the warm
+			*                      cache; auto-disposed after the idle TTL.
+			*  - `device-pool`   — a concurrent per-device pool (Phase 2
+			*                      multi-device, keyed by `deviceKey`) resolved
+			*                      via `resolveDeviceFactory`. Runs alongside the
+			*                      `runtime` engine on a DIFFERENT accelerator
+			*                      (NPU / iGPU / Coral) — this is how the
+			*                      Engines tab shows all pools running at once.
+			*/
+			kind: _enum([
+				"runtime",
+				"warm-override",
+				"device-pool"
+			]),
+			/** Native pid of the underlying Python pool (null when no pool). */
+			poolPid: number().nullable(),
+			/** ms since this factory was last used (null when not warm-tracked). */
+			idleMs: number().nullable(),
+			/** Idle TTL after which `warm-override` factories self-evict (null when not applicable). */
+			idleTtlMs: number().nullable()
+		})).readonly()),
+		/** Warm up an engine without running a frame. No-op if already loaded. */
+		spinEngine: method(object({ engine: PipelineEngineChoiceSchema }), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Unload an engine from RAM. `force:true` unloads even when cameras
+		* are actively using it (they re-spin on next frame). Default is
+		* gated — returns `{success:false, reason}` when in use.
+		*/
+		killEngine: method(object({
+			engine: PipelineEngineChoiceSchema,
+			force: boolean().optional()
+		}), object({
+			success: boolean(),
+			reason: string().optional()
+		}), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		listReferenceImages: method(_void(), array(ReferenceImageEntrySchema).readonly()),
+		getReferenceImage: method(object({ filename: string() }), ReferenceImageBodySchema.nullable()),
+		getReferenceAudioFiles: method(_void(), array(ReferenceAudioEntrySchema).readonly()),
+		getReferenceAudio: method(object({ filename: string() }), ReferenceAudioBodySchema.nullable()),
+		getAudioCapabilities: method(_void(), AudioCapabilitiesSchema),
+		runAudioTest: method(object({
+			addonId: string(),
+			modelId: string(),
+			filename: string().optional(),
+			settings: record(string(), unknown()).optional()
+		}), AudioTestResultSchema, { kind: "mutation" }),
+		getDetectionConfigSchema: method(_void(), ConfigUISchemaNullableBridge)
+	}
+};
+/**
+* Per-stage gating mode applied to the zones a rule references.
+*
+* - `include`: the rule contributes to a **whitelist** for its stage.
+*   When at least one `include` rule fires for a stage, only entities
+*   inside one of those zones pass that stage.
+* - `exclude`: the rule contributes to a **blacklist** for its stage.
+*   Entities inside one of those zones are dropped at that stage.
+*
+* `monitor`-style observation (count without filtering) is not a rule
+* mode — zones without any matching rule are observed naturally by
+* `zone-analytics` (live snapshot + history), so an "I just want to
+* count, not filter" use case needs no rule at all.
+*/
+var ZoneRuleModeEnum = _enum(["include", "exclude"]);
+/**
+* Per-consumer rule that references existing zones (geometry) and
+* defines how a specific pipeline stage should treat them. Each
+* consumer addon owns its own `ZoneRule[]` array in its per-device
+* settings:
+*
+* - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
+* - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
+* - future: notification rules, audio gating, etc.
+*
+* One rule applies to N zones (`zoneIds[]`) so the operator can
+* express "ignore motion in ALL of {garden, street}" with a single
+* rule. `classFilter` narrows the rule to specific object classes —
+* "drop person detections in the street, but keep cars" is one
+* `exclude` rule with `classFilter: ['person']`.
+*
+* `enabled` is a soft toggle — the operator can keep the rule
+* configured but inert without deleting it.
+*/
+var ZoneRuleSchema = object({
+	/** Stable rule id — survives edits, used by the UI for diffing. */
+	id: string(),
+	/** Optional human-readable label rendered in the rule editor. */
+	name: string().optional(),
+	/** Zones this rule targets. The rule's `mode` applies to ALL
+	*  listed zones (OR-set: a detection in any one of them counts).
+	*  At least one zone id required — a rule with no targets is a
+	*  configuration mistake and the form validator rejects it. */
+	zoneIds: array(string()).min(1).readonly(),
+	mode: ZoneRuleModeEnum,
+	/**
+	* Class names this rule applies to. Empty / undefined ⇒ rule
+	* applies to every class. Class strings match the `macroClass`
+	* field on detections (e.g. `person`, `car`, `dog`).
+	*/
+	classFilter: array(string()).readonly().optional(),
+	/**
+	* Minimum bbox/mask overlap (0–1) with any of the rule's zones
+	* required to consider an entity "in the zone". Defaults to the
+	* consumer's stage default when omitted. Kept for back-compat with
+	* existing per-rule overrides; new operators pick the value via
+	* `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
+	* set, the lower-level engine reads it as a 0–1 fraction.
+	*/
+	overlapThreshold: number().min(0).max(1).optional(),
+	/**
+	* Operator-friendly version of `overlapThreshold` — the percentage
+	* of the detection's bbox that must lie inside the zone for the
+	* rule to match. Documented default is 85%; the engine substitutes
+	* that when the field is omitted (kept optional so existing rules
+	* stored without it stay valid).
+	*
+	* When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
+	* rule, the engine prefers `bboxInclusionPct` because it's the
+	* field exposed in the UI. Internally both feed the same gate.
+	*/
+	bboxInclusionPct: number().min(0).max(100).optional(),
+	/**
+	* When `true` and a detection has a segmentation mask, use the
+	* mask for overlap instead of the bbox. Detection-stage only;
+	* motion rules ignore this field.
+	*/
+	preferMask: boolean().optional(),
+	/**
+	* Soft-toggle: `false` disables the rule without deleting it.
+	* Defaults to `true` so operators creating a rule via the UI
+	* see it active immediately.
+	*/
+	enabled: boolean().default(true)
+});
+array(ZoneRuleSchema).readonly();
+/**
+* Zone — pure geometry + identity. NO filtering behaviour.
+*
+* Zones describe **where** in the frame the operator wants to flag
+* something; consumer-owned {@link ZoneRule} arrays describe **how**
+* each pipeline stage uses them. Splitting the two means a single
+* polygon "Driveway" can simultaneously back a motion-exclude rule,
+* a detection-include rule on `['car']`, and an occupancy aggregate
+* — without three duplicated polygons.
+*
+* Owned by the orchestrator addon (provider) and mirrored into the
+* `zones` device-state slice on every mutation. Consumers
+* (motion-wasm, pipeline-executor, analytics, admin UI) read either
+* via `api.zones.listZones` (one-shot) or via `dev.state.zones` (live
+* mirror with `onChanged`).
+*
+* Coordinates are normalised fractions of the frame (0–1) so zones
+* survive resolution changes and stream profile switches.
+*
+* `kind` discriminates between full polygons (closed regions used
+* for intrusion / occupancy filters) and tripwires (open 2-point
+* line segments used for cross events). Onboard / firmware-reported
+* zones (Reolink, ONVIF) are out of scope for now — see the deferred
+* task list.
+*/
+var ZoneKindEnum = _enum(["polygon", "tripwire"]);
+/** Polygon vertex in fraction-of-frame coordinates (0–1). */
+var PolygonPointSchema = object({
+	x: number(),
+	y: number()
+});
+/** A camera detection zone — pure geometry/identity. */
+var ZoneSchema = object({
+	id: string(),
+	name: string(),
+	kind: ZoneKindEnum.default("polygon"),
+	/** Polygon vertices, fraction of frame (0–1). */
+	polygon: array(PolygonPointSchema).readonly(),
+	/** Visual color for UI rendering. */
+	color: string().default("#3b82f6")
+});
+/**
+* Zones capability — per-camera CRUD over polygon detection zones.
+*
+* Provider lives in `addon-pipeline-orchestrator` (hub-only). Persists
+* to per-device settings and mirrors into the `zones` device-state
+* slice on every mutation, so downstream consumers can subscribe via
+* `dev.state.zones.onChanged`.
+*
+* The cap surface only handles geometry + identity; filtering
+* behaviour (per-class, include/exclude, threshold) lives in the
+* consumer addons' rule arrays — see `ZoneRuleSchema` exported from
+* `capabilities/schemas/zone-rule.js`.
+*/
+var zonesCapability = {
+	name: "zones",
+	scope: "device",
+	mode: "singleton",
+	deviceTypes: [DeviceType.Camera],
+	methods: {
+		listZones: method(object({ deviceId: number() }), array(ZoneSchema).readonly()),
+		addZone: method(object({
+			deviceId: number(),
+			zone: ZoneSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		removeZone: method(object({
+			deviceId: number(),
+			zoneId: string()
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		updateZone: method(object({
+			deviceId: number(),
+			zone: ZoneSchema
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
+	},
+	/**
+	* Runtime-state slice — the live zone catalogue mirrored by the
+	* orchestrator on every CRUD mutation. Consumers read via
+	* `device.state.zones.value` / `.watch(...)` without round-tripping
+	* the cap, and the codegen DeviceProxy auto-wires the reactive
+	* handle. Slice shape is `{ zones: Zone[] }` so future extensions
+	* (e.g. zone groupings) can sit alongside the polygon list.
+	*/
+	runtimeState: object({ zones: array(ZoneSchema).readonly() }),
+	/**
+	* Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
+	*
+	* See `RuntimeStateDurability`. Enforced by
+	* `scripts/check-runtime-state-durability.ts`.
+	*/
+	durability: "restored"
+};
+/**
+* pipeline-analytics — device-scoped wrapper cap. Refines raw
+* per-frame detections emitted by the pipeline runner into tracked
+* objects, per-kind event collections (motion / object / audio), and
+* persisted media. Owns the post-detection domain end-to-end:
+*
+*   runner emits PipelineInferenceResult
+*     ↓ (event bus)
+*   pipeline-analytics subscriber
+*     ↓ SORT tracker + zone engine + state analyzer + event emitter
+*   → three DB collections (one per kind), one FS media tree, one
+*     unified event emitter (FrameTracked + TrackStarted/Ended +
+*     DetectionEvent on bus)
+*
+* Pure subscriber model. No `processFrame` cap method — the runner
+* already publishes the raw frame on the bus. The cap surface is
+* only QUERIES + per-device settings, bound on/off via
+* `device-manager.setWrapperActive`. `defaultActive: true` because
+* every camera with a detection pipeline wants its raw detections
+* refined; operators opt out per-device via BindingsTab when needed.
+*
+* Replaces the legacy `analysis-pipeline`, `analysis-data-persistence`
+* (per-device surface) and `track-trail` caps — see P11 cleanup.
+*/
+var TrackStateSchema = _enum([
+	"new",
+	"entered",
+	"left",
+	"moving",
+	"idle"
+]);
+var EventKindSchema = _enum([
+	"motion",
+	"object",
+	"audio"
+]);
+/**
+* Spatial filter for `listTracks` — the rect + polygon variants of the shared
+* MaskShape vocabulary (see `mask-shape.ts`). Coordinates are NORMALIZED 0..1
+* of the camera frame (top-left origin), matching the drawing-plane editor.
+*/
+var TrackZoneFilterSchema = discriminatedUnion("kind", [MaskRectShapeSchema, MaskPolygonShapeSchema]);
+/** Closed icon vocabulary so clients render a known glyph per kind. */
+var EventKindIconSchema = _enum([
+	"motion",
+	"audio",
+	"person",
+	"vehicle",
+	"animal",
+	"door",
+	"pir",
+	"smoke",
+	"water",
+	"button",
+	"package",
+	"generic"
+]);
+var EventKindCategorySchema = _enum([
+	"motion",
+	"audio",
+	"detection",
+	"sensor",
+	"control",
+	"custom",
+	"package"
+]);
+/** Taxonomy level — macro (timeline lane) vs sub (events-page leaf). */
+var EventKindLevelSchema = _enum(["macro", "sub"]);
+var EventKindDescriptorSchema = object({
+	/** Stable kind id (e.g. 'motion', 'vehicle', 'car', 'lock'). */
+	kind: string(),
+	/** i18n key resolved on the UI side; `label` is the English fallback. */
+	labelKey: string(),
+	/** English fallback label (kept for clients that don't translate). */
+	label: string(),
+	/** Hex color for timeline/legend rendering. */
+	color: string(),
+	/** Dictionary id → lucide component on the UI side. */
+	iconId: string(),
+	/** Legacy closed-vocab glyph — fallback for `iconId`. */
+	icon: EventKindIconSchema,
+	category: EventKindCategorySchema,
+	/** Macro parent for this kind ('car' → 'vehicle'); null for a macro. */
+	parentKind: string().nullable(),
+	/** Derived from `parentKind`, explicit for the client tree. */
+	level: EventKindLevelSchema,
+	/** Which cap + device contributes this kind. For built-ins the camera
+	*  itself; for sensor kinds the LINKED source device. */
+	source: object({
+		capName: string(),
+		deviceId: number()
+	})
+});
+/** One camera's event vocabulary, as returned by `listEventKindsBatch`. */
+var EventKindsForDeviceSchema = object({
+	deviceId: number(),
+	kinds: array(EventKindDescriptorSchema).readonly()
+});
+var SensorEventSchema = object({
+	id: string(),
+	/** The CAMERA the event is attributed to (a sensor linked to N cameras
+	*  yields N rows, one per camera). */
+	deviceId: number(),
+	/** The linked sensor device whose state changed. */
+	sourceDeviceId: number(),
+	/** Event kind id — matches an `EventKindDescriptor.kind`. */
+	kind: string(),
+	/** Snapshot of the sensor cap's runtime-state slice at the change. */
+	value: record(string(), unknown()).nullable(),
+	timestamp: number()
+});
+var TrackPositionSchema = object({
+	x: number(),
+	y: number(),
+	timestamp: number(),
+	bbox: BoundingBoxSchema
+});
+var TrackSnapshotSchema = object({
+	timestamp: number(),
+	position: TrackPositionSchema,
+	/** MediaStore key; resolve via `getTrackMedia({ trackId })`. */
+	mediaKey: string()
+});
+/**
+* Normalized 0..1 trajectory envelope (min/max over every position bbox,
+* divided by the track's detection-frame dims), computed at persist time.
+* Absent when the frame dims were unknown when the track was persisted
+* (legacy rows / dims-less sources) and on active (in-RAM) tracks.
+*/
+var TrackEnvelopeSchema = object({
+	minX: number(),
+	minY: number(),
+	maxX: number(),
+	maxY: number()
+});
+/**
+* Row projection for track list queries. `full` (default) returns the
+* complete Track including the frame-rate `positions[]` history and the
+* `snapshots[]` references — megabytes across a page of tracks. `slim`
+* keeps every scalar the list surfaces actually render (ids, class(es),
+* label / audioLabels / importance enrichment, firstSeen/lastSeen, state,
+* zonesVisited, bestEventId, envelope, hasFace, hasEmbeddedFace, hasRider) and returns `positions` /
+* `snapshots` as EMPTY arrays — detail views re-fetch the full row via
+* `getTrack`. Mirrors the event-store `projection` convention
+* (`getObjectEvents` et al.).
+*/
+var TrackProjectionSchema = _enum(["full", "slim"]);
+/**
+* One audio-classification label heard on the track's camera while the
+* track was alive, aggregated per label. An "episode" is one persisted
+* audio event (the confident-classification path: score ≥ the device's
+* `classificationMinScore`, class-change-or-heartbeat coalesced) — NOT
+* one 32 ms inference chunk, so counts stay human-scaled.
+*/
+var TrackAudioLabelSchema = object({
+	label: string(),
+	/** Highest classification score observed across the label's episodes. */
+	peakScore: number(),
+	/** Number of coalesced audio-event episodes carrying this label. */
+	count: number(),
+	firstAt: number(),
+	lastAt: number()
+});
+/**
+* How a track was produced. `pipeline` (default / absent) = the spatial
+* detection+tracking pipeline. Every OTHER value is a SYNTHETIC projection —
+* no positions, a single snapshot, and no bbox trajectory at all:
+*
+*  - `sensor` — a linked sensor/control device state change.
+*  - `audio` — an audio event on the camera itself that was anomalous for
+*    THAT camera, loud, and heard while nothing visual was happening (D62).
+*
+* The spatial subsystems (tracker association, occupancy count, re-id /
+* embedding, resurrection) MUST skip every synthetic source. Test for that
+* with `isSpatialTrack`, which allow-lists `pipeline` — a `!== 'sensor'`
+* check silently readmits every source added after it was written.
+*/
+var TrackSourceSchema = _enum([
+	"pipeline",
+	"sensor",
+	"audio"
+]);
+/**
+* Where a track sits in the RETRAIN lifecycle (D81).
+*
+*  - `none` — never marked, or un-marked. Evictable.
+*  - `staging` — the operator wants this track as training material and has not
+*    finished with it. **This is the only state retention holds**: the track and
+*    everything it owns (object events, crops, keyframes, CLIP vector) survive
+*    the device's age window.
+*  - `trained` — the retrain page has taken what it needed. The frames it chose
+*    were COPIED into the retrain dataset at selection time, so the dataset no
+*    longer depends on the track's media and the track becomes EVICTABLE again.
+*    Terminal for the plain `markForTrain` toggle: returning it to `staging` is
+*    a deliberate action of the retrain page, not a side effect of a checkbox.
+*
+* There is no `null`. The state is stored `TEXT NOT NULL DEFAULT 'none'` because
+* the store's filter language has only positive equality and `whereIn` — no
+* negation, no IS NULL — so a NULL would be unselectable by ANY predicate and
+* would make the entire pre-column history immortal in one deploy.
+*/
+var RetrainStatusSchema = _enum([
 	"none",
 	"staging",
 	"trained"
@@ -19526,6 +20516,24 @@ var RebuildStatusSchema = object({
 	/** Present when the pass ended by throwing. */
 	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() });
 var pipelineAnalyticsCapability = {
 	name: "pipeline-analytics",
 	scope: "device",
@@ -19811,931 +20819,401 @@ var pipelineAnalyticsCapability = {
 		*  Backed by a declared pipeline-analytics SQLite collection. */
 		/** Internal migration-participant lease. It drains active MediaStore
 		* writes and refuses new ones without changing analytics bindings. */
-		pauseForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		resumeForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Drops cached location roots after the storage coordinator repoints a
-		* default so future event-media writes use the new root. */
-		refreshStorageLocationsForMigration: method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		startStorageMigrationMove: method(StorageMigrationMediaMoveInputSchema, object({ jobId: string() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		getStorageMigrationMoveStatus: method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }),
-		cancelStorageMigrationMove: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		listOpsLog: method(OpsLogQueryInputSchema, array(OpsLogEntrySchema).readonly(), {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* The CHEAP QUESTION, asked before any media moves: how big is the dataset
-		* the marked (`markForTrain`) tracks would produce?
-		*
-		* Answered from media INDEX rows only — key, kind, size, timestamp — so it
-		* costs ~2 KB of reads per track and no blob reads at all. The measured harm
-		* behind D56 was a bulk pass that read and base64'd every blob a track owned
-		* before deciding anything, taking hub-main to 82 s busy out of 120; an
-		* export is that same I/O shape, so it inherits the same discipline: know
-		* the size, then decide.
-		*
-		* `truncated` reports that more marked tracks exist than one pass carries.
-		* Empty `deviceIds` ⇒ every device that has marked tracks.
-		*/
-		getTrainingExportSummary: method(object({ deviceIds: array(number()).optional() }), TrainingExportSummarySchema, {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* Where to download the dataset archive.
-		*
-		* The BYTES do not come back through this cap — they come from the returned
-		* data-plane URL, which streams a tar built entry by entry. A multi-gigabyte
-		* archive base64'd through a unary RPC envelope would be held whole in
-		* memory twice on a hub this repo has already OOM'd once (D9/D18 are the
-		* same lesson about frames). `getDownloadUrl` on `recordingExport` is the
-		* precedent, and this follows it deliberately.
-		*
-		* The archive contains a `manifest.json` FIRST, then the stored media
-		* VERBATIM under `tracks/<deviceId>/<trackId>/…`. No crop is derived and no
-		* model is run: a training set's pixels must be the pixels the pipeline saw.
-		*/
-		getTrainingExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* The staging worklist for one camera, or for every camera that has one.
-		*
-		* Fetched ON DEMAND, over the staging set only — the page never scans
-		* history, because making the working set small is the entire purpose of
-		* the mark. Each row carries how many frames the dataset already holds from
-		* the track and how many subjects were annotated on them, so
-		* `frameCount: 0` reads as "still to work" without a second call per track.
-		*
-		* `auth: 'admin'`, unlike the viewer-level mark itself: marking a track is
-		* curation you do while looking at it, but building the training set the
-		* fleet's models are fine-tuned on is not.
-		*/
-		listRetrainStaging: method(object({
-			/** Empty ⇒ every camera that has staging tracks. A LIST, not a single
-			*  `deviceId`, deliberately: `deviceId` would make this device-bound and
-			*  route it at one camera's owner, and "every camera" would stop being
-			*  expressible at all. */
-			deviceIds: array(number()).optional(),
-			limit: number().int().min(1).max(500).optional()
-		}), array(RetrainTrackSchema).readonly(), {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* What a track can contribute, and what it already has.
-		*
-		* `candidates` are the track's whole, unannotated frames — index rows only,
-		* so this is cheap. `copies` are the frames already inside the dataset, and
-		* a candidate whose copy exists is marked `copied: true`: selecting it again
-		* is free and CANNOT fail, whatever became of the original.
-		*
-		* A crop, a thumbnail and `fullFrameBoxed` are never candidates. The last
-		* one matters most: it has the model's own rectangle burned into the pixels,
-		* and a detector trained on it learns to find a green line.
-		*/
-		listRetrainFrames: method(object({ trackId: string() }), RetrainFrameListSchema, {
-			kind: "query",
-			auth: "admin"
-		}),
-		/**
-		* COPY-ON-SELECT — the write that makes `trained` safe to evict.
-		*
-		* Selecting a frame copies its bytes into retrain storage immediately: not
-		* a reference, not a lease. Once the copy exists the dataset no longer
-		* depends on the track's media, which is exactly what lets D81 hand a
-		* `trained` track back to retention.
-		*
-		* The order inside is load-bearing and is pinned by a test: an EXISTING
-		* copy is returned without touching the source, so an original that
-		* evaporated blocks the selection of THAT ORIGINAL and never the copy
-		* already taken. Every refusal comes back named — a dropped selection is
-		* never silent, on the wire or in the log.
-		*/
-		selectRetrainFrames: method(object({
-			deviceId: number(),
-			trackId: string(),
-			mediaKeys: array(string()).min(1)
-		}), RetrainFrameSelectionSchema, {
+		pauseForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ paused: literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Un-select a frame: its annotations go first, then the copy and its blob.
-		*  Deliberately destructive and deliberately explicit — it is the only way
-		*  a frame leaves the dataset before export. */
-		deselectRetrainFrame: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string()
-		}), object({
-			removed: boolean(),
-			removedAnnotations: number().int()
-		}), {
+		resumeForStorageMigration: method(StorageMigrationLeaseInputSchema, object({ resumed: literal(true) }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/**
-		* The pixels of ONE copied frame, base64.
-		*
-		* Through the cap rather than a data plane because it is genuinely one
-		* frame at a time, on demand, at human speed — the shape D9/D18 permit
-		* (what they forbid is frames crossing a boundary at frame RATE). The
-		* annotation canvas needs the image and its exact dimensions in the same
-		* answer: a canvas that places a normalised box against a size it guessed
-		* draws every box in the wrong place.
-		*/
-		getRetrainFrameImage: method(object({ frameId: string() }), object({
-			base64: string(),
-			width: number().int(),
-			height: number().int()
-		}), {
-			kind: "query",
+		/** Drops cached location roots after the storage coordinator repoints a
+		* default so future event-media writes use the new root. */
+		refreshStorageLocationsForMigration: method(StorageMigrationLeaseInputSchema, object({ refreshed: literal(true) }), {
+			kind: "mutation",
 			auth: "admin"
 		}),
-		/**
-		* Ask the pipeline what it sees, as a PROPOSAL.
-		*
-		* Runs through `pipelineRunner.runStatelessStep` on the COPIED frame, and
-		* every box comes back as a draft with `source: 'assist'` plus the model and
-		* score that produced it. The operator confirms, edits, adds and deletes;
-		* nothing is stored until `saveRetrainAnnotations`.
-		*
-		* For packages the request is `rfdetr-package` on the ZONE CROP at 0.35 —
-		* never the whole frame, where a package detector at that threshold proposes
-		* furniture. A package request with no zone is REFUSED rather than widened,
-		* because the silent widening would look like a bad model for as long as
-		* nobody checked which rectangle it ran on.
-		*/
-		proposeRetrainAnnotations: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string(),
-			subject: RetrainAssistSubjectSchema,
-			/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
-			nodeId: string().optional()
-		}), RetrainAssistResultSchema, {
+		startStorageMigrationMove: method(StorageMigrationMediaMoveInputSchema, object({ jobId: string() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/** Every annotation on a track, oldest first. */
-		listRetrainAnnotations: method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
-			kind: "query",
+		getStorageMigrationMoveStatus: method(object({ jobId: string() }), RelocateJobSchema.nullable(), { auth: "admin" }),
+		cancelStorageMigrationMove: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
+			kind: "mutation",
 			auth: "admin"
 		}),
 		/**
-		* Replace EVERY annotation on one frame with the supplied set.
-		*
-		* Whole-frame replacement, not per-box upsert: the unit of ground truth is
-		* the frame, and "the operator deleted a box" must be the same durable
-		* outcome as "the operator never drew it". A per-box patch would let a frame
-		* keep a box the operator removed on a surface that only knew about the
-		* boxes it sent.
-		*
-		* Refuses a macro class typed into `label` or `subLabel` — the tiers are
-		* separate and the guard is at the WRITE, because a mixed taxonomy cannot
-		* be un-mixed by reading it.
+		* Moves event media between locations — the OPERATOR's mover, without the
+		* coordinator's lease. Twin of `recording.relocateFootage`: the same
+		* engine the lease-gated coordinated migration uses
+		* (`startStorageMigrationMove`), armable in the background and WITHOUT
+		* pausing anything. Exists because `eventMedia` was the only storage
+		* class whose only move path went through the recorder's global pause.
 		*/
-		saveRetrainAnnotations: method(object({
-			deviceId: number(),
-			trackId: string(),
-			frameId: string(),
-			annotations: array(RetrainAnnotationDraftSchema)
-		}), array(RetrainAnnotationSchema).readonly(), {
+		relocateMedia: method(RelocateMediaInputSchema, object({ jobId: string() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		/**
-		* Finish with a track: `staging → trained`. **The only writer of that
-		* state** — D81 shipped the column with it deliberately unreachable.
-		*
-		* Refuses a track the dataset holds no copies from. `trained` un-pins the
-		* track's media, so completing without a copy is a delete order for material
-		* nothing ever extracted anything from; that refusal IS the safety argument
-		* of D81, expressed as a precondition.
-		*/
-		completeRetrainTrack: method(object({
-			deviceId: number(),
-			trackId: string()
-		}), RetrainTransitionResultSchema, {
-			kind: "mutation",
+		/** Every relocate job this addon knows about, newest first (in RAM: the
+		*  move is resumable, so a lost list costs nothing but the display). */
+		listRelocateMediaJobs: method(object({}), array(RelocateJobSchema).readonly(), {
+			kind: "query",
 			auth: "admin"
 		}),
-		/**
-		* The deliberate return: `trained → staging`, for the rare case.
-		*
-		* The generic `setTrackFlags` toggle refuses this in both directions by
-		* design (D81) — re-staging from a checkbox is how the same material gets
-		* annotated twice under two ground truths. Doing it here means the operator
-		* is looking at the annotations that already exist while they decide, and
-		* those annotations are LEFT ALONE: "put this back" must not be a
-		* destructive act wearing a navigational name.
-		*/
-		restageRetrainTrack: method(object({
-			deviceId: number(),
-			trackId: string()
-		}), RetrainTransitionResultSchema, {
+		/** Cancel a running or queued relocate job. */
+		cancelRelocateMedia: method(object({ jobId: string() }), object({ cancelled: boolean() }), {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		listOpsLog: method(OpsLogQueryInputSchema, array(OpsLogEntrySchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
 		/**
-		* Where to download the ANNOTATED dataset.
+		* The CHEAP QUESTION, asked before any media moves: how big is the dataset
+		* the marked (`markForTrain`) tracks would produce?
 		*
-		* The sibling of `getTrainingExportUrl` and deliberately not the same
-		* archive: that one streams a marked track's stored media verbatim, this one
-		* streams the retrain COPIES plus an `annotations.json` carrying, for every
-		* subject, the canonical full-frame box AND the geometry derived for each
-		* model shape (letterboxed root / zone-cropped package / subject-cropped
-		* classifier). Derived at export, never stored — one box in, three shapes
-		* out, so two crops of the same subject can never end up in one feature
-		* space (D52).
+		* Answered from media INDEX rows only — key, kind, size, timestamp — so it
+		* costs ~2 KB of reads per track and no blob reads at all. The measured harm
+		* behind D56 was a bulk pass that read and base64'd every blob a track owned
+		* before deciding anything, taking hub-main to 82 s busy out of 120; an
+		* export is that same I/O shape, so it inherits the same discipline: know
+		* the size, then decide.
+		*
+		* `truncated` reports that more marked tracks exist than one pass carries.
+		* Empty `deviceIds` ⇒ every device that has marked tracks.
 		*/
-		getRetrainExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+		getTrainingExportSummary: method(object({ deviceIds: array(number()).optional() }), TrainingExportSummarySchema, {
 			kind: "query",
 			auth: "admin"
 		}),
-		getEventMedia: method(object({
-			eventId: string(),
-			kind: MediaFileKindEnum.optional(),
-			deviceId: number()
-		}), array(MediaFileSchema).readonly()),
-		/** All media rows owned by a track. `kinds` narrows to a kind subset so a
-		*  client can fetch the SMALL display variants on open and pull the
-		*  multi-MB native variants only on demand (mirrors `getEventMedia.kind`).
-		*  Absent ⇒ every kind (back-compat). */
-		getTrackMedia: method(object({
-			trackId: string(),
-			kinds: array(MediaFileKindEnum).optional(),
-			deviceId: number()
-		}), array(MediaFileSchema).readonly()),
 		/**
-		* What media a track HAS, without any of it.
+		* Where to download the dataset archive.
 		*
-		* The detail view needs the shape of a track's media to build its strip —
-		* which kinds exist, in what order, at what size — and then wants each tile
-		* fetched as an image, not as base64 inside this response. Measured: the
-		* full `getTrackMedia` is 5.3-7.7 MB and blocks the view; this manifest is
-		* ~2 KB.
+		* The BYTES do not come back through this cap — they come from the returned
+		* data-plane URL, which streams a tar built entry by entry. A multi-gigabyte
+		* archive base64'd through a unary RPC envelope would be held whole in
+		* memory twice on a hub this repo has already OOM'd once (D9/D18 are the
+		* same lesson about frames). `getDownloadUrl` on `recordingExport` is the
+		* precedent, and this follows it deliberately.
 		*
-		* It also restores a fact a `kinds` filter destroys: filtering
-		* `getTrackMedia` drops whole ROWS, taking `kind` and `sizeBytes` with
-		* them, so a client that fetched only the small variants could no longer
-		* tell a full-resolution variant existed — and the affordance that opens it
-		* would silently disappear.
-		*/
-		listTrackMedia: method(object({
-			trackId: string(),
-			deviceId: number()
-		}), array(MediaFileInfoSchema).readonly()),
-		/**
-		* Search object events by text query using CLIP cosine similarity.
-		* Encodes `text` via the `embedding-encoder` cap, queries the
-		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
-		* embeddings by cosine similarity, and joins winners to their
-		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
-		* `minScore`, sorted descending by score.
+		* The archive contains a `manifest.json` FIRST, then the stored media
+		* VERBATIM under `tracks/<deviceId>/<trackId>/…`. No crop is derived and no
+		* model is run: a training set's pixels must be the pixels the pipeline saw.
 		*/
-		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
-		wipeObjectEmbeddings: method(object({}), WipeObjectEmbeddingsResultSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
-			kind: "mutation",
+		getTrainingExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+			kind: "query",
 			auth: "admin"
 		}),
-		getObjectEmbeddingRebuildStatus: method(object({}), RebuildStatusSchema)
-	},
-	events: {
 		/**
-		* Enriched frame emitted after refinement — the live-overlay source of
-		* truth (two-plane re-injection). Carries the frame's detections in the
-		* `ObjectDetection` wire shape: first-level roots (with track info +
-		* enrichment labels) plus synthesized `kind:'detail'` face/plate entries
-		* re-projected from per-track detail state, so stream overlays render
-		* boxes + recognized names without querying full Track state.
+		* The staging worklist for one camera, or for every camera that has one.
+		*
+		* Fetched ON DEMAND, over the staging set only — the page never scans
+		* history, because making the working set small is the entire purpose of
+		* the mark. Each row carries how many frames the dataset already holds from
+		* the track and how many subjects were annotated on them, so
+		* `frameCount: 0` reads as "still to work" without a second call per track.
+		*
+		* `auth: 'admin'`, unlike the viewer-level mark itself: marking a track is
+		* curation you do while looking at it, but building the training set the
+		* fleet's models are fine-tuned on is not.
 		*/
-		onFrameTracked: { data: object({
-			deviceId: number(),
-			timestamp: number(),
-			frameWidth: number(),
-			frameHeight: number(),
-			detections: array(OverlayDetectionSchema).readonly()
-		}) },
-		/** Track entered active state (first-seen). */
-		onTrackStarted: { data: object({
-			deviceId: number(),
-			trackId: string(),
-			className: string()
-		}) },
-		/** Track expired (TTL reached after last detection). */
-		onTrackEnded: { data: object({
-			deviceId: number(),
-			trackId: string(),
-			className: string(),
-			durationMs: number()
-		}) },
-		/** Canonical "something happened at device X" event, per-kind. */
-		onDetectionEvent: { data: object({
-			deviceId: number(),
-			kind: EventKindSchema,
-			eventId: string(),
-			timestamp: number()
-		}) }
-	}
-};
-/**
-* Reference to the frame's retained NATIVE surface + the parent crop's placement
-* within the frame, so the executor can re-cut a leaf child ROI at native
-* resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
-*/
-var NativeCropRefSchema = object({
-	/** Handle keying the retained native surface (node-pinned to its owner). */
-	handle: FrameHandleSchema,
-	/** The parent crop's padded/clamped rectangle in FRAME-space pixels. */
-	cropFrameSpace: object({
-		x: number(),
-		y: number(),
-		w: number(),
-		h: number()
-	})
-});
-object({
-	crop: object({
-		left: number(),
-		top: number(),
-		width: number().positive(),
-		height: number().positive()
-	}).optional(),
-	content: object({
-		width: number().int().positive(),
-		height: number().int().positive()
-	}),
-	fit: _enum(["stretch", "contain"]),
-	format: _enum([
-		"rgb",
-		"gray",
-		"jpeg"
-	])
-});
-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)),
+		listRetrainStaging: method(object({
+			/** Empty ⇒ every camera that has staging tracks. A LIST, not a single
+			*  `deviceId`, deliberately: `deviceId` would make this device-bound and
+			*  route it at one camera's owner, and "every camera" would stop being
+			*  expressible at all. */
+			deviceIds: array(number()).optional(),
+			limit: number().int().min(1).max(500).optional()
+		}), array(RetrainTrackSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
 		/**
-		* 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.
+		* What a track can contribute, and what it already has.
+		*
+		* `candidates` are the track's whole, unannotated frames — index rows only,
+		* so this is cheap. `copies` are the frames already inside the dataset, and
+		* a candidate whose copy exists is marked `copied: true`: selecting it again
+		* is free and CANNOT fail, whatever became of the original.
+		*
+		* A crop, a thumbnail and `fullFrameBoxed` are never candidates. The last
+		* one matters most: it has the model's own rectangle burned into the pixels,
+		* and a detector trained on it learns to find a green line.
 		*/
-		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",
+		listRetrainFrames: method(object({ trackId: string() }), RetrainFrameListSchema, {
+			kind: "query",
 			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`.
+		* COPY-ON-SELECT — the write that makes `trained` safe to evict.
 		*
-		* 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.
+		* Selecting a frame copies its bytes into retrain storage immediately: not
+		* a reference, not a lease. Once the copy exists the dataset no longer
+		* depends on the track's media, which is exactly what lets D81 hand a
+		* `trained` track back to retention.
+		*
+		* The order inside is load-bearing and is pinned by a test: an EXISTING
+		* copy is returned without touching the source, so an original that
+		* evaporated blocks the selection of THAT ORIGINAL and never the copy
+		* already taken. Every refusal comes back named — a dropped selection is
+		* never silent, on the wire or in the log.
 		*/
-		clearDeviceOverrides: method(object({ nodeId: string() }), object({
-			success: literal(true),
-			clearedDevices: number()
+		selectRetrainFrames: method(object({
+			deviceId: number(),
+			trackId: string(),
+			mediaKeys: array(string()).min(1)
+		}), RetrainFrameSelectionSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Un-select a frame: its annotations go first, then the copy and its blob.
+		*  Deliberately destructive and deliberately explicit — it is the only way
+		*  a frame leaves the dataset before export. */
+		deselectRetrainFrame: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string()
+		}), object({
+			removed: boolean(),
+			removedAnnotations: number().int()
 		}), {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		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.
+		* The pixels of ONE copied frame, base64.
+		*
+		* Through the cap rather than a data plane because it is genuinely one
+		* frame at a time, on demand, at human speed — the shape D9/D18 permit
+		* (what they forbid is frames crossing a boundary at frame RATE). The
+		* annotation canvas needs the image and its exact dimensions in the same
+		* answer: a canvas that places a normalised box against a size it guessed
+		* draws every box in the wrong place.
 		*/
-		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" }),
+		getRetrainFrameImage: method(object({ frameId: string() }), object({
+			base64: string(),
+			width: number().int(),
+			height: number().int()
+		}), {
+			kind: "query",
+			auth: "admin"
+		}),
 		/**
-		* Stateless single-frame execution. Callers (runner, benchmark) pass
-		* the complete `engine` + `steps` tree; the executor holds no state
-		* about cameras or saved pipelines.
+		* Ask the pipeline what it sees, as a PROPOSAL.
 		*
-		* `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.
+		* Runs through `pipelineRunner.runStatelessStep` on the COPIED frame, and
+		* every box comes back as a draft with `source: 'assist'` plus the model and
+		* score that produced it. The operator confirms, edits, adds and deletes;
+		* nothing is stored until `saveRetrainAnnotations`.
 		*
-		* 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.
+		* For packages the request is `rfdetr-package` on the ZONE CROP at 0.35 —
+		* never the whole frame, where a package detector at that threshold proposes
+		* furniture. A package request with no zone is REFUSED rather than widened,
+		* because the silent widening would look like a bad model for as long as
+		* nobody checked which rectangle it ran on.
 		*/
-		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" }),
+		proposeRetrainAnnotations: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string(),
+			subject: RetrainAssistSubjectSchema,
+			/** Which node runs it. Absent ⇒ wherever an unowned call lands. */
+			nodeId: string().optional()
+		}), RetrainAssistResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/**
-		* 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.
+		* The FrameProcessor pass of a replay run — see the `Replay` section
+		* above this capability's definition for why this is not the
+		* `processFrame` method this file's header says pipeline-analytics does
+		* not have.
 		*
-		* Used by `scripts/bench-batch-style.mts` for batch benchmarking —
-		* N frames in one call to amortise per-call IPC overhead.
+		* Constructs a FRESH `FrameProcessor` for `(deviceId, source)`, feeds it
+		* `frames` IN THE ORDER GIVEN (the caller is responsible for time
+		* ordering — this method does not sort), and returns the tracks it
+		* produced. Zero persistence: no `TrackStore`, no event bus, no media
+		* capture. `zones` / `detectionRules` are the run's OWN zone set —
+		* typically the camera's real zones plus an ephemeral overlay
+		* (`addon-benchmark`'s `replay-plan.ts`), never read from or written to
+		* the `zones` capability by this method itself.
 		*/
-		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" }),
+		runReplayFrameProcessor: method(object({
+			deviceId: number(),
+			source: DetectionSourceSchema,
+			zones: array(ZoneSchema).readonly().optional(),
+			detectionRules: array(ZoneRuleSchema).readonly().optional(),
+			zoneMembershipMinOverlap: number().min(0).max(1).optional(),
+			frames: array(ReplayFrameInputSchema).min(1)
+		}), RunReplayFrameProcessorResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/** Every annotation on a track, oldest first. */
+		listRetrainAnnotations: method(object({ trackId: string() }), array(RetrainAnnotationSchema).readonly(), {
+			kind: "query",
+			auth: "admin"
+		}),
 		/**
-		* 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.
+		* Replace EVERY annotation on one frame with the supplied set.
+		*
+		* Whole-frame replacement, not per-box upsert: the unit of ground truth is
+		* the frame, and "the operator deleted a box" must be the same durable
+		* outcome as "the operator never drew it". A per-box patch would let a frame
+		* keep a box the operator removed on a surface that only knew about the
+		* boxes it sent.
+		*
+		* Refuses a macro class typed into `label` or `subLabel` — the tiers are
+		* separate and the guard is at the WRITE, because a mixed taxonomy cannot
+		* be un-mixed by reading it.
 		*/
-		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" }),
+		saveRetrainAnnotations: method(object({
+			deviceId: number(),
+			trackId: string(),
+			frameId: string(),
+			annotations: array(RetrainAnnotationDraftSchema)
+		}), array(RetrainAnnotationSchema).readonly(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/**
-		* 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.
+		* Finish with a track: `staging → trained`. **The only writer of that
+		* state** — D81 shipped the column with it deliberately unreachable.
+		*
+		* Refuses a track the dataset holds no copies from. `trained` un-pins the
+		* track's media, so completing without a copy is a delete order for material
+		* nothing ever extracted anything from; that refusal IS the safety argument
+		* of D81, expressed as a precondition.
 		*/
-		inferCached: method(object({
-			stepId: string(),
-			frameId: number().int()
-		}), record(string(), unknown()), { kind: "mutation" }),
+		completeRetrainTrack: method(object({
+			deviceId: number(),
+			trackId: string()
+		}), RetrainTransitionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/**
-		* Release a cached frame from the Python pool's memory.
+		* The deliberate return: `trained → staging`, for the rare case.
+		*
+		* The generic `setTrackFlags` toggle refuses this in both directions by
+		* design (D81) — re-staging from a checkbox is how the same material gets
+		* annotated twice under two ground truths. Doing it here means the operator
+		* is looking at the annotations that already exist while they decide, and
+		* those annotations are LEFT ALONE: "put this back" must not be a
+		* destructive act wearing a navigational name.
 		*/
-		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()
-		})),
+		restageRetrainTrack: method(object({
+			deviceId: number(),
+			trackId: string()
+		}), RetrainTransitionResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/**
-		* 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.
+		* Where to download the ANNOTATED dataset.
+		*
+		* The sibling of `getTrainingExportUrl` and deliberately not the same
+		* archive: that one streams a marked track's stored media verbatim, this one
+		* streams the retrain COPIES plus an `annotations.json` carrying, for every
+		* subject, the canonical full-frame box AND the geometry derived for each
+		* model shape (letterboxed root / zone-cropped package / subject-cropped
+		* classifier). Derived at export, never stored — one box in, three shapes
+		* out, so two crops of the same subject can never end up in one feature
+		* space (D52).
 		*/
-		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",
+		getRetrainExportUrl: method(object({ deviceIds: array(number()).optional() }), object({ url: string() }), {
+			kind: "query",
 			auth: "admin"
 		}),
+		getEventMedia: method(object({
+			eventId: string(),
+			kind: MediaFileKindEnum.optional(),
+			deviceId: number()
+		}), array(MediaFileSchema).readonly()),
+		/** All media rows owned by a track. `kinds` narrows to a kind subset so a
+		*  client can fetch the SMALL display variants on open and pull the
+		*  multi-MB native variants only on demand (mirrors `getEventMedia.kind`).
+		*  Absent ⇒ every kind (back-compat). */
+		getTrackMedia: method(object({
+			trackId: string(),
+			kinds: array(MediaFileKindEnum).optional(),
+			deviceId: number()
+		}), array(MediaFileSchema).readonly()),
 		/**
-		* 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.
+		* What media a track HAS, without any of it.
+		*
+		* The detail view needs the shape of a track's media to build its strip —
+		* which kinds exist, in what order, at what size — and then wants each tile
+		* fetched as an image, not as base64 inside this response. Measured: the
+		* full `getTrackMedia` is 5.3-7.7 MB and blocks the view; this manifest is
+		* ~2 KB.
+		*
+		* It also restores a fact a `kinds` filter destroys: filtering
+		* `getTrackMedia` drops whole ROWS, taking `kind` and `sizeBytes` with
+		* them, so a client that fetched only the small variants could no longer
+		* tell a full-resolution variant existed — and the affordance that opens it
+		* would silently disappear.
 		*/
-		killEngine: method(object({
-			engine: PipelineEngineChoiceSchema,
-			force: boolean().optional()
-		}), object({
-			success: boolean(),
-			reason: string().optional()
-		}), {
+		listTrackMedia: method(object({
+			trackId: string(),
+			deviceId: number()
+		}), array(MediaFileInfoSchema).readonly()),
+		/**
+		* Search object events by text query using CLIP cosine similarity.
+		* Encodes `text` via the `embedding-encoder` cap, queries the
+		* `ObjectEmbeddingStore` with optional prefilters, ranks all matching
+		* embeddings by cosine similarity, and joins winners to their
+		* ObjectEvents by trackId. Returns up to `limit` events scored ≥
+		* `minScore`, sorted descending by score.
+		*/
+		searchObjectEvents: method(SearchObjectEventsInput, array(ScoredObjectEventSchema).readonly()),
+		wipeObjectEmbeddings: method(object({}), WipeObjectEmbeddingsResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		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)
+		rebuildObjectEmbeddings: method(RebuildObjectEmbeddingsInput, RebuildObjectEmbeddingsResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getObjectEmbeddingRebuildStatus: method(object({}), RebuildStatusSchema)
+	},
+	events: {
+		/**
+		* Enriched frame emitted after refinement — the live-overlay source of
+		* truth (two-plane re-injection). Carries the frame's detections in the
+		* `ObjectDetection` wire shape: first-level roots (with track info +
+		* enrichment labels) plus synthesized `kind:'detail'` face/plate entries
+		* re-projected from per-track detail state, so stream overlays render
+		* boxes + recognized names without querying full Track state.
+		*/
+		onFrameTracked: { data: object({
+			deviceId: number(),
+			timestamp: number(),
+			frameWidth: number(),
+			frameHeight: number(),
+			detections: array(OverlayDetectionSchema).readonly()
+		}) },
+		/** Track entered active state (first-seen). */
+		onTrackStarted: { data: object({
+			deviceId: number(),
+			trackId: string(),
+			className: string()
+		}) },
+		/** Track expired (TTL reached after last detection). */
+		onTrackEnded: { data: object({
+			deviceId: number(),
+			trackId: string(),
+			className: string(),
+			durationMs: number()
+		}) },
+		/** Canonical "something happened at device X" event, per-kind. */
+		onDetectionEvent: { data: object({
+			deviceId: number(),
+			kind: EventKindSchema,
+			eventId: string(),
+			timestamp: number()
+		}) }
 	}
 };
 object({
@@ -20763,106 +21241,6 @@ var CameraMetricsSchema = object({
 });
 var CameraMetricsWithDeviceIdSchema = CameraMetricsSchema.extend({ deviceId: number() });
 /**
-* Zone — pure geometry + identity. NO filtering behaviour.
-*
-* Zones describe **where** in the frame the operator wants to flag
-* something; consumer-owned {@link ZoneRule} arrays describe **how**
-* each pipeline stage uses them. Splitting the two means a single
-* polygon "Driveway" can simultaneously back a motion-exclude rule,
-* a detection-include rule on `['car']`, and an occupancy aggregate
-* — without three duplicated polygons.
-*
-* Owned by the orchestrator addon (provider) and mirrored into the
-* `zones` device-state slice on every mutation. Consumers
-* (motion-wasm, pipeline-executor, analytics, admin UI) read either
-* via `api.zones.listZones` (one-shot) or via `dev.state.zones` (live
-* mirror with `onChanged`).
-*
-* Coordinates are normalised fractions of the frame (0–1) so zones
-* survive resolution changes and stream profile switches.
-*
-* `kind` discriminates between full polygons (closed regions used
-* for intrusion / occupancy filters) and tripwires (open 2-point
-* line segments used for cross events). Onboard / firmware-reported
-* zones (Reolink, ONVIF) are out of scope for now — see the deferred
-* task list.
-*/
-var ZoneKindEnum = _enum(["polygon", "tripwire"]);
-/** Polygon vertex in fraction-of-frame coordinates (0–1). */
-var PolygonPointSchema = object({
-	x: number(),
-	y: number()
-});
-/** A camera detection zone — pure geometry/identity. */
-var ZoneSchema = object({
-	id: string(),
-	name: string(),
-	kind: ZoneKindEnum.default("polygon"),
-	/** Polygon vertices, fraction of frame (0–1). */
-	polygon: array(PolygonPointSchema).readonly(),
-	/** Visual color for UI rendering. */
-	color: string().default("#3b82f6")
-});
-/**
-* Zones capability — per-camera CRUD over polygon detection zones.
-*
-* Provider lives in `addon-pipeline-orchestrator` (hub-only). Persists
-* to per-device settings and mirrors into the `zones` device-state
-* slice on every mutation, so downstream consumers can subscribe via
-* `dev.state.zones.onChanged`.
-*
-* The cap surface only handles geometry + identity; filtering
-* behaviour (per-class, include/exclude, threshold) lives in the
-* consumer addons' rule arrays — see `ZoneRuleSchema` exported from
-* `capabilities/schemas/zone-rule.js`.
-*/
-var zonesCapability = {
-	name: "zones",
-	scope: "device",
-	mode: "singleton",
-	deviceTypes: [DeviceType.Camera],
-	methods: {
-		listZones: method(object({ deviceId: number() }), array(ZoneSchema).readonly()),
-		addZone: method(object({
-			deviceId: number(),
-			zone: ZoneSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		removeZone: method(object({
-			deviceId: number(),
-			zoneId: string()
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		updateZone: method(object({
-			deviceId: number(),
-			zone: ZoneSchema
-		}), _void(), {
-			kind: "mutation",
-			auth: "admin"
-		})
-	},
-	/**
-	* Runtime-state slice — the live zone catalogue mirrored by the
-	* orchestrator on every CRUD mutation. Consumers read via
-	* `device.state.zones.value` / `.watch(...)` without round-tripping
-	* the cap, and the codegen DeviceProxy auto-wires the reactive
-	* handle. Slice shape is `{ zones: Zone[] }` so future extensions
-	* (e.g. zone groupings) can sit alongside the polygon list.
-	*/
-	runtimeState: object({ zones: array(ZoneSchema).readonly() }),
-	/**
-	* Runtime-state durability: **restored** — written only on operator mutation, so a camera that never had one has nothing to re-derive from. This is the slice `zone-mirror-hydration.ts` exists to paper over.
-	*
-	* See `RuntimeStateDurability`. Enforced by
-	* `scripts/check-runtime-state-durability.ts`.
-	*/
-	durability: "restored"
-};
-/**
 * A bounding box in NORMALIZED [0,1] frame coordinates for `getNativeCrop`. The
 * decode worker resolves it against the RETAINED native frame's real pixel dims,
 * so the caller supplies only the detection-res bbox divided by the detection
@@ -23146,6 +23524,20 @@ var ssoBridgeCapability = {
 	mode: "singleton",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — `signBridgeToken` was reachable on the
+		* AppRouter by ANY authenticated session at the default
+		* `auth: 'protected'`. The claims (including `isAdmin`) are CALLER-
+		* SUPPLIED: an unprivileged session could have minted its own
+		* `isAdmin: true` bridge token and redeemed it at
+		* `/api/auth/sso/finish` to become admin — a full privilege escalation
+		* through the exact surface this cap exists to close (see the module
+		* docblock). Every real caller (`oauth-grants.ts`, `main.ts`
+		* registration, the OIDC/magic-link addons) reaches this through
+		* `ctx.api` / the in-process registry — never through tRPC — so
+		* `auth: 'admin'` costs those callers nothing.
+		*/
 		signBridgeToken: method(object({
 			claims: SsoBridgeClaimsSchema,
 			/**
@@ -23158,8 +23550,8 @@ var ssoBridgeCapability = {
 			* linking rather than produce an eternal token.
 			*/
 			ttlSec: union([number().int().positive(), literal("never")]).optional()
-		}), object({ token: string() })),
-		verifyBridgeToken: method(object({ token: string() }), SsoBridgeClaimsSchema.nullable())
+		}), object({ token: string() }), { auth: "admin" }),
+		verifyBridgeToken: method(object({ token: string() }), SsoBridgeClaimsSchema.nullable(), { auth: "admin" })
 	}
 };
 var ProviderListEntrySchema = discriminatedUnion("shouldSaveDiskSpace", [object({
@@ -23308,8 +23700,15 @@ var storageEvictableCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`) — this was reachable on the AppRouter by ANY
+		* authenticated session at the default `auth: 'protected'`. The only
+		* consumer is the orchestrator's `StoragePressureManager`, which calls
+		* `ctx.api` — never tRPC — so `auth: 'admin'` costs it nothing.
+		*/
 		/** Bytes this provider holds on the given location — drives proportional fan-out. */
-		getEvictableUsage: method(object({ locationId: string() }), EvictableUsageSchema),
+		getEvictableUsage: method(object({ locationId: string() }), EvictableUsageSchema, { auth: "admin" }),
 		/**
 		* Free approximately `targetBytes` of this provider's OWN least-valuable
 		* data on the location (oldest footage, expired clips, …). Returns what it
@@ -23318,7 +23717,10 @@ var storageEvictableCapability = {
 		evict: method(object({
 			locationId: string(),
 			targetBytes: number().int().positive()
-		}), EvictResultSchema, { kind: "mutation" })
+		}), EvictResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /**
@@ -23421,43 +23823,82 @@ var storageProviderCapability = {
 	mode: "collection",
 	internal: true,
 	methods: {
+		/**
+		* Every method below except `testLocation` had NO `auth` override —
+		* `internal: true` did not gate the mount (see the 2026-08-26 note on
+		* `data-store-provider`), so this was reachable on the AppRouter by ANY
+		* authenticated session at the default `auth: 'protected'`: arbitrary
+		* read/write/delete/list against any storage location the operator has
+		* configured, keyed only by a caller-supplied `location` + `relativePath`
+		* — the same "public consumers never see this cap" claim that was false
+		* for `data-store-provider`, here gating raw file I/O instead of raw
+		* settings rows. The only legitimate caller,
+		* `addon-registry.service.ts`'s `activeStorageProvider`, calls the
+		* provider object directly (in-process) — never tRPC — so `auth: 'admin'`
+		* on every method costs it nothing. Public consumers already go through
+		* the separate `storage` singleton cap.
+		*/
 		/** Self-description for the "Add location" wizard. */
-		getProviderInfo: method(_void(), ProviderInfoSchema),
+		getProviderInfo: method(_void(), ProviderInfoSchema, { auth: "admin" }),
 		/** Validate config + probe connectivity. Called on add and on edit. */
 		testLocation: method(object({ config: record(string(), unknown()) }), TestLocationResultSchema, { auth: "admin" }),
 		resolve: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), string()),
+		}), string(), { auth: "admin" }),
 		write: method(object({
 			location: StorageLocationSchema,
 			relativePath: string(),
 			data: _instanceof(Uint8Array)
-		}), _void(), { kind: "mutation" }),
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		read: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), _instanceof(Uint8Array)),
+		}), _instanceof(Uint8Array), { auth: "admin" }),
 		exists: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), boolean()),
+		}), boolean(), { auth: "admin" }),
 		list: method(object({
 			location: StorageLocationSchema,
 			prefix: string().optional()
-		}), array(string()).readonly()),
+		}), array(string()).readonly(), { auth: "admin" }),
 		delete: method(object({
 			location: StorageLocationSchema,
 			relativePath: string()
-		}), _void(), { kind: "mutation" }),
-		getAvailableSpace: method(object({ location: StorageLocationSchema }), number().nullable()),
-		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, { kind: "mutation" }),
-		writeChunk: method(WriteChunkInputSchema, _void(), { kind: "mutation" }),
-		finalizeUpload: method(FinalizeUploadInputSchema, _void(), { kind: "mutation" }),
-		abortUpload: method(AbortUploadInputSchema, _void(), { kind: "mutation" }),
-		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, { kind: "mutation" }),
-		readChunk: method(ReadChunkInputSchema, _instanceof(Uint8Array)),
-		endDownload: method(EndDownloadInputSchema, _void(), { kind: "mutation" })
+		}), _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		getAvailableSpace: method(object({ location: StorageLocationSchema }), number().nullable(), { auth: "admin" }),
+		beginUpload: method(BeginUploadInputSchema, BeginUploadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		writeChunk: method(WriteChunkInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		finalizeUpload: method(FinalizeUploadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		abortUpload: method(AbortUploadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		beginDownload: method(BeginDownloadInputSchema, BeginDownloadResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		readChunk: method(ReadChunkInputSchema, _instanceof(Uint8Array), { auth: "admin" }),
+		endDownload: method(EndDownloadInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		})
 	}
 };
 /** Profile-exported FormBuilder schema. Shape is ConfigUISchema at the UI. */
@@ -23790,9 +24231,28 @@ var userPasskeysCapability = {
 			auth: "admin",
 			access: "create"
 		}),
+		/**
+		* The four methods below had NO `auth` override — `internal: true` did
+		* not gate the mount (see the 2026-08-26 note on `data-store-provider`),
+		* so they were reachable on the AppRouter at the default
+		* `auth: 'protected'` (any authenticated session), inconsistent with
+		* every other method on this cap (all already `auth: 'admin'`).
+		*
+		* ⚠ Checked before gating: these are also the PRE-AUTH login-ceremony
+		* methods, so admin-gating them here must not break login for an
+		* unauthenticated principal. It doesn't — the real login path is the
+		* PUBLIC `auth.beginAuthentication` / `auth.finishAuthentication` /
+		* `auth.beginDiscoverableAuthentication` / `auth.finishDiscoverableAuthentication`
+		* procedures in `server/backend/src/api/core/auth.router.ts`, which call
+		* `provider.beginAuthentication(...)` etc. directly against the
+		* capability-registry-resolved provider — never through this cap's own
+		* tRPC route. `auth: 'admin'` here only closes a redundant, unused
+		* second entry point onto the same ceremony.
+		*/
 		beginAuthentication: method(object({ userId: string().optional() }), object({ optionsJSON: record(string(), unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishAuthentication: method(object({
 			/** Required — the user the assertion belongs to (verified). */
@@ -23801,11 +24261,13 @@ var userPasskeysCapability = {
 			response: record(string(), unknown())
 		}), object({ verified: boolean() }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		beginDiscoverableAuthentication: method(object({}), object({ optionsJSON: record(string(), unknown()) }), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		finishDiscoverableAuthentication: method(object({ 
 		/** AuthenticationResponseJSON from the browser. */
@@ -23814,7 +24276,8 @@ response: record(string(), unknown()) }), object({
 			userId: string().nullable()
 		}), {
 			kind: "mutation",
-			access: "view"
+			access: "view",
+			auth: "admin"
 		}),
 		listPasskeys: method(object({ userId: string() }), array(PasskeySummarySchema), { auth: "admin" }),
 		removePasskey: method(object({
@@ -23992,6 +24455,14 @@ var VectorStatsResultSchema = object({
 	/** False when the backend ranks approximately. */
 	exact: boolean()
 });
+/**
+* `internal: true` did not gate the mount (see the 2026-08-26 note on
+* `data-store-provider`) — every method below was reachable on the AppRouter
+* by ANY authenticated session at the default `auth: 'protected'`. The only
+* consumers (`addon-post-analysis`'s embedding stores) reach this cap via
+* `ctx.api` — UDS/Moleculer, never tRPC — so `auth: 'admin'` on every method
+* costs them nothing. No client (viewer or admin-ui) calls `vectorStore.*`.
+*/
 var vectorStoreCapability = {
 	name: "vector-store",
 	scope: "system",
@@ -23999,14 +24470,26 @@ var vectorStoreCapability = {
 	internal: true,
 	methods: {
 		/** Idempotent. Re-declaring with a different `dim` is an error, not a wipe. */
-		declareIndex: method(VectorDeclareIndexInputSchema, _void(), { kind: "mutation" }),
-		upsert: method(VectorUpsertInputSchema, VectorUpsertResultSchema, { kind: "mutation" }),
-		query: method(VectorQueryInputSchema, VectorQueryResultSchema),
+		declareIndex: method(VectorDeclareIndexInputSchema, _void(), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		upsert: method(VectorUpsertInputSchema, VectorUpsertResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		query: method(VectorQueryInputSchema, VectorQueryResultSchema, { auth: "admin" }),
 		/** Metadata by id, no vectors — see {@link VectorGetResultSchema}. */
-		getByIds: method(VectorGetInputSchema, VectorGetResultSchema),
-		deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		deleteByFilter: method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, { kind: "mutation" }),
-		stats: method(VectorStatsInputSchema, VectorStatsResultSchema)
+		getByIds: method(VectorGetInputSchema, VectorGetResultSchema, { auth: "admin" }),
+		deleteByIds: method(VectorDeleteInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		deleteByFilter: method(VectorDeleteByFilterInputSchema, VectorDeleteResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		stats: method(VectorStatsInputSchema, VectorStatsResultSchema, { auth: "admin" })
 	}
 };
 var ClipSchema = object({
@@ -26855,7 +27338,27 @@ var faceGalleryCapability = {
 	scope: "system",
 	mode: "singleton",
 	methods: {
-		listIdentities: method(_void(), array(IdentitySchema).readonly()),
+		listIdentities: method(object({ 
+		/**
+		* Inline {@link IdentitySchema.coverBase64} on every row.
+		*
+		* Default `false`, the same inversion `listRecentFaces` and
+		* `listPlates` took on 2026-08-25 (see `include-crops-default.ts` for
+		* why the burden belongs on the caller that WANTS the bytes). Measured
+		* on the live hub the same day: four identities cost 40,979 B with the
+		* covers inline, ~10 KB of base64 per row, on a query this UI mounts
+		* four times and the viewer holds at `staleTime: 30_000`.
+		*
+		* Nothing loses its avatar: `coverMediaKey` is already on every row and
+		* the `event-media` plane serves that key `immutable` with an ETag.
+		*
+		* **This is an INPUT field, so it does not reach the addon until the
+		* next train** — the hub router validates cap inputs against its own
+		* compiled Zod and strips a key it does not know. Until then the
+		* provider sees `undefined`, which resolves to `false`: the cheap shape
+		* is what ships, and the opt-in becomes reachable when the train lands.
+		*/
+includeCrops: boolean().optional() }).optional(), array(IdentitySchema).readonly()),
 		createIdentity: method(object({ name: string().min(1) }), IdentitySchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -30108,8 +30611,10 @@ var PlateInfoSchema = object({
 	keyFrameMediaKey: string().optional(),
 	base64: string().optional(),
 	/**
-	* Same crop as a data-plane URL. `getPlateByTrack` returns this and
-	* never inlines JPEG; `listPlates` still inlines for the admin-ui.
+	* Same crop as a data-plane URL, always present when the plate has a stored
+	* crop. `getPlateByTrack` returns this and never inlines JPEG; `listPlates`
+	* and `searchPlates` inline the crop only when their `includeCrops` input is
+	* left at its `true` default.
 	*/
 	cropUrl: string().optional()
 });
@@ -30142,7 +30647,25 @@ var plateGalleryCapability = {
 	methods: {
 		listPlates: method(object({
 			deviceId: number().int().optional(),
-			limit: number().int().positive().optional()
+			limit: number().int().positive().optional(),
+			/**
+			* Inline the base64 crop on every row. Default `true` — the existing
+			* behaviour, kept so no caller breaks.
+			*
+			* Set `false` once the caller renders {@link PlateInfo.cropUrl}.
+			* Measured on the live hub at the 500 rows the Plates view asks for:
+			* 879,403 B and 27.7 s with the crops inline, against a few KiB of
+			* metadata without them — and the browser then caches the images.
+			*
+			* This is the plate twin of `faceGallery.listRecentFaces`'s option;
+			* plates were the one gallery list left without it.
+			*
+			* **This is an INPUT field, so it does not reach the addon until the
+			* next train.** The hub router validates cap inputs against its own
+			* compiled Zod and strips a key it does not know. Until the train
+			* ships, sending `false` is harmless and keeps the crops inline.
+			*/
+			includeCrops: boolean().optional()
 		}).optional(), array(PlateInfoSchema).readonly()),
 		getPlateByTrack: method(object({
 			deviceId: number().int(),
@@ -30153,7 +30676,9 @@ var plateGalleryCapability = {
 		searchPlates: method(object({
 			text: string().min(1),
 			maxDistance: number().int().min(0).optional(),
-			limit: number().int().positive().optional()
+			limit: number().int().positive().optional(),
+			/** See `listPlates.includeCrops`. Default `true`. */
+			includeCrops: boolean().optional()
 		}), array(PlateInfoSchema).readonly()),
 		/** Suggest groups of near-identical reads (same physical plate) for review/merge. */
 		suggestPlateClusters: method(object({
@@ -30173,7 +30698,13 @@ var plateGalleryCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
-		listVehicles: method(_void(), array(VehicleSchema).readonly()),
+		listVehicles: method(object({ 
+		/** Inline {@link VehicleSchema.coverBase64} on every row. Default
+		*  `false` — the vehicle twin of `faceGallery.listIdentities`'s
+		*  option; `coverMediaKey` + the `event-media` plane carry the picture.
+		*  INPUT field: stripped by the hub router until the train ships, which
+		*  resolves to `false` and is exactly the intended default. */
+includeCrops: boolean().optional() }).optional(), array(VehicleSchema).readonly()),
 		createVehicle: method(object({ name: string().min(1) }), VehicleSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -31916,92 +32447,6 @@ var sceneMonitorCapability = {
 	durability: "session"
 };
 /**
-* Per-stage gating mode applied to the zones a rule references.
-*
-* - `include`: the rule contributes to a **whitelist** for its stage.
-*   When at least one `include` rule fires for a stage, only entities
-*   inside one of those zones pass that stage.
-* - `exclude`: the rule contributes to a **blacklist** for its stage.
-*   Entities inside one of those zones are dropped at that stage.
-*
-* `monitor`-style observation (count without filtering) is not a rule
-* mode — zones without any matching rule are observed naturally by
-* `zone-analytics` (live snapshot + history), so an "I just want to
-* count, not filter" use case needs no rule at all.
-*/
-var ZoneRuleModeEnum = _enum(["include", "exclude"]);
-/**
-* Per-consumer rule that references existing zones (geometry) and
-* defines how a specific pipeline stage should treat them. Each
-* consumer addon owns its own `ZoneRule[]` array in its per-device
-* settings:
-*
-* - `addon-motion-wasm` → `motionZoneRules: ZoneRule[]` (motion stage)
-* - `addon-detection-pipeline` → `detectionZoneRules: ZoneRule[]` (detection stage)
-* - future: notification rules, audio gating, etc.
-*
-* One rule applies to N zones (`zoneIds[]`) so the operator can
-* express "ignore motion in ALL of {garden, street}" with a single
-* rule. `classFilter` narrows the rule to specific object classes —
-* "drop person detections in the street, but keep cars" is one
-* `exclude` rule with `classFilter: ['person']`.
-*
-* `enabled` is a soft toggle — the operator can keep the rule
-* configured but inert without deleting it.
-*/
-var ZoneRuleSchema = object({
-	/** Stable rule id — survives edits, used by the UI for diffing. */
-	id: string(),
-	/** Optional human-readable label rendered in the rule editor. */
-	name: string().optional(),
-	/** Zones this rule targets. The rule's `mode` applies to ALL
-	*  listed zones (OR-set: a detection in any one of them counts).
-	*  At least one zone id required — a rule with no targets is a
-	*  configuration mistake and the form validator rejects it. */
-	zoneIds: array(string()).min(1).readonly(),
-	mode: ZoneRuleModeEnum,
-	/**
-	* Class names this rule applies to. Empty / undefined ⇒ rule
-	* applies to every class. Class strings match the `macroClass`
-	* field on detections (e.g. `person`, `car`, `dog`).
-	*/
-	classFilter: array(string()).readonly().optional(),
-	/**
-	* Minimum bbox/mask overlap (0–1) with any of the rule's zones
-	* required to consider an entity "in the zone". Defaults to the
-	* consumer's stage default when omitted. Kept for back-compat with
-	* existing per-rule overrides; new operators pick the value via
-	* `bboxInclusionPct` (operator-friendly 0–100). Whichever field is
-	* set, the lower-level engine reads it as a 0–1 fraction.
-	*/
-	overlapThreshold: number().min(0).max(1).optional(),
-	/**
-	* Operator-friendly version of `overlapThreshold` — the percentage
-	* of the detection's bbox that must lie inside the zone for the
-	* rule to match. Documented default is 85%; the engine substitutes
-	* that when the field is omitted (kept optional so existing rules
-	* stored without it stay valid).
-	*
-	* When BOTH `overlapThreshold` and `bboxInclusionPct` are set on a
-	* rule, the engine prefers `bboxInclusionPct` because it's the
-	* field exposed in the UI. Internally both feed the same gate.
-	*/
-	bboxInclusionPct: number().min(0).max(100).optional(),
-	/**
-	* When `true` and a detection has a segmentation mask, use the
-	* mask for overlap instead of the bbox. Detection-stage only;
-	* motion rules ignore this field.
-	*/
-	preferMask: boolean().optional(),
-	/**
-	* Soft-toggle: `false` disables the rule without deleting it.
-	* Defaults to `true` so operators creating a rule via the UI
-	* see it active immediately.
-	*/
-	enabled: boolean().default(true)
-});
-array(ZoneRuleSchema).readonly();
-/**
 * Script-runner cap. Models HA `script.*` entities on
 * `DeviceType.Script`. A Script is a pre-recorded action sequence
 * that can be invoked imperatively — optionally with a variables
@@ -36917,6 +37362,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.cancelRelocateMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.cancelStorageMigrationMove": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37091,6 +37542,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineAnalytics.listRelocateMediaJobs": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineAnalytics.listRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37169,6 +37626,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.relocateMedia": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.restageRetrainTrack": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37181,6 +37644,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineAnalytics.runReplayFrameProcessor": {
+		capName: "pipeline-analytics",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineAnalytics.saveRetrainAnnotations": {
 		capName: "pipeline-analytics",
 		capScope: "device",
@@ -37313,6 +37782,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineExecutor.getInferenceDeviceHealth": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineExecutor.getOrchestratorConfigSchema": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -37385,6 +37860,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineExecutor.rearmInferenceDevice": {
+		capName: "pipeline-executor",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineExecutor.runAudioTest": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -40633,6 +41114,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineAnalytics.runReplayFrameProcessor": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineAnalytics.saveRetrainAnnotations": [{
 		name: "deviceId",
 		form: "single",