@camstack/addon-decoder-nodeav 1.2.119 → 1.2.121

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { randomUUID } 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";
@@ -3771,7 +3762,7 @@ function initializeContext(params) {
 		external: params?.external ?? void 0
 	};
 }
-function process$1(schema, ctx, _params = {
+function process(schema, ctx, _params = {
 	path: [],
 	schemaPath: []
 }) {
@@ -3808,7 +3799,7 @@ function process$1(schema, ctx, _params = {
 		const parent = schema._zod.parent;
 		if (parent) {
 			if (!result.ref) result.ref = parent;
-			process$1(parent, ctx, params);
+			process(parent, ctx, params);
 			ctx.seen.get(parent).isParent = true;
 		}
 	}
@@ -4028,7 +4019,7 @@ var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
 		...params,
 		processors
 	});
-	process$1(schema, ctx);
+	process(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -4040,7 +4031,7 @@ var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) =
 		io,
 		processors
 	});
-	process$1(schema, ctx);
+	process(schema, ctx);
 	extractDefs(ctx, schema);
 	return finalize(ctx, schema);
 };
@@ -4154,7 +4145,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
 	if (typeof minimum === "number") json.minItems = minimum;
 	if (typeof maximum === "number") json.maxItems = maximum;
 	json.type = "array";
