@camstack/addon-pipeline-orchestrator 1.2.295 → 1.2.297

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-//#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";
@@ -503,15 +503,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";
@@ -5382,7 +5373,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DAJ9Er57.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).
@@ -6781,32 +6772,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
@@ -6832,50 +6803,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.
@@ -6883,8 +6810,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({
@@ -6902,11 +6829,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(),
@@ -6937,9 +6863,7 @@ var BrokerStatsSchema = object({
 		"stopped"
 	]),
 	inputFps: number(),
-	decodeFps: number(),
 	encodedSubscribers: number(),
-	decodedSubscribers: number(),
 	uptimeMs: number(),
 	bitrateKbps: number(),
 	idrIntervalMs: number(),
@@ -6952,14 +6876,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
@@ -11297,70 +11213,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.
@@ -13564,13 +13416,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(),
@@ -13662,7 +13507,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(),
@@ -14031,11 +13875,7 @@ method(object({
 	auth: "admin"
 }), method(object({ brokerId: string() }), BrokerClientsSchema), method(object({
 	brokerId: string(),
-	channel: _enum([
-		"rtsp",
-		"decoded",
-		"audio"
-	]),
+	channel: _enum(["rtsp", "audio"]),
 	handle: string()
 }), object({ killed: boolean() }), {
 	kind: "mutation",
@@ -14070,10 +13910,7 @@ method(object({
 }), method(SubscribeAudioChunksInputSchema, SubscribeAudioChunksResultSchema, { kind: "mutation" }), method(object({
 	subscriptionId: string(),
 	maxCount: number().int().positive().default(8)
-}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(SubscribeFramesInputSchema, SubscribeFramesResultSchema, { kind: "mutation" }), method(object({
-	subscriptionId: string(),
-	maxCount: number().int().positive().default(4)
-}), array(FrameHandleSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
+}), array(DecodedAudioChunkSchema).readonly()), method(object({ subscriptionId: string() }), object({ released: boolean() }), { kind: "mutation" }), method(object({
 	brokerId: string(),
 	seconds: number().min(0).max(30)
 }), _void(), {
@@ -15230,54 +15067,12 @@ id: union([string(), number()]) }), {
 	kind: "mutation",
 	auth: "admin"
 });
-/**
-* 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()
-});
-method(object({ codec: string() }), boolean()), method(_void(), object({
+method(_void(), object({
 	id: string(),
 	name: string(),
-	isPullMode: boolean().optional(),
-	priority: number().optional(),
 	hwaccel: string().optional(),
 	probedBestHwaccel: string().optional()
-})), method(DecoderSessionConfigSchema, object({
-	sessionId: string(),
-	nodeId: string()
-})), method(object({ sessionId: string() }), _void()), method(object({
-	sessionId: string(),
-	packet: EncodedPacketSchema
-}), _void()), method(object({
-	sessionId: string(),
-	url: string()
-}), _void()), method(object({
-	sessionId: string(),
-	maxCount: number().default(1),
-	waitMs: number().optional()
-}), array(DecodedFrameSchema)), method(object({
-	sessionId: string(),
-	maxCount: number().default(1),
-	waitMs: number().optional()
-}), array(FrameHandleSchema)), method(object({ handle: FrameHandleSchema }), DecodedFrameSchema.nullable()), method(object({ sessionId: string() }), ShmRingStatsSchema.nullable()), method(object({
-	sessionId: string(),
-	config: DecoderSessionConfigSchema.partial()
-}), _void()), method(object({ sessionId: string() }), DecoderStatsSchema), method(_void(), array(object({
-	sessionId: string(),
-	codec: string(),
-	outputFormat: string(),
-	createdAtMs: number()
-})).readonly()), method(_void(), object({ backend: string() }), {
+})), method(_void(), object({ backend: string() }), {
 	kind: "mutation",
 	auth: "admin"
 });
@@ -22347,8 +22142,8 @@ function interpretStoredClusterModel(raw) {
 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,
@@ -26480,14 +26275,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({
@@ -26810,7 +26606,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(),
@@ -26899,8 +26698,14 @@ 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()
@@ -29989,8 +29794,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()
 });
@@ -30569,6 +30372,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",
@@ -30651,10 +30507,14 @@ method(_void(), array(AddonListItemSchema).readonly()), method(object({
 }), method(object({ packageName: string() }), InstallPackageResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({ packageName: string() }), unknown(), {
+}), method(_void(), boolean()), method(_void(), array(unknown()).readonly()), method(object({
+	packageName: string().min(1),
+	nodeId: string().optional(),
+	everywhere: boolean().optional()
+}), UninstallPackageResultSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), ReloadPackagesResultSchema, {
+}), method(object({ packageName: string().optional() }), PackageInstallationsSchema, { auth: "admin" }), method(_void(), ReloadPackagesResultSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({ query: string().optional() }), array(SearchResultSchema)), method(object({ nodeId: string().optional() }), array(PackageUpdateSchema).readonly(), { auth: "admin" }), method(object({
@@ -39054,6 +38914,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"addons.listInstallations": {
+		capName: "addons",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"addons.listJobs": {
 		capName: "addons",
 		capScope: "system",
@@ -40236,90 +40102,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",
@@ -45366,12 +45160,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",
@@ -45438,12 +45226,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",
@@ -45456,12 +45238,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",
@@ -48003,11 +47779,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"decoder.createSession": [{
-		name: "deviceId",
-		form: "single",
-		optional: true
-	}],
 	"detectionPipeline.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -54724,6 +54495,40 @@ var LoadShedController = class LoadShedController {
 	}
 };
 //#endregion
+//#region src/default-pool-attribution.ts
+/** The backend prefix of a `<backend>:<device>` key (bare `cpu` → `cpu`). */
+function backendOf(deviceKey) {
+	const colon = deviceKey.indexOf(":");
+	return colon >= 0 ? deviceKey.slice(0, colon) : deviceKey;
+}
+/**
+* `load` with its unattributed sessions credited to `eligibleKeys[0]` when that
+* is the node's ONLY eligible device; `load` itself (same reference) otherwise.
+* `eligibleKeys` null = the eligible set is not known.
+*/
+function attributeDefaultPoolSessions(load, eligibleKeys) {
+	if (eligibleKeys === null || eligibleKeys.length !== 1) return load;
+	const onlyKey = eligibleKeys[0];
+	if (onlyKey === void 0) return load;
+	const attributed = load.devices.reduce((sum, d) => sum + d.attachedCameras, 0);
+	const unattributed = load.attachedCameras - attributed;
+	if (unattributed <= 0) return load;
+	const existing = load.devices.find((d) => d.deviceKey === onlyKey);
+	const credited = existing ? {
+		...existing,
+		attachedCameras: existing.attachedCameras + unattributed
+	} : {
+		deviceKey: onlyKey,
+		backend: backendOf(onlyKey),
+		attachedCameras: unattributed
+	};
+	const devices = [...load.devices.filter((d) => d.deviceKey !== onlyKey), credited].toSorted((a, b) => a.deviceKey.localeCompare(b.deviceKey));
+	return {
+		...load,
+		devices
+	};
+}
+//#endregion
 //#region src/dispatch-timing.ts
 /**
 * How long the placement census waits for ONE runner's `getLocalCameras`
@@ -54790,6 +54595,25 @@ var AgentLoadService = class AgentLoadService {
 	getAgentLoadSummaries() {
 		return [...this.cachedAgentLoad.values()];
 	}
+	/**
+	* The cached summaries as the load REPORT (`getAgentLoad`) carries them: a
+	* single-device node's default-pool sessions credited to its one device
+	* (`default-pool-attribution.ts`). The balancer's census
+	* ({@link collectAgentLoad}) stays the runner's raw answer.
+	*/
+	async reportedAgentLoad() {
+		const resolve = this.deps.eligibleDeviceKeys;
+		const summaries = this.getAgentLoadSummaries();
+		if (resolve === void 0) return summaries;
+		return Promise.all(summaries.map(async (summary) => {
+			const eligible = await resolve(summary.nodeId).catch(() => null);
+			const load = attributeDefaultPoolSessions(summary.load, eligible);
+			return load === summary.load ? summary : {
+				...summary,
+				load
+			};
+		}));
+	}
 	cachedAgentLoadNodeIds() {
 		return [...this.cachedAgentLoad.keys()];
 	}
@@ -57237,8 +57061,7 @@ function mapBroker(brokerResult) {
 			width: p.width,
 			height: p.height,
 			subscribers: p.subscribers,
-			inFps: p.inFps,
-			outFps: p.outFps
+			inFps: p.inFps
 		})),
 		webrtcSessions: brokerResult.webrtcSessions,
 		rtspRestream: brokerResult.rtspRestream
@@ -57625,11 +57448,9 @@ var CameraStatusService = class {
 	* `allSlotsFetch` (fetched once by the caller) to avoid a second
 	* round-trip. Per-slot `getBrokerStats` + `listClients` are fetched in
 	* parallel. WebRTC sessions are counted by filtering `encoded[]` entries
-	* whose `attribution.kind` is one of the `WEBRTC_KINDS`. Also captures the
-	* broker's actual decode-session node into `liveDecoder` (T6) — the first
-	* slot that reports one wins.
+	* whose `attribution.kind` is one of the `WEBRTC_KINDS`.
 	*/
-	buildBrokerStage(api, allSlotsFetch, deviceId, sourceNodeId, pass, liveDecoder, sink) {
+	buildBrokerStage(api, allSlotsFetch, deviceId, sourceNodeId, pass, sink) {
 		if (!api || !allSlotsFetch) return Promise.resolve(null);
 		return this.boundedStage(allSlotsFetch.then(async (slots) => {
 			const deviceSlots = slots.filter((s) => s.deviceId === deviceId);
@@ -57646,19 +57467,16 @@ var CameraStatusService = class {
 					clients
 				};
 			})), pass.rtspEntries(api, sourceNodeId).catch(() => null)]);
-			const profileDetails = statsAndClients.map(({ slot, stats, clients }) => ({
-				profile: slot.profile,
-				status: slot.status,
-				codec: stats?.codec ?? slot.codec ?? "",
-				width: slot.resolution?.width ?? 0,
-				height: slot.resolution?.height ?? 0,
-				subscribers: clients?.encodedSubscribers ?? 0,
-				inFps: stats?.inputFps ?? 0,
-				outFps: stats?.decodeFps ?? 0
-			}));
-			for (const { stats } of statsAndClients) if (liveDecoder.nodeId === null && typeof stats?.decoderNodeId === "string") liveDecoder.nodeId = stats.decoderNodeId;
 			return {
-				profiles: profileDetails,
+				profiles: statsAndClients.map(({ slot, stats, clients }) => ({
+					profile: slot.profile,
+					status: slot.status,
+					codec: stats?.codec ?? slot.codec ?? "",
+					width: slot.resolution?.width ?? 0,
+					height: slot.resolution?.height ?? 0,
+					subscribers: clients?.encodedSubscribers ?? 0,
+					inFps: stats?.inputFps ?? null
+				})),
 				webrtcSessions: statsAndClients.reduce((total, { clients }) => {
 					if (!clients) return total;
 					return total + clients.encoded.filter((c) => WEBRTC_KINDS.has(c.attribution.kind)).length;
@@ -57852,10 +57670,9 @@ var CameraStatusService = class {
 		const api = this.deps.api();
 		const degradations = { entries: [] };
 		const { detectionNodeId, sourceNodeId, pinned, detectionReason, audioNodeId, audioPinned } = this.buildAssignmentContext(deviceId);
-		const liveDecoder = { nodeId: null };
 		const allSlotsFetch = api ? pass.profileSlots(api, sourceNodeId) : null;
 		const sourceFetch = this.buildSourceStage(api, allSlotsFetch, deviceId, degradations);
-		const brokerFetch = this.buildBrokerStage(api, allSlotsFetch, deviceId, sourceNodeId, pass, liveDecoder, degradations);
+		const brokerFetch = this.buildBrokerStage(api, allSlotsFetch, deviceId, sourceNodeId, pass, degradations);
 		const decoderFetch = this.buildDecoderStage(detectionNodeId);
 		const motionResult = this.buildMotionStage(deviceId);
 		const detectionFetch = this.buildDetectionStage(api, detectionNodeId, deviceId, pass, degradations);
@@ -57870,11 +57687,10 @@ var CameraStatusService = class {
 			switchesFetch
 		]);
 		const audioResult = this.buildAudioStage(audioNodeId, switchedOff);
-		const liveDecoderNodeId = brokerResult !== null ? liveDecoder.nodeId : null;
-		const decoderNodeId = liveDecoderNodeId ?? detectionNodeId;
+		const decoderNodeId = detectionNodeId;
 		const reasons = {
 			detection: detectionReason,
-			decoder: liveDecoderNodeId !== null ? "session" : decoderNodeId !== null ? "co-located" : void 0,
+			decoder: decoderNodeId !== null ? "co-located" : void 0,
 			audio: audioPinned ? "manual" : void 0
 		};
 		return composeCameraStatus({
@@ -60111,7 +59927,7 @@ function deviceAsLoad(deviceKey, load) {
 		activeCameras: 0,
 		avgInferenceFps: 0,
 		avgInferenceTimeMs: 0,
-		queueDepthTotal: load?.queueDepthTotal ?? 0,
+		queueDepthTotal: 0,
 		devices: [],
 		hardware: { hasGpu: false }
 	};
@@ -61091,8 +60907,7 @@ function tallyLoad(load, nodeDelta, perDevice) {
 	}), ...[...perDevice ?? /* @__PURE__ */ new Map()].filter(([deviceKey, delta]) => !known.has(deviceKey) && delta > 0).map(([deviceKey, delta]) => ({
 		deviceKey,
 		backend: deviceKey.split(":")[0] ?? deviceKey,
-		attachedCameras: delta,
-		queueDepthTotal: 0
+		attachedCameras: delta
 	}))];
 	return {
 		...load,
@@ -69080,6 +68895,10 @@ async function buildOrchestratorControllers(deps) {
 		onCensus: (entries) => {
 			motionSliceGate?.noteCensus(entries);
 			providerSliceGate?.refreshIfStale("runner-census");
+		},
+		eligibleDeviceKeys: async (nodeId) => {
+			const read = await deps.getEligibleInferenceDevicesIfCached(nodeId);
+			return read.kind === "eligible" ? Object.keys(read.eligible) : null;
 		}
 	});
 	/**
@@ -69938,12 +69757,12 @@ function buildGlobalSettingsSections(options) {
 			id: CLUSTER_MODEL_SECTION_ID,
 			title: "Enrichment models",
 			tab: "pipeline",
-			description: "The encoders that turn a crop into a VECTOR, and the admission knobs those encoders share. One value each for the whole cluster, because each writes into a single shared index. Changing a model does not corrupt what is already stored (every vector carries the model that produced it) but it does STRAND it until a re-embed pass has run. Step knobs such as the face-size floor apply to every node for the same reason.",
+			description: "The face and search encoders, one each for the whole cluster: each fills a single shared index, and vectors from two models cannot be compared. Changing one keeps what is stored but hides it from matching and search until it is re-embedded.",
 			fields: [...CLUSTER_MODEL_SCOPED_STEPS.map((step) => ({
 				key: clusterModelSettingKey(step.stepId),
 				type: "select",
 				label: step.label,
-				description: `Applies to every node. A node whose engine ships no build of the chosen model REFUSES this step and says so in its log, rather than quietly running a different encoder into ${step.indexName}. Changing this strands every vector already in ${step.indexName} until it is re-embedded.`,
+				description: `Used on every node. A node that has no build of this model skips the step (and logs it) rather than use another model. Changing it hides what is already in ${step.indexName} until it is re-embedded.`,
 				options: step.options.map((o) => ({
 					value: o.id,
 					label: o.label
@@ -69965,12 +69784,12 @@ function buildGlobalSettingsSections(options) {
 			id: DETAIL_CROP_SECTION_ID,
 			title: "Enrichment crop",
 			tab: "pipeline",
-			description: "How the crop fed to enrichment steps (semantic-search embedding, face, plate) is cut out of the frame. ONE value for the whole cluster: the semantic-search index is a single feature space, and vectors cut with different conventions cannot be compared, so a per-node value would silently corrupt search results. Changing either knob invalidates the stored index — follow it with a rebuild (Camera → Semantic search index → Rebuild), which now cuts through this same setting.",
+			description: "How the crop handed to the search, face and plate models is cut from the frame. One value for the whole cluster, because search results are only comparable when every crop is cut the same way. After changing it, rebuild the search index (Camera → Semantic search index → Rebuild).",
 			fields: [{
 				key: DETAIL_CROP_PADDING_KEY,
 				type: "slider",
 				label: "Crop margin",
-				description: "Fraction of the detection box added on EACH side before cutting. 0 is the pixel-tight box; 0.15 is the shipped default; 0.2 gives a 1.4x window. CLIP is trained on natural images WITH surroundings, so a tight crop removes exactly the context it is strongest on — but the right value is empirical, which is why it is a knob.",
+				description: "Extra margin added on each side of the detection box, as a fraction of its size. 0 = tight box, 0.15 = default. Search works better with some surroundings in the crop.",
 				min: DETAIL_CROP_PADDING_FIELD.min,
 				max: DETAIL_CROP_PADDING_FIELD.max,
 				step: DETAIL_CROP_PADDING_FIELD.step,
@@ -69980,7 +69799,7 @@ function buildGlobalSettingsSections(options) {
 				key: DETAIL_CROP_SQUARE_KEY,
 				type: "boolean",
 				label: "Square the crop",
-				description: "Grow the shorter side so the crop is square before it reaches the model. CLIP's input is square, so a tall subject resized straight to NxN is squashed into a shape the model never saw in training. Off by default because the stored index was built unsquared.",
+				description: "Widen the crop to a square so a tall subject is not squashed when the model resizes it. Off by default because the existing index was built without it.",
 				default: DEFAULT_DETAIL_CROP_CONVENTION.square
 			}]
 		},
@@ -69988,13 +69807,13 @@ function buildGlobalSettingsSections(options) {
 			id: NATIVE_LEASE_SECTION_ID,
 			title: "Native frame lease",
 			tab: "pipeline",
-			description: "How a decode worker keeps native pixels available for a LATE crop (post-analysis snapshot, face/plate detail) instead of falling back to the ≤640 detection frame. Two things are kept and they cost very differently: a HELD FRAME is a full native raster (~24.9 MB at 4K on the default pinned-RGB24 path, ~6.2 MB at 1080p) and lives only until its own detection result arrives; a TILE is one subject cut from that frame at native resolution and JPEG-encoded (~60-120 KB at 4K), and lives for tens of seconds. A frame on which nothing was detected produces no tiles and costs nothing. Takes effect on the NEXT decode session for a camera, not on sessions already running.",
+			description: "How each camera keeps full-resolution pixels so a crop taken seconds later (snapshot, face, plate) is sharp instead of cut from the small detection frame. A held frame is a whole picture (~25 MB at 4K) kept until its detections arrive; a tile is one subject, or one whole-scene copy, saved as JPEG for tens of seconds. Applies from the next session of each camera.",
 			fields: [
 				{
 					key: NATIVE_LEASE_HOLD_KEY,
 					type: "slider",
 					label: "Frames held at once",
-					description: "How many delivered frames a worker keeps alive while waiting for their detection results. A frame is freed as soon as its own result comes back and its subject tiles have been cut, so the steady state is inference latency × delivered fps — 1 to 4 frames in practice. This number is only the bound above which the OLDEST held frame is dropped, which is what stops a runner that has stopped answering from pinning RAM. Raising it does not improve crop hit rate; it buys tolerance for a slow runner, and holdOverflow on the metrics line is what tells you that you need it.",
+					description: "Most frames kept per camera while their detections are pending; past it the oldest is dropped. 1 to 4 are in use normally. Raise it only if a slow node drops frames (holdOverflow in the logs) — it does not make crops sharper.",
 					min: NATIVE_LEASE_HOLD_FIELD.min,
 					max: NATIVE_LEASE_HOLD_FIELD.max,
 					step: NATIVE_LEASE_HOLD_FIELD.step,
@@ -70006,7 +69825,7 @@ function buildGlobalSettingsSections(options) {
 					key: NATIVE_LEASE_TILE_BUDGET_KEY,
 					type: "slider",
 					label: "Subject tile RAM",
-					description: "RAM per decode worker for the compressed SUBJECT TILES — the native-resolution crops taken at the moment a frame's detections are known, and kept long after the frame itself is gone. This is what serves a crop that arrives seconds late, which measurement says is the ordinary case (2 to 10 seconds on this cluster). At ~60-120 KB a tile, 64 MB is many hundreds of subjects. 0 turns tiles OFF and restores the old behaviour, where a late crop had nothing to fall back to but the ≤640 detection frame.",
+					description: "RAM per camera for subject tiles: full-resolution crops of each detected subject, kept so a crop asked for seconds later is still sharp. A tile is ~60-120 KB. 0 = off (late crops come from the small detection frame).",
 					min: NATIVE_LEASE_TILE_BUDGET_FIELD.min,
 					max: NATIVE_LEASE_TILE_BUDGET_FIELD.max,
 					step: NATIVE_LEASE_TILE_BUDGET_FIELD.step,
@@ -70018,7 +69837,7 @@ function buildGlobalSettingsSections(options) {
 					key: NATIVE_LEASE_SCENE_BUDGET_KEY,
 					type: "slider",
 					label: "Scene tile RAM",
-					description: "RAM per decode worker for the SCENE TILES — one JPEG copy of the WHOLE native frame, taken at the same instant as the subject tiles above, and only on frames that detected something. A subject tile cannot answer a request for the whole frame (containment is strict, so that a crop never quietly comes from a different part of the scene), which left the native key frame, the detail plane's full-frame rung and the gallery fallback with nothing to fall back to once the held raster was released — measured at 23.3% of key-frame captures lost, 95.7% of them for exactly that reason. A scene tile is ~1.5-2.5 MB at 4K against ~24 MB for the raster it came from, so this budget buys tens of seconds of coverage where holding the rasters for ten would cost around half a gigabyte per camera. 0 turns scene tiles OFF and restores that gap.",
+					description: "RAM per camera for scene tiles: a full-resolution JPEG of the whole picture (~2 MB at 4K) on frames where something was detected, for key frames and whole-frame crops. 0 = off (those then fall back to the small detection frame).",
 					min: NATIVE_LEASE_SCENE_BUDGET_FIELD.min,
 					max: NATIVE_LEASE_SCENE_BUDGET_FIELD.max,
 					step: NATIVE_LEASE_SCENE_BUDGET_FIELD.step,
@@ -70030,7 +69849,7 @@ function buildGlobalSettingsSections(options) {
 					key: NATIVE_LEASE_BUDGET_KEY,
 					type: "slider",
 					label: "Lease RAM ceiling",
-					description: "Hard RAM ceiling for held frames, PER decode worker (one worker per camera per plane). This is a safety ceiling, not the working size — the hold count above is what reclaims frames now, and the ceiling is the number above which something is wrong. Lower it on a small host to bound the worst case. 0 DISABLES the lease entirely and falls the worker back to the tiny GPU surface ring, which misses roughly 85% of late crops — that is the behaviour the lease exists to replace, so 0 is a diagnostic setting, not a tuning one.",
+					description: "Safety ceiling on the RAM held frames may use per camera; the frame count above is what normally limits it. Lower it on a small host. 0 turns full-resolution crops off almost entirely — for diagnosis only.",
 					min: NATIVE_LEASE_BUDGET_FIELD.min,
 					max: NATIVE_LEASE_BUDGET_FIELD.max,
 					step: NATIVE_LEASE_BUDGET_FIELD.step,
@@ -70042,7 +69861,7 @@ function buildGlobalSettingsSections(options) {
 					key: NATIVE_LEASE_ACTIVITY_KEY,
 					type: "slider",
 					label: "Demand window",
-					description: "Retention only runs within this long of the last native-crop request (or of the stream dialling). A camera nothing is cropping therefore retains nothing and pays no GPU→RAM download at all; the first crop after the window closes misses once, falls back, and re-opens the window for the retry. 0 means ALWAYS ON — it turns the gate off, it does not turn retention off — which is the legacy behaviour that saturated an N100 with 24 native-4K downloads per second on a camera with zero crop demand. Leave it non-zero unless you are reproducing that.",
+					description: "Keep full-resolution pixels only within this long of the last crop request, so a camera nobody crops costs nothing; the first crop after a quiet spell falls back once. 0 = always keep (heavy on small hosts).",
 					min: NATIVE_LEASE_ACTIVITY_FIELD.min,
 					max: NATIVE_LEASE_ACTIVITY_FIELD.max,
 					step: NATIVE_LEASE_ACTIVITY_FIELD.step,
@@ -70055,7 +69874,7 @@ function buildGlobalSettingsSections(options) {
 					key: NATIVE_LEASE_ADMISSION_KEY,
 					type: "select",
 					label: "What to retain",
-					description: "WHICH delivered frames get a native copy. A late crop always names one specific frame, and the only way a frame id leaves the runner is on an inference result — so 'Only frames sent to inference' keeps exactly the set a crop can ever ask for and drops the rest, which at the governor's usual 5-in-25 admit rate is around 80% less retained RAM and 80% less GPU→RAM download. 'Every delivered frame' is the older, unconditional behaviour; choose it if a crop ever has to reach a frame the pipeline never inferred. The decode worker counts any crop that names a non-inferred frame on its metrics line (leaseUnmarkedCrops), so a wrong choice here is visible rather than silent.",
+					description: "Which frames get a full-resolution copy. 'Only frames sent to inference' keeps the frames a crop can actually ask for (about 80% less RAM); 'Every delivered frame' keeps all of them.",
 					options: NATIVE_LEASE_ADMISSION_FIELD.options,
 					default: NATIVE_LEASE_ADMISSION_FIELD.default
 				}
@@ -70068,7 +69887,8 @@ function buildGlobalSettingsSections(options) {
 				{
 					key: "onDisconnect",
 					type: "select",
-					label: "On runner disconnect",
+					label: "When a node disconnects",
+					description: "Move its unpinned cameras to other nodes, or leave them stopped.",
 					default: DEFAULT_FAILOVER_POLICY.onDisconnect,
 					options: [{
 						value: "migrate",
@@ -70081,7 +69901,8 @@ function buildGlobalSettingsSections(options) {
 				{
 					key: "pinnedOnDisconnect",
 					type: "select",
-					label: "Pinned cameras on disconnect",
+					label: "Its pinned cameras",
+					description: "Keep the pin and wait for the node, or drop the pin and move them.",
 					default: DEFAULT_FAILOVER_POLICY.pinnedOnDisconnect,
 					options: [{
 						value: "leave-pinned",
@@ -70094,7 +69915,8 @@ function buildGlobalSettingsSections(options) {
 				{
 					key: "onReconnect",
 					type: "select",
-					label: "On runner reconnect",
+					label: "When it comes back",
+					description: "Put its cameras back where they were, or rebalance the whole cluster.",
 					default: DEFAULT_FAILOVER_POLICY.onReconnect,
 					options: [{
 						value: "restore",
@@ -72095,7 +71917,7 @@ var PipelineOrchestratorAddon = class PipelineOrchestratorAddon extends BaseAddo
 	async getAgentLoad() {
 		await this.loadService.refreshDecodeHwaccels();
 		await this.loadService.collectAgentLoad();
-		return this.loadService.getAgentLoadSummaries();
+		return this.loadService.reportedAgentLoad();
 	}
 	async getGlobalMetrics() {
 		const summaries = await this.getAgentLoad();