@camstack/addon-post-analysis 1.2.340 → 1.2.342

package/dist/{clip-model-registry-vdRtJheb.mjs → clip-model-registry-Dhjpee-Q.mjs}

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-//#region ../types/dist/event-category-BGmz_oxW.mjs
+//#region ../types/dist/event-category-B_0XEcLF.mjs
 var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["SystemBoot"] = "system.boot";
 	EventCategory["SystemAddonsReady"] = "system.addons-ready";
@@ -500,15 +500,6 @@ var EventCategory = /* @__PURE__ */ function(EventCategory) {
 	EventCategory["AgentWsDisconnected"] = "agent.ws.disconnected";
 	EventCategory["AgentBackupActivated"] = "agent.backup.activated";
 	EventCategory["OrchestrationSettingsUpdated"] = "orchestration.settings-updated";
-	/**
-	* Per-agent hwaccel preference changed (user override set, cleared, or
-	* re-probed). Observability event — decoders pull the current pref at
-	* `createSession`, so running sessions keep their current backend until
-	* they rotate naturally (camera add/remove, stream restart). Future
-	* work can wire a listener in stream-broker that force-rotates live
-	* sessions; for now this event powers logs + admin-UI toast feedback.
-	*/
-	EventCategory["PipelineAgentHwaccelChanged"] = "pipeline.agent-hwaccel-changed";
 	EventCategory["MotionAnalysis"] = "detection.motion-analysis";
 	/** All raw motion zones from CCL before minArea filter — for UI debug overlay. */
 	EventCategory["MotionZonesRaw"] = "detection.motion-zones-raw";
@@ -5451,7 +5442,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-C16NCZR2.mjs
+//#region ../types/dist/sleep-BNeXenvr.mjs
 /**
 * The audio chunk plane's byte format, and the ONE expansion from a coded
 * window to float samples (D455).
@@ -6817,32 +6808,12 @@ object({
 	audioCodec: string().optional(),
 	metadata: record(string(), unknown()).readonly().optional()
 });
-var EncodedPacketSchema = object({
-	type: _enum(["video", "audio"]),
-	data: _instanceof(Uint8Array),
-	pts: number(),
-	dts: number(),
-	keyframe: boolean(),
-	codec: string()
-});
-var DecodedFrameSchema = object({
-	data: _instanceof(Uint8Array),
-	width: number(),
-	height: number(),
-	format: _enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]),
-	timestamp: number()
-});
 /**
 * Wire schema for `FrameHandle` — a zero-pixel, serialisable reference to a
 * frame in a shared-memory ring (Phase 5 / D9). Mirrors the `FrameHandle` TS
-* interface in `interfaces/frame-handle.ts` field-for-field so a decoder cap
-* method (`pullHandles`) can carry handles over tRPC / Moleculer.
+* interface in `interfaces/frame-handle.ts` field-for-field so a cap method
+* (the runner's native-crop and pipeline-executor inputs) can carry handles
+* over tRPC / Moleculer.
 *
 * The `satisfies` assertion below pins this schema to the interface: if a
 * field is added to / removed from `FrameHandle` without a matching schema
@@ -6868,50 +6839,6 @@ var FrameHandleSchema = object({
 	slotCount: number().int().positive()
 });
 /**
-* Pixel format a frame-handle subscriber can request from the broker
-* (Phase 5 / D9). The packed, raster subset of `FrameFormat` — the formats a
-* `frameSink: 'shm'` decoder session can write into a `FrameRing` slot.
-* `jpeg` is excluded: a variable-length stream is not a fixed-stride ring
-* payload, and no decoded-frame consumer requests it over the shm plane.
-*/
-var FrameHandleFormatSchema = _enum([
-	"rgb",
-	"bgr",
-	"yuv420",
-	"gray"
-]);
-/**
-* Input for `stream-broker.subscribeFrames` (Phase 5 / D9). A consumer asks the
-* broker for a `FrameHandle` stream of one `format`; the broker maintains one
-* shared-memory ring per `(brokerId, format)` actually requested, so a `gray`
-* subscriber (motion) and an `rgb` subscriber (detection) each read the format
-* they asked for with no broker-side conversion.
-*/
-var SubscribeFramesInputSchema = object({
-	brokerId: string(),
-	format: FrameHandleFormatSchema,
-	/**
-	* Optional reader-side cadence hint in frames per second. The broker does
-	* NOT throttle — latest-wins ring reads drop frames implicitly for a slow
-	* consumer. The value is echoed back in `SubscribeFramesResult.maxFps` so
-	* the consumer can pace its own `pullFrameHandles` polling.
-	*/
-	maxFps: number().positive().optional(),
-	/** Short caller-identity tag (`motion`, `detection`, …) for diagnostics. */
-	tag: string().optional()
-});
-/**
-* Result of `stream-broker.subscribeFrames`. The consumer then polls
-* `pullFrameHandles({ subscriptionId, maxCount })` and feeds each returned
-* `FrameHandle` to a `FrameRingReader`.
-*/
-var SubscribeFramesResultSchema = object({
-	/** Opaque id the consumer passes to `pullFrameHandles` / `unsubscribeFrames`. */
-	subscriptionId: string(),
-	/** Reader-side cadence hint (frames/s) — echoes `SubscribeFramesInput.maxFps`. */
-	maxFps: number().nonnegative()
-});
-/**
 * Wire schema for a decoded audio chunk (Phase 5 / D9). Mirrors the
 * `DecodedAudioChunk` TS interface in `interfaces/stream-broker.ts`: PCM
 * sample bytes plus the track parameters a consumer needs to interpret them.
@@ -6919,8 +6846,8 @@ var SubscribeFramesResultSchema = object({
 * Audio chunks are tiny (a ~500ms AudioCodecSession window is a few KB of
 * Float32 PCM), so unlike video frames they ship their bytes INLINE over
 * tRPC / Moleculer — no shared-memory plane. `data` is typed `Uint8Array`
-* (the wire-serialisable supertype of `Buffer`) to match `DecodedFrameSchema`
-* / `EncodedPacketSchema`'s precedent; a `Buffer` is assignable to it.
+* (the wire-serialisable supertype of `Buffer`); a `Buffer` is assignable to
+* it.
 */
 var AudioChunkFormatSchema = _enum(AUDIO_CHUNK_FORMATS);
 var DecodedAudioChunkSchema = object({
@@ -6938,11 +6865,10 @@ var DecodedAudioChunkSchema = object({
 	format: AudioChunkFormatSchema.optional()
 });
 /**
-* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). The
-* handle-free, ship-bytes-inline analogue of `subscribeFrames`: a consumer
-* asks the broker for the decoded audio-chunk stream of one broker; the
-* broker keeps a per-subscription bounded FIFO queue the consumer drains via
-* `pullAudioChunks`.
+* Input for `stream-broker.subscribeAudioChunks` (Phase 5 / D9). Audio ships
+* its bytes inline: a consumer asks the broker for the decoded audio-chunk
+* stream of one broker; the broker keeps a per-subscription bounded FIFO queue
+* the consumer drains via `pullAudioChunks`.
 */
 var SubscribeAudioChunksInputSchema = object({
 	brokerId: string(),
@@ -6973,9 +6899,7 @@ var BrokerStatsSchema = object({
 		"stopped"
 	]),
 	inputFps: number(),
-	decodeFps: number(),
 	encodedSubscribers: number(),
-	decodedSubscribers: number(),
 	uptimeMs: number(),
 	bitrateKbps: number(),
 	idrIntervalMs: number(),
@@ -6988,14 +6912,6 @@ var BrokerStatsSchema = object({
 	preBufferMs: number(),
 	preBufferPackets: number(),
 	/**
-	* Moleculer node id of the decoder provider currently servicing this
-	* stream's decoded subscribers. `null` until the deferred decoder is
-	* created (no decoded clients yet, or codec not detected). Surfaces the
-	* runtime decoder placement so the UI can show "Decoder: <agent>" without
-	* a separate cap call per broker.
-	*/
-	decoderNodeId: string().nullable(),
-	/**
 	* Detected audio track parameters from the RTSP DESCRIBE / SDP. `null`
 	* when the stream has no audio track or the broker is in cold start.
 	* `supported = false` means the codec was detected but the local
@@ -11178,70 +11094,6 @@ var StorageLocationDeclarationSchema = object({
 		"backup"
 	]).optional()
 });
-var DecoderStatsSchema = object({
-	inputFps: number(),
-	outputFps: number(),
-	avgDecodeTimeMs: number(),
-	droppedFrames: number(),
-	/**
-	* Pull-mode adaptive-fps telemetry (optional — only pull sessions run the
-	* lag-driven controller; push sessions omit these). `lagMs` is the EWMA of
-	* the decoder's real-time drift (rising = falling behind live); `adaptiveFps`
-	* is the current lag-throttled emit rate (≤ `effectiveFps` ceiling).
-	*/
-	lagMs: number().optional(),
-	effectiveFps: number().optional(),
-	adaptiveFps: number().optional()
-});
-var DecoderSessionConfigSchema = object({
-	codec: string(),
-	maxFps: number().default(0),
-	outputFormat: _enum([
-		"jpeg",
-		"rgb",
-		"bgr",
-		"yuv420",
-		"gray"
-	]).default("jpeg"),
-	scale: number().default(1),
-	width: number().optional(),
-	height: number().optional(),
-	/**
-	* Identifier of the camera this decoder session serves. Optional
-	* because the cap is generic (any caller could request decode), but
-	* stream-broker passes it so decoder logs include `deviceId` for
-	* per-camera filtering when diagnosing failures (e.g. node-av
-	* sendPacket errors on a single hung camera).
-	*/
-	deviceId: number().int().nonnegative().optional(),
-	/**
-	* Free-form tag for log scoping. Stream-broker uses
-	* `broker:<deviceId>/<profile>`. Decoder session logger surfaces it
-	* on every line so `grep tag=broker:5/high` filters one camera
-	* profile cleanly.
-	*/
-	tag: string().optional(),
-	/**
-	* Where the session delivers decoded frames (Phase 5 / D9):
-	*
-	* - `'callback'` (default) — the legacy pixel path: decoded frames are
-	*   buffered as `DecodedFrame`s and drained via `pullFrames`.
-	* - `'shm'` — the shared-memory frame plane: decoded frames are written
-	*   into an OS shared-memory ring and drained as zero-pixel
-	*   `FrameHandle`s via `pullHandles`. A session is one mode or the
-	*   other — `pullFrames` returns nothing for an `'shm'` session and
-	*   `pullHandles` returns nothing for a `'callback'` session.
-	*/
-	frameSink: _enum(["callback", "shm"]).default("callback"),
-	/**
-	* Per-camera decoder DEBUG facility. When `true`, a pull-mode session emits
-	* a throttled (~1Hz) structured `decoder debug` line (effective/adaptive fps,
-	* real-time lag, dropped-frame delta, avg decode time, hwaccel). Mirrors the
-	* stream-broker's `streamingDebug` gate — off by default so production logs
-	* stay quiet and the emit path pays zero per-frame cost when disabled.
-	*/
-	debug: boolean().optional()
-});
 /**
 * Per-component log CHANNELS — the gate a hot path consults, and the registry
 * an addon declares its channels in.
@@ -11614,7 +11466,53 @@ var ModelFormatEntrySchema = object({
 	/** Multi-file payload (directory members or sibling files). */
 	files: array(string()).readonly().optional(),
 	/** Runtime(s) that can use this format. If omitted, inferred from ModelFormat key */
-	runtimes: array(_enum(["python"])).readonly().optional()
+	runtimes: array(_enum(["python"])).readonly().optional(),
+	/**
+	* Content revision of the artefact, for one hosted OFF the CamStack mirror.
+	* A format on the mirror leaves it unset: its revision (the sha256 of its
+	* weight file) comes from the downloader's generated table, kept in step
+	* with the mirror by `scripts/check-hosted-model-revisions.ts` (D744). A
+	* node records the revision it downloaded next to the file
+	* (`<file>.revision`); a copy with no record or a different one is stale
+	* unless its weight file hashes to the revision, and a stale copy is
+	* downloaded again, the old one serving until the new one is complete. No
+	* revision at all ⇒ a file on disk is current, whatever it holds (D743).
+	*/
+	revision: string().min(1).optional()
+});
+/**
+* What a node holds for one (model, format) (D746). `current` is a complete
+* copy at its catalog revision — exactly what `downloaded: true` means.
+* `stale` is bytes on disk that are not (yet) proven current under D743/D744:
+* no or a different revision record, or a missing sibling. `missing` is no
+* copy. `downloaded` alone folds `stale` into "not downloaded", which hid
+* reclaimable bytes and a copy about to be replaced.
+*/
+var ModelOnDiskStateSchema = _enum([
+	"current",
+	"stale",
+	"missing"
+]);
+/**
+* The numeric precision of one format's BUILD (D746) — reported only when the
+* build states it (file-name token, an INT8 variant, an EdgeTPU compile, a
+* CamStack Core ML export). Absent means "not stated", never "fp32".
+*/
+var ModelFormatPrecisionSchema = _enum([
+	"fp32",
+	"fp16",
+	"int8"
+]);
+/**
+* One format of one model as a node's `pipelineExecutor.getSchema` reports it.
+* `onDisk` / `precision` are optional for version skew: a runner that predates
+* them omits them, and a reader falls back to `downloaded`.
+*/
+var PipelineModelFormatStatusSchema = object({
+	downloaded: boolean(),
+	sizeMB: number(),
+	onDisk: ModelOnDiskStateSchema.optional(),
+	precision: ModelFormatPrecisionSchema.optional()
 });
 /**
 * Extra file that must be downloaded alongside the model (e.g., labels JSON, dict.txt).
@@ -11823,6 +11721,35 @@ var ModelCatalogEntrySchema = object({
 	*/
 	defaultConfidence: number().min(0).max(1).optional(),
 	/**
+	* Per-MODEL default of the per-class confidence floors (`minConfidence<Macro>`
+	* on a detector step), keyed by macro class: `{ person: 0.45 }`. A class
+	* absent here runs at the step slider's global default. The same row shape
+	* the floor measurement produces (`model-floors.json`: modelId → floors), so
+	* a measured table is copied in as-is. An operator override is bound to the
+	* model it was made for and does not survive a model change (D738). A custom
+	* / imported model may declare it; without it, the global defaults apply.
+	*/
+	defaultClassFloors: record(string(), number().min(0).max(1)).optional(),
+	/**
+	* The inference precision this model's OpenVINO IR needs on an Intel GPU.
+	* Absent ⇒ the device default (f16 on a GPU). Set to `'f32'` for an FP32 IR
+	* that produces invalid output at f16 — measured 2026-10-07 for YOLO26
+	* base IRs (`yolo26s`: 0 true / 146 false positives; `yolo26m*`: NaN
+	* scores) on the Core Ultra iGPU and the N100. Threaded to the pool as
+	* `PoolModelConfig.gpuInferencePrecision`; the pool sets
+	* INFERENCE_PRECISION_HINT on a GPU only. Costs ~60% latency on the GPU.
+	*/
+	gpuInferencePrecision: _enum(["f32", "f16"]).optional(),
+	/**
+	* ROOT detectors only: per supplied step (`animal-classifier`, …), the
+	* minimum DETECTION score from which this root's own fine label (species,
+	* vehicle type — D736 root supply) is taken (D741). Below it the detection
+	* keeps its macro class without the fine label. `1` = never take it from
+	* this root. Absent ⇒ no floor beyond the macro floor. The supplied step's
+	* `minConfidence` slider, bound to the ROOT model, overrides it.
+	*/
+	suppliedLabelFloors: record(string(), number().min(0).max(1)).optional(),
+	/**
 	* When true, the executor produces a landmark-aligned crop (similarity warp
 	* onto the canonical template) before this step runs, instead of a plain
 	* axis-aligned bbox crop. Required for face-recognition embedders (ArcFace):
@@ -13952,13 +13879,6 @@ var BrokerRtspClientSchema = object({
 	lastRtpAt: number(),
 	bytesSent: number()
 });
-var BrokerDecodedClientSchema = object({
-	tag: string(),
-	subscribedAt: number(),
-	maxFps: number(),
-	framesDelivered: number(),
-	framesDropped: number()
-});
 var BrokerAudioClientSchema = object({
 	tag: string(),
 	subscribedAt: number(),
@@ -14050,7 +13970,6 @@ var BrokerEncodedClientSchema = object({
 });
 var BrokerClientsSchema = object({
 	rtsp: array(BrokerRtspClientSchema).readonly(),
-	decoded: array(BrokerDecodedClientSchema).readonly(),
 	audio: array(BrokerAudioClientSchema).readonly(),
 	encoded: array(BrokerEncodedClientSchema).readonly(),
 	pipeClients: number(),
@@ -14542,11 +14461,7 @@ var streamBrokerCapability = {
 		listClients: method(object({ brokerId: string() }), BrokerClientsSchema),
 		killClient: method(object({
 			brokerId: string(),
-			channel: _enum([
-				"rtsp",
-				"decoded",
-				"audio"
-			]),
+			channel: _enum(["rtsp", "audio"]),
 			handle: string()
 		}), object({ killed: boolean() }), {
 			kind: "mutation",
@@ -14645,31 +14560,6 @@ var streamBrokerCapability = {
 			maxCount: number().int().positive().default(8)
 		}), array(DecodedAudioChunkSchema).readonly()),
 		unsubscribeAudioChunks: method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }),
-		/**
-		* ── Shared-memory frame plane (Phase 5 / D9) ──────────────────────
-		*
-		* The handle-based replacement for the live-object `IStreamBroker.
-		* onDecodedFrame` callback path. A consumer:
-		*
-		*   1. `subscribeFrames({ brokerId, format })` — the broker spins up
-		*      (or reuses) a `frameSink: 'shm'` decoder session producing that
-		*      `format` and returns a `subscriptionId`.
-		*   2. polls `pullFrameHandles({ subscriptionId, maxCount })` — drains
-		*      zero-pixel `FrameHandle[]`; each handle is fed to a
-		*      `FrameRingReader` that opens the named shm segment and reads the
-		*      pixels back zero-copy.
-		*   3. `unsubscribeFrames({ subscriptionId })` on teardown.
-		*
-		* The broker keeps one shm ring per `(brokerId, format)` actually
-		* requested — no broker-side `sharp` conversion. fps throttling is
-		* implicit (latest-wins ring reads drop frames for a slow consumer).
-		*/
-		subscribeFrames: method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }),
-		pullFrameHandles: method(object({
-			subscriptionId: string(),
-			maxCount: number().int().positive().default(4)
-		}), array(FrameHandleSchema).readonly()),
-		unsubscribeFrames: method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }),
 		setPreBufferDuration: method(object({
 			brokerId: string(),
 			seconds: number().min(0).max(30)
@@ -16396,72 +16286,18 @@ id: union([string(), number()]) }), {
 		})
 	}
 };