-	json.items = process$1(def.element, ctx, {
+	json.items = process(def.element, ctx, {
 		...params,
 		path: [...params.path, "items"]
 	});
@@ -4165,7 +4156,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	json.type = "object";
 	json.properties = {};
 	const shape = def.shape;
-	for (const key in shape) json.properties[key] = process$1(shape[key], ctx, {
+	for (const key in shape) json.properties[key] = process(shape[key], ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4183,7 +4174,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 	if (def.catchall?._zod.def.type === "never") json.additionalProperties = false;
 	else if (!def.catchall) {
 		if (ctx.io === "output") json.additionalProperties = false;
-	} else if (def.catchall) json.additionalProperties = process$1(def.catchall, ctx, {
+	} else if (def.catchall) json.additionalProperties = process(def.catchall, ctx, {
 		...params,
 		path: [...params.path, "additionalProperties"]
 	});
@@ -4191,7 +4182,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
 	const isExclusive = def.inclusive === false;
-	const options = def.options.map((x, i) => process$1(x, ctx, {
+	const options = def.options.map((x, i) => process(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4204,7 +4195,7 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const a = process$1(def.left, ctx, {
+	const a = process(def.left, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4212,7 +4203,7 @@ var intersectionProcessor = (schema, ctx, json, params) => {
 			0
 		]
 	});
-	const b = process$1(def.right, ctx, {
+	const b = process(def.right, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4229,7 +4220,7 @@ var tupleProcessor = (schema, ctx, _json, params) => {
 	json.type = "array";
 	const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
 	const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-	const prefixItems = def.items.map((x, i) => process$1(x, ctx, {
+	const prefixItems = def.items.map((x, i) => process(x, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4237,7 +4228,7 @@ var tupleProcessor = (schema, ctx, _json, params) => {
 			i
 		]
 	}));
-	const rest = def.rest ? process$1(def.rest, ctx, {
+	const rest = def.rest ? process(def.rest, ctx, {
 		...params,
 		path: [
 			...params.path,
@@ -4268,7 +4259,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 	const keyType = def.keyType;
 	const patterns = keyType._zod.bag?.patterns;
 	if (def.mode === "loose" && patterns && patterns.size > 0) {
-		const valueSchema = process$1(def.valueType, ctx, {
+		const valueSchema = process(def.valueType, ctx, {
 			...params,
 			path: [
 				...params.path,
@@ -4279,11 +4270,11 @@ var recordProcessor = (schema, ctx, _json, params) => {
 		json.patternProperties = {};
 		for (const pattern of patterns) json.patternProperties[pattern.source] = valueSchema;
 	} else {
-		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process$1(def.keyType, ctx, {
+		if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") json.propertyNames = process(def.keyType, ctx, {
 			...params,
 			path: [...params.path, "propertyNames"]
 		});
-		json.additionalProperties = process$1(def.valueType, ctx, {
+		json.additionalProperties = process(def.valueType, ctx, {
 			...params,
 			path: [...params.path, "additionalProperties"]
 		});
@@ -4296,7 +4287,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	const inner = process$1(def.innerType, ctx, params);
+	const inner = process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	if (ctx.target === "openapi-3.0") {
 		seen.ref = def.innerType;
@@ -4305,27 +4296,27 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	if (ctx.io === "input") json._prefault = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var catchProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	let catchValue;
@@ -4340,26 +4331,26 @@ var pipeProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
 	const inIsTransform = def.in._zod.traits.has("$ZodTransform");
 	const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
-	process$1(innerType, ctx, params);
+	process(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 	json.readOnly = true;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
 	const def = schema._zod.def;
-	process$1(def.innerType, ctx, params);
+	process(def.innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
 	const innerType = schema._zod.innerType;
-	process$1(innerType, ctx, params);
+	process(innerType, ctx, params);
 	const seen = ctx.seen.get(schema);
 	seen.ref = innerType;
 };
@@ -5379,7 +5370,7 @@ var ZodIssueCode = {
 var ZodFirstPartyTypeKind;
 ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {});
 //#endregion
-//#region ../types/dist/sleep-DXKLNFvA.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).
@@ -6745,32 +6736,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
@@ -6796,50 +6767,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.
@@ -6847,8 +6774,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({
@@ -6866,11 +6793,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(),
@@ -6901,9 +6827,7 @@ var BrokerStatsSchema = object({
 		"stopped"
 	]),
 	inputFps: number(),
-	decodeFps: number(),
 	encodedSubscribers: number(),
-	decodedSubscribers: number(),
 	uptimeMs: number(),
 	bitrateKbps: number(),
 	idrIntervalMs: number(),
@@ -6916,14 +6840,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
@@ -10255,70 +10171,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.
@@ -10461,6 +10313,26 @@ var ClipSearchStrictnessSchema = _enum([
 	"balanced",
 	"strict"
 ]);
+/** Steps whose effect a root label can BE. */
+var LABEL_SUPPLY_STEP_IDS = [
+	"animal-classifier",
+	"vehicle-classifier",
+	"package-detection"
+];
+/** Steps whose box a root detection can BE. */
+var CROP_SUPPLY_STEP_IDS = ["plate-detection", "face-detection"];
+/**
+* Steps whose per-detection MASK a root detection can carry (D737). The live
+* mask step is `segmentation` — a frame-plane refiner that runs its own model
+* once per detection crop. (`instance-segmentation` is a dormant step id that
+* no camera tree carries.)
+*/
+var MASK_SUPPLY_STEP_IDS = ["segmentation"];
+[
+	...LABEL_SUPPLY_STEP_IDS,
+	...CROP_SUPPLY_STEP_IDS,
+	...MASK_SUPPLY_STEP_IDS
+];
 var MODEL_FORMATS = [
 	"onnx",
 	"coreml",
@@ -10489,7 +10361,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).
@@ -10530,11 +10448,11 @@ var ModelVariantGroupSchema = object({
 	/** Quantization axis. Omit ⇒ the fp32 base build. */
 	precision: _enum(["fp32", "int8"]).optional(),
 	/**
-	* Speed-optimization axis. Omit ⇒ the standard build. `fast` marks a
-	* latency-optimized export (e.g. ReLU-activation variant) — the slot the
-	* future performance variants plug into.
+	* Training / latency-variant axis. Omit ⇒ the standard build. `test` marks
+	* an alternate training of the same family (Scrypted `relu_test`); chip
+	* label is "Test".
 	*/
-	optimization: _enum(["standard", "fast"]).optional(),
+	optimization: _enum(["standard", "test"]).optional(),
 	/**
 	* Input-resolution axis (square input side, px). Omit ⇒ the family's native
 	* resolution (640 for yolo26). Reduced-input builds (320 / 256) are a big,
@@ -10557,9 +10475,10 @@ var ModelProviderIdSchema = _enum([
 * are per upstream. A persisted custom-model row written when this field was a
 * string still parses — the string is lifted into `{ weights }`.
 *
-* Every licence surface (the admin "Models and licenses" page,
-* `THIRD_PARTY_MODELS.md`, the Hugging Face model table) is GENERATED from
-* these records by `scripts/gen-model-licenses.ts` (D661).
+* Every machine licence surface (`THIRD_PARTY_MODELS.md`, the Hugging Face
+* model table) is GENERATED from these records by
+* `scripts/gen-model-licenses.ts` (D661). Operator-facing docs live in
+* `camstack/docs` → `/docs/detection/models`.
 */
 var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { weights: value } : value, object({
 	/** SPDX id of the WEIGHTS' terms, a `LicenseRef-*` for non-SPDX terms, or `UNKNOWN`. */
@@ -10592,6 +10511,46 @@ var ModelLicenseSchema = preprocess((value) => typeof value === "string" ? { wei
 	/** True when the weights or their data forbid commercial use. */
 	nonCommercial: boolean().optional()
 }));
+/**
+* One step a ROOT detector can supply from its own output (D730) — see
+* `ModelCatalogEntry.suppliesSteps`.
+*
+* - `label`: the root's raw class IS the step's answer. `labelToEffect` maps
+*   the root's label to the step's vocabulary; `uncovered` is the vocabulary
+*   the root cannot produce (shown as unavailable, never a blocker).
+* - `crop`: the root draws the box the step would have found (`license_plate`
+*   for plate-detection, `face` for face-detection). The box becomes a detail
+*   child of the `parentMacro` detection that contains it — never a track.
+* - `mask`: the root's decode emits an instance mask with every detection (a
+*   YOLO26-seg root, D737) — the `segmentation` step's result, carried on the
+*   detection in the shape that step produces. Derived from the model's
+*   postprocessor on read, never stored by an import.
+*/
+var RootStepSupplySchema = discriminatedUnion("kind", [
+	object({
+		kind: literal("label"),
+		stepId: _enum(LABEL_SUPPLY_STEP_IDS),
+		labelToEffect: record(string(), string()),
+		uncovered: array(string()).readonly()
+	}),
+	object({
+		kind: literal("crop"),
+		stepId: _enum(CROP_SUPPLY_STEP_IDS),
+		rootLabels: array(string()).readonly(),
+		parentMacro: _enum(["vehicle", "person"]),
+		childClass: _enum(["plate", "face"]),
+		/**
+		* The root's smaller input side, stamped on read by `rootSuppliesOf` from
+		* the model entry — what a step's `minRootInputPx` gate judges. Never
+		* stored by an import.
+		*/
+		rootInputPx: number().int().positive().optional()
+	}),
+	object({
+		kind: literal("mask"),
+		stepId: _enum(MASK_SUPPLY_STEP_IDS)
+	})
+]);
 var ModelCatalogEntrySchema = object({
 	id: string(),
 	name: string(),
@@ -10657,6 +10616,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):
@@ -10718,6 +10706,16 @@ var ModelCatalogEntrySchema = object({
 	*/
 	classMap: DetectionCatalogClassMapSchema.optional(),
 	/**
+	* The pipeline steps this ROOT detector can supply from its own output
+	* (D730): its labels name a step's effect (`deer` for `animal-classifier`)
+	* or draw a step's box (`license_plate` for `plate-detection`). Computed at
+	* import from THIS model's labelmap by `deriveRootSupplies`, never written
+	* by hand and never assumed per family; a row without it is derived on read
+	* (`rootSuppliesOf`). Whether a camera uses it is the step's own
+	* `useRootModel` flag (`resolveRootSupply`).
+	*/
+	suppliesSteps: array(RootStepSupplySchema).readonly().optional(),
+	/**
 	* The model's CLIP feature-space contract (text encoder, dimension, vector
 	* index, token window, search floor) — see `clip-model.ts`. Present ONLY on a
 	* CLIP image encoder; its absence is what "not a CLIP model" means to the
@@ -12356,13 +12354,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(),
@@ -12454,7 +12445,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(),
@@ -12823,11 +12813,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",
@@ -12862,10 +12848,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(), {
@@ -14082,72 +14065,18 @@ var DEFAULT_DECODER_HWACCEL_CONFIG = {
 	hwaccel: "auto",
 	probedBestHwaccel: ""
 };
-/**
-* 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
@@ -14218,7 +14147,7 @@ DeviceType.Camera;
 * This matters here more than anywhere else in the repo, because every provider
 * that knows a device's host knows its PASSWORD too: `{ host, port, username,
 * password }` sit in one object on Hikvision, Amcrest, Reolink and ONVIF alike,
-* and `http://admin:hunter2@192.168.x.x/` is a URL a browser accepts. The
+* and `http://admin:hunter2@192.168.60.139/` is a URL a browser accepts. The
 * camera's own page will ask for its own login. That is correct, and pre-
 * filling it is the operator's business, not ours.
 *
@@ -16006,6 +15935,12 @@ method(_void(), array(string()).readonly(), { auth: "admin" }), method(object({
 	kind: "mutation",
 	auth: "admin"
 });
+var HUB_ADDRESS_ROLES = [
+	"appConnections",
+	"notificationTaps",
+	"internal",
+	"publicEndpoint"
+];
 /**
 * Transport bounds for AI capability methods.
 *
@@ -17202,7 +17137,7 @@ method(object({
 	timeoutMs: 6e5
 });
 method(object({
-	nodeId: string(),
+	targetNodeId: string(),
 	modelId: string(),
 	format: _enum(MODEL_FORMATS),
 	entry: ModelCatalogEntrySchema
@@ -18570,6 +18505,8 @@ var NcSystemEventKindSchema = _enum([
 	"stream-offline",
 	"node-online",
 	"node-offline",
+	"node-restarting",
+	"node-updating",
 	"node-inference-unavailable",
 	"detection-blind",
 	"addon-crash-loop",
@@ -19668,8 +19605,9 @@ var NcRuleSchema = NcRuleInputSchema.extend({
 	disabledTargetIds: array(string()).default([])
 });
 /**
-* The state-summary SECTIONS (D647 / D698): the D637 kind groups that report a
-* still-true state. `backups-exports` and `alarm` are not sections — a completed
+* The state-summary SECTIONS (D647 / D698 / D708): the D637 kind groups that
+* report a still-true state. `addons` is the crash-looped addons only and
+* `addon-updates` the addons that are behind (D708 split them). `backups-exports` and `alarm` are not sections — a completed
 * job is not an open state, and the alarm stays instant.
 */
 var NcStateSummarySectionIdSchema = _enum([
@@ -19681,6 +19619,7 @@ var NcStateSummarySectionIdSchema = _enum([
 	"detection-blind",
 	"nodes",
 	"addons",
+	"addon-updates",
 	"updates"
 ]);
 /** One section of a previewed state summary. `unavailable` = its state could not be read. */
@@ -20161,7 +20100,25 @@ var NcAlarmModeDelaysListSchema = array(object({
 	* When this mode may be armed. Absent / null = always allowed (same as a
 	* rule with no `schedule`). Evaluated with {@link isScheduleActive}.
 	*/
-	schedule: NcScheduleSchema.optional()
+	schedule: NcScheduleSchema.optional(),
+	/**
+	* D706: while this mode's ENTRY DELAY runs, do the alarm rules' own pushes go out (as an
+	* intrusion naming the locations)? Absent = false — the entry-delay notification is the
+	* only one, and the matches ride the triggered notification's mosaic (D705).
+	*/
+	notifyDuringEntryDelay: boolean().optional(),
+	/**
+	* D706: notify "watched again" when a sensor this arm bypassed closes and opens again.
+	* Absent = false (logged, not sent). Even when true it is not sent when that same sensor
+	* is the one that starts the entry delay — the entry-delay notification already names it.
+	*/
+	notifySensorRewatched: boolean().optional(),
+	/**
+	* D735: notify "ignored" when a sensor this arm bypassed really MOVED while armed (its own
+	* change time is after the arm) and set nothing off. Absent = false (logged, not sent). A
+	* re-sync, a recovery from `unavailable` or a duplicate is never announced, switch or not.
+	*/
+	notifySensorIgnored: boolean().optional()
 })).max(8).refine(uniqueModes, { message: "modeDelays: at most one entry per arm mode" });
 var NcAlarmModeDelaysEditListSchema = array(object({
 	mode: AlarmArmModeSchema,
@@ -20170,7 +20127,13 @@ var NcAlarmModeDelaysEditListSchema = array(object({
 	triggeredDurationSec: NcAlarmTriggeredSecSchema.nullable().optional(),
 	postTriggeredAction: NcAlarmPostTriggeredActionSchema.nullable().optional(),
 	/** Set a schedule, or `null` to clear (mode always allowed again). */
-	schedule: NcScheduleSchema.nullable().optional()
+	schedule: NcScheduleSchema.nullable().optional(),
+	/** D706: set the switch, or `null` to clear it (back to the default, false). */
+	notifyDuringEntryDelay: boolean().nullable().optional(),
+	/** D706: set the switch, or `null` to clear it (back to the default, false). */
+	notifySensorRewatched: boolean().nullable().optional(),
+	/** D735: set the switch, or `null` to clear it (back to the default, false). */
+	notifySensorIgnored: boolean().nullable().optional()
 })).max(8).refine(uniqueModes, { message: "modeDelays: at most one edit per arm mode" });
 /** One switch of the alarm table: put ONE device on, or take it off, ONE mode's list. */
 var NcAlarmNonBlockingEditSchema = object({
@@ -21131,45 +21094,25 @@ Object.freeze(Object.fromEntries([{
 	label: "Face recognition model",
 	defaultModelId: "auraface-r100",
 	indexName: "the enrolled face gallery",
-	options: [
-		{
-			id: "auraface-r100",
-			label: "AuraFace R100"
-		},
-		{
-			id: "arcface-r100",
-			label: "ArcFace (ResNet34)"
-		},
-		{
-			id: "inception-resnet-v1",
-			label: "Inception ResNet V1"
-		}
-	]
+	options: [{
+		id: "auraface-r100",
+		label: "AuraFace R100"
+	}]
 }, {
 	stepId: "clip-embedding",
 	label: "Semantic search model",
-	defaultModelId: "mobileclip-s1",
+	defaultModelId: "siglip2-b16-224",
 	indexName: "the object semantic-search index",
-	options: [
-		{
-			id: "mobileclip-s1",
-			label: "MobileCLIP S1"
-		},
-		{
-			id: "mobileclip-s2",
-			label: "MobileCLIP S2"
-		},
-		{
-			id: "siglip2-b16-224",
-			label: "SigLIP2 B/16 (Apache-2.0)"
-		}
-	]
+	options: [{
+		id: "siglip2-b16-224",
+		label: "SigLIP2 B/16 (Apache-2.0)"
+	}]
 }].map((s) => [s.stepId, s.defaultModelId])));
 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,
@@ -23089,6 +23032,34 @@ DeviceType.Camera, method(object({ deviceId: number() }), array(TrackSchema).rea
 	timestamp: number()
 });
 /**
+* A root model's boxes standing in for one crop-kind step's own inference
+* (D730) — see `runPipeline.suppliedRoot`.
+*/
+var SuppliedRootOutputSchema = object({
+	stepId: string(),
+	/** The root model that drew the boxes — stamped on the result. */
+	modelId: string(),
+	detections: array(object({
+		/** `[x1, y1, x2, y2]` in the pixels of the call's image. */
+		bbox: tuple([
+			number(),
+			number(),
+			number(),
+			number()
+		]),
+		score: number(),
+		/**
+		* Five facial landmarks in the same pixels — a face the step's own
+		* detector already re-found inside a root face box (D730), so its
+		* embedder child aligns it exactly as it aligns any detected face.
+		*/
+		landmarks: array(object({
+			x: number(),
+			y: number()
+		})).optional()
+	})).min(1)
+});
+/**
 * Reference to the frame's retained NATIVE surface + the parent crop's placement
 * within the frame, so the executor can re-cut a leaf child ROI at native
 * resolution on the detail plane. See the `runPipeline` `nativeCropRef` field.
@@ -23136,7 +23107,7 @@ var FrameRefSchema = object({
 	timestamp: number(),
 	capturedAt: number().optional()
 });
-var ModelFormatSchema$1 = _enum([
+var ModelFormatSchema$2 = _enum([
 	"onnx",
 	"coreml",
 	"openvino",
@@ -23154,7 +23125,7 @@ var PipelineSlotSchema = _enum([
 var PipelineEngineChoiceSchema = object({
 	runtime: literal("python"),
 	backend: string(),
-	format: ModelFormatSchema$1,
+	format: ModelFormatSchema$2,
 	device: string().optional()
 });
 /**
@@ -23193,32 +23164,15 @@ 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(),
-	defaultConfidence: number().optional()
+	defaultConfidence: number().optional(),
+	suppliesSteps: array(RootStepSupplySchema).readonly().optional()
 });
 var ConfigFieldBridge = custom();
 var PipelineAddonSchemaSchema = object({
@@ -23380,6 +23334,22 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 }), {
 	kind: "mutation",
 	auth: "admin"
+}), 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"
 }), method(object({ nodeId: string() }), object({ unhealthy: array(object({
 	/** `<backend>:<device>`, e.g. `openvino:gpu`. */
 	deviceKey: string(),
@@ -23405,22 +23375,14 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 }), method(_void(), PipelineSchemaSchema), method(_void(), array(PipelineDefaultStepSchema).readonly().nullable()), method(_void(), PipelineConfigBridge), method(_void(), ConfigUISchemaBridge), method(object({
 	steps: array(PipelineStepInputSchema),
 	deviceKey: string().optional()
-}), PipelineValidationResultSchema), method(_void(), array(PipelineTemplateSchema$1).readonly()), method(object({
-	name: string(),
-	steps: array(PipelineTemplateStepSchema).readonly(),
-	engine: PipelineEngineChoiceSchema
-}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({
-	id: string(),
-	name: string().optional(),
-	steps: array(PipelineTemplateStepSchema).readonly().optional()
-}), PipelineTemplateSchema$1, { kind: "mutation" }), method(object({ id: string() }), _void(), { kind: "mutation" }), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
+}), PipelineValidationResultSchema), method(_void(), InferenceCapabilitiesBridge), method(object({ addonId: string() }), ModelAvailabilityListBridge), method(object({
 	addonId: string(),
 	modelId: string(),
-	format: ModelFormatSchema$1
+	format: ModelFormatSchema$2
 }), DownloadModelResultSchema, { kind: "mutation" }), method(object({
 	addonId: string(),
 	modelId: string(),
-	format: ModelFormatSchema$1
+	format: ModelFormatSchema$2
 }), object({ success: literal(true) }), { kind: "mutation" }), method(object({
 	steps: array(PipelineStepInputSchema).min(1),
 	frame: FrameInputSchema.optional(),
@@ -23486,7 +23448,16 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	* `device-not-servable`), and nothing reaches the camera's live
 	* trace stream. Absent ⇒ unchanged behaviour.
 	*/
-	replay: literal(true).optional()
+	replay: literal(true).optional(),
+	/**
+	* Root-supplied detections for the tree's ROOT step (D730). Set by
+	* `runDetailSubtree` when the camera's root model supplies a crop-kind
+	* step (a Frigate+ `license_plate` for `plate-detection`): the step is
+	* NOT inferred, these boxes are its output, and its children (the plate
+	* reader) run on them through their own crop policy. Boxes are in the
+	* PIXELS of the image this call carries. Absent ⇒ the root step runs.
+	*/
+	suppliedRoot: SuppliedRootOutputSchema.optional()
 }), PipelineRunResultBridge, { kind: "mutation" }), method(object({
 	steps: array(PipelineStepInputSchema).min(1),
 	frames: array(FrameInputSchema).min(1).max(255),
@@ -23568,6 +23539,375 @@ method(_void(), array(PipelineEngineChoiceSchema)), method(_void(), PipelineEngi
 	filename: string().optional(),
 	settings: record(string(), unknown()).optional()
 }), AudioTestResultSchema, { kind: "mutation" }), 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(),
@@ -24011,6 +24351,22 @@ var MotionSourceEnum = _enum([
 	"device-activity"
 ]);
 /**
+* What opened an on-motion detection SESSION: the motion source that passed the
+* camera's `motionSources` gate, and what raised it (the camera itself, or a
+* sensor the operator attached — D672). `sensorName` is the attached sensor's
+* device name as the orchestrator's camera-sensors resolution last read it;
+* absent when unknown or when the camera itself triggered.
+*
+* Carried on the session attach ONLY so the runner's `DetectionPhaseTransition`
+* can say what started the session (D672 rule 11, amended 2026-10-06). The
+* runner never decides anything on it.
+*/
+var SessionTriggerSchema = object({
+	source: MotionSourceEnum,
+	triggeredBy: MotionTriggeredBySchema,
+	sensorName: string().optional()
+});
+/**
 * List of motion sources active on a camera. Empty array is valid:
 * "no source" — happens for battery cams without firmware motion when
 * the operator hasn't opted into the SW analyzer (would hold the
@@ -24262,6 +24618,14 @@ var RunnerCameraConfigSchema = object({
 	*/
 	motionSources: MotionSourcesSchema.default(["analyzer"]),
 	/**
+	* What opened this attach, on a SESSION attach only (see
+	* {@link SessionTriggerSchema}). OPTIONAL with no default: absent on a
+	* standing attach, an occupancy burst, a re-dispatch with no motion event
+	* behind it, and every attach from an orchestrator older than the field — the
+	* runner then names no source on the phase event.
+	*/
+	sessionTrigger: SessionTriggerSchema.optional(),
+	/**
 	* WHICH root detector runs for this camera. The detection counterpart of
 	* {@link motionSources}, same shape and same discipline: a per-camera list
 	* of sources the system understands, vendor-agnostic, owned here.
@@ -24421,14 +24785,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({
@@ -24564,7 +24929,22 @@ method(RunnerCameraConfigSchema, object({ success: literal(true) }), { kind: "mu
 	*/
 	cropJpeg: string().optional(),
 	parent: DetailParentSchema,
-	steps: array(string()).optional()
+	steps: array(string()).optional(),
+	/**
+	* The camera's root model already drew this step's boxes (D730): a
+	* `license_plate` inside the parent vehicle. The named step is NOT
+	* inferred — these FRAME-space boxes are its output — and its
+	* requested children (the plate reader) run on them. Absent ⇒ every
+	* requested step infers as before.
+	*/
+	supplied: object({
+		stepId: string(),
+		modelId: string(),
+		boxes: array(object({
+			bbox: NativeCropBboxSchema,
+			score: number()
+		})).min(1)
+	}).optional()
 }), object({ details: array(DetailResultSchema) }).nullable(), { kind: "mutation" }), method(object({
 	/** Catalog step id, e.g. `clip-embedding`. */
 	stepId: string(),
@@ -24627,14 +25007,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(),
@@ -24708,9 +25080,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()
 });
@@ -24743,7 +25116,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(),
@@ -24832,26 +25208,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(),
@@ -25208,12 +25585,6 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
-}), method(object({
-	agentNodeId: string(),
-	detectWeight: number().positive().nullable()
-}), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
 }), method(object({
 	agentNodeId: string(),
 	detect: boolean().nullable().optional(),
@@ -25255,6 +25626,15 @@ method(object({
 }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(AutoTuneOptionsSchema, AutoTunePlanSchema, { auth: "admin" }), method(AutoTuneApplyInputSchema, AutoTuneApplyResultSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(LoadBalancingSharesInputSchema, object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
+}), method(PlacementStatsInputSchema, PlacementStatsSchema, { auth: "admin" }), method(SuggestSharesInputSchema, SuggestSharesResultSchema, { auth: "admin" }), method(_void(), EffectiveSharesSchema, { auth: "admin" }), method(SetShareSourceInputSchema, object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({ deviceId: number() }), CameraPipelineSettingsSchema.nullable()), method(object({
 	deviceId: number(),
 	addonId: string(),
@@ -25271,6 +25651,13 @@ method(object({
 }), object({ success: literal(true) }), {
 	kind: "mutation",
 	auth: "admin"
+}), method(object({
+	deviceId: number(),
+	addonId: string(),
+	settings: record(string(), unknown()).nullable()
+}), object({ success: literal(true) }), {
+	kind: "mutation",
+	auth: "admin"
 }), method(object({
 	deviceId: number(),
 	agentNodeId: string(),
@@ -25294,25 +25681,7 @@ method(object({
 }), method(_void(), DiskReconcileJobSchema, {
 	kind: "mutation",
 	auth: "admin"
-}), method(_void(), DiskReconcileJobSchema, { auth: "admin" }), method(_void(), array(PipelineTemplateSchema).readonly()), method(object({
-	name: string(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema
-}), PipelineTemplateSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({
-	id: string(),
-	name: string().optional(),
-	description: string().optional(),
-	config: CameraPipelineConfigSchema.optional()
-}), PipelineTemplateSchema, {
-	kind: "mutation",
-	auth: "admin"
-}), method(object({ id: string() }), object({ success: literal(true) }), {
-	kind: "mutation",
-	auth: "admin"
-});
+}), method(_void(), DiskReconcileJobSchema, { auth: "admin" });
 /**
 * Cap → event-kind mapping for the SENSOR / CONTROL cap families — the table
 * `pipeline-analytics.listEventKinds` uses to turn a linked device's bound
@@ -27532,8 +27901,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()
 });
@@ -27865,6 +28232,14 @@ DeviceType.Camera, method(object({ deviceId: number().int().nonnegative() }), ar
 	*/
 	alive: boolean()
 })), method(object({
+	deviceId: number().int().nonnegative(),
+	sessionId: string(),
+	downlinkMbps: number().nonnegative()
+}), object({
+	outcome: _enum(["switching", "held"]),
+	tier: CamProfileSchema.nullable(),
+	reason: string()
+}), { kind: "mutation" }), method(object({
 	deviceId: number().int().nonnegative(),
 	sessionId: string()
 }), WebrtcSessionDebugSchema, { kind: "query" });
@@ -28104,6 +28479,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",
@@ -28186,10 +28614,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({
@@ -30485,7 +30917,7 @@ var LocalInterfaceSchema = object({
 	name: string(),
 	family: _enum(["IPv4", "IPv6"]),
 	address: string(),
-	/** CIDR shorthand (e.g. `192.168.x.x/24`). Empty when OS doesn't expose. */
+	/** CIDR shorthand (e.g. `192.168.10.10/24`). Empty when OS doesn't expose. */
 	cidr: string(),
 	/** OS netmask. Stable across calls so the SDK can hash on it. */
 	netmask: string(),
@@ -30539,7 +30971,9 @@ var ConnectionEndpointSchema = object({
 		"lan-ipv4",
 		"lan-ipv6",
 		"public",
-		"loopback"
+		"loopback",
+		"app-link",
+		"custom"
 	]),
 	/**
 	* Originating-interface kind — `lan`/`wifi`/`docker`/`vpn`/`other`/
@@ -30608,15 +31042,27 @@ var GetConnectionEndpointsResultSchema = object({
 	localPort: AdvertisedLocalPortSchema
 });
 /**
-* The chosen outbound endpoint for notification artifacts. `baseUrl: null` =
-* AUTO (resolved from the candidate ranking at send time); `resolved` reports
-* what AUTO currently picks, so the UI can show the effective value either way.
+* The address flagged for notification taps (`notificationTaps`). `baseUrl: null` = AUTO, which
+* since D709 is the CamStack app link; `resolved` reports the effective value,
+* so the UI can show it either way.
 */
 var NotificationEndpointSchema = object({
 	/** The operator's explicit choice, or null for AUTO. */
 	baseUrl: string().nullable(),
-	/** What the ranking currently resolves to (null when nothing is reachable). */
-	resolved: string().nullable()
+	/**
+	* The effective flagged address: the explicit choice, else (AUTO) the
+	* CamStack app link `https://camstack.zentik.app` (D709). A pre-D709 hub
+	* answered the public tunnel / mesh here, or null.
+	*/
+	resolved: string().nullable(),
+	/**
+	* The hub origin an app link carries as `hub=` (D709): the hub's best
+	* public HTTPS address — the tunnel, then the mesh (Tailscale MagicDNS) —
+	* picked from this cap's own palette by `pickAppLinkHub`. `null` when the
+	* hub advertises neither; the app link is then minted without `hub=`.
+	* Absent on a pre-D709 hub.
+	*/
+	appLinkHub: string().nullable()
 });
 /**
 * The URLs the SDK / viewer should race for API access. `baseUrls` empty =
@@ -30629,6 +31075,72 @@ var ViewerEndpointsSchema = object({
 	/** What the ranking currently resolves to (may be empty if nothing is up). */
 	resolved: array(string()).readonly()
 });
+/**
+* DEPRECATED compatibility shape of `getHubAddresses` (D729 amendment, kept
+* for addons built against it): `cluster` is the `internal` role, `browser`
+* the `publicEndpoint` role; `override` is the flagged address.
+*/
+var HubAddressSnapshotSchema = object({
+	override: string().nullable(),
+	resolved: string().nullable(),
+	source: _enum([
+		"override",
+		"auto",
+		"none"
+	])
+});
+var HubAddressesSchema = object({
+	cluster: HubAddressSnapshotSchema,
+	browser: HubAddressSnapshotSchema
+});
+/**
+* What an address is used for (`hub-address.ts`, D734). `appConnections` is
+* many-valued; `notificationTaps`, `publicEndpoint` and `internal` are carried
+* by at most one address.
+*/
+var HubAddressRoleSchema = _enum(HUB_ADDRESS_ROLES);
+var RoleSourceSchema = _enum([
+	"flagged",
+	"auto",
+	"none"
+]);
+/** One single-valued role: the flagged address, the one in use, and why. */
+var HubAddressRoleResolutionSchema = object({
+	/** The address carrying the flag, or null = automatic. */
+	flagged: string().nullable(),
+	/** The address in use, or null when nothing qualifies (never loopback). */
+	resolved: string().nullable(),
+	source: RoleSourceSchema
+});
+var HubAppConnectionsResolutionSchema = object({
+	/** The addresses flagged `appConnections`, or empty = automatic. */
+	flagged: array(string()).readonly(),
+	/** What the apps race right now. */
+	resolved: array(string()).readonly(),
+	source: RoleSourceSchema
+});
+var HubAddressBookSchema = object({
+	rows: array(ConnectionEndpointSchema.extend({
+		/** In the hub's detected palette right now. */
+		detected: boolean(),
+		/** Entered by the operator (removable). */
+		custom: boolean(),
+		/** The roles explicitly flagged on this address. */
+		flags: array(HubAddressRoleSchema).readonly(),
+		/** The roles this address serves right now — flagged or automatic. */
+		inUse: array(HubAddressRoleSchema).readonly(),
+		/** The roles this address may be flagged with. */
+		eligible: array(HubAddressRoleSchema).readonly()
+	})).readonly(),
+	roles: object({
+		appConnections: HubAppConnectionsResolutionSchema,
+		notificationTaps: HubAddressRoleResolutionSchema,
+		internal: HubAddressRoleResolutionSchema,
+		publicEndpoint: HubAddressRoleResolutionSchema
+	}),
+	/** The `hub=` an app link carries (D709), or null. */
+	appLinkHub: string().nullable()
+});
 var AllowedAddressesSchema = object({ 
 /**
 * Allowlist of interface addresses operators have explicitly opted
@@ -30670,8 +31182,29 @@ method(_void(), ListResultSchema), method(_void(), PreferredSchema), method(obje
 	*  Pass `'https'` when the caller is itself loaded over HTTPS
 	*  to avoid mixed-content blocks in the browser. The public
 	*  tunnel always emits `https://` regardless. */
-	scheme: _enum(["http", "https"]).optional()
-}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
+	scheme: _enum(["http", "https"]).optional(),
+	/** Append the CamStack app link entry (`kind: 'app-link'`, D709) —
+	*  an address notification taps can be flagged with, not a hub
+	*  route. Default `false`: racers and rankers never see it. */
+	includeAppLink: boolean().optional()
+}), GetConnectionEndpointsResultSchema), method(_void(), NotificationEndpointSchema), method(object({ baseUrl: string().nullable() }), NotificationEndpointSchema, { kind: "mutation" }), method(_void(), ViewerEndpointsSchema), method(object({ baseUrls: array(string()).readonly() }), ViewerEndpointsSchema, { kind: "mutation" }), method(object({ scheme: _enum(["http", "https"]).optional() }).optional(), HubAddressBookSchema), method(object({
+	baseUrl: string(),
+	label: string().max(80)
+}), HubAddressBookSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({ baseUrl: string() }), HubAddressBookSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(object({
+	role: HubAddressRoleSchema,
+	baseUrl: string().nullable(),
+	enabled: boolean(),
+	acceptInsecureHttp: boolean().optional()
+}), HubAddressBookSchema, {
+	kind: "mutation",
+	auth: "admin"
+}), method(_void(), HubAddressesSchema), method(_void(), AllowedAddressesSchema), method(AllowedAddressesSchema, object({ success: literal(true) }), { kind: "mutation" }), method(_void(), AllowedAddressesSchema, { kind: "mutation" }), method(_void(), TlsStatusSchema), method(object({ reason: string().optional() }), TlsStatusSchema, {
 	kind: "mutation",
 	auth: "admin"
 }), method(object({
@@ -30931,7 +31464,7 @@ var MeshPeerSchema = object({
 	tags: array(string()).readonly(),
 	/** True when the peer advertises itself as an exit-node candidate. */
 	exitNodeOption: boolean(),
-	/** Subnet routes the peer advertises (e.g. `["192.168.x.x/24"]`). */
+	/** Subnet routes the peer advertises (e.g. `["192.168.10.0/24"]`). */
 	advertisedRoutes: array(string()).readonly(),
 	/** Owner account login (e.g. `foo@example.com`). Null for tagged peers. */
 	userLogin: string().nullable(),
@@ -31061,7 +31594,8 @@ object({
 	*   writes this slice (not even a boot seed), and neither does the runner's
 	*   phase machine: its phase is "a session is attached" for every on-motion
 	*   session, not motion, and it now has its own `DetectionPhaseTransition`.
-	*   A provider's `isDetected` answers from the hub's slice.
+	*   A provider's `isDetected` and `getStatus` answer from the hub's slice
+	*   (`hubMotionNativeProvider`).
 	* - **Sensors** (Home Assistant binary sensors, Homematic, Matter, Alexa
 	*   imports) — the provider pushes both edges itself, from the upstream
 	*   system's own state change. That is the sensor's own fact.
@@ -31875,7 +32409,13 @@ var OsdStatusSchema = object({ overlays: array(object({
 	*/
 	availablePositions: array(OsdPositionEnum).readonly(),
 	/** Firmware does not allow editing the `text` field (e.g. timestamp). */
-	readOnly: boolean().optional()
+	readOnly: boolean().optional(),
+	/**
+	* Firmware text ceiling for this overlay. Absent = no known limit.
+	* The OSD manager truncates here on every write — never stores its own
+	* copy on the binding.
+	*/
+	maxCharacters: number().int().positive().optional()
 })).readonly() });
 var OsdOverlayPatchSchema = object({
 	enabled: boolean().optional(),
@@ -31926,7 +32466,9 @@ var OsdTemplateBindingSchema = object({
 	valuePath: string().min(1).max(64),
 	/** Convert TO this unit at render (`tryConvertUnit`). Absent = source unit. */
 	displayUnit: string().max(16).optional(),
-	maxDecimals: number().int().min(0).max(4).default(1)
+	maxDecimals: number().int().min(0).max(4).default(1),
+	/** Raw value → display text (same shape as slot binding). Empty string hides. */
+	valueMap: record(string(), string()).optional()
 });
 /**
 * A named template: bindings (alias → leaf field) + a parser that
@@ -31976,18 +32518,11 @@ var OsdSlotBindingSchema = object({
 	source: OsdSourceSchema,
 	/** `${value}` and `${unit}` are substituted; every occurrence. */
 	template: string().max(96).default("${value}"),
-	/** Truncate with an ellipsis past this length. Absent = no limit. */
-	maxCharacters: number().int().min(4).max(64).optional(),
 	/**
 	* Decimal places for a numeric value. `0` yields an integer — the
 	* documented workaround for firmwares that reject `.` in overlay text.
 	*/
 	maxDecimals: number().int().min(0).max(4).default(1),
-	/**
-	* Appended via `${unit}` when no unit conversion produces a label.
-	* Prefer `source.displayUnit` for converted device-state values.
-	*/
-	unitLabel: string().max(8).optional(),
 	/** Raw value → display text, e.g. `{"true":"MOTION","false":""}`. */
 	valueMap: record(string(), string()).optional(),
 	/** Time windows in which the slot is shown. Absent = always. */
@@ -31996,9 +32531,7 @@ var OsdSlotBindingSchema = object({
 	* Display gate, in the notification centre's condition vocabulary.
 	* Only the keys reported by `getConditionSupport` are accepted.
 	*/
-	conditions: NcConditionsSchema.optional(),
-	/** Rendered when the gate is closed or the value unreadable. Empty = hide. */
-	fallbackText: string().max(64).default("")
+	conditions: NcConditionsSchema.optional()
 });
 /** One camera slot, as the operator sees it: firmware truth + our binding. */
 var OsdSlotViewSchema = object({
@@ -36193,6 +36726,16 @@ DeviceType.Camera, method(object({
 	package: array(ZoneRuleSchema).readonly()
 });
 SOURCE_CAPS.filter((cap) => cap !== "switch" && cap !== "motion");
+Object.freeze({
+	person: .5,
+	vehicle: .5,
+	animal: .5
+});
+Object.freeze({
+	person: .65,
+	vehicle: .65,
+	animal: .65
+});
 /**
 * Accessory device helpers — shared across drivers.
 *
@@ -36367,6 +36910,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"addons.listInstallations": {
+		capName: "addons",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"addons.listJobs": {
 		capName: "addons",
 		capScope: "system",
@@ -37549,90 +38098,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",
@@ -39121,12 +39598,24 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.addCustomAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.downloadCa": {
 		capName: "local-network",
 		capScope: "system",
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getAddresses": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -39139,6 +39628,12 @@ Object.freeze({
 		addonId: null,
 		access: "view"
 	},
+	"localNetwork.getHubAddresses": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "view"
+	},
 	"localNetwork.getNotificationEndpoint": {
 		capName: "local-network",
 		capScope: "system",
@@ -39175,6 +39670,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.removeCustomAddress": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "delete"
+	},
 	"localNetwork.resetAllowlistToBestMatch": {
 		capName: "local-network",
 		capScope: "system",
@@ -39187,6 +39688,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"localNetwork.setAddressRole": {
+		capName: "local-network",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"localNetwork.setAllowedAddresses": {
 		capName: "local-network",
 		capScope: "system",
@@ -40681,13 +41188,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,
@@ -40831,12 +41338,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",
@@ -40861,12 +41362,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",
@@ -40885,41 +41380,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",
@@ -41011,6 +41500,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",
@@ -41047,19 +41542,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,
@@ -41071,6 +41566,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",
@@ -41113,12 +41614,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",
@@ -41131,12 +41626,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",
@@ -41173,6 +41662,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",
@@ -41191,25 +41686,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,
@@ -42649,12 +43156,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",
@@ -42721,12 +43222,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",
@@ -42739,12 +43234,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",
@@ -43441,6 +43930,12 @@ Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"webrtcSession.applyDownlinkProbe": {
+		capName: "webrtc-session",
+		capScope: "device",
+		addonId: null,
+		access: "create"
+	},
 	"webrtcSession.closeSession": {
 		capName: "webrtc-session",
 		capScope: "device",
@@ -45252,11 +45747,6 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
-	"decoder.createSession": [{
-		name: "deviceId",
-		form: "single",
-		optional: true
-	}],
 	"detectionPipeline.applyDeviceSettingsPatch": [{
 		name: "deviceId",
 		form: "single",
@@ -46487,6 +46977,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineExecutor.clearModelBoundDeviceOverrides": [{
+		name: "deviceIds",
+		form: "array",
+		optional: true
+	}],
 	"pipelineExecutor.runPipeline": [{
 		name: "deviceId",
 		form: "single",
@@ -46592,6 +47087,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"pipelineOrchestrator.setCameraStepSettings": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"pipelineOrchestrator.setCameraStepToggle": [{
 		name: "deviceId",
 		form: "single",
@@ -47363,6 +47863,11 @@ Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"webrtcSession.applyDownlinkProbe": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"webrtcSession.closeSession": [{
 		name: "deviceId",
 		form: "single",
@@ -47592,6 +48097,8 @@ new Map(Object.entries({
 	"detection-blind": "device-events",
 	"node-online": "system",
 	"node-offline": "system",
+	"node-restarting": "system",
+	"node-updating": "system",
 	"node-inference-unavailable": "system",
 	"addon-crash-loop": "system",
 	"addon-update-available": "system",
@@ -47669,18 +48176,21 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
 	{
 		id: "addons",
 		family: "system",
-		label: "Addons",
-		kinds: [
-			"addon-crash-loop",
-			"addon-update-available",
-			"addon-updated"
-		]
+		label: "Addons stopped",
+		kinds: ["addon-crash-loop"]
+	},
+	{
+		id: "addon-updates",
+		family: "system",
+		label: "Addon updates",
+		kinds: ["addon-update-available", "addon-updated"]
 	},
 	{
 		id: "updates",
@@ -47688,6 +48198,7 @@ var NC_SYSTEM_EVENT_KIND_GROUP_SPECS = [
 		label: "Server & container updates",
 		kinds: [
 			"server-update-available",
+			"node-updating",
 			"server-updated",
 			"wrapper-update-available"
 		]
@@ -47835,18 +48346,21 @@ var STATE_SUMMARY_SECTION_VARS = [
 		kinds: [
 			"node-offline",
 			"node-online",
+			"node-restarting",
 			"node-inference-unavailable"
 		]
 	},
 	{
 		name: "summaryAddons",
-		label: "Summary: addons",
-		example: "@camstack/addon-recorder 1.2.3 → 1.2.4",
-		kinds: [
-			"addon-crash-loop",
-			"addon-update-available",
-			"addon-updated"
-		]
+		label: "Summary: addons stopped",
+		example: "hub — recorder stopped after repeated crashes",
+		kinds: ["addon-crash-loop"]
+	},
+	{
+		name: "summaryAddonUpdates",
+		label: "Summary: addon updates",
+		example: "hub:\n• @camstack/addon-recorder 1.2.3 → 1.2.4",
+		kinds: ["addon-update-available", "addon-updated"]
 	},
 	{
 		name: "summaryUpdates",
@@ -47854,6 +48368,7 @@ var STATE_SUMMARY_SECTION_VARS = [
 		example: "server 1.2.377 → 1.2.378",
 		kinds: [
 			"server-update-available",
+			"node-updating",
 			"server-updated",
 			"wrapper-update-available"
 		]
@@ -47886,7 +48401,7 @@ var STATE_SUMMARY_VARS = [
 	{
 		name: "summarySection",
 		label: "Summary: this section",
-		description: "The section a per-section summary row is about (D698); on a summary sent as one message, every section it reports, comma-separated.",
+		description: "The section a per-section summary row is about; on a summary sent as one message, every section it reports, comma-separated.",
 		example: "Batterie scariche",
 		group: "system",
 		families: ["rule"],
@@ -47930,6 +48445,7 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_BODY_ONLY],
 	[...RULE_TEXT],
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
+	([...RULE_TEXT], [...COMBINED_ALARM]),
 	([...RULE_TEXT], [...DEVICE_EVENTS]),
 	([...RULE_TEXT], [...BATTERY, ...CONSUMABLE]),
 	([...RULE_TEXT], [...CONSUMABLE]),
@@ -47970,6 +48486,8 @@ var STATE_SUMMARY_VARS = [
 	[...RULE_TEXT],
 	[...RULE_TEXT],
 	[...RULE_TEXT],
+	[...RULE_TEXT],
+	[...RULE_TEXT],
 	...STATE_SUMMARY_VARS
 ];
 new Set([
@@ -48489,45 +49007,17 @@ DEFAULT_NATIVE_LEASE_SETTINGS.sceneBudgetMb;
 DEFAULT_NATIVE_LEASE_SETTINGS.admission;
 var MB = 1024 * 1024;
 1024 * MB, 3072 * MB;
-/**
-* Fixed-capacity ring buffer. When full, push() overwrites the oldest entry.
-* drain() returns up to maxCount items in FIFO order and removes them.
-*/
-var RingBuffer = class {
-	capacity;
-	items;
-	head = 0;
-	tail = 0;
-	count = 0;
-	constructor(capacity) {
-		this.capacity = capacity;
-		this.items = Array.from({ length: capacity });
-	}
-	get size() {
-		return this.count;
-	}
-	push(item) {
-		this.items[this.tail] = item;
-		this.tail = (this.tail + 1) % this.capacity;
-		if (this.count < this.capacity) this.count++;
-		else this.head = (this.head + 1) % this.capacity;
-	}
-	drain(maxCount) {
-		const result = [];
-		const n = Math.min(maxCount, this.count);
-		for (let i = 0; i < n; i++) {
-			result.push(this.items[this.head]);
-			this.items[this.head] = void 0;
-			this.head = (this.head + 1) % this.capacity;
-		}
-		this.count -= n;
-		return result;
-	}
-};
 //#endregion
-//#region src/ffmpeg-args.ts
+//#region src/decode-hwaccel-rank.ts
 /**
-* Canonical decode-hwaccel preference order for the ffmpeg-subprocess decoder.
+* Decode-hwaccel ranking for `reprobeHwaccel`: the kernel resolver's preferred
+* order, re-ranked so the backend this node reports is the one that actually
+* decodes (vaapi above qsv on Intel). A copy of the broker's
+* `packages/addon-pipeline/src/shared/ffmpeg-decode-args.ts` ranking — addons
+* do not import each other.
+*/
+/**
+* Canonical decode-hwaccel preference order.
 *
 * `vaapi` is ranked ABOVE `qsv` deliberately: on the Intel hub the `qsv` decode
 * child exits early (`code=171`, no frames) while the `vaapi` path decodes 8MP
@@ -48592,1234 +49082,6 @@ function rankDecodeHwAccels(preferred, supportedMethods) {
 	return candidates.sort((a, b) => decodeHwAccelRankIndex(a) - decodeHwAccelRankIndex(b));
 }
 //#endregion
-//#region src/shared/notifying-ring-buffer.ts
-/**
-* A {@link RingBuffer} that can notify a single blocked consumer the moment an
-* item commits — the server side of the `pullFrames` long-poll.
-*
-* The decoder's `onFrame` callback drives `push()`; a consumer
-* that finds the ring momentarily empty calls {@link waitForItem} and is woken
-* on the very next `push()` (a real commit signal) rather than spinning at
-* ~1kHz on `setTimeout(…,1)`. If nothing commits it resolves after `waitMs`,
-* and {@link cancel} (session teardown) resolves any in-flight wait promptly so
-* a blocked long-poll never waits out `waitMs` on destroy.
-*
-* Semantics are otherwise identical to `RingBuffer`: fixed capacity,
-* latest-wins overwrite when full, FIFO `drain`.
-*/
-var NotifyingRingBuffer = class {
-	ring;
-	waiters = /* @__PURE__ */ new Set();
-	constructor(capacity) {
-		this.ring = new RingBuffer(capacity);
-	}
-	get size() {
-		return this.ring.size;
-	}
-	push(item) {
-		this.ring.push(item);
-		this.wakeAll();
-	}
-	drain(maxCount) {
-		return this.ring.drain(maxCount);
-	}
-	/**
-	* Resolve as soon as an item commits to the ring, or after `waitMs`,
-	* whichever comes first. Returns immediately when items are already present
-	* or `waitMs <= 0` (legacy immediate-return). {@link cancel} also resolves an
-	* in-flight wait.
-	*/
-	async waitForItem(waitMs) {
-		if (this.ring.size > 0 || waitMs <= 0) return;
-		await new Promise((resolve) => {
-			let settled = false;
-			const finish = () => {
-				if (settled) return;
-				settled = true;
-				this.waiters.delete(wake);
-				clearTimeout(timer);
-				resolve();
-			};
-			const wake = () => finish();
-			const timer = setTimeout(finish, waitMs);
-			if (typeof timer.unref === "function") timer.unref();
-			this.waiters.add(wake);
-		});
-	}
-	/**
-	* Cancel every in-flight {@link waitForItem} — called on session teardown so
-	* a blocked long-poll returns promptly instead of waiting out `waitMs`.
-	*/
-	cancel() {
-		this.wakeAll();
-	}
-	wakeAll() {
-		if (this.waiters.size === 0) return;
-		const pending = [...this.waiters];
-		this.waiters.clear();
-		for (const wake of pending) wake();
-	}
-};
-//#endregion
-//#region src/shared/decoder-backend-keys.ts
-/** Built-in default when a node has no selection — the in-process node-av
-* decoder. node-av is the standing default everywhere; the ffmpeg subprocess
-* decoder is an explicit opt-in fallback only. A stale/failed settings read at
-* boot therefore resolves to node-av (never leaves the node with no decoder). */
-var DEFAULT_DECODER_BACKEND = "nodeav";
-//#endregion
-//#region src/shared/decoder-backend.ts
-/**
-* Resolve the decoder backend this addon should run. Owner settings are
-* ignored: persisted `backend@<nodeId>` rows stay in the store and are not
-* consulted. The runtime default is always {@link DEFAULT_DECODER_BACKEND}.
-*/
-async function resolveDecoderBackend(_api, _nodeId, _logger) {
-	return DEFAULT_DECODER_BACKEND;
-}
-//#endregion
-//#region src/pull-demuxer-options.ts
-/**
-* libav demuxer options for the node-av PULL decode path — RTP sources
-* (`isRtpSource()`) dialing the broker's RTSP restream (`rtsp://…/muted`).
-*
-* Without low-latency flags libav buffers up to `analyzeduration` (default
-* **5s**) of the live stream during `avformat_find_stream_info`, and that buffer
-* becomes a fixed ~5s offset on the decoded-frame timeline — detection overlays
-* then lag the WebRTC raw-RTP passthrough (which never decodes) by ~5s. Adding
-* `fflags: nobuffer` + a short `analyzeduration` collapses that offset to
-* sub-second, mirroring the ffmpeg backend's `-fflags +nobuffer` on its pull
-* path (decoder-ffmpeg/ffmpeg-args.ts).
-*
-* ‼ `analyzeduration`/`probesize` stay SMALL BUT NON-ZERO. Probe-zeroing
-* (`analyzeduration 0`) on the pull RTSP path STARVES the Reolink rfc4571
-* restream demuxer (garbage / zero frames — looked like a ~3000fps churn
-* runaway); that optimisation is push-mode-only. Keep them > 0.
-*/
-function buildPullDemuxerOptions() {
-	return {
-		rtsp_transport: "tcp",
-		fflags: "nobuffer",
-		analyzeduration: "1000000",
-		probesize: "1000000",
-		max_delay: "0",
-		reorder_queue_size: "0",
-		user_agent: "decoder"
-	};
-}
-//#endregion
-//#region src/scaler-geometry.ts
-/**
-* Decide the scaler action for an incoming frame's source geometry.
-*
-* @param current  The scaler's configured source geometry, or `null` when no
-*                 scaler has been built yet.
-* @param incoming The source geometry of the frame about to be scaled.
-*/
-function resolveScalerAction(current, incoming) {
-	if (current === null) return "init";
-	if (current.width === incoming.width && current.height === incoming.height && current.format === incoming.format) return "reuse";
-	return "rebuild";
-}
-//#endregion
-//#region src/nodeav-decoder-session.ts
-/**
-* Pull-mode re-dial backoff. On a pull input error/EOF the loop waits this long
-* before re-opening the URL — mirrors the ffmpeg pull decoder's 3s re-dial so a
-* transient RTSP restream blip (source suspended on idle, keyframe wait) does
-* not hot-loop `Demuxer.open`.
-*/
-var PULL_REDIAL_MS = 3e3;
-/**
-* Short re-dial backoff for the adaptive "drop-to-live" path. When the decoder
-* has fallen hopelessly behind the live edge ({@link DROP_TO_LIVE_LAG_MS}) the
-* loop tears the input down and re-dials fast so the restream's burst-prime
-* re-seats it at the live edge, instead of waiting the full {@link PULL_REDIAL_MS}
-* (which is for transient stream blips, not a deliberate re-seat).
-*/
-var PULL_FAST_REDIAL_MS = 250;
-/** Adaptive controller cadence — recompute emit-fps from lag at most this often. */
-var ADAPTIVE_TICK_MS = 1e3;
-/** Lag EWMA above this (ms) → halve the adaptive emit-fps. */
-var ADAPTIVE_LAG_HIGH_MS = 750;
-/** Lag EWMA below this (ms), sustained {@link ADAPTIVE_RECOVER_SUSTAIN_MS} → grow emit-fps. */
-var ADAPTIVE_LAG_LOW_MS = 250;
-/** How long lag must stay below {@link ADAPTIVE_LAG_LOW_MS} before growing emit-fps. */
-var ADAPTIVE_RECOVER_SUSTAIN_MS = 5e3;
-/** Floor the adaptive controller never sheds below (fps). */
-var ADAPTIVE_MIN_FPS = 2;
-/**
-* Ceiling the adaptive controller recovers toward when the subscriber requested
-* an UNLIMITED rate (`maxFps <= 0`). Source cameras run ≤ this, so the clamp is
-* a no-op in practice while keeping the /2 shed + *1.5 recover math bounded.
-*/
-var ADAPTIVE_FALLBACK_CEILING_FPS = 30;
-/**
-* Lag EWMA above this (ms) = hopelessly behind → drop-to-live re-seat.
-*
-* This bounds the MAX glass-to-box media staleness: `lagMsEwma` is how far the
-* decoder's media clock trails live, i.e. how old the *content* of an emitted
-* frame is (distinct from `frameAge`, which only measures decode→pick pipeline
-* delay and does NOT capture this media lag). On a host that decodes marginally
-* below real-time the lag sawtooths up to this ceiling, then re-seats to live —
-* so this constant directly caps how stale the boxes can get. 1200 ms (was
-* 2000) trades slightly more frequent 250 ms re-seats for fresher overlays; the
-* re-seat cost is negligible (~1.4 drops/cam/min at the observed drift). The
-* real fix — keeping decode at real-time so the lag never builds — is the
-* co-located / subprocess-decode epic.
-*/
-var DROP_TO_LIVE_LAG_MS = 1200;
-/** Never trigger drop-to-live more than once per this window (ms). */
-var DROP_TO_LIVE_MIN_INTERVAL_MS = 3e3;
-/** Decoder DEBUG facility flush cadence (~1Hz). */
-var DEBUG_FLUSH_MS = 1e3;
-/** Map our canonical backend name to the node-av `AV_HWDEVICE_TYPE_*` constant. */
-function backendToHwDeviceConst(backend, consts) {
-	switch (backend) {
-		case "videotoolbox": return consts.AV_HWDEVICE_TYPE_VIDEOTOOLBOX;
-		case "cuda": return consts.AV_HWDEVICE_TYPE_CUDA;
-		case "nvdec": return consts.AV_HWDEVICE_TYPE_CUDA;
-		case "vaapi": return consts.AV_HWDEVICE_TYPE_VAAPI;
-		case "qsv": return consts.AV_HWDEVICE_TYPE_QSV;
-		case "d3d11va": return consts.AV_HWDEVICE_TYPE_D3D11VA;
-		case "dxva2": return consts.AV_HWDEVICE_TYPE_DXVA2;
-		case "amf": return consts.AV_HWDEVICE_TYPE_AMF;
-		case "vdpau": return consts.AV_HWDEVICE_TYPE_VDPAU;
-		case "drm": return consts.AV_HWDEVICE_TYPE_DRM;
-		default: return null;
-	}
-}
-/** Pick the hw pixel format for a given backend — used in get_format callback. */
-function backendToHwPixFmt(backend, consts) {
-	switch (backend) {
-		case "videotoolbox": return consts.AV_PIX_FMT_VIDEOTOOLBOX;
-		case "cuda": return consts.AV_PIX_FMT_CUDA;
-		case "nvdec": return consts.AV_PIX_FMT_CUDA;
-		case "vaapi": return consts.AV_PIX_FMT_VAAPI;
-		case "qsv": return consts.AV_PIX_FMT_QSV;
-		case "d3d11va": return consts.AV_PIX_FMT_D3D11;
-		case "dxva2": return consts.AV_PIX_FMT_DXVA2_VLD;
-		case "amf": return consts.AV_PIX_FMT_D3D11;
-		case "vdpau": return consts.AV_PIX_FMT_VDPAU;
-		case "drm": return consts.AV_PIX_FMT_DRM_PRIME;
-		default: return null;
-	}
-}
-var _nav = null;
-var _consts = null;
-var _sharp = null;
-async function getNodeAv() {
-	if (!_nav) _nav = await import("node-av");
-	return _nav;
-}
-async function getConstants() {
-	if (!_consts) _consts = await import("node-av/constants");
-	return _consts;
-}
-async function getSharp() {
-	if (!_sharp) _sharp = (await import("sharp")).default;
-	return _sharp;
-}
-var noopLogger = {
-	debug() {},
-	info() {},
-	warn() {},
-	error() {},
-	child() {
-		return noopLogger;
-	},
-	withTags() {
-		return noopLogger;
-	}
-};
-var NodeAvDecoderSession = class NodeAvDecoderSession {
-	config;
-	logger;
-	frameCallbacks = /* @__PURE__ */ new Set();
-	destroyed = false;
-	parser = null;
-	codecCtx = null;
-	scaler = null;
-	avPacket = null;
-	avFrame = null;
-	dstFrame = null;
-	EAGAIN = -11;
-	PIX_FMT_GRAY8 = 8;
-	PIX_FMT_RGB24 = 2;
-	SWS_FAST_BILINEAR = 1;
-	/**
-	* Decoder output mode. Drives both the scaler's destination pixel
-	* format and whether sharp runs the JPEG encode at the end:
-	*
-	* - `'jpeg'` — scaler→RGB24 → sharp encode → emit JPEG bytes
-	* - `'rgb'`  — scaler→RGB24 → emit raw RGB24 (no sharp)
-	* - `'gray'` — scaler→GRAY8 → emit raw GRAY8 (no sharp)
-	*
-	* The broker holds the policy decision on which mode to request based
-	* on its active subscribers; on-the-fly conversion (e.g. RGB→JPEG for
-	* a WebRTC consumer that joined while detection holds the decoder in
-	* RGB mode) happens broker-side via the per-frame conversion cache.
-	*/
-	outputMode;
-	sharpFn = null;
-	/**
-	* Backpressure for the sharp JPEG encode pipeline. The broker
-	* currently creates sessions with `maxFps: 0` (unlimited) and relies
-	* on per-subscriber throttling, so without a bound the
-	* fire-and-forget `sharp(...).toBuffer()` chain would accumulate
-	* unboundedly whenever sharp falls behind the decoder. Cap at
-	* `MAX_JPEG_INFLIGHT` pending encodes per session — any frame that
-	* arrives while the cap is saturated is dropped and counted.
-	*/
-	static MAX_JPEG_INFLIGHT = 2;
-	jpegEncodeInFlight = 0;
-	/**
-	* Map a `DecoderSessionConfig.outputFormat` value to one of the three
-	* native scaler/encoder modes the session understands. The cap-level
-	* format vocabulary is broader (it accepts `bgr`, `yuv420`) than what
-	* libav's scaler is wired for here — anything else degrades to RGB
-	* (the canonical raw mode) and the broker is expected to convert
-	* downstream if a subscriber needs a different shape.
-	*/
-	static resolveOutputMode(format) {
-		if (format === "jpeg" || format === void 0) return "jpeg";
-		if (format === "gray") return "gray";
-		return "rgb";
-	}
-	initialized = false;
-	initializing = false;
-	scalerInitializing = false;
-	/**
-	* Monotonic counter incremented by `updateConfig` whenever the
-	* scaler + dstFrame get invalidated (e.g. output format toggle).
-	* `initScaler` captures the current value at entry and aborts — or
-	* disposes the locally-built scaler — if the epoch moved while
-	* its async init was in flight. Without this, a toggle racing an
-	* in-flight init could leave two scalers allocated natively while
-	* `this.scaler` only holds a reference to one → libav leak.
-	*/
-	scalerEpoch = 0;
-	/**
-	* One-shot guard for the "first frame" diagnostic log + raw frame
-	* dump. Setting this synchronously inside `emitDecodedFrame`
-	* prevents re-entry — without it we were using `outputFrames === 0`
-	* which stays true until the async sharp encode callback runs, so
-	* several decoded frames could trigger the dump before the first
-	* JPEG landed.
-	*/
-	firstFrameLogged = false;
-	outWidth = 0;
-	outHeight = 0;
-	/**
-	* The SOURCE geometry the current `scaler` was built for. `sws_scale` trusts
-	* these dimensions blindly; if a later decoded frame arrives with different
-	* width/height/format we MUST rebuild the scaler rather than feed it mismatched
-	* planes (an out-of-bounds read/write → uncatchable SIGBUS). `-1` means "no
-	* scaler built yet" (mirrors `this.scaler === null`).
-	*/
-	scalerSrcW = -1;
-	scalerSrcH = -1;
-	scalerSrcFmt = -1;
-	lastEmitTime = 0;
-	minIntervalMs;
-	/** Gates {@link emitDebugFlash}; set from `config.debug === true`. Off = zero cost. */
-	debugEnabled;
-	/** Wall-clock of the last `decoder debug` flush — throttles the facility to ~1Hz. */
-	lastDebugFlush = 0;
-	/** `droppedFrames` snapshot at the last debug flush — window base for the drop delta. */
-	debugWindowDropped = 0;
-	/** Subscriber-requested emit ceiling (fps). `maxFps<=0` clamps to the fallback ceiling. */
-	ceilingFps;
-	/** Current lag-throttled emit rate (fps) — starts at the ceiling, floored at ADAPTIVE_MIN_FPS. */
-	adaptiveFps;
-	/** Frames actually emitted/sec over the last adaptive-tick window (feeds getStats + debug). */
-	effectiveFps = 0;
-	/** `outputFrames` snapshot at the last adaptive tick — window base for effective-fps. */
-	adaptiveWindowFrames = 0;
-	/** First sampled frame's pts (timebase units); `null` until the current dial seeds it. */
-	basePts = null;
-	/** Wall-clock at `basePts` — the real-time anchor for the drift computation. */
-	baseWall = 0;
-	/** EWMA of real-time drift (ms). Rising = decoder falling behind the live edge. */
-	lagMsEwma = 0;
-	/** Wall-clock the lag EWMA first dropped below ADAPTIVE_LAG_LOW_MS (0 = not low). */
-	lowLagSince = 0;
-	/** Wall-clock of the last adaptive-controller tick. */
-	lastAdaptiveCheck = 0;
-	/** Wall-clock of the last drop-to-live re-seat — rate-limits the re-dial. */
-	lastDropToLive = 0;
-	/** Set by drop-to-live so `runPullLoop` uses the SHORT re-dial backoff for one iteration. */
-	pullFastRedial = false;
-	inputPackets = 0;
-	outputFrames = 0;
-	droppedFrames = 0;
-	totalDecodeTimeMs = 0;
-	startTime = Date.now();
-	hwaccelPref;
-	hwaccelResolver;
-	/** The backend that actually initialised successfully — `'none'` = software fallback. */
-	activeHwAccel = "none";
-	hwDevice = null;
-	swTransferFrame = null;
-	/** True once `openStream` has armed the pull loop; drives `isPullMode`. */
-	pullActive = false;
-	/** One-shot guard so a stray push into a pull session logs once, not per-packet. */
-	pullStrayPushLogged = false;
-	/** The URL the pull loop (re)dials — updatable while active. */
-	pullUrl = null;
-	/** Pending re-dial timer + its resolver, so `destroy` can wake it instantly. */
-	pullRedialTimer = null;
-	pullRedialResolve = null;
-	/** High-level demuxer/decoder for the CURRENT dial — recreated per re-dial. */
-	pullDemuxer = null;
-	pullDecoder = null;
-	/** HW context — resolved once, reused across re-dials, freed in `destroy`. */
-	pullHwContext = null;
-	constructor(config, logger = noopLogger, options) {
-		this.config = { ...config };
-		const sessionTags = {};
-		if (typeof config.deviceId === "number") sessionTags["deviceId"] = config.deviceId;
-		if (typeof config.tag === "string" && config.tag.length > 0) sessionTags["tag"] = config.tag;
-		this.logger = Object.keys(sessionTags).length > 0 ? logger.withTags(sessionTags) : logger;
-		this.minIntervalMs = config.maxFps > 0 ? 1e3 / config.maxFps : 0;
-		this.debugEnabled = config.debug === true;
-		this.ceilingFps = config.maxFps > 0 ? config.maxFps : ADAPTIVE_FALLBACK_CEILING_FPS;
-		this.adaptiveFps = this.ceilingFps;
-		this.outputMode = NodeAvDecoderSession.resolveOutputMode(config.outputFormat);
-		this.hwaccelPref = options?.hwaccel ?? "auto";
-		this.hwaccelResolver = options?.hwaccelResolver ?? null;
-	}
-	/**
-	* Resolve the backend preference list and try each one against
-	* node-av's HW context APIs. The first backend whose
-	* `HardwareDeviceContext.create()` succeeds gets attached to
-	* `codecCtx.hwDeviceCtx` + its hw pixel format registered via
-	* `setHardwarePixelFormat`. On any failure, falls through to the
-	* next backend; if all fail, returns with `activeHwAccel='none'`
-	* and the decoder runs in software on the same context.
-	*/
-	async tryAttachHwAccel(nav, C) {
-		if (!this.codecCtx) return;
-		if (this.hwaccelPref === "none") {
-			this.activeHwAccel = "none";
-			return;
-		}
-		const explicit = this.hwaccelPref === "auto" ? null : this.hwaccelPref;
-		const resolution = this.hwaccelResolver ? await this.hwaccelResolver.resolve(explicit) : explicit ? {
-			preferred: [explicit],
-			rationale: "explicit (no resolver)"
-		} : {
-			preferred: [],
-			rationale: "auto + no resolver → software"
-		};
-		if (resolution.preferred.length === 0) {
-			this.activeHwAccel = "none";
-			return;
-		}
-		for (const backend of resolution.preferred) {
-			const deviceType = backendToHwDeviceConst(backend, C);
-			const hwPixFmt = backendToHwPixFmt(backend, C);
-			if (!deviceType || !hwPixFmt) continue;
-			const device = new nav.HardwareDeviceContext();
-			const rc = device.create(deviceType);
-			if (rc < 0) {
-				this.logger.warn("node-av: hwaccel device create failed — trying next", { meta: {
-					backend,
-					rc
-				} });
-				device.free();
-				continue;
-			}
-			try {
-				this.codecCtx.hwDeviceCtx = device;
-				this.codecCtx.setHardwarePixelFormat(hwPixFmt);
-			} catch (err) {
-				this.logger.warn("node-av: hwaccel context attach failed — trying next", { meta: {
-					backend,
-					error: errMsg(err)
-				} });
-				device.free();
-				continue;
-			}
-			this.hwDevice = device;
-			this.activeHwAccel = backend;
-			return;
-		}
-		this.logger.warn("node-av: no hwaccel backend initialised — using software", { meta: {
-			attempted: resolution.preferred.join(","),
-			rationale: resolution.rationale
-		} });
-		this.activeHwAccel = "none";
-	}
-	/**
-	* Download a HW frame (format == hw pix fmt) into a SW frame so the
-	* rest of the pipeline (scaler, JPEG encoder, grayscale passthrough)
-	* handles it identically to the pure-software path. Uses the sync
-	* variant so the synchronous receive loop below doesn't need to be
-	* async-ified. Returns `null` on transfer failure, meaning the
-	* caller should drop the frame.
-	*/
-	transferHwFrame(hwFrame) {
-		if (this.activeHwAccel === "none" || !this.swTransferFrame) return hwFrame;
-		const rc = hwFrame.hwframeTransferDataSync(this.swTransferFrame, 0);
-		if (rc < 0) {
-			this.logger.warn("node-av: hwframeTransferData failed", { meta: { rc } });
-			return null;
-		}
-		return this.swTransferFrame;
-	}
-	/**
-	* Initialize the decoder pipeline on the first keyframe.
-	* After this returns, all hot-path methods are fully synchronous (except JPEG encode).
-	*/
-	async initDecoder() {
-		if (this.initialized || this.initializing || this.destroyed) return;
-		this.initializing = true;
-		try {
-			const nav = await getNodeAv();
-			const C = await getConstants();
-			this.EAGAIN = C.AVERROR_EAGAIN;
-			this.PIX_FMT_GRAY8 = C.AV_PIX_FMT_GRAY8;
-			this.PIX_FMT_RGB24 = C.AV_PIX_FMT_RGB24;
-			this.SWS_FAST_BILINEAR = C.SWS_FAST_BILINEAR;
-			if (this.outputMode === "jpeg") this.sharpFn = await getSharp();
-			nav.Log.setLevel(C.AV_LOG_FATAL);
-			const codecId = this.config.codec === "h265" || this.config.codec === "hevc" ? C.AV_CODEC_ID_HEVC : C.AV_CODEC_ID_H264;
-			this.parser = new nav.CodecParser();
-			this.parser.init(codecId);
-			const codec = nav.Codec.findDecoder(codecId);
-			if (!codec) {
-				this.logger.error("node-av: no decoder found", { meta: { codec: this.config.codec } });
-				return;
-			}
-			this.codecCtx = new nav.CodecContext();
-			this.codecCtx.allocContext3(codec);
-			if (this.config.width && this.config.height) {
-				this.codecCtx.width = this.config.width;
-				this.codecCtx.height = this.config.height;
-			}
-			this.codecCtx.threadCount = 1;
-			await this.tryAttachHwAccel(nav, C);
-			const ret = await this.codecCtx.open2(codec);
-			if (ret < 0) if (this.activeHwAccel !== "none") {
-				this.logger.warn("node-av: open2 failed with hwaccel — retrying in software", { meta: {
-					ret,
-					hwAccel: this.activeHwAccel
-				} });
-				this.hwDevice?.free();
-				this.hwDevice = null;
-				this.activeHwAccel = "none";
-				this.codecCtx = new nav.CodecContext();
-				this.codecCtx.allocContext3(codec);
-				if (this.config.width && this.config.height) {
-					this.codecCtx.width = this.config.width;
-					this.codecCtx.height = this.config.height;
-				}
-				this.codecCtx.threadCount = 1;
-				const retry = await this.codecCtx.open2(codec);
-				if (retry < 0) {
-					this.logger.error("node-av: failed to open decoder (sw fallback)", { meta: { ret: retry } });
-					return;
-				}
-			} else {
-				this.logger.error("node-av: failed to open decoder", { meta: { ret } });
-				return;
-			}
-			if (this.activeHwAccel !== "none") {
-				this.swTransferFrame = new nav.Frame();
-				this.swTransferFrame.alloc();
-			}
-			this.avPacket = new nav.Packet();
-			this.avPacket.alloc();
-			this.avFrame = new nav.Frame();
-			this.avFrame.alloc();
-			this.initialized = true;
-			this.logger.info("node-av push decoder initialized", { meta: {
-				codec: this.config.codec,
-				output: this.outputMode,
-				hwAccel: this.activeHwAccel
-			} });
-		} catch (err) {
-			this.logger.error("node-av init error", { meta: { error: errMsg(err) } });
-		} finally {
-			this.initializing = false;
-		}
-	}
-	/**
-	* Initialize the scaler after the first frame tells us the actual
-	* dimensions. Output pixel format: RGB24 for JPEG encoding, GRAY8
-	* for raw motion.
-	*
-	* Builds `scaler` + `dstFrame` on local variables and publishes
-	* them onto `this` in a single atomic step at the end. Captures
-	* `scalerEpoch` at entry; if `updateConfig` invalidated the scaler
-	* while this init was in flight (epoch mismatch), the locally
-	* built pair is disposed and discarded so the later init wins.
-	* Without the local-first approach, partial state (scaler set,
-	* dstFrame still null) could be observed by a concurrent
-	* `emitDecodedFrame` call.
-	*/
-	async initScaler(srcW, srcH, srcFmt) {
-		if (this.scalerInitializing) return;
-		this.scalerInitializing = true;
-		const myEpoch = this.scalerEpoch;
-		let localScaler = null;
-		let localDstFrame = null;
-		try {
-			const nav = await getNodeAv();
-			if (this.destroyed || myEpoch !== this.scalerEpoch) return;
-			const scale = this.config.scale > 1 ? this.config.scale : 1;
-			const maxW = Math.floor(640 / scale);
-			const outWidth = Math.min(srcW, maxW);
-			const outHeight = Math.round(outWidth * srcH / srcW);
-			const dstFmt = this.outputMode === "gray" ? this.PIX_FMT_GRAY8 : this.PIX_FMT_RGB24;
-			const fmtName = this.outputMode === "gray" ? "gray8" : "rgb24";
-			localScaler = new nav.SoftwareScaleContext();
-			localScaler.getContext(srcW, srcH, srcFmt, outWidth, outHeight, dstFmt, this.SWS_FAST_BILINEAR);
-			const ret = localScaler.initContext();
-			if (ret < 0) {
-				this.logger.error("node-av: sws_init_context failed", { meta: { ret } });
-				return;
-			}
-			localDstFrame = new nav.Frame();
-			localDstFrame.alloc();
-			localDstFrame.width = outWidth;
-			localDstFrame.height = outHeight;
-			localDstFrame.format = dstFmt;
-			const allocRet = localDstFrame.allocBuffer();
-			if (allocRet < 0) {
-				this.logger.error("node-av: dst frame allocBuffer failed", { meta: { ret: allocRet } });
-				return;
-			}
-			if (this.destroyed || myEpoch !== this.scalerEpoch) return;
-			this.scaler?.[Symbol.dispose]?.();
-			this.dstFrame?.[Symbol.dispose]?.();
-			this.scaler = localScaler;
-			this.dstFrame = localDstFrame;
-			this.outWidth = outWidth;
-			this.outHeight = outHeight;
-			this.scalerSrcW = srcW;
-			this.scalerSrcH = srcH;
-			this.scalerSrcFmt = srcFmt;
-			localScaler = null;
-			localDstFrame = null;
-			this.logger.info("node-av scaler initialized", { meta: {
-				srcWidth: srcW,
-				srcHeight: srcH,
-				outWidth,
-				outHeight,
-				format: fmtName
-			} });
-		} catch (err) {
-			this.logger.error("Scaler init failed", { meta: { error: errMsg(err) } });
-		} finally {
-			localScaler?.[Symbol.dispose]?.();
-			localDstFrame?.[Symbol.dispose]?.();
-			this.scalerInitializing = false;
-		}
-	}
-	/**
-	* Start PULL mode: libav dials `url` and demuxes it in-process, decoding
-	* every frame through the same emit path as push mode. Idempotent while
-	* active (updates the re-dial target). Throws if the session already took a
-	* push packet — a session is push-mode or pull-mode for its whole life.
-	*/
-	openStream(url) {
-		if (this.destroyed) return Promise.resolve();
-		if (this.inputPackets > 0 || this.initialized || this.initializing) throw new Error("node-av decoder: openStream on a push-fed session — a session is push-mode or pull-mode, never both");
-		if (this.pullActive) {
-			this.pullUrl = url;
-			return Promise.resolve();
-		}
-		this.pullActive = true;
-		this.pullUrl = url;
-		this.logger.info("node-av decoder: pull-mode openStream — dialing input URL", { meta: { url } });
-		this.runPullLoop().catch((err) => {
-			this.logger.error("node-av decoder: pull loop crashed", { meta: { error: errMsg(err) } });
-		});
-		return Promise.resolve();
-	}
-	/**
-	* The pull-mode supervisor loop: resolve HW once, then repeatedly dial +
-	* decode the URL, re-dialing after {@link PULL_REDIAL_MS} on any exit/error
-	* until the session is destroyed. Each iteration rebuilds a fresh
-	* demuxer/decoder (the previous one is disposed in `closePullInput`).
-	*/
-	async runPullLoop() {
-		const nav = await getNodeAv();
-		const C = await getConstants();
-		this.EAGAIN = C.AVERROR_EAGAIN;
-		this.PIX_FMT_GRAY8 = C.AV_PIX_FMT_GRAY8;
-		this.PIX_FMT_RGB24 = C.AV_PIX_FMT_RGB24;
-		this.SWS_FAST_BILINEAR = C.SWS_FAST_BILINEAR;
-		nav.Log.setLevel(C.AV_LOG_FATAL);
-		if (this.outputMode === "jpeg" && !this.sharpFn) this.sharpFn = await getSharp();
-		await this.ensurePullHwContext(nav, C);
-		while (!this.destroyed && this.pullActive) {
-			const url = this.pullUrl;
-			if (!url) break;
-			try {
-				await this.pullDialAndDecode(nav, C, url);
-			} catch (err) {
-				if (this.destroyed) break;
-				this.logger.warn("node-av decoder: pull-mode dial ended — re-dial scheduled", { meta: {
-					error: errMsg(err),
-					redialInMs: PULL_REDIAL_MS
-				} });
-			} finally {
-				this.closePullInput();
-			}
-			if (this.destroyed || !this.pullActive) break;
-			const backoffMs = this.pullFastRedial ? PULL_FAST_REDIAL_MS : PULL_REDIAL_MS;
-			this.pullFastRedial = false;
-			await this.pullSleep(backoffMs);
-		}
-	}
-	/**
-	* One dial: open the demuxer, pick the video stream, create a HW/SW decoder
-	* that downloads + normalises frames to YUV420P (so the shared scaler in
-	* `emitDecodedFrame` reads plain software planes regardless of hwaccel), and
-	* pump `demuxer.packets(video) → decoder.frames → emitDecodedFrame` until the
-	* stream ends or the session is torn down.
-	*/
-	async pullDialAndDecode(nav, C, url) {
-		const demuxer = await nav.Demuxer.open(url, { options: buildPullDemuxerOptions() });
-		if (this.destroyed || !this.pullActive) {
-			demuxer[Symbol.dispose]?.();
-			return;
-		}
-		this.pullDemuxer = demuxer;
-		const videoStream = demuxer.video();
-		if (!videoStream) throw new Error("node-av decoder: pull input has no video stream");
-		const decoder = await nav.Decoder.create(videoStream, {
-			...this.pullHwContext ? { hardware: this.pullHwContext } : {},
-			rescale: { pixelFormat: C.AV_PIX_FMT_YUV420P },
-			exitOnError: false
-		});
-		if (this.destroyed || !this.pullActive) {
-			decoder[Symbol.dispose]?.();
-			return;
-		}
-		this.pullDecoder = decoder;
-		this.logger.info("node-av pull decoder initialized", { meta: {
-			codec: this.config.codec,
-			output: this.outputMode,
-			hwAccel: this.activeHwAccel,
-			streamIndex: videoStream.index
-		} });
-		const probeTb = videoStream.timeBase;
-		const tbNum = probeTb?.num ?? 0;
-		const tbDen = probeTb?.den ?? 0;
-		this.resetLagTracker(Date.now());
-		await this.consumePullFrames(decoder.frames(demuxer.packets(videoStream.index)), tbNum, tbDen);
-	}
-	/**
-	* Consume decoded pull frames until the stream ends or the session is torn
-	* down. Each yielded frame is a node-av `Frame` — for the HW path a `clone`
-	* that refs a VAAPI surface + the decoder's whole `hw_frames_ctx`, so a SINGLE
-	* unfreed frame pins the dial's entire GPU surface pool (i915 GEM/shmem) until
-	* the process dies. Therefore EVERY exit path (teardown break, drop-to-live
-	* re-seat, normal emit, or a throw from the lag/emit calls) MUST `frame.free()`
-	* — the `try/finally` below is the single release point that guarantees it.
-	*
-	* Extracted from {@link pullDialAndDecode} so this free-on-all-paths contract
-	* is unit-testable with a stub async iterable (no live libav / GPU needed).
-	*/
-	async consumePullFrames(frames, tbNum, tbDen) {
-		for await (const frame of frames) {
-			if (!frame) {
-				if (this.destroyed || !this.pullActive) break;
-				continue;
-			}
-			try {
-				if (this.destroyed || !this.pullActive) break;
-				this.inputPackets++;
-				const wallNow = Date.now();
-				this.updateLagTracker(frame.pts, tbNum, tbDen, wallNow);
-				this.runAdaptiveController(wallNow);
-				this.emitDebugFlash(wallNow);
-				if (this.shouldDropToLive(wallNow)) {
-					this.logger.warn("node-av decoder: lag beyond recovery — dropping to live edge", { meta: {
-						lagMs: Math.round(this.lagMsEwma),
-						redialInMs: PULL_FAST_REDIAL_MS
-					} });
-					this.pullFastRedial = true;
-					break;
-				}
-				this.emitDecodedFrame(frame);
-			} finally {
-				frame.free();
-			}
-		}
-	}
-	/**
-	* Resolve and build the HW context for pull mode ONCE (reused across every
-	* re-dial, freed in `destroy`). Explicit backend → single try; `'auto'` → the
-	* kernel resolver's ordered list; no resolver → software. The first
-	* `HardwareContext.create` that succeeds wins; all failures fall through to
-	* software decode (`hardware: null`).
-	*/
-	async ensurePullHwContext(nav, C) {
-		if (this.hwaccelPref === "none") {
-			this.activeHwAccel = "none";
-			return;
-		}
-		const explicit = this.hwaccelPref === "auto" ? null : this.hwaccelPref;
-		const resolution = this.hwaccelResolver ? await this.hwaccelResolver.resolve(explicit) : explicit ? {
-			preferred: [explicit],
-			rationale: "explicit (no resolver)"
-		} : {
-			preferred: [],
-			rationale: "auto + no resolver → software"
-		};
-		for (const backend of resolution.preferred) {
-			const deviceType = backendToHwDeviceConst(backend, C);
-			if (!deviceType) continue;
-			const hw = nav.HardwareContext.create(deviceType);
-			if (!hw) {
-				this.logger.debug("node-av: pull hwaccel context create failed — trying next", { meta: { backend } });
-				continue;
-			}
-			this.pullHwContext = hw;
-			this.activeHwAccel = backend;
-			return;
-		}
-		this.logger.warn("node-av: no pull hwaccel backend initialised — using software", { meta: {
-			attempted: resolution.preferred.join(","),
-			rationale: resolution.rationale
-		} });
-		this.activeHwAccel = "none";
-	}
-	/** Dispose the CURRENT dial's demuxer + decoder (HW context is reused). */
-	closePullInput() {
-		if (this.pullDecoder) {
-			this.pullDecoder[Symbol.dispose]?.();
-			this.pullDecoder = null;
-		}
-		if (this.pullDemuxer) {
-			this.pullDemuxer[Symbol.dispose]?.();
-			this.pullDemuxer = null;
-		}
-	}
-	/** Interruptible sleep for the re-dial backoff — `destroy` resolves it early. */
-	pullSleep(ms) {
-		return new Promise((resolve) => {
-			this.pullRedialResolve = resolve;
-			this.pullRedialTimer = setTimeout(() => {
-				this.pullRedialTimer = null;
-				this.pullRedialResolve = null;
-				resolve();
-			}, ms);
-		});
-	}
-	/**
-	* Re-anchor the real-time lag tracker + per-dial controllers at the start of
-	* each dial. A fresh dial (including a drop-to-live re-seat) begins at the
-	* live edge, so the drift EWMA resets to 0 — otherwise the just-torn dial's
-	* accumulated lag would re-trigger drop-to-live immediately. The learned
-	* `adaptiveFps` is intentionally NOT reset: a re-seat should keep the shed
-	* emit-rate and recover from there once lag stays low.
-	*/
-	resetLagTracker(wallNow) {
-		this.basePts = null;
-		this.baseWall = 0;
-		this.lagMsEwma = 0;
-		this.lowLagSince = 0;
-		this.lastAdaptiveCheck = wallNow;
-		this.adaptiveWindowFrames = this.outputFrames;
-		this.lastDebugFlush = wallNow;
-		this.debugWindowDropped = this.droppedFrames;
-	}
-	/**
-	* Update the EWMA of the decoder's real-time drift from a decoded frame's
-	* pts. The first frame of a dial anchors `basePts`/`baseWall`; every later
-	* frame compares elapsed wall-clock against elapsed media time —
-	* `lagMs = wallElapsed - mediaElapsed`. A rising EWMA means the decoder is
-	* falling behind the live edge (wall time outrunning the media timeline).
-	*/
-	updateLagTracker(pts, tbNum, tbDen, wallNow) {
-		if (tbDen === 0) return;
-		if (this.basePts === null) {
-			this.basePts = pts;
-			this.baseWall = wallNow;
-			return;
-		}
-		const sample = wallNow - this.baseWall - Number(pts - this.basePts) * 1e3 * tbNum / tbDen;
-		this.lagMsEwma = .9 * this.lagMsEwma + .1 * sample;
-	}
-	/**
-	* Lag-driven adaptive emit-fps controller (P1), self-throttled to
-	* {@link ADAPTIVE_TICK_MS}. Under load (lag EWMA high) it halves the emit-fps
-	* — fewer frames transferred + GPU-scaled + emitted, so the decoder stays
-	* real-time instead of accumulating lag; once lag stays low for a sustained
-	* window it grows the emit-fps back toward the subscriber's ceiling.
-	* `minIntervalMs` (the throttle both emit paths honour) is recomputed from
-	* `adaptiveFps`, NOT the raw ceiling.
-	*/
-	runAdaptiveController(wallNow) {
-		const windowMs = wallNow - this.lastAdaptiveCheck;
-		if (windowMs < ADAPTIVE_TICK_MS) return;
-		this.lastAdaptiveCheck = wallNow;
-		const framesDelta = this.outputFrames - this.adaptiveWindowFrames;
-		this.adaptiveWindowFrames = this.outputFrames;
-		this.effectiveFps = windowMs > 0 ? framesDelta * 1e3 / windowMs : 0;
-		const lag = this.lagMsEwma;
-		if (lag > ADAPTIVE_LAG_HIGH_MS) {
-			this.adaptiveFps = Math.max(ADAPTIVE_MIN_FPS, this.adaptiveFps / 2);
-			this.lowLagSince = 0;
-		} else if (lag < ADAPTIVE_LAG_LOW_MS) {
-			if (this.lowLagSince === 0) this.lowLagSince = wallNow;
-			else if (wallNow - this.lowLagSince >= ADAPTIVE_RECOVER_SUSTAIN_MS) {
-				this.adaptiveFps = Math.min(this.ceilingFps, this.adaptiveFps * 1.5);
-				this.lowLagSince = wallNow;
-			}
-		} else this.lowLagSince = 0;
-		this.minIntervalMs = this.adaptiveFps > 0 ? 1e3 / this.adaptiveFps : 0;
-	}
-	/**
-	* Whether the decoder is hopelessly behind the live edge and should tear the
-	* input down for a fast re-seat. Rate-limited to at most once per
-	* {@link DROP_TO_LIVE_MIN_INTERVAL_MS} so a bad stretch can't hot-loop the
-	* dial. Records the trigger time as a side effect when it returns `true`.
-	*/
-	shouldDropToLive(wallNow) {
-		if (this.lagMsEwma <= DROP_TO_LIVE_LAG_MS) return false;
-		if (wallNow - this.lastDropToLive < DROP_TO_LIVE_MIN_INTERVAL_MS) return false;
-		this.lastDropToLive = wallNow;
-		return true;
-	}
-	/**
-	* Per-camera DEBUG facility (mirrors the stream-broker's `streamingDebug`
-	* gate). When `config.debug` is set, flush a single structured `decoder
-	* debug` line at ~1Hz — effective/adaptive fps, real-time lag, dropped-frame
-	* delta, avg decode time, hwaccel. `deviceId`/`tag` ride on the logger tags.
-	* Cheap: all values come from running counters, and the whole method is a
-	* no-op (one comparison) when debug is disabled or the window hasn't elapsed.
-	*/
-	emitDebugFlash(wallNow) {
-		if (!this.debugEnabled) return;
-		if (wallNow - this.lastDebugFlush < DEBUG_FLUSH_MS) return;
-		this.lastDebugFlush = wallNow;
-		const droppedDelta = this.droppedFrames - this.debugWindowDropped;
-		this.debugWindowDropped = this.droppedFrames;
-		const decodeMsAvg = this.outputFrames > 0 ? this.totalDecodeTimeMs / this.outputFrames : 0;
-		this.logger.info("decoder debug", { meta: {
-			effectiveFps: Number(this.effectiveFps.toFixed(1)),
-			adaptiveFps: Number(this.adaptiveFps.toFixed(1)),
-			ceilingFps: this.ceilingFps,
-			lagMs: Math.round(this.lagMsEwma),
-			droppedFrames: droppedDelta,
-			decodeMs: Number(decodeMsAvg.toFixed(2)),
-			hwAccel: this.activeHwAccel
-		} });
-	}
-	pushPacket(packet) {
-		if (this.destroyed) return;
-		if (this.pullActive) {
-			if (!this.pullStrayPushLogged) {
-				this.pullStrayPushLogged = true;
-				this.logger.debug("node-av decoder: pushPacket on a pull-mode session — ignored");
-			}
-			return;
-		}
-		this.inputPackets++;
-		if (!this.initialized && !this.initializing && packet.keyframe) {
-			this.initDecoder().then(() => {
-				if (this.initialized) this.decodeRawData(packet.data, packet.pts ?? Date.now());
-			}).catch((err) => {
-				this.logger.error("node-av init failed", { meta: { error: errMsg(err) } });
-			});
-			return;
-		}
-		if (!this.initialized) return;
-		this.decodeRawData(packet.data, packet.pts ?? Date.now());
-	}
-	decodeRawData(data, pts) {
-		if (!this.parser || !this.codecCtx || !this.avPacket || !this.avFrame) return;
-		const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
-		const bigPts = BigInt(pts);
-		let offset = 0;
-		while (offset < buf.length) {
-			const remaining = buf.subarray(offset);
-			const consumed = this.parser.parse2(this.codecCtx, this.avPacket, remaining, bigPts, bigPts, offset);
-			if (consumed < 0) {
-				this.logger.warn("node-av parser error", { meta: { ret: consumed } });
-				break;
-			}
-			offset += consumed;
-			if (this.avPacket.size > 0) {
-				this.decodePacket();
-				this.avPacket.unref();
-			}
-		}
-	}
-	decodePacket() {
-		if (!this.codecCtx || !this.avFrame) return;
-		const sendRet = this.codecCtx.sendPacketSync(this.avPacket);
-		if (sendRet < 0 && sendRet !== this.EAGAIN) {
-			this.logger.warn("node-av sendPacket error", { meta: { ret: sendRet } });
-			return;
-		}
-		while (true) {
-			if (this.codecCtx.receiveFrameSync(this.avFrame) < 0) break;
-			const frame = this.transferHwFrame(this.avFrame);
-			if (!frame) continue;
-			this.emitDecodedFrame(frame);
-		}
-	}
-	emitDecodedFrame(frame) {
-		const now = performance.now();
-		if (frame.isHwFrame()) {
-			this.droppedFrames++;
-			return;
-		}
-		if (this.minIntervalMs > 0 && now - this.lastEmitTime < this.minIntervalMs) {
-			this.droppedFrames++;
-			return;
-		}
-		if (this.scalerInitializing) return;
-		const incoming = {
-			width: frame.width,
-			height: frame.height,
-			format: frame.format
-		};
-		const current = this.scaler !== null ? {
-			width: this.scalerSrcW,
-			height: this.scalerSrcH,
-			format: this.scalerSrcFmt
-		} : null;
-		const action = resolveScalerAction(current, incoming);
-		if (action === "init") {
-			this.initScaler(incoming.width, incoming.height, incoming.format);
-			return;
-		}
-		if (action === "rebuild") {
-			this.logger.info("node-av: decoded source geometry changed — rebuilding scaler", { meta: {
-				from: current,
-				to: incoming
-			} });
-			this.scalerEpoch++;
-			this.scaler?.[Symbol.dispose]?.();
-			this.scaler = null;
-			this.dstFrame?.[Symbol.dispose]?.();
-			this.dstFrame = null;
-			this.scalerSrcW = -1;
-			this.scalerSrcH = -1;
-			this.scalerSrcFmt = -1;
-			this.initScaler(incoming.width, incoming.height, incoming.format);
-			return;
-		}
-		if (!this.dstFrame || !this.scaler) return;
-		const decodeStart = performance.now();
-		try {
-			this.dstFrame.makeWritable();
-			this.scaler.scaleFrameSync(this.dstFrame, frame);
-		} catch (err) {
-			this.logger.warn("node-av scale error", { meta: { error: errMsg(err) } });
-			return;
-		}
-		if (!this.firstFrameLogged) {
-			this.firstFrameLogged = true;
-			const channels = this.outputMode === "gray" ? 1 : 3;
-			const ls = this.dstFrame.linesize;
-			const buf = this.dstFrame.toBuffer();
-			this.logger.info("dstFrame after scale", { meta: {
-				phase: "frame-debug",
-				width: this.dstFrame.width,
-				height: this.dstFrame.height,
-				linesize: [
-					ls[0],
-					ls[1],
-					ls[2]
-				],
-				expectedStride: this.dstFrame.width * channels,
-				bufLen: buf.length,
-				expectedPacked: this.dstFrame.width * channels * this.dstFrame.height,
-				srcFormat: frame.format ?? "?"
-			} });
-			if (this.outputMode !== "gray") import("node:fs").then((fsModule) => {
-				import("node:path").then((pathModule) => {
-					const dumpPath = pathModule.join(process.cwd(), "camstack-data", "debug-frame-rgb24.raw");
-					fsModule.writeFileSync(dumpPath, buf);
-					this.logger.info("Dumped first RGB24 frame", { meta: {
-						phase: "frame-debug",
-						path: dumpPath,
-						bytes: buf.length
-					} });
-				}).catch(() => {});
-			}).catch(() => {});
-		}
-		const rawBuf = this.extractPackedBuffer(this.dstFrame);
-		if (this.outputMode === "jpeg") this.encodeAndEmitJpeg(rawBuf, decodeStart);
-		else if (this.outputMode === "rgb") this.emitRawFrame(rawBuf, "rgb", decodeStart);
-		else this.emitRawFrame(rawBuf, "gray", decodeStart);
-	}
-	/**
-	* Extract packed pixel buffer from a decoded frame.
-	* FFmpeg's av_frame_get_buffer() may pad each row to alignment (32/64 bytes).
-	* Sharp and WASM consumers expect tightly-packed rows (stride = width * channels).
-	* If linesize matches expected stride, return the buffer directly (zero-copy).
-	*/
-	extractPackedBuffer(frame) {
-		const channels = this.outputMode === "gray" ? 1 : 3;
-		const expectedStride = frame.width * channels;
-		const actualStride = frame.linesize[0] ?? expectedStride;
-		const src = frame.data?.[0];
-		if (!src) return frame.toBuffer();
-		if (actualStride === expectedStride) return Buffer.from(src.buffer, src.byteOffset, expectedStride * frame.height);
-		const dst = Buffer.allocUnsafe(expectedStride * frame.height);
-		for (let y = 0; y < frame.height; y++) src.copy(dst, y * expectedStride, y * actualStride, y * actualStride + expectedStride);
-		return dst;
-	}
-	/**
-	* Encode RGB24 raw buffer as JPEG and emit.
-	*
-	* Drops the frame (and counts it) when `MAX_JPEG_INFLIGHT` encodes
-	* are already pending — prevents unbounded growth of the
-	* fire-and-forget promise chain when sharp cannot keep up with the
-	* decode rate.
-	*/
-	encodeAndEmitJpeg(rgb, decodeStart) {
-		if (!this.sharpFn) return;
-		if (this.jpegEncodeInFlight >= NodeAvDecoderSession.MAX_JPEG_INFLIGHT) {
-			this.droppedFrames++;
-			return;
-		}
-		this.jpegEncodeInFlight++;
-		this.sharpFn(rgb, { raw: {
-			width: this.outWidth,
-			height: this.outHeight,
-			channels: 3
-		} }).jpeg({
-			quality: 80,
-			mozjpeg: false
-		}).toBuffer().then((jpegBuf) => {
-			if (this.destroyed) return;
-			this.emitRawFrame(jpegBuf, "jpeg", decodeStart);
-		}).catch((err) => {
-			this.logger.warn("sharp jpeg encode error", { meta: { error: errMsg(err) } });
-		}).finally(() => {
-			this.jpegEncodeInFlight--;
-		});
-	}
-	emitRawFrame(data, format, decodeStart) {
-		const decodeMs = performance.now() - decodeStart;
-		this.totalDecodeTimeMs += decodeMs;
-		this.outputFrames++;
-		this.lastEmitTime = performance.now();
-		if (this.outputFrames === 1 || this.outputFrames % 500 === 0) this.logger.info("node-av frame emitted", { meta: {
-			frameNumber: this.outputFrames,
-			width: this.outWidth,
-			height: this.outHeight,
-			format,
-			decodeMs,
-			subs: this.frameCallbacks.size
-		} });
-		const decodedFrame = {
-			data,
-			width: this.outWidth,
-			height: this.outHeight,
-			format,
-			timestamp: Date.now()
-		};
-		for (const cb of this.frameCallbacks) cb(decodedFrame);
-	}
-	onFrame(callback) {
-		this.frameCallbacks.add(callback);
-		return () => {
-			this.frameCallbacks.delete(callback);
-		};
-	}
-	updateConfig(update) {
-		const prevFormat = this.config.outputFormat;
-		this.config = {
-			...this.config,
-			...update
-		};
-		if (update.maxFps !== void 0) this.minIntervalMs = update.maxFps > 0 ? 1e3 / update.maxFps : 0;
-		if (update.outputFormat !== void 0 && update.outputFormat !== prevFormat) {
-			const prevMode = this.outputMode;
-			this.outputMode = NodeAvDecoderSession.resolveOutputMode(update.outputFormat);
-			if (this.outputMode === prevMode) return;
-			this.scalerEpoch++;
-			if (this.scaler) {
-				this.scaler[Symbol.dispose]?.();
-				this.scaler = null;
-			}
-			if (this.dstFrame) {
-				this.dstFrame[Symbol.dispose]?.();
-				this.dstFrame = null;
-			}
-			this.scalerSrcW = -1;
-			this.scalerSrcH = -1;
-			this.scalerSrcFmt = -1;
-			if (this.outputMode === "jpeg" && !this.sharpFn) getSharp().then((fn) => {
-				this.sharpFn = fn;
-			}).catch(() => {});
-			this.logger.info("node-av: output format changed — scaler will reinit", { meta: {
-				from: prevFormat,
-				to: update.outputFormat,
-				mode: this.outputMode
-			} });
-		}
-	}
-	async destroy() {
-		if (this.destroyed) return;
-		this.destroyed = true;
-		this.frameCallbacks.clear();
-		this.pullActive = false;
-		if (this.pullRedialTimer) {
-			clearTimeout(this.pullRedialTimer);
-			this.pullRedialTimer = null;
-		}
-		if (this.pullRedialResolve) {
-			const resolve = this.pullRedialResolve;
-			this.pullRedialResolve = null;
-			resolve();
-		}
-		this.closePullInput();
-		if (this.pullHwContext) {
-			if (!this.pullHwContext.isDisposed) this.pullHwContext.dispose();
-			this.pullHwContext = null;
-		}
-		this.dstFrame?.[Symbol.dispose]?.();
-		this.avFrame?.[Symbol.dispose]?.();
-		this.avPacket?.[Symbol.dispose]?.();
-		this.scaler?.[Symbol.dispose]?.();
-		this.parser?.[Symbol.dispose]?.();
-		this.swTransferFrame?.[Symbol.dispose]?.();
-		this.codecCtx?.[Symbol.dispose]?.();
-		this.hwDevice?.free();
-		this.dstFrame = null;
-		this.avFrame = null;
-		this.avPacket = null;
-		this.scaler = null;
-		this.parser = null;
-		this.codecCtx = null;
-		this.swTransferFrame = null;
-		this.hwDevice = null;
-	}
-	getStats() {
-		const uptimeSec = Math.max((Date.now() - this.startTime) / 1e3, 1);
-		const base = {
-			inputFps: this.inputPackets / uptimeSec,
-			outputFps: this.outputFrames / uptimeSec,
-			avgDecodeTimeMs: this.outputFrames > 0 ? this.totalDecodeTimeMs / this.outputFrames : 0,
-			droppedFrames: this.droppedFrames
-		};
-		if (!this.pullActive) return base;
-		return {
-			...base,
-			lagMs: this.lagMsEwma,
-			effectiveFps: this.effectiveFps,
-			adaptiveFps: this.adaptiveFps
-		};
-	}
-	get isPullMode() {
-		return this.pullActive;
-	}
-};
-//#endregion
 //#region src/audio-codec/codec-catalog.ts
 /**
 * Normalise an SDP-reported codec name to the libav/ffmpeg name. Mirrors
@@ -50635,21 +49897,22 @@ function peekNodeAvRuntime() {
 }
 //#endregion
 //#region src/addon/index.ts
-var FRAME_BUFFER_CAPACITY = 32;
+/**
+* The node's `decoder` + `audio-codec` provider.
+*
+* The `decoder` cap is per-node hwaccel only (D763): `getInfo` reports this
+* node's operator choice and probed best backend, `reprobeHwaccel` re-runs the
+* probe. Both are per-node settings (`hwaccel@<node>`,
+* `probedBestHwaccel@<node>`); the egress transcode, HomeKit and the load view
+* read them through `getInfo`, pinned to the node. Video decoding itself runs in the pipeline runner's session-decode
+* workers, which use node-av directly. The `audio-codec` cap is the node-av
+* codec (encode/decode + resample) every audio session on the node runs on.
+*/
 var DecoderNodeAvAddon = class extends BaseAddon {
 	/**
-	* Sessions are stored as the concrete `NodeAvDecoderSession` (the only type
-	* this addon ever creates).
-	*/
-	sessions = /* @__PURE__ */ new Map();
-	/** Pixel-frame buffers drained by `pullFrames`. */
-	frameBuffers = /* @__PURE__ */ new Map();
-	unsubscribers = /* @__PURE__ */ new Map();
-	sessionMeta = /* @__PURE__ */ new Map();
-	/**
-	* node-av audio-codec provider — registered independently of the video
-	* decoder backend gate whenever node-av loads on this node, so this single
-	* addon provides both the `decoder` and `audio-codec` caps.
+	* node-av audio-codec provider — registered whenever node-av loads on this
+	* node, so this single addon provides both the `decoder` and `audio-codec`
+	* caps.
 	*/
 	audioProvider = null;
 	constructor() {
@@ -50660,7 +49923,7 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 			id: "hwaccel",
 			title: "Hardware acceleration",
 			tab: "decoder",
-			description: "Backend used by node-av decoder sessions. \"Auto\" defers to the probed best; concrete backends force it. Changes apply to NEW sessions — existing sessions keep the backend they were created with.",
+			description: "Decode hwaccel this node reports through decoder.getInfo — read by the egress transcode and HomeKit. \"Auto\" defers to the probed best; concrete backends force it. Changes apply to NEW transcodes.",
 			fields: [this.field({
 				type: "select",
 				key: "hwaccel",
@@ -50705,12 +49968,7 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 				provider: this.audioProvider
 			});
 		}
-		const backend = await resolveDecoderBackend(this.ctx.api, this.resolveLocalNodeId(), this.ctx.logger);
-		if (backend !== "nodeav") {
-			this.ctx.logger.info("node-av decoder: this node selects a different decoder backend — standing down (no decoder provider registered)", { meta: { selectedBackend: backend } });
-			return registrations;
-		}
-		this.ctx.logger.info("node-av decoder addon initialized", { meta: { selectedBackend: backend } });
+		this.ctx.logger.info("node-av decoder addon initialized");
 		if (!this.config.probedBestHwaccel) this.reprobeHwaccel().catch((err) => {
 			this.ctx.logger.warn("nodeav: auto-reprobe hwaccel failed", { meta: { error: err instanceof Error ? err.message : String(err) } });
 		});
@@ -50721,16 +49979,6 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 		return registrations;
 	}
 	/**
-	* Resolve the effective hwaccel backend for a new session — from THIS addon's
-	* OWN per-node `hwaccel` config (edited via the Pipeline UI when node-av is
-	* the active decoder). No cross-read of another addon's store. `'auto'`
-	* defers to the session's local resolver (`ctx.kernel.hwaccel`); fails safe
-	* to `'auto'`.
-	*/
-	resolveHwAccelPref() {
-		return Promise.resolve(this.config.hwaccel ?? "auto");
-	}
-	/**
 	* Re-run the platform probe on this host and persist the detected
 	* backend as `probedBestHwaccel`. The operator's `hwaccel` setting
 	* is intentionally left alone — the probe only updates the hint.
@@ -50758,191 +50006,30 @@ var DecoderNodeAvAddon = class extends BaseAddon {
 			return { backend: "none" };
 		}
 	}
-	async supportsCodec(input) {
-		return [
-			"h264",
-			"h265",
-			"hevc"
-		].includes(input.codec.toLowerCase());
-	}
 	async getInfo() {
 		return {
 			id: "decoder-nodeav",
 			name: "Decoder (node-av)",
-			isPullMode: true,
-			priority: 10,
 			hwaccel: this.config.hwaccel,
 			probedBestHwaccel: this.config.probedBestHwaccel || void 0
 		};
 	}
 	/**
-	* The cluster node id of this decoder — the Moleculer nodeID (`hub`,
-	* `dev-agent-0`, …), not the addon id. Returned from `createSession` so the
-	* caller can route session-scoped calls to the node that owns the session.
-	* A hierarchical broker nodeID (`hub/...`) is collapsed to the
-	* cluster-visible parent; in-process boot is left as-is. Mirrors the
-	* resolution `PipelineRunnerAddon.onInitialize` performs.
+	* The cluster node id of this addon — the Moleculer nodeID (`hub`,
+	* `dev-agent-0`, …), not the addon id. A hierarchical broker nodeID
+	* (`hub/...`) is collapsed to the cluster-visible parent; in-process boot is
+	* left as-is. Mirrors the resolution `PipelineRunnerAddon.onInitialize`
+	* performs.
 	*/
 	resolveLocalNodeId() {
 		const raw = this.ctx.kernel.localNodeId ?? this.ctx.id;
 		return raw.includes("/") ? raw.split("/")[0] : raw;
 	}
-	async createSession(config) {
-		const sessionId = randomUUID();
-		const hwaccel = await this.resolveHwAccelPref();
-		const nodeId = this.resolveLocalNodeId();
-		const session = new NodeAvDecoderSession(config, this.ctx.logger, {
-			hwaccel,
-			hwaccelResolver: this.ctx.kernel.hwaccel
-		});
-		const unsub = this.wireCallbackSink(sessionId, session);
-		this.sessions.set(sessionId, session);
-		this.unsubscribers.set(sessionId, unsub);
-		this.sessionMeta.set(sessionId, {
-			codec: config.codec,
-			outputFormat: config.outputFormat,
-			createdAtMs: Date.now(),
-			deviceId: config.deviceId
-		});
-		this.ctx.logger.info("node-av: created session", {
-			tags: typeof config.deviceId === "number" ? { deviceId: config.deviceId } : void 0,
-			meta: {
-				sessionId,
-				codec: config.codec,
-				hwaccelPref: hwaccel,
-				nodeId
-			}
-		});
-		return {
-			sessionId,
-			nodeId
-		};
-	}
-	/**
-	* Subscribe a `'callback'` session's pixel frames into a per-session
-	* ring buffer drained by `pullFrames`.
-	*/
-	wireCallbackSink(sessionId, session) {
-		const ringBuffer = new NotifyingRingBuffer(FRAME_BUFFER_CAPACITY);
-		this.frameBuffers.set(sessionId, ringBuffer);
-		return session.onFrame((frame) => {
-			const { format } = frame;
-			if (format !== "jpeg" && format !== "rgb" && format !== "bgr" && format !== "yuv420" && format !== "gray") return;
-			const arrayBuf = new ArrayBuffer(frame.data.byteLength);
-			new Uint8Array(arrayBuf).set(frame.data);
-			const capFrame = {
-				data: new Uint8Array(arrayBuf),
-				width: frame.width,
-				height: frame.height,
-				format,
-				timestamp: frame.timestamp
-			};
-			ringBuffer.push(capFrame);
-		});
-	}
-	async destroySession(input) {
-		const { sessionId } = input;
-		const session = this.sessions.get(sessionId);
-		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${sessionId}`);
-		const unsub = this.unsubscribers.get(sessionId);
-		if (unsub) unsub();
-		this.frameBuffers.get(sessionId)?.cancel();
-		const deviceId = this.sessionMeta.get(sessionId)?.deviceId;
-		await session.destroy();
-		this.sessions.delete(sessionId);
-		this.frameBuffers.delete(sessionId);
-		this.unsubscribers.delete(sessionId);
-		this.sessionMeta.delete(sessionId);
-		this.ctx.logger.info("node-av: destroyed session", {
-			tags: typeof deviceId === "number" ? { deviceId } : void 0,
-			meta: { sessionId }
-		});
-	}
-	async listActiveSessions() {
-		const out = [];
-		for (const [sessionId, meta] of this.sessionMeta) out.push({
-			sessionId,
-			codec: meta.codec,
-			outputFormat: meta.outputFormat,
-			createdAtMs: meta.createdAtMs
-		});
-		return out;
-	}
-	async pushPacket(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		const rawData = input.packet.data;
-		const data = Buffer.isBuffer(rawData) ? rawData : rawData instanceof Uint8Array ? Buffer.from(rawData.buffer, rawData.byteOffset, rawData.byteLength) : Buffer.from(rawData);
-		session.pushPacket({
-			...input.packet,
-			data
-		});
-	}
-	async openStream(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		await session.openStream(input.url);
-	}
-	async pullFrames(input) {
-		if (!this.sessions.has(input.sessionId)) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		const ringBuffer = this.frameBuffers.get(input.sessionId);
-		if (!ringBuffer) return [];
-		if (ringBuffer.size === 0 && input.waitMs) await ringBuffer.waitForItem(input.waitMs);
-		return ringBuffer.drain(input.maxCount);
-	}
-	/**
-	* DORMANT — the shm `FrameHandle` frame plane is retired. Every session now
-	* delivers pixels over the callback path drained by `pullFrames`, so no
-	* handles are ever produced. Kept to satisfy the (still-defined) cap method;
-	* always returns an empty list. Removal rides a later framework train.
-	*/
-	async pullHandles() {
-		return [];
-	}
-	async updateConfig(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		session.updateConfig(input.config);
-	}
-	async getStats(input) {
-		const session = this.sessions.get(input.sessionId);
-		if (!session) throw new Error(`decoder-nodeav: unknown sessionId ${input.sessionId}`);
-		return session.getStats();
-	}
-	/**
-	* DORMANT — shm handle read-back is retired (the decoder no longer owns a
-	* `/dev/shm` ring). Kept to satisfy the (still-defined) cap method; always
-	* returns `null`. Full-frame retrieval by handle now flows through the
-	* runner's RAM-backed `pipelineRunner.getNativeCrop`. Removal rides a later
-	* framework train.
-	*/
-	async getFrame() {
-		return null;
-	}
-	/**
-	* DORMANT — no shm ring exists to report stats for. Kept to satisfy the
-	* (still-defined) cap method; always returns `null`. Removal rides a later
-	* framework train.
-	*/
-	async getShmStats() {
-		return null;
-	}
 	async onShutdown() {
 		this.audioProvider?.stop();
 		this.audioProvider = null;
-		this.ctx.logger.info("node-av decoder addon shutdown — destroying all sessions");
-		const destroyPromises = [];
-		for (const [sessionId, session] of this.sessions) {
-			const unsub = this.unsubscribers.get(sessionId);
-			if (unsub) unsub();
-			destroyPromises.push(session.destroy());
-		}
-		await Promise.all(destroyPromises);
-		this.sessions.clear();
-		this.frameBuffers.clear();
-		this.unsubscribers.clear();
-		this.sessionMeta.clear();
+		this.ctx.logger.info("node-av decoder addon shutdown");
 	}
 };
 //#endregion
-export { DecoderNodeAvAddon, DecoderNodeAvAddon as default, NodeAvAudioCodecProvider, NodeAvAudioDecodeSession, NodeAvAudioEncodeSession, NodeAvDecoderSession, loadNodeAvRuntime, peekNodeAvRuntime };
+export { DecoderNodeAvAddon, DecoderNodeAvAddon as default, NodeAvAudioCodecProvider, NodeAvAudioDecodeSession, NodeAvAudioEncodeSession, loadNodeAvRuntime, peekNodeAvRuntime };