-/**
-* shm ring usage stats for a `frameSink: 'shm'` decoder session —
-* exposed via `decoder.getShmStats` so downstream consumers can
-* observe ring pressure (slot count, byte budget, hit/miss ratio).
-*/
-var ShmRingStatsSchema = object({
-	sessionId: string(),
-	slotCount: number().int(),
-	slotByteLength: number().int(),
-	segmentBytes: number().int(),
-	budgetMb: number().int(),
-	framesWritten: number().int(),
-	getFrameHits: number().int(),
-	getFrameMisses: number().int()
-});
 var decoderCapability = {
 	name: "decoder",
 	scope: "system",
 	mode: "singleton",
 	preferredProvider: "decoder-nodeav",
 	methods: {
-		supportsCodec: method(object({ codec: string() }), boolean()),
 		getInfo: method(_void(), object({
 			id: string(),
 			name: string(),
-			isPullMode: boolean().optional(),
-			priority: number().optional(),
 			hwaccel: string().optional(),
 			probedBestHwaccel: string().optional()
 		})),
-		createSession: method(DecoderSessionConfigSchema, object({
-			sessionId: string(),
-			nodeId: string()
-		})),
-		destroySession: method(object({ sessionId: string() }), _void()),
-		pushPacket: method(object({
-			sessionId: string(),
-			packet: EncodedPacketSchema
-		}), _void()),
-		openStream: method(object({
-			sessionId: string(),
-			url: string()
-		}), _void()),
-		pullFrames: method(object({
-			sessionId: string(),
-			maxCount: number().default(1),
-			waitMs: number().optional()
-		}), array(DecodedFrameSchema)),
-		pullHandles: method(object({
-			sessionId: string(),
-			maxCount: number().default(1),
-			waitMs: number().optional()
-		}), array(FrameHandleSchema)),
-		getFrame: method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()),
-		getShmStats: method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()),
-		updateConfig: method(object({
-			sessionId: string(),
-			config: DecoderSessionConfigSchema.partial()
-		}), _void()),
-		getStats: method(object({ sessionId: string() }), DecoderStatsSchema),
-		listActiveSessions: method(_void(), array(object({
-			sessionId: string(),
-			codec: string(),
-			outputFormat: string(),
-			createdAtMs: number()
-		})).readonly()),
 		/**
 		* Re-run the host platform-probe for the decoder's hwaccel backend
 		* and write the detected value into the addon's own global
@@ -26066,8 +25902,8 @@ function flattenHydratedView(view, wanted) {
 var CLUSTER_STEP_SETTING_FIELDS = [{
 	stepId: "face-embedding",
 	key: "minLandmarkFaceSize",
-	label: "Min face size for recognition (detection px)",
-	description: "Refuse to embed a face smaller than this IN THE DETECTION FRAME. Applies to every node — the enrolled gallery is one index, and two admission floors would fill it from two policies. 0 disables the gate.",
+	label: "Min face size to embed (detection-frame px)",
+	description: "Faces smaller than this in the small frame the detector sees are not embedded, so they can never be recognised. Below it the face cannot be aligned reliably and a bad embedding matches everyone. Same value on every node. 0 = no limit.",
 	type: "slider",
 	min: 0,
 	max: 64,
@@ -28752,7 +28588,7 @@ var FrameRefSchema = object({
 	timestamp: number(),
 	capturedAt: number().optional()
 });
-var ModelFormatSchema$1 = _enum([
+var ModelFormatSchema$2 = _enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -28770,7 +28606,7 @@ var PipelineSlotSchema = _enum([
 var PipelineEngineChoiceSchema = object({
 	runtime: literal("python"),
 	backend: string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: string().optional()
 });
 /**
@@ -28809,28 +28645,10 @@ var PipelineDefaultStepSchema = lazy(() => object({
 	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()
-	})),
+	formats: record(string(), PipelineModelFormatStatusSchema),
 	group: ModelVariantGroupSchema.optional(),
 	legacy: boolean().optional(),
 	provider: ModelProviderIdSchema.optional(),
@@ -29045,6 +28863,32 @@ var pipelineExecutorCapability = {
 			auth: "admin"
 		}),
 		/**
+		* Auto tune (D745): the MODEL-BOUND thresholds (`bindsToModel` keys of
+		* the object-detection root, and their binding keys) stored in THIS node's
+		* per-camera detector settings — and, unless `dryRun`, remove them so the
+		* running model's own defaults apply. Every other key of a camera's store
+		* is kept. `nodeId` is the ROUTING key. `deviceIds` absent ⇒ every camera
+		* with a store. A camera whose store could not be read is `refused`, never
+		* reported as clean.
+		*/
+		clearModelBoundDeviceOverrides: method(object({
+			nodeId: string(),
+			deviceIds: array(number()).readonly().optional(),
+			dryRun: boolean()
+		}), object({
+			entries: array(object({
+				deviceId: number(),
+				keys: array(string()).readonly()
+			})).readonly(),
+			refused: array(object({
+				deviceId: number(),
+				reason: string()
+			})).readonly()
+		}), {
+			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).
 		*
@@ -29122,29 +28966,17 @@ var pipelineExecutorCapability = {
 			steps: array(PipelineStepInputSchema),
 			deviceKey: string().optional()
 		}), PipelineValidationResultSchema),
-		listTemplates: method(_void(), array(PipelineTemplateSchema$1).readonly()),
-		saveTemplate: method(object({
-			name: string(),
-			steps: array(PipelineTemplateStepSchema).readonly(),
-			engine: PipelineEngineChoiceSchema
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		updateTemplate: method(object({
-			id: string(),
-			name: string().optional(),
-			steps: array(PipelineTemplateStepSchema).readonly().optional()
-		}), PipelineTemplateSchema$1, { kind: "mutation" }),
-		deleteTemplate: method(object({ id: string() }), _void(), { kind: "mutation" }),
 		getCapabilities: method(_void(), InferenceCapabilitiesBridge),
 		getAddonModels: method(object({ addonId: string() }), ModelAvailabilityListBridge),
 		downloadModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), DownloadModelResultSchema, { kind: "mutation" }),
 		deleteModel: method(object({
 			addonId: string(),
 			modelId: string(),
-			format: ModelFormatSchema$1
+			format: ModelFormatSchema$2
 		}), object({ success: literal(true) }), { kind: "mutation" }),
 		/**
 		* Stateless single-frame execution. Callers (runner, benchmark) pass
@@ -29390,6 +29222,375 @@ var pipelineExecutorCapability = {
 		getDetectionConfigSchema: method(_void(), ConfigUISchemaNullableBridge)
 	}
 };
+/**
+* The wire shapes of the Auto tune plan and apply (D745), used by the
+* `pipeline-orchestrator` cap. The recommender's own types
+* (`recommend.ts`) are the TS face of the same data; these
+* schemas are what crosses the cap boundary.
+*/
+var ModelFormatSchema$1 = _enum(MODEL_FORMATS);
+/** The operator's range for it. */
+var MIN_SESSIONS_PER_DEVICE_RANGE = {
+	min: 1,
+	max: 8
+};
+var HardwareClassIdSchema = _enum([
+	"intel-core-ultra",
+	"intel-n-series",
+	"apple-m-base",
+	"apple-m-pro",
+	"unknown"
+]);
+var AcceleratorKindSchema = _enum([
+	"intel-npu",
+	"intel-igpu",
+	"x86-cpu",
+	"arm-cpu",
+	"apple-ane",
+	"coral"
+]);
+var RecommendationReasonSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("capacity"),
+		sessions: number(),
+		minSessions: number()
+	}),
+	object({
+		kind: literal("tie-faster"),
+		over: string(),
+		recallDelta: number()
+	}),
+	object({
+		kind: literal("stepped-down"),
+		from: string(),
+		to: string(),
+		limitedBy: string()
+	}),
+	object({
+		kind: literal("no-fit-lightest"),
+		sessions: number(),
+		minSessions: number()
+	}),
+	object({
+		kind: literal("derived-latency"),
+		modelId: string()
+	}),
+	object({ kind: literal("cpu-device") }),
+	object({ kind: literal("coral-untouched") }),
+	object({ kind: literal("device-disabled") }),
+	object({ kind: literal("device-unavailable") }),
+	object({ kind: literal("node-offline") }),
+	object({ kind: literal("no-hardware-facts") }),
+	object({
+		kind: literal("no-measured-data"),
+		hardwareClass: HardwareClassIdSchema
+	}),
+	object({
+		kind: literal("no-family-build"),
+		format: ModelFormatSchema$1
+	})
+]);
+var DeviceModelChoiceSchema = object({
+	modelId: string(),
+	p50Ms: number(),
+	fps: number(),
+	measured: boolean(),
+	/** Parallel sessions at the camera rate with the headroom kept free: ⌊fps × (1 − headroom) / camera fps⌋. */
+	capacitySessions: number(),
+	personRecall: number()
+});
+var DeviceRecommendationSchema = object({
+	deviceKey: string(),
+	accelerator: AcceleratorKindSchema.nullable(),
+	enabled: boolean(),
+	available: boolean(),
+	chosen: DeviceModelChoiceSchema.nullable(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var NodeRecommendationSchema = object({
+	nodeId: string(),
+	reachable: boolean(),
+	hardwareClass: HardwareClassIdSchema.nullable(),
+	cpuModel: string().nullable(),
+	skipped: boolean(),
+	acceleratorModelId: string().nullable(),
+	devices: array(DeviceRecommendationSchema).readonly(),
+	reasons: array(RecommendationReasonSchema).readonly()
+});
+var ModelPinChangeSchema = object({
+	stepId: string(),
+	before: string().nullable(),
+	after: string().nullable()
+});
+var NodeDeviceChangeSchema = object({
+	nodeId: string(),
+	deviceKey: string(),
+	madeExplicit: boolean(),
+	modelPins: array(ModelPinChangeSchema).readonly(),
+	thresholds: array(object({
+		stepId: string(),
+		keys: array(string()).readonly()
+	})).readonly()
+});
+var CameraOverrideClearSchema = object({
+	deviceId: number(),
+	source: _enum(["step-override", "wholesale"]),
+	nodeId: string(),
+	deviceKey: string().nullable(),
+	stepId: string(),
+	modelIdBefore: string().nullable(),
+	keys: array(string()).readonly()
+});
+var DetectorStoreClearSchema = object({
+	deviceId: number(),
+	keys: array(string()).readonly()
+});
+var AutoTuneWarningSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("detector-store-cluster-wide"),
+		skippedNodes: array(string()).readonly()
+	}),
+	object({
+		kind: literal("detector-store-unreadable"),
+		error: string()
+	}),
+	object({
+		kind: literal("coral-enabled"),
+		nodeId: string(),
+		deviceKey: string()
+	})
+]);
+var AutoTuneOptionsSchema = object({
+	/** Share of each accelerator's throughput kept free (0.3–0.5). */
+	headroom: number().min(.3).max(.5).default(.4),
+	/**
+	* The least number of parallel sessions every device must sustain at the
+	* camera rate with the headroom kept free (D755). The most accurate model
+	* that reaches it wins.
+	*/
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
+});
+var AutoTunePlanSchema = object({
+	/** Hash of everything the apply will write — the apply refuses a different one. */
+	planHash: string(),
+	family: literal("yolov9"),
+	headroom: number(),
+	minSessionsPerDevice: number(),
+	/** The detection rate a session is counted at (the fastest camera running the pipeline root). */
+	cameraFps: number(),
+	generatedAt: number(),
+	nodes: array(NodeRecommendationSchema).readonly(),
+	nodeChanges: array(NodeDeviceChangeSchema).readonly(),
+	cameraClears: array(CameraOverrideClearSchema).readonly(),
+	detectorStoreClears: array(DetectorStoreClearSchema).readonly(),
+	warnings: array(AutoTuneWarningSchema).readonly()
+});
+var AutoTuneApplyInputSchema = object({
+	planHash: string(),
+	headroom: number().min(.3).max(.5).default(.4),
+	minSessionsPerDevice: number().int().min(MIN_SESSIONS_PER_DEVICE_RANGE.min).max(MIN_SESSIONS_PER_DEVICE_RANGE.max).default(2)
+});
+var AutoTunePhaseResultSchema = object({
+	phase: _enum([
+		"download",
+		"camera-overrides",
+		"detector-thresholds",
+		"node-models",
+		"redispatch"
+	]),
+	ok: boolean(),
+	detail: string()
+});
+var AutoTuneApplyResultSchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("applied"),
+		planHash: string(),
+		phases: array(AutoTunePhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("aborted"),
+		phases: array(AutoTunePhaseResultSchema).readonly()
+	}),
+	object({
+		kind: literal("stale"),
+		plan: AutoTunePlanSchema
+	}),
+	object({
+		kind: literal("refused"),
+		reason: _enum(["apply-in-progress"])
+	})
+]);
+/**
+* Wire shapes of the Load balancing surface (D748): the session placement
+* policy, the atomic share write, the observed placement statistics, the
+* hardware share suggestion and the stale device pins.
+*/
+/**
+* How a new detection session picks its node and device.
+*  - `least-loaded` — the historical rule: lowest `attached / weight`, a
+*    constant node order at a tie (D37). An idle node always ties at 0, so a
+*    weight only bites once a node already holds a session.
+*  - `share` — the share of PARALLEL sessions is held to the weights, and a
+*    full or drowning node yields to a free one (D748).
+*/
+var SessionPlacementPolicySchema = _enum(["least-loaded", "share"]);
+var LoadBalancingSharesInputSchema = object({
+	/** nodeId → share (> 0). A node left out keeps its weight. */
+	nodes: record(string(), number().positive()).default({}),
+	/** nodeId → deviceKey → share (> 0). A device left out keeps its weight. */
+	devices: record(string(), record(string(), number().positive())).default({})
+});
+var PlacementStatsInputSchema = object({ 
+/** Window the observed shares are averaged over (default 1 h, max 24 h). */
+windowMs: number().int().min(6e4).max(1440 * 60 * 1e3).default(3600 * 1e3) });
+var PlacementDeviceStatsSchema = object({
+	deviceKey: string(),
+	/** Sessions running on this device now. */
+	sessionsNow: number(),
+	/** Sessions started on this device inside the window. */
+	sessionsStarted: number(),
+	/** Time-weighted share of the node's parallel sessions over the window (0–1); null = no session ran. */
+	observedShare: number().nullable()
+});
+var PlacementNodeStatsSchema = object({
+	nodeId: string(),
+	sessionsNow: number(),
+	sessionsStarted: number(),
+	/** Time-weighted share of the cluster's parallel sessions over the window (0–1); null = none ran. */
+	observedShare: number().nullable(),
+	/** Most sessions this node ran at once inside the window. */
+	peakSessions: number(),
+	/** Sessions a share election handed elsewhere because this node was full or drowning. */
+	yieldsAway: number(),
+	devices: array(PlacementDeviceStatsSchema).readonly()
+});
+/** A camera's device pin that the session path cannot honour. */
+var StaleDevicePinSchema = object({
+	deviceId: number(),
+	deviceKey: string(),
+	/** `disabled` — the key exists on some node but is not enabled anywhere; `absent` — no node has it. */
+	reason: _enum(["disabled", "absent"])
+});
+var PlacementStatsSchema = object({
+	policy: SessionPlacementPolicySchema,
+	windowMs: number(),
+	/** How much of the window was actually observed (the hub keeps it in memory). */
+	observedForMs: number(),
+	sessionsNow: number(),
+	/** Most parallel sessions across the cluster inside the window. */
+	clusterPeakSessions: number(),
+	nodes: array(PlacementNodeStatsSchema).readonly(),
+	stalePins: array(StaleDevicePinSchema).readonly()
+});
+/**
+* Where an automatic share's capacity comes from (D755).
+*  - `hardware` — the static capacity of each device at its Auto tune model:
+*    the measured latency table for the node's hardware class.
+*  - `benchmark` — the node's own measured capacity (node benchmark results).
+*    A node with no results falls back to `hardware`, and says so.
+*/
+var CapacitySourceSchema = _enum(["hardware", "benchmark"]);
+/** Why a node under the `benchmark` source was sized from hardware instead. */
+var CapacityFallbackSchema = _enum(["no-benchmark-results", "partial-benchmark-results"]);
+var SuggestSharesInputSchema = object({
+	headroom: number().min(.3).max(.5).default(.4),
+	/** Default `hardware`. */
+	source: CapacitySourceSchema.default("hardware")
+});
+var SuggestedDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Share of the node (0–100, rounded). */
+	share: number(),
+	modelId: string().nullable(),
+	/** Inferences per second at that model, from the measured table; null when sized by a benchmark. */
+	fps: number().nullable(),
+	/** False for a table cell derived from another chip; true for a measured cell or a benchmark. */
+	measured: boolean(),
+	/**
+	* Advisory session cap: ⌊fps × (1 − headroom) / camera fps⌋ from the table,
+	* or the benchmark's measured max sessions. Never enforced.
+	*/
+	suggestedMaxSessions: number().nullable()
+});
+var SuggestedNodeShareSchema = object({
+	nodeId: string(),
+	/** Share of the cluster (0–100, rounded); null = node skipped (offline, unknown hardware). */
+	share: number().nullable(),
+	/** Parallel sessions the node sustains at the suggested models with the headroom kept free. */
+	capacitySessions: number(),
+	devices: array(SuggestedDeviceShareSchema).readonly(),
+	skippedReason: string().nullable(),
+	/** What this node's capacity was read from; null when the node is skipped. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Set when the `benchmark` source was asked for and this node used `hardware`. */
+	capacityFallback: CapacityFallbackSchema.nullable()
+});
+var SuggestSharesResultSchema = object({
+	headroom: number(),
+	/** The source asked for; each node says what it actually used. */
+	source: CapacitySourceSchema,
+	/** Camera detection rate the capacity is counted in (the fastest camera's fps). */
+	cameraFps: number(),
+	/** The Auto tune capacity floor the models were picked at. */
+	minSessionsPerDevice: number(),
+	nodes: array(SuggestedNodeShareSchema).readonly()
+});
+/**
+* Where the node and device shares come from (D750, D755).
+*  - `hardware` (default) — computed by the system from each node's static
+*    capacity (its accelerators at their Auto tune models, from the measured
+*    latency table), recomputed whenever a node or device joins, leaves, is
+*    switched on or off, or changes model. No load input.
+*  - `benchmark` — the same, from each node's measured capacity (node
+*    benchmark results); a node without results falls back to `hardware`.
+*  - `manual` — the operator's stored sliders.
+* Either way a node or device that cannot take sessions gives its share to
+* the others in proportion; the stored values are never rewritten for that.
+*/
+var ShareSourceSchema = _enum([
+	"hardware",
+	"benchmark",
+	"manual"
+]);
+var SetShareSourceInputSchema = object({ source: ShareSourceSchema });
+object({
+	nodes: record(string(), number()),
+	devices: record(string(), record(string(), number()))
+});
+var EffectiveDeviceShareSchema = object({
+	deviceKey: string(),
+	/** Can take sessions now (enabled, available, can run the root). */
+	eligible: boolean(),
+	/** The share the source assigns, as a percentage of the node's devices. */
+	configuredPct: number(),
+	/** The share actually used, after an ineligible device's share went to the others. */
+	effectivePct: number()
+});
+var EffectiveNodeShareSchema = object({
+	nodeId: string(),
+	eligible: boolean(),
+	configuredPct: number(),
+	effectivePct: number(),
+	/** Automatic sources: what this node's share was computed from; null under `manual` or before the first answer. */
+	capacitySource: CapacitySourceSchema.nullable(),
+	/** Automatic `benchmark`: why this node used `hardware` instead. */
+	capacityFallback: CapacityFallbackSchema.nullable(),
+	devices: array(EffectiveDeviceShareSchema).readonly()
+});
+var EffectiveSharesSchema = object({
+	source: ShareSourceSchema,
+	policy: SessionPlacementPolicySchema,
+	/** An automatic source with no computed answer yet: the stored sliders are used meanwhile. */
+	autoPending: boolean(),
+	/** When the automatic shares were last computed (ms epoch); null = never. */
+	computedAt: number().nullable(),
+	/** What made the system recompute them last. */
+	trigger: string().nullable(),
+	nodes: array(EffectiveNodeShareSchema).readonly(),
+	/** The relative weights the election reads (before eligibility). */
+	nodeWeights: record(string(), number()),
+	deviceWeights: record(string(), record(string(), number()))
+});
 object({
 	activeCameras: number(),
 	throttledCameras: number(),
@@ -30307,14 +30508,15 @@ var RunnerLocalLoadSchema = object({
 	* Per-inference-device live load (multi-device C4). One entry per deviceKey
 	* this runner currently has attached cameras on, so the orchestrator's second
 	* `balance()` pass (over a node's devices) weights on real per-pool session
-	* counts. Empty on single-device / pre-multi-device runners. `queueDepthTotal`
-	* per device is 0 until the pool backlog gets a public accessor (follow-up).
+	* counts. Empty on single-device / pre-multi-device runners. There is no
+	* per-device queue depth: the inference pool's backlog has no accessor, and
+	* a field that always read 0 was removed rather than shown as a measurement
+	* (D762).
 	*/
 	devices: array(object({
 		deviceKey: string(),
 		backend: string(),
-		attachedCameras: number(),
-		queueDepthTotal: number()
+		attachedCameras: number()
 	})).default([]),
 	/** Hardware capability flags reported by this node. */
 	hardware: object({
@@ -30720,14 +30922,6 @@ var CameraPipelineConfigSchema = object({
 		settings: record(string(), unknown()).readonly().optional()
 	}).nullable().optional()
 });
-var PipelineTemplateSchema = object({
-	id: string(),
-	name: string(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema,
-	createdAt: string(),
-	updatedAt: string()
-});
 var DeviceStepConfigSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).optional(),
@@ -30801,9 +30995,10 @@ var CameraStepOverridePatchSchema = object({
 	modelId: string().optional(),
 	settings: record(string(), unknown()).readonly().optional()
 });
+var CameraStepSettingsSchema = record(string(), record(string(), unknown()).readonly());
 var CameraPipelineSettingsSchema = object({
-	pinnedAgentNodeId: string().optional(),
 	stepToggles: record(string(), boolean()).optional(),
+	stepSettings: CameraStepSettingsSchema.optional(),
 	stepOverridesByDevice: record(string(), record(string(), record(string(), CameraStepOverridePatchSchema))).optional(),
 	pipelineByAgent: record(string(), CameraPipelineForAgentSchema).optional()
 });
@@ -30836,7 +31031,10 @@ var PipelineAssignmentSchema = object({
 });
 /**
 * Per-agent load summary surfaced to the load balancer + dashboards.
-* Aggregated from each runner's `getLocalLoad` cap call.
+* Aggregated from each runner's `getLocalLoad` cap call. In the
+* `getAgentLoad` report, a single-device node's default-pool sessions (no
+* `deviceKey`) are credited to its one eligible device in `load.devices` —
+* the default pool IS that device (D745); the balancer's census stays raw.
 */
 var AgentLoadSummarySchema = object({
 	nodeId: string(),
@@ -30925,26 +31123,27 @@ var CameraBrokerStatusSchema = object({
 		width: number(),
 		height: number(),
 		subscribers: number(),
-		inFps: number(),
-		outFps: number()
+		/**
+		* Encoded packets/s the broker receives from the camera. null when the
+		* broker's stats read failed — unknown, never 0 (a 0 here reads as a stall).
+		* There is no output rate: decoding runs in the session decode workers, not
+		* in the broker, so the broker's own decoded-frame rate is 0 on every live
+		* camera and is not served (D758).
+		*/
+		inFps: number().nullable()
 	})).readonly(),
 	webrtcSessions: number(),
 	rtspRestream: boolean()
 });
-/** Shared-memory ring statistics within the decoder block. */
-var CameraDecoderShmSchema = object({
-	framesWritten: number(),
-	getFrameHits: number(),
-	getFrameMisses: number(),
-	budgetMb: number()
-});
-/** Decoder block — null when the decoder stage is unreachable or inactive. */
-var CameraDecoderStatusSchema = object({
-	nodeId: string(),
-	formats: array(string()).readonly(),
-	sessionCount: number(),
-	shm: CameraDecoderShmSchema
-});
+/**
+* Decoder block — WHERE decode runs (co-located with the detection node by
+* construction); null when the camera has no detection node. It carries no
+* frame counter: the shared-memory plane whose counters it used to serve is
+* gone, and those fields read 0 forever. Whether frames actually flow is read
+* from `detection.actualFps` (frames delivered to and processed by the
+* detector), never from a counter nothing feeds.
+*/
+var CameraDecoderStatusSchema = object({ nodeId: string() });
 /** Motion block — null when motion detection is not active for this device. */
 var CameraMotionStatusSchema = object({
 	enabled: boolean(),
@@ -31450,18 +31649,6 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/**
-		* Set a node's detection WEIGHT (relative share for the quota balancer).
-		* `null` clears it (back to the implicit weight 1). Unpinned cameras
-		* distribute proportionally to weight; `maxCameras` still clamps on top.
-		*/
-		setAgentDetectWeight: method(object({
-			agentNodeId: string(),
-			detectWeight: number().positive().nullable()
-		}), object({ success: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/**
 		* Set one node's placement CAPABILITIES — the per-node record that
 		* replaced the four flat orchestrator lists (`enabledNodes`,
 		* `enabledDecoderNodes`, `enabledAudioNodes`, `remoteSourcingNodes`).
@@ -31580,6 +31767,76 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Auto tune (D745, D755) — DRY RUN. Recommends ONE detector family
+		* (YOLOv9) for the whole cluster from each node's static hardware class
+		* and the measured latency table: per device, the most accurate model
+		* that sustains at least `minSessionsPerDevice` parallel sessions at the
+		* camera rate with the headroom kept free (no load input), and lists every write
+		* the apply would make: the node model pins set, the enrichment pins and
+		* model-bound thresholds removed (node level and per camera), and the
+		* per-camera detector thresholds cleared. Writes nothing. Step
+		* enablement, device enablement, pins, recording, notifications, zones and
+		* rules are never part of it. `planHash` names exactly this diff.
+		*/
+		planAutoTune: method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }),
+		/**
+		* Auto tune (D745) — APPLY the plan the operator confirmed. Recomputes
+		* the plan and refuses (`stale`, with the fresh plan) when its hash is not
+		* `planHash`, so what is written is exactly the confirmed diff. Offline
+		* nodes are skipped; there is no undo.
+		*/
+		applyAutoTune: method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Load balancing (D748) — write node shares (`detectWeight`) and per-node
+		* device shares (inference-device `weight`) in ONE atomic read-modify-write
+		* of the agent settings — the only writer of node shares (the per-node
+		* `setAgentDetectWeight` it replaced raced its siblings, one RMW each).
+		* A node or device left out keeps its weight. Never changes the
+		* `sessionPlacement` policy.
+		*/
+		setLoadBalancingShares: method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
+		/**
+		* Load balancing (D748) — what placement actually did: per node and
+		* device, sessions now, sessions started and the time-weighted share of
+		* PARALLEL sessions over `windowMs`; the cluster's parallel peak; yields
+		* a share election made; and every device pin the session path cannot
+		* honour. In memory on the hub — a restart starts a new window.
+		*/
+		getPlacementStats: method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D748, D755) — shares proportional to each node's
+		* capacity in parallel sessions: from the latency table at the models
+		* Auto tune picks (`hardware`), or from node benchmark results
+		* (`benchmark`, each node without results falling back to `hardware` and
+		* saying so). The automatic shares are exactly this answer. Per device,
+		* an ADVISORY session cap. Writes nothing.
+		*/
+		suggestShares: method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D750) — the shares placement reads now: the source
+		* (automatic capacity shares or the operator's sliders), each node's and
+		* device's configured share, and the effective share after a node or
+		* device that cannot take sessions gave its share to the others.
+		*/
+		getEffectiveShares: method(_void(), EffectiveSharesSchema, { auth: "admin" }),
+		/**
+		* Load balancing (D750, D755) — switch the share source: `hardware`
+		* (automatic, from static capacity), `benchmark` (automatic, from node
+		* benchmark results) or `manual`. Going manual seeds the sliders with the
+		* current automatic shares (one atomic write), so nothing jumps; going
+		* to an automatic source recomputes at once.
+		*/
+		setShareSource: method(SetShareSourceInputSchema, object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Read one camera's settings. Null when never touched (inherits agent defaults fully). */
 		getCameraSettings: method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()),
 		/** Set or clear the 3-state toggle for one (camera, addonId). Pass `enabled: null` to clear and revert to agent default. */
@@ -31609,6 +31866,22 @@ var pipelineOrchestratorCapability = {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Write or clear one step's CAMERA-WIDE settings (D754) — the fields this
+		* camera overrides on every accelerator it runs on. `settings` is the
+		* whole field-level bag for that step (only the overridden keys; a
+		* model-bound field travels with its binding key); `null` or `{}` clears
+		* it. Merged at dispatch between the node base and the per-(node,device)
+		* override, key by key.
+		*/
+		setCameraStepSettings: method(object({
+			deviceId: number(),
+			addonId: string(),
+			settings: record(string(), unknown()).nullable()
+		}), object({ success: literal(true) }), {
+			kind: "mutation",
+			auth: "admin"
+		}),
 		/** Write or clear the wholesale per-agent pipeline override. Pass `pipeline: null` to drop the override. */
 		setCameraPipelineForAgent: method(object({
 			deviceId: number(),
@@ -31724,33 +31997,7 @@ var pipelineOrchestratorCapability = {
 			auth: "admin"
 		}),
 		/** Snapshot of the in-flight or last disk-wins fleet reconcile. */
-		getReconcileFromDiskStatus: method(_void(), DiskReconcileJobSchema, { auth: "admin" }),
-		/** List every template the operator has saved. */
-		listTemplates: method(_void(), array(PipelineTemplateSchema).readonly()),
-		/** Create a new named preset from a given CameraPipelineConfig. */
-		saveTemplate: method(object({
-			name: string(),
-			description: string().optional(),
-			config: CameraPipelineConfigSchema
-		}), PipelineTemplateSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Partial update of a template. Any omitted field is preserved. */
-		updateTemplate: method(object({
-			id: string(),
-			name: string().optional(),
-			description: string().optional(),
-			config: CameraPipelineConfigSchema.optional()
-		}), PipelineTemplateSchema, {
-			kind: "mutation",
-			auth: "admin"
-		}),
-		/** Remove a template. Camera configs that were seeded from it keep a copy. */
-		deleteTemplate: method(object({ id: string() }), object({ success: literal(true) }), {
-			kind: "mutation",
-			auth: "admin"
-		})
+		getReconcileFromDiskStatus: method(_void(), DiskReconcileJobSchema, { auth: "admin" })
 	}
 };
 /**
@@ -34722,8 +34969,6 @@ var WebrtcStreamChoiceSchema = object({
 	]).nullable(),
 	/** Input FPS from the camera (null for adaptive). */
 	inputFps: number().nullable(),
-	/** Decoded FPS (null for adaptive). */
-	decodeFps: number().nullable(),
 	/** Bitrate in kbps (null for adaptive). */
 	bitrateKbps: number().nullable()
 });
@@ -35492,6 +35737,59 @@ var AddonAutoUpdateSchema = ChannelWithInheritSchema;
 var RestartAddonResultSchema = unknown();
 var InstallPackageResultSchema = unknown();
 var ReloadPackagesResultSchema = unknown();
+/**
+* What an uninstall did on ONE node.
+*  - `uninstalled`       — removed: runner(s) stopped, caps gone, code deleted.
+*  - `not-installed`     — the node did not have it (nothing to do).
+*  - `refused`           — protected / bootstrap package; nothing touched.
+*  - `failed`            — attempted and did not complete; `error` says why.
+*  - `pending-reconnect` — the node is OFFLINE: its record was pruned so the
+*    back-fill never returns the package, and the stale-addon sweep removes the
+*    copy when the node registers again (only once the hub no longer has it).
+*/
+var UninstallNodeOutcomeSchema = _enum([
+	"uninstalled",
+	"not-installed",
+	"refused",
+	"failed",
+	"pending-reconnect"
+]);
+var UninstallNodeResultSchema = object({
+	nodeId: string(),
+	outcome: UninstallNodeOutcomeSchema,
+	error: string().optional(),
+	addonIds: array(string()).readonly(),
+	runnersStopped: array(string()).readonly(),
+	warnings: array(string()).readonly()
+});
+var UninstallPackageResultSchema = object({
+	/** Every targeted node ended `uninstalled`, `not-installed` or `pending-reconnect`. */
+	success: boolean(),
+	packageName: string(),
+	results: array(UninstallNodeResultSchema).readonly()
+});
+/**
+* `unreachable` lists online agents whose status read FAILED — absence from
+* `installations` is only "not installed" for a node that answered (D315).
+*/
+var PackageInstallationsSchema = object({
+	installations: array(object({
+		packageName: string(),
+		nodeId: string(),
+		nodeName: string(),
+		isHub: boolean(),
+		isOnline: boolean(),
+		version: string().nullable(),
+		addonIds: array(string()).readonly(),
+		source: _enum(["live", "recorded"]),
+		/** The hub installs this package too. `false` on an agent row = an orphan. */
+		onHub: boolean()
+	})).readonly(),
+	unreachable: array(object({
+		nodeId: string(),
+		error: string()
+	})).readonly()
+});
 var BulkUpdateItemStatusSchema = _enum([
 	"queued",
 	"updating",
@@ -35600,10 +35898,31 @@ var addonsCapability = {
 		}),
 		isWorkspaceAvailable: method(_void(), boolean()),
 		listWorkspacePackages: method(_void(), array(unknown()).readonly()),
-		uninstallPackage: method(object({ packageName: string() }), unknown(), {
+		/**
+		* Uninstall a package. `nodeId` omitted (or `'hub'`) uninstalls on the hub
+		* — the original behaviour, which still THROWS on failure. An agent
+		* `nodeId` removes it from that agent through `$agent.undeploy`
+		* (runners stopped, caps deregistered, code deleted) and prunes the node's
+		* declared roster so the back-fill never returns it. `everywhere: true`
+		* does both for every node that has it (agents first, hub last); offline
+		* nodes answer `pending-reconnect`. Node-level failures in those two modes
+		* are REPORTED per node, never thrown. Protected packages are refused.
+		*/
+		uninstallPackage: method(object({
+			packageName: string().min(1),
+			nodeId: string().optional(),
+			everywhere: boolean().optional()
+		}), UninstallPackageResultSchema, {
 			kind: "mutation",
 			auth: "admin"
 		}),
+		/**
+		* Which nodes have a package (or, with no `packageName`, every package on
+		* every node). Hub from its installer, online agents from `$agent.status`
+		* (in parallel, bounded), offline agents from their declared roster.
+		* Drives the uninstall confirm and the Addons page's "not on the hub" list.
+		*/
+		listInstallations: method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }),
 		reloadPackages: method(_void(), ReloadPackagesResultSchema, {
 			kind: "mutation",
 			auth: "admin"
@@ -47749,6 +48068,16 @@ var zoneRulesCapability = {
 	durability: "restored"
 };
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
+Object.freeze({
+	person: .5,
+	vehicle: .5,
+	animal: .5
+});
+Object.freeze({
+	person: .65,
+	vehicle: .65,
+	animal: .65
+});
 /**
 * Most specific first. Extending this list is how a new device kind becomes
 * gateable; nothing else needs to change.
@@ -49023,6 +49352,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"addons.listInstallations": {
+		capName: "addons",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"addons.listJobs": {
 		capName: "addons",
 		capScope: "system",
@@ -50205,90 +50540,18 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"decoder.createSession": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.destroySession": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "delete"
-	},
-	"decoder.getFrame": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"decoder.getInfo": {
 		capName: "decoder",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"decoder.getShmStats": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.getStats": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.listActiveSessions": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.openStream": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.pullFrames": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.pullHandles": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.pushPacket": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"decoder.reprobeHwaccel": {
 		capName: "decoder",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"decoder.supportsCodec": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
-	"decoder.updateConfig": {
-		capName: "decoder",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"detectionPipeline.applyDeviceSettingsPatch": {
 		capName: "detection-pipeline",
 		capScope: "device",
@@ -53367,13 +53630,13 @@ Object.freeze({
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineExecutor.deleteModel": {
+	"pipelineExecutor.clearModelBoundDeviceOverrides": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
 		access: "delete"
 	},
-	"pipelineExecutor.deleteTemplate": {
+	"pipelineExecutor.deleteModel": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
@@ -53517,12 +53780,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineExecutor.listTemplates": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"pipelineExecutor.rearmInferenceDevice": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -53547,12 +53804,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineExecutor.saveTemplate": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.setVideoPipelineSteps": {
 		capName: "pipeline-executor",
 		capScope: "system",
@@ -53571,41 +53822,35 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineExecutor.updateTemplate": {
-		capName: "pipeline-executor",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineExecutor.validatePipeline": {
 		capName: "pipeline-executor",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.applyDeviceSettingsPatch": {
+	"pipelineOrchestrator.applyAutoTune": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.assignAudio": {
+	"pipelineOrchestrator.applyDeviceSettingsPatch": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.assignPipeline": {
+	"pipelineOrchestrator.assignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.deleteTemplate": {
+	"pipelineOrchestrator.assignPipeline": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
-		access: "delete"
+		access: "create"
 	},
 	"pipelineOrchestrator.getAgentLoad": {
 		capName: "pipeline-orchestrator",
@@ -53697,6 +53942,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"pipelineOrchestrator.getEffectiveShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.getGlobalMetrics": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -53733,19 +53984,19 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.getReconcileFromDiskStatus": {
+	"pipelineOrchestrator.getPlacementStats": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.listAgentSettings": {
+	"pipelineOrchestrator.getReconcileFromDiskStatus": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
-	"pipelineOrchestrator.listTemplates": {
+	"pipelineOrchestrator.listAgentSettings": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -53757,6 +54008,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.planAutoTune": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"pipelineOrchestrator.rebalance": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -53799,12 +54056,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.saveTemplate": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentCapabilities": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -53817,12 +54068,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.setAgentDetectWeight": {
-		capName: "pipeline-orchestrator",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"pipelineOrchestrator.setAgentInferenceDevices": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -53859,6 +54104,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setCameraStepSettings": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setCameraStepToggle": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
@@ -53877,25 +54128,37 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"pipelineOrchestrator.setLoadBalancingShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"pipelineOrchestrator.setPipelineDevicePin": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.unassignAudio": {
+	"pipelineOrchestrator.setShareSource": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.unassignPipeline": {
+	"pipelineOrchestrator.suggestShares": {
+		capName: "pipeline-orchestrator",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
+	"pipelineOrchestrator.unassignAudio": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
 		access: "create"
 	},
-	"pipelineOrchestrator.updateTemplate": {
+	"pipelineOrchestrator.unassignPipeline": {
 		capName: "pipeline-orchestrator",
 		capScope: "system",
 		addonId: null,
@@ -55335,12 +55598,6 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
-	"streamBroker.pullFrameHandles": {
-		capName: "stream-broker",
-		capScope: "system",
-		addonId: null,
-		access: "view"
-	},
 	"streamBroker.regenerateRtspToken": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -55407,12 +55664,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"streamBroker.subscribeFrames": {
-		capName: "stream-broker",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"streamBroker.unassignProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -55425,12 +55676,6 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
-	"streamBroker.unsubscribeFrames": {
-		capName: "stream-broker",
-		capScope: "system",
-		addonId: null,
-		access: "create"
-	},
 	"streamCatalog.getCatalog": {
 		capName: "stream-catalog",
 		capScope: "device",
@@ -58120,11 +58365,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"decoder.createSession": [{
-		name: "deviceId",
-		form: "single",
-		optional: true
-	}],
 	"detectionPipeline.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -59355,6 +59595,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -59460,6 +59705,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",