@camstack/addon-pipeline 1.2.342 → 1.2.344

package/dist/stream-broker/index.js

@@ -3,12 +3,12 @@ Object.defineProperties(exports, {
 	[Symbol.toStringTag]: { value: "Module" }
 });
 const require_chunk = require("../chunk-emK7D4bc.js");
-const require_dist = require("../dist-w_gA9z8W.js");
-const require_node = require("../node-BTsWSPyQ.js");
+const require_dist = require("../dist-DNsARIUD.js");
+const require_node = require("../node-D-U3T-h-.js");
 const require_restream_intent = require("../restream-intent-7uDNqMKs.js");
 const require_remote_restream = require("../remote-restream-CO36Sr30.js");
 const require_retire_root_keys = require("../retire-root-keys-Csb8z2f3.js");
-const require_segment_demux_js = require("../segment-demux-js-D4kTUDck.js");
+const require_segment_demux_js = require("../segment-demux-js-vZ6iniOU.js");
 let node_os = require("node:os");
 node_os = require_chunk.__toESM(node_os);
 let node_crypto = require("node:crypto");
@@ -565,16 +565,6 @@ var STREAM_BROKER_RETIRED_ROOT_KEYS = [
 	}
 ];
 //#endregion
-//#region src/stream-broker/stream-broker/ffmpeg-args-common.ts
-/** The `-hide_banner -loglevel <level>` preamble every broker ffmpeg site opens with. */
-function logBannerArgs(level) {
-	return [
-		"-hide_banner",
-		"-loglevel",
-		level
-	];
-}
-//#endregion
 //#region src/shared/ffmpeg-decode-args.ts
 /** Default DRM render node used for the VA-API / QSV hardware decode path. */
 var DEFAULT_VAAPI_RENDER_DEVICE = "/dev/dri/renderD128";
@@ -7711,15 +7701,15 @@ function isH265IrapAccessUnit(annexB) {
 //#endregion
 //#region src/stream-broker/stream-broker/annexb-param-sets.ts
 /**
-* Annex-B parameter-set detection for the decoder-priming path.
+* Annex-B parameter-set detection for the clip-priming path.
 *
-* The frame-handle-plane decoder (`ffmpeg -f h264|hevc -i pipe:0`) initialises
-* only once it sees the codec parameter sets (H.264 SPS+PPS / H.265 SPS+PPS,
-* plus VPS) in its Annex-B input. Most cameras carry them in-band with each
-* IDR; some (Reolink high-profile native streams) ship them ONLY in the SDP.
-* The broker harvests those SDP param sets (`sdpParameterSets`) but must not
-* blindly re-inject them ahead of every keyframe — that would duplicate the
-* sets for well-behaved cameras. This scan lets the broker inject only when a
+* A decoder of a pre-buffer clip (`prebuffer-clip.ts`) initialises only once it
+* sees the codec parameter sets (H.264 SPS+PPS / H.265 SPS+PPS, plus VPS) in
+* its Annex-B input. Most cameras carry them in-band with each IDR; some
+* (Reolink high-profile native streams) ship them ONLY in the SDP. The broker
+* harvests those SDP param sets (`sdpParameterSets`) but must not blindly
+* re-inject them ahead of every keyframe — that would duplicate the sets for
+* well-behaved cameras. This scan lets the clip writer inject only when a
 * keyframe's own NAL stream is missing them.
 *
 * Pure byte scanning: no allocation beyond the walk; safe on any Annex-B blob.
@@ -7765,20 +7755,6 @@ function annexBHasParameterSets(data, codec) {
 	}
 	return hasSps && hasPps;
 }
-/**
-* Concatenate raw parameter-set NAL payloads into a single Annex-B buffer
-* (each prefixed with a 4-byte start code) — the shape the decoder's stdin
-* expects. Mirrors the existing SDP-param-set replay for encoded subscribers.
-*/
-function concatParameterSetsAnnexB(parameterSets) {
-	const startCode = Buffer.from([
-		0,
-		0,
-		0,
-		1
-	]);
-	return Buffer.concat(parameterSets.flatMap((ps) => [startCode, ps]));
-}
 //#endregion
 //#region src/stream-broker/stream-broker/prebuffer-clip.ts
 /** Profiles cheapest-first — the default picks the first one assigned. */
@@ -11370,806 +11346,6 @@ var EncodedRingBuffer = class {
 	}
 };
 //#endregion
-//#region src/stream-broker/stream-broker/decoder-session-proxy.ts
-/**
-* Long-poll window handed to `pullFrames`/`pullHandles`: an empty drain blocks
-* decoder-side until a frame commits or this elapses, replacing the old ~1kHz
-* `setTimeout(…,1)` busy-spin with a single await-notify round-trip. Kept
-* modest so a hung UDS/Moleculer transport can't pin the call; the decoder
-* cancels the waiter on `destroySession` so teardown never waits it out.
-*/
-var POLL_WAIT_MS = 50;
-var DecoderSessionProxy = class {
-	api;
-	sessionId;
-	polling = false;
-	constructor(api, sessionId) {
-		this.api = api;
-		this.sessionId = sessionId;
-	}
-	/**
-	* Guarantee an empty drain cannot re-poll faster than `POLL_WAIT_MS`,
-	* regardless of the peer. A WELL-BEHAVED decoder blocks server-side for
-	* `waitMs` (await-notify long-poll), so `elapsedMs >= POLL_WAIT_MS` and this
-	* is a no-op. But the loop's liveness must NOT depend on peer courtesy: a
-	* peer that resolves `[]` instantly — the dormant `decoder-nodeav.pullHandles`
-	* stub, an old decoder that predates `waitMs`, a test fake — would otherwise
-	* turn `startPolling`/`startHandlePolling` into a ZERO-YIELD microtask spin
-	* that pins the CPU, starves every timer in the process, and allocates until
-	* the heap dies (observed: a 4 GB OOM in under 15 s).
-	*/
-	async paceEmptyDrain(drainStartedAt) {
-		const remainderMs = POLL_WAIT_MS - (Date.now() - drainStartedAt);
-		if (remainderMs > 0) await new Promise((resolve) => setTimeout(resolve, remainderMs));
-	}
-	async pushPacket(packet) {
-		await this.api.pushPacket({
-			sessionId: this.sessionId,
-			packet
-		});
-	}
-	async openStream(url) {
-		await this.api.openStream({
-			sessionId: this.sessionId,
-			url
-		});
-	}
-	async startPolling(onFrame) {
-		this.polling = true;
-		while (this.polling) {
-			const drainStartedAt = Date.now();
-			const frames = await this.api.pullFrames({
-				sessionId: this.sessionId,
-				maxCount: 4,
-				waitMs: POLL_WAIT_MS
-			});
-			for (const frame of frames) onFrame(frame);
-			if (frames.length === 0 && this.polling) await this.paceEmptyDrain(drainStartedAt);
-		}
-	}
-	/**
-	* Poll a `frameSink: 'shm'` session for `FrameHandle`s (Phase 5 / D9).
-	* Mirrors `startPolling` but drains `pullHandles` — the decoder has
-	* already written the pixels into a shared-memory ring, so what crosses
-	* the cap boundary is the tiny serialisable handle. Runs until
-	* `stopPolling`, `destroy`, or the session is destroyed externally.
-	*
-	* When the decoder reports the session is gone (`unknown sessionId` /
-	* `Service … not found`) the loop exits gracefully — those errors are
-	* expected during decoder restart/shutdown and must not be re-thrown to
-	* the caller's `.catch()` handler, which would otherwise spin forever.
-	*/
-	async startHandlePolling(onHandle) {
-		this.polling = true;
-		while (this.polling) try {
-			const drainStartedAt = Date.now();
-			const handles = await this.api.pullHandles({
-				sessionId: this.sessionId,
-				maxCount: 4,
-				waitMs: POLL_WAIT_MS
-			});
-			for (const handle of handles) onHandle(handle);
-			if (handles.length === 0 && this.polling) await this.paceEmptyDrain(drainStartedAt);
-		} catch (err) {
-			this.polling = false;
-			const msg = err instanceof Error ? err.message : String(err);
-			if (!msg.includes("unknown sessionId") && !msg.includes("Service") && !msg.includes("not found")) throw err;
-			return;
-		}
-	}
-	stopPolling() {
-		this.polling = false;
-	}
-	async updateConfig(config) {
-		await this.api.updateConfig({
-			sessionId: this.sessionId,
-			config
-		});
-	}
-	async getStats() {
-		return this.api.getStats({ sessionId: this.sessionId });
-	}
-	async destroy() {
-		this.stopPolling();
-		await this.api.destroySession({ sessionId: this.sessionId });
-	}
-};
-//#endregion
-//#region src/stream-broker/stream-broker/frame-handle-plane.ts
-/**
-* `FrameHandlePlane` — the broker's shared-memory frame-handle surface
-* (Phase 5 / D9).
-*
-* This is the handle-based replacement for `StreamBroker.onDecodedFrame`'s
-* live-object callback path. Instead of fanning pixel `DecodedFrame`s out to
-* in-process callbacks (which cannot cross a process boundary), the broker
-* publishes zero-pixel, serialisable `FrameHandle`s a consumer drains over
-* tRPC and reads back from a shared-memory ring with a `FrameRingReader`.
-*
-* ## Ring-per-format model
-*
-* A `frameSink: 'shm'` decoder session produces exactly ONE pixel format
-* (the decoder's scaler is configured for it). The broker therefore keeps
-* one decoder session — hence one shm ring — per `(brokerId, format)` that a
-* consumer actually subscribes to:
-*
-*   - motion subscribes `gray`  → one `gray` decoder session + ring
-*   - detection subscribes `rgb` → one `rgb` decoder session + ring
-*
-* Only the formats consumers ask for are materialised. There is NO
-* broker-side `sharp` conversion any more — each consumer reads the exact
-* format it requested. A session is reference-counted by its subscriber set
-* and torn down when the last subscriber of that format leaves.
-*
-* ## fps throttling
-*
-* Throttling is implicit: the ring is latest-wins, so a slow consumer that
-* polls `pullFrameHandles` infrequently simply receives the newest handles
-* and the intervening frames are dropped at the ring (a recycled slot the
-* consumer never read). The optional `maxFps` from `subscribeFrames` is NOT
-* enforced here — it is echoed back to the consumer as a reader-side polling
-* cadence hint.
-*
-* ## Packet feed
-*
-* The plane's decoder sessions are push-mode by default: the broker forwards
-* every video `EncodedPacket` to `pushPacket`. For a pull-mode decoder the
-* broker supplies a `pullModeUrl` and the plane calls `openStream` once the
-* session exists.
-*/
-/**
-* Collapse a hierarchical Moleculer nodeID (`hub/child-abc`) to its owning
-* node (`hub`). Frame-plane co-location only cares about the physical node, not
-* which forked child within it hosts the session.
-*/
-function collapseNodeId(nodeId) {
-	const slash = nodeId.indexOf("/");
-	return slash >= 0 ? nodeId.slice(0, slash) : nodeId;
-}
-/**
-* Decide whether a decoder session created on `decoderNodeId` is co-located
-* with the broker whose local node is `brokerNodeId`.
-*
-* The broker's shm frame ring is NODE-LOCAL: a decoder session on any other
-* node can never deliver frame handles to this broker's consumers, so a
-* mis-placed session must be rejected. Both ids are collapsed (`hub/child`→
-* `hub`) before comparison.
-*
-* A `null` `brokerNodeId` means the broker's own node is unknown — enforcement
-* is skipped (legacy behavior, accept any placement).
-*/
-function isDecoderNodeColocated(brokerNodeId, decoderNodeId) {
-	if (brokerNodeId === null) return true;
-	return collapseNodeId(brokerNodeId) === collapseNodeId(decoderNodeId);
-}
-/** Per-subscription handle-queue capacity. A handle is tiny; 64 absorbs a
-*  burst between two `pullFrameHandles` polls without unbounded growth. */
-var HANDLE_QUEUE_CAPACITY = 64;
-/** Default reader-side cadence hint when a subscriber omits `maxFps`. */
-var DEFAULT_HINT_FPS = 5;
-/** Rolling window for the aggregate `decodeFps` rate, ms. Mirrors the
-*  broker's 2s `inputFps` window so the two stats are comparable. */
-var DECODE_FPS_WINDOW_MS = 2e3;
-/**
-* Keep-warm grace before a decoder session with no subscribers is torn down.
-*
-* Subscribers flap on ~30s cadences (occupancy recheck bursts, detection
-* motion-gating watch↔active, onboard gray gating). Destroying the
-* ffmpeg/VAAPI decode session the instant the last subscriber leaves spawns +
-* destroys a full session every cycle — wasted setup/teardown. Chosen >30s so
-* consecutive bursts and watch↔active flips reuse the warm session, yet a
-* genuinely idle session still frees its ffmpeg within ~a minute.
-*/
-var SESSION_LINGER_MS = 45e3;
-/**
-* Short keep-warm grace for a PURE-OCCUPANCY session (every remaining
-* subscriber is a periodic on-motion occupancy recheck, tag `'occupancy'`).
-*
-* Occupancy rechecks subscribe to decoded frames for ~1s every ~30s. The
-* normal `SESSION_LINGER_MS` (45s) EXCEEDS that ~30s interval, so the linger
-* timer is perpetually cancelled by the next recheck before it can fire — the
-* decoder never tears down and decodes continuously at source-rate to serve a
-* 1s/30s consumer (~30x wasted decode; multiplied across cameras this is the
-* iGPU baseline that saturated the decoder). A pure-occupancy session instead
-* tears down between polls: short enough to fire well before the next ~30s
-* recheck, long enough to absorb the ~1s poll plus minor jitter. Re-dial is
-* cheap on GPU-scale decode and the restream burst re-primes the live edge
-* fast, so on-demand re-arm on the next recheck is fine.
-*/
-var OCCUPANCY_LINGER_MS = 5e3;
-/** Subscription tag emitted by the periodic on-motion occupancy recheck. A
-*  session whose subscribers have only ever carried this tag gets the short
-*  `OCCUPANCY_LINGER_MS` teardown; any other subscriber biases to the long
-*  `SESSION_LINGER_MS` warm linger (interactive viewers, detection, motion). */
-var OCCUPANCY_TAG = "occupancy";
-/**
-* Default retry cooldown after a decoder session lands on a NON-LOCAL node
-* (see `FrameHandlePlaneOptions.sessionRetryCooldownMs`). Long enough to
-* turn a per-packet storm into a slow probe; short enough that the plane
-* recovers within seconds once the local decoder respawns.
-*/
-var SESSION_RETRY_COOLDOWN_MS = 1e4;
-/**
-* Owns the broker's shared-memory frame-handle subscriptions and the
-* per-format `frameSink: 'shm'` decoder sessions that feed them.
-*/
-var FrameHandlePlane = class {
-	decoderApi;
-	logger;
-	resolveStreamInfo;
-	localNodeId;
-	sessionRetryCooldownMs;
-	getSeedPackets;
-	isDebugEnabled;
-	subscriptions = /* @__PURE__ */ new Map();
-	sessions = /* @__PURE__ */ new Map();
-	/** Per-format retry gate set when a session lands on a non-local node:
-	*  `ensureSession` skips creation until the epoch-ms deadline passes. */
-	sessionRetryCooldownUntil = /* @__PURE__ */ new Map();
-	/** In-flight `ensureSession` creation per format. Coalesces concurrent
-	*  same-format callers onto ONE decoder session — without it two callers
-	*  both pass the `sessions.get` check, both `createSession` (two ffmpeg),
-	*  and the second registration orphans the first with no `destroySession`. */
-	sessionCreating = /* @__PURE__ */ new Map();
-	disposed = false;
-	/** Re-entrancy guard for `armPendingSessions` — collapses the per-packet
-	*  `pushPacket` calls into a single in-flight deferred-arm pass. */
-	armInFlight = false;
-	/** DIAG(592): P-frames skipped on an un-bootstrapped session before its
-	*  first live keyframe. Reset when a keyframe bootstraps the session. */
-	unbootstrappedSkips = 0;
-	/** Aggregate decoded-frame rate state — frames fanned out in the current
-	*  rolling window, the window's start epoch, and the last computed fps. */
-	framesInWindow = 0;
-	windowStartMs = Date.now();
-	decodedFps = 0;
-	constructor(options) {
-		this.decoderApi = options.decoderApi;
-		this.logger = options.logger;
-		this.resolveStreamInfo = options.resolveStreamInfo;
-		this.localNodeId = options.localNodeId;
-		this.sessionRetryCooldownMs = options.sessionRetryCooldownMs ?? SESSION_RETRY_COOLDOWN_MS;
-		this.getSeedPackets = options.getSeedPackets;
-		this.isDebugEnabled = options.isDebugEnabled;
-	}
-	/** Number of active handle subscriptions — surfaced for diagnostics. */
-	get subscriberCount() {
-		return this.subscriptions.size;
-	}
-	/**
-	* Moleculer nodeIDs of the decoder providers currently hosting this plane's
-	* `frameSink: 'shm'` sessions. Used by the broker-manager's per-agent
-	* hwaccel-change handler to decide which brokers need a decoder rotation.
-	*/
-	decoderNodeIds() {
-		const ids = [];
-		for (const session of this.sessions.values()) if (session.nodeId) ids.push(session.nodeId);
-		return ids;
-	}
-	/**
-	* Rotate every shm decoder session hosted on `agentNodeId` — destroy and
-	* rebuild it so the new session re-pulls the latest per-agent decoder
-	* preferences (hwaccel backend, …). Subscriptions are preserved: the same
-	* `subscriptionId`s read from the rebuilt session's fresh ring. A no-op for
-	* sessions on other nodes. Returns the number of sessions rotated.
-	*/
-	async rotate(agentNodeId, reason) {
-		if (this.disposed) return 0;
-		let rotated = 0;
-		for (const session of this.sessions.values()) {
-			if ((session.nodeId && session.nodeId.includes("/") ? session.nodeId.split("/")[0] : session.nodeId) !== agentNodeId) continue;
-			this.logger?.info("frame-handle plane: rotating shm decoder session", { meta: {
-				format: session.format,
-				reason,
-				nodeId: session.nodeId
-			} });
-			await this.destroySession(session);
-			let restarted = false;
-			try {
-				restarted = await this.startSessionDecoder(session);
-			} finally {
-				if (!restarted) this.sessions.delete(session.format);
-			}
-			if (restarted) rotated += 1;
-		}
-		return rotated;
-	}
-	/**
-	* Register a frame-handle subscription. Spins up (or reuses) a
-	* `frameSink: 'shm'` decoder session producing `format`. The returned
-	* `subscriptionId` is the handle the consumer passes to
-	* `pullFrameHandles` / `unsubscribe`.
-	*/
-	async subscribe(input) {
-		if (this.disposed) throw new Error("FrameHandlePlane: subscribe after dispose");
-		const subscriptionId = `fh-${(0, node_crypto.randomUUID)()}`;
-		const maxFps = input.maxFps !== void 0 && input.maxFps > 0 ? input.maxFps : DEFAULT_HINT_FPS;
-		const subscription = {
-			id: subscriptionId,
-			format: input.format,
-			maxFps,
-			tag: input.tag ?? "unknown",
-			subscribedAt: Date.now(),
-			queue: new require_dist.RingBuffer(HANDLE_QUEUE_CAPACITY),
-			framesDelivered: 0
-		};
-		this.subscriptions.set(subscriptionId, subscription);
-		await this.ensureSession(input.format, subscriptionId);
-		this.reconcileSessionFps(input.format);
-		this.logger?.info("frame-handle subscription added", { meta: {
-			subscriptionId,
-			format: input.format,
-			tag: subscription.tag,
-			maxFps
-		} });
-		return {
-			subscriptionId,
-			maxFps
-		};
-	}
-	/**
-	* The emit `maxFps` a format's decoder session should run at — the MAX of all
-	* current subscribers' `maxFps` for that format (fallback `DEFAULT_HINT_FPS`
-	* when none, e.g. mid-teardown). The decoder emits at this rate; each
-	* subscriber then down-samples to its own `maxFps` on read (latest-wins).
-	*/
-	computeFormatFps(format) {
-		let max = 0;
-		for (const sub of this.subscriptions.values()) if (sub.format === format && sub.maxFps > max) max = sub.maxFps;
-		return max > 0 ? max : DEFAULT_HINT_FPS;
-	}
-	/**
-	* Recompute a format session's emit `maxFps` after a subscriber joins/leaves
-	* and push it to the live decoder via `updateConfig` when it changed — so the
-	* decoder emits only as fast as the busiest reader needs (saving the
-	* scale+convert+shm-write for frames nobody reads).
-	*/
-	reconcileSessionFps(format) {
-		const session = this.sessions.get(format);
-		if (!session || !session.proxy) return;
-		const target = this.computeFormatFps(format);
-		if (target === session.targetFps) return;
-		session.targetFps = target;
-		session.proxy.updateConfig({ maxFps: target }).catch((err) => {
-			this.logger?.warn("frame-handle plane: updateConfig(maxFps) failed", { meta: {
-				format,
-				maxFps: target,
-				error: require_dist.errMsg(err)
-			} });
-		});
-	}
-	/**
-	* Drain up to `maxCount` `FrameHandle`s for a subscription, latest-wins.
-	* An unknown subscription id returns `[]` (the consumer may have been
-	* torn down concurrently).
-	*/
-	pullHandles(subscriptionId, maxCount) {
-		const subscription = this.subscriptions.get(subscriptionId);
-		if (!subscription) return [];
-		const stale = subscription.queue.size - maxCount;
-		if (stale > 0) subscription.queue.drain(stale);
-		const handles = subscription.queue.drain(maxCount);
-		subscription.framesDelivered += handles.length;
-		return handles;
-	}
-	/**
-	* Release a subscription. When it was the last reader of its format the
-	* underlying decoder session is destroyed (and its shm segment unlinked
-	* by the decoder). Returns `true` when a known subscription was released.
-	*/
-	async unsubscribe(subscriptionId, immediate = false) {
-		const subscription = this.subscriptions.get(subscriptionId);
-		if (!subscription) return false;
-		this.subscriptions.delete(subscriptionId);
-		const session = this.sessions.get(subscription.format);
-		if (session) {
-			session.subscriberIds.delete(subscriptionId);
-			if (session.subscriberIds.size === 0) if (immediate) {
-				this.clearLinger(session);
-				this.sessions.delete(subscription.format);
-				await this.destroySession(session);
-			} else this.scheduleLinger(session);
-			else this.reconcileSessionFps(subscription.format);
-		}
-		this.logger?.info("frame-handle subscription removed", { meta: {
-			subscriptionId,
-			format: subscription.format
-		} });
-		return true;
-	}
-	/**
-	* Arm the keep-warm teardown timer for a session whose last subscriber just
-	* left. Clears any existing timer first (idempotent). On fire it re-checks
-	* `subscriberIds.size === 0` — a subscriber may have returned in the interim,
-	* in which case the timer is a no-op — and only then removes the session and
-	* destroys the decoder. The timer is `unref`'d so a lingering warm session
-	* never keeps the process alive.
-	*/
-	scheduleLinger(session) {
-		this.clearLinger(session);
-		const occupancyOnly = !session.hasNonOccupancySubscriberEver;
-		const lingerMs = occupancyOnly ? OCCUPANCY_LINGER_MS : SESSION_LINGER_MS;
-		this.logger?.debug(occupancyOnly ? "frame-handle plane: short occupancy linger scheduled" : "frame-handle plane: keep-warm linger scheduled", { meta: {
-			format: session.format,
-			lingerMs,
-			occupancyOnly
-		} });
-		const timer = setTimeout(() => {
-			session.lingerTimer = null;
-			if (session.subscriberIds.size > 0) return;
-			this.sessions.delete(session.format);
-			this.destroySession(session).catch(() => {});
-		}, lingerMs);
-		timer.unref?.();
-		session.lingerTimer = timer;
-	}
-	/**
-	* Latch `session.hasNonOccupancySubscriberEver` when the subscription
-	* `subscriptionId` carries any tag other than `OCCUPANCY_TAG`. Called at
-	* every point a subscription is attached to a session so the keep-warm
-	* decision only fast-tears-down sessions that have been PURELY on-demand
-	* occupancy rechecks. Unknown ids (mid-teardown) are ignored.
-	*/
-	noteSessionSubscriberTag(session, subscriptionId) {
-		const subscription = this.subscriptions.get(subscriptionId);
-		if (subscription && subscription.tag !== OCCUPANCY_TAG) session.hasNonOccupancySubscriberEver = true;
-	}
-	/** Cancel a session's pending keep-warm teardown timer, if any. */
-	clearLinger(session) {
-		if (session.lingerTimer) {
-			clearTimeout(session.lingerTimer);
-			session.lingerTimer = null;
-		}
-	}
-	/**
-	* Forward a video `EncodedPacket` to every active shm decoder session.
-	* Push-mode decoders consume this; a pull-mode decoder ignores it (it
-	* reads its own pipe via `openStream`). Audio packets are not forwarded.
-	*
-	* The packet feed doubles as the plane's stream-ready signal: the broker
-	* only calls `pushPacket` once it has a source and the first keyframe has
-	* landed — exactly the point `resolveStreamInfo` starts returning a
-	* descriptor. Each packet therefore triggers `armPendingSessions`, which
-	* re-attempts session creation for any deferred subscription so a lone
-	* first subscriber on a not-yet-started broker self-arms without a
-	* redundant re-`subscribe`.
-	*/
-	pushPacket(packet) {
-		if (this.disposed || packet.type !== "video") return;
-		this.armPendingSessions(packet).catch((err) => {
-			this.logger?.warn("frame-handle plane: arm pending sessions error", { meta: { error: require_dist.errMsg(err) } });
-		});
-		this.feedSessions(packet);
-	}
-	/** Forward a video `EncodedPacket` to every live PUSH-mode shm decoder session. */
-	feedSessions(packet) {
-		for (const session of this.sessions.values()) {
-			if (!session.proxy) continue;
-			if (session.pullMode) continue;
-			if (!session.bootstrapped) {
-				if (!packet.keyframe) {
-					this.unbootstrappedSkips = (this.unbootstrappedSkips ?? 0) + 1;
-					continue;
-				}
-				this.logger?.debug("frame-handle plane: session bootstrapped from live keyframe", { meta: {
-					format: session.format,
-					pFramesSkippedBefore: this.unbootstrappedSkips ?? 0
-				} });
-				this.unbootstrappedSkips = 0;
-				session.bootstrapped = true;
-			}
-			session.proxy.pushPacket(packet).catch((err) => {
-				const msg = require_dist.errMsg(err);
-				this.logger?.warn("frame-handle plane: decoder push error", { meta: {
-					format: session.format,
-					error: msg
-				} });
-				if (msg.includes("unknown sessionId") || msg.includes("Service") || msg.includes("not found")) {
-					this.logger?.info("frame-handle plane: invalidating stale proxy", { meta: { format: session.format } });
-					this.destroySession(session).catch(() => {});
-					this.sessions.delete(session.format);
-				}
-			});
-		}
-	}
-	/**
-	* Re-attempt session creation for every subscription whose format has no
-	* live `FormatSession` yet — the subscriptions whose `startSessionDecoder`
-	* was deferred because the broker had no stream at `subscribe` time. Driven
-	* off the `pushPacket` feed (event-driven, no polling timer); a no-op once
-	* every subscribed format already owns a session.
-	*
-	* `armInFlight` collapses re-entrant calls: `pushPacket` fires per packet,
-	* but `ensureSession` is async — without the guard a burst of packets would
-	* launch overlapping decoder-creation round-trips for the same format.
-	*
-	* `triggerPacket` is the packet whose arrival armed the pass. Because
-	* `ensureSession` is async, the synchronous `feedSessions` in `pushPacket`
-	* runs before the session lands in `this.sessions`, so the triggering packet
-	* would be lost to the new session. `startSessionDecoder` normally bootstraps
-	* it by replaying the broker's keyframe-aligned seed GOP; only when NO seed
-	* was available (no `getSeedPackets`, or the ring held no keyframe yet) is the
-	* session left un-bootstrapped — and then this method hands it the triggering
-	* packet, but ONLY if that packet is a keyframe. A P-frame trigger is left for
-	* `feedSessions` to skip until the first live keyframe, so a push-mode decoder
-	* never sees a slice referencing an unseen param set.
-	*/
-	async armPendingSessions(triggerPacket) {
-		if (this.disposed || this.armInFlight) return;
-		const pending = /* @__PURE__ */ new Map();
-		for (const subscription of this.subscriptions.values()) {
-			if (this.sessions.has(subscription.format)) continue;
-			if (!pending.has(subscription.format)) pending.set(subscription.format, subscription.id);
-		}
-		if (pending.size === 0) return;
-		this.armInFlight = true;
-		try {
-			for (const [format, subscriptionId] of pending) {
-				if (this.disposed) return;
-				await this.ensureSession(format, subscriptionId);
-				const armed = this.sessions.get(format);
-				if (armed?.proxy && !armed.bootstrapped && triggerPacket.keyframe) {
-					armed.bootstrapped = true;
-					armed.proxy.pushPacket(triggerPacket).catch((err) => {
-						this.logger?.warn("frame-handle plane: decoder push error", { meta: {
-							format,
-							error: require_dist.errMsg(err)
-						} });
-					});
-				}
-			}
-		} finally {
-			this.armInFlight = false;
-		}
-	}
-	/**
-	* Aggregate decoded-frame rate across every `frameSink: 'shm'` session in
-	* this plane, frames/s. Each `fanoutHandle` call is one decoded frame
-	* delivered into the plane; the rate is recomputed over a rolling
-	* `DECODE_FPS_WINDOW_MS` window. Returns the last computed value between
-	* window rolls, and `0` while no session is producing.
-	*/
-	decodeFps() {
-		this.rollDecodeFpsWindow();
-		return this.decodedFps;
-	}
-	/**
-	* Roll the decoded-fps window when it has elapsed: convert frames seen in
-	* the window into a per-second rate, then reset the counter. Called both
-	* on every fanout and on every `decodeFps()` read so a stalled session
-	* (no fanout) decays its rate to `0` rather than reporting a stale value.
-	*/
-	rollDecodeFpsWindow() {
-		const now = Date.now();
-		const windowMs = now - this.windowStartMs;
-		if (windowMs < DECODE_FPS_WINDOW_MS) return;
-		this.decodedFps = this.framesInWindow / windowMs * 1e3;
-		this.framesInWindow = 0;
-		this.windowStartMs = now;
-	}
-	/** Diagnostic snapshot of every active frame-handle subscription. */
-	listSubscribers() {
-		return [...this.subscriptions.values()].map((s) => ({
-			tag: s.tag,
-			subscribedAt: s.subscribedAt,
-			maxFps: s.maxFps,
-			framesDelivered: s.framesDelivered
-		}));
-	}
-	/**
-	* Force-release every subscription whose tag matches `tag`. Returns the
-	* number released. Decoder sessions wind down when their last subscriber
-	* leaves, same as a normal `unsubscribe`.
-	*/
-	async killByTag(tag) {
-		const victims = [...this.subscriptions.values()].filter((s) => s.tag === tag).map((s) => s.id);
-		for (const id of victims) await this.unsubscribe(id, true);
-		return victims.length;
-	}
-	/** Tear down every subscription + decoder session. Idempotent. */
-	async dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.subscriptions.clear();
-		const sessions = [...this.sessions.values()];
-		this.sessions.clear();
-		await Promise.all(sessions.map((s) => this.destroySession(s)));
-	}
-	/**
-	* Ensure a `frameSink: 'shm'` decoder session for `format` exists and add
-	* `subscriptionId` to its reader set. Reuses the session when one already
-	* runs for that format.
-	*
-	* When a session is created fresh, its reader set is seeded with EVERY
-	* subscription currently reading `format`, not just `subscriptionId` — a
-	* deferred-arm pass (`armPendingSessions`) may create the session long
-	* after several subscriptions of that format have registered, and the
-	* session is reference-counted by `subscriberIds`. Seeding only the one id
-	* would let an `unsubscribe` of that id tear the session down while its
-	* sibling subscriptions still read it.
-	*/
-	async ensureSession(format, subscriptionId) {
-		const existing = this.sessions.get(format);
-		if (existing) {
-			this.clearLinger(existing);
-			existing.subscriberIds.add(subscriptionId);
-			this.noteSessionSubscriberTag(existing, subscriptionId);
-			return;
-		}
-		const inflight = this.sessionCreating.get(format);
-		if (inflight) {
-			await inflight;
-			const session = this.sessions.get(format);
-			if (session) {
-				session.subscriberIds.add(subscriptionId);
-				this.noteSessionSubscriberTag(session, subscriptionId);
-			}
-			return;
-		}
-		if (Date.now() < (this.sessionRetryCooldownUntil.get(format) ?? 0)) return;
-		const creation = (async () => {
-			const subscriberIds = new Set([subscriptionId]);
-			for (const subscription of this.subscriptions.values()) if (subscription.format === format) subscriberIds.add(subscription.id);
-			const session = {
-				format,
-				proxy: null,
-				nodeId: null,
-				subscriberIds,
-				bootstrapped: false,
-				pullMode: false,
-				targetFps: this.computeFormatFps(format),
-				lingerTimer: null,
-				hasNonOccupancySubscriberEver: false
-			};
-			for (const id of subscriberIds) this.noteSessionSubscriberTag(session, id);
-			let started = false;
-			try {
-				started = await this.startSessionDecoder(session);
-			} catch (err) {
-				this.sessionRetryCooldownUntil.set(format, Date.now() + this.sessionRetryCooldownMs);
-				throw err;
-			}
-			if (started) this.sessions.set(format, session);
-		})();
-		this.sessionCreating.set(format, creation);
-		try {
-			await creation;
-		} finally {
-			this.sessionCreating.delete(format);
-		}
-	}
-	/**
-	* Create the `frameSink: 'shm'` decoder for a `FormatSession` and start
-	* draining its handle queue. Mutates `session.proxy` / `session.nodeId` in
-	* place so a `rotate()` can rebuild a registered session without disturbing
-	* its `subscriberIds`. Returns `false` when no stream / unsupported codec
-	* means no decoder could be created.
-	*/
-	async startSessionDecoder(session) {
-		const { format } = session;
-		const info = this.resolveStreamInfo();
-		if (!info) {
-			this.logger?.info("frame-handle plane: no stream — session deferred", { meta: { format } });
-			return false;
-		}
-		if (!await this.decoderApi.supportsCodec({ codec: info.codec })) {
-			this.logger?.warn("frame-handle plane: codec unsupported — session skipped", { meta: {
-				format,
-				codec: info.codec
-			} });
-			return false;
-		}
-		const targetFps = this.computeFormatFps(format);
-		session.targetFps = targetFps;
-		const { sessionId, nodeId } = await this.decoderApi.createSession({
-			codec: info.codec,
-			maxFps: targetFps,
-			outputFormat: format,
-			scale: 1,
-			frameSink: "shm",
-			...info.numericDeviceId !== void 0 ? { deviceId: info.numericDeviceId } : {},
-			tag: `${info.tag}:shm:${format}`,
-			...this.isDebugEnabled?.() ? { debug: true } : {}
-		});
-		if (!isDecoderNodeColocated(this.localNodeId, nodeId)) {
-			this.sessionRetryCooldownUntil.set(format, Date.now() + this.sessionRetryCooldownMs);
-			this.logger?.warn("frame-handle plane: decoder session landed on a non-local node — destroying (shm ring is node-local)", { meta: {
-				format,
-				requestedNode: this.localNodeId,
-				gotNode: nodeId,
-				sessionId,
-				retryInMs: this.sessionRetryCooldownMs
-			} });
-			await this.decoderApi.destroySession({ sessionId }).catch((err) => {
-				this.logger?.warn("frame-handle plane: failed to destroy mis-placed decoder session", { meta: {
-					format,
-					sessionId,
-					error: require_dist.errMsg(err)
-				} });
-			});
-			return false;
-		}
-		this.sessionRetryCooldownUntil.delete(format);
-		const proxy = new DecoderSessionProxy(this.decoderApi, sessionId);
-		session.proxy = proxy;
-		session.nodeId = nodeId;
-		session.bootstrapped = false;
-		session.pullMode = false;
-		proxy.startHandlePolling((handle) => {
-			this.fanoutHandle(format, handle);
-		}).catch((err) => {
-			this.logger?.warn("frame-handle plane: handle polling error", { meta: {
-				format,
-				error: require_dist.errMsg(err)
-			} });
-		});
-		if (info.pullModeUrl) {
-			session.pullMode = true;
-			session.bootstrapped = true;
-			proxy.openStream(info.pullModeUrl).catch((err) => {
-				this.logger?.error("frame-handle plane: pull-mode openStream failed", { meta: {
-					format,
-					error: require_dist.errMsg(err)
-				} });
-			});
-			this.logger?.info("frame-handle plane: shm decoder session created (pull-mode RTSP)", { meta: {
-				format,
-				codec: info.codec,
-				sessionId,
-				nodeId,
-				pullModeUrl: info.pullModeUrl
-			} });
-			return true;
-		}
-		const seed = this.getSeedPackets?.() ?? [];
-		if (seed.length > 0) {
-			for (const seedPacket of seed) await proxy.pushPacket(seedPacket).catch((err) => {
-				this.logger?.warn("frame-handle plane: seed-replay push error", { meta: {
-					format,
-					error: require_dist.errMsg(err)
-				} });
-			});
-			session.bootstrapped = true;
-			this.logger?.debug("frame-handle plane: session bootstrapped from seed GOP", { meta: {
-				format,
-				seedPackets: seed.length
-			} });
-		}
-		this.logger?.info("frame-handle plane: shm decoder session created", { meta: {
-			format,
-			codec: info.codec,
-			sessionId,
-			nodeId
-		} });
-		return true;
-	}
-	/** Push one decoded `FrameHandle` to every subscription of `format`. */
-	fanoutHandle(format, handle) {
-		this.rollDecodeFpsWindow();
-		this.framesInWindow += 1;
-		for (const subscription of this.subscriptions.values()) {
-			if (subscription.format !== format) continue;
-			subscription.queue.push(handle);
-		}
-	}
-	/** Destroy a decoder session, swallowing teardown errors. */
-	async destroySession(session) {
-		this.clearLinger(session);
-		const proxy = session.proxy;
-		session.proxy = null;
-		session.nodeId = null;
-		if (!proxy) return;
-		try {
-			await proxy.destroy();
-		} catch (err) {
-			this.logger?.warn("frame-handle plane: session destroy failed", { meta: {
-				format: session.format,
-				error: require_dist.errMsg(err)
-			} });
-		}
-	}
-};
-//#endregion
 //#region src/stream-broker/stream-broker/g711-mulaw.ts
 /**
 * G.711 µ-law encoder — converts 16-bit signed PCM samples to µ-law (ITU-T G.711).
@@ -12866,8 +12042,8 @@ var MAX_RECONNECT_DELAY_MS = 3e4;
 var SUSPEND_GRACE_MS = 5e3;
 /**
 * Grace window before an idle audio-codec decode session is torn down
-* after the last audio consumer detaches. Mirrors the frame-handle /
-* suspend occupancy-linger pattern: a brief gap between consumers (e.g.
+* after the last audio consumer detaches. Mirrors the suspend linger
+* pattern: a brief gap between consumers (e.g.
 * a WebRTC renegotiation or an analyzer re-subscribe) must not thrash
 * the upstream decode session create/destroy.
 */
@@ -12905,8 +12081,6 @@ var StreamBroker = class StreamBroker {
 	* falls back to the source passed to `start()`.
 	*/
 	sourceProvider = null;
-	/** Resolver for this broker's own RTSP restream URL — see `setRestreamUrlResolver`. */
-	restreamUrlResolver = null;
 	/**
 	* Manager-supplied notifier that asks the publishing addon to
 	* refresh its loopback transport (e.g. re-run
@@ -12931,25 +12105,8 @@ var StreamBroker = class StreamBroker {
 	lastKickAt = 0;
 	/** Detected or configured codec — persists across reconnects */
 	detectedCodec;
-	/**
-	* The shared-memory frame-handle surface (Phase 5 / D9) — the broker's sole
-	* decoded-frame path. Lazily created on the first `subscribeFrameHandles`
-	* call; owns the per-format `frameSink: 'shm'` decoder sessions a handle
-	* consumer reads from. `null` until a consumer subscribes.
-	*/
-	frameHandlePlane = null;
-	/** One-shot latch for the "seed ring not filled" line — see `pushEncodedPacket`. */
-	seedRingSkipLogged = false;
-	decoderApi;
 	audioCodecApi;
 	logger;
-	/**
-	* This broker's OWN local Moleculer node id, threaded from the manager
-	* (`ctx.kernel.localNodeId`). Passed to the `FrameHandlePlane` so it can
-	* reject decoder sessions that land on a different node (the shm frame ring
-	* is node-local). `null` = unknown → co-location enforcement skipped.
-	*/
-	localNodeId;
 	startedAt = Date.now();
 	/**
 	* How many times `start()` has actually dialed. `> 0` at dial time means the
@@ -13041,9 +12198,9 @@ var StreamBroker = class StreamBroker {
 	* The lazy branch is re-entered on every materialize poll tick, so stopping
 	* the pump is not enough on its own: the very next tick would re-open a
 	* window that real bytes have already closed, and the consumer would get a
-	* still picture painted over live video every second. Reset exactly where
-	* `firstKeyframeReceived` is — broker stop and suspend — so a battery camera
-	* that goes back to sleep gets its sentry again on the next wake.
+	* still picture painted over live video every second. Reset on broker stop
+	* and suspend, so a battery camera that goes back to sleep gets its sentry
+	* again on the next wake.
 	*/
 	sentryWindowClosed = false;
 	reconnectDelayMs = INITIAL_RECONNECT_DELAY_MS;
@@ -13221,17 +12378,6 @@ var StreamBroker = class StreamBroker {
 	pipeServer;
 	rtspRestreamer;
 	preBuffer;
-	/**
-	* Keyframe-aligned GOP of the EXACT packets fed to the decoder plane (i.e.
-	* param-set prepended). Replayed to a freshly-armed shm decoder session so it
-	* initialises on a keyframe (SPS/PPS) instead of the next live P-frame — the
-	* decoder cold-start fix for push-mode sessions. Populated for ALL source
-	* types (unlike `preBuffer`, which push-only sources fill for the WebRTC
-	* late-join path): an rfc4571 Reolink source has an EMPTY `preBuffer`, so this
-	* is the only GOP available to seed its decoder. `getPackets()` returns just
-	* the current GOP (from the last keyframe), so a modest retention suffices.
-	*/
-	decoderSeedBuffer;
 	encodedCallbacks = /* @__PURE__ */ new Map();
 	/**
 	* Source-RTP video subscribers — receive raw on-wire RTP bytes
@@ -13270,13 +12416,6 @@ var StreamBroker = class StreamBroker {
 	* so it gets a scoped logger child.
 	*/
 	audioChunkPlane;
-	/**
-	* Gate for feeding encoded packets to the decoder: H.264/H.265 decoders
-	* need the SPS/PPS carried in the first keyframe to initialise, so the
-	* broker withholds packets from the shm frame plane until the first
-	* keyframe arrives.
-	*/
-	firstKeyframeReceived = false;
 	/** Timer for push-mode stall detection. */
 	pushStallTimer;
 	/**
@@ -13462,20 +12601,11 @@ var StreamBroker = class StreamBroker {
 	* (`isClampedByBytes`).
 	*/
 	static CLIP_RING_MAX_BYTES = 16 * 1024 * 1024;
-	/**
-	* Retention for the decoder-seed GOP ring. Only ever needs to hold the
-	* current GOP (a fresh keyframe evicts the previous GOP on read), so a few
-	* seconds covers every realistic keyframe interval; cameras with a GOP longer
-	* than this fall back to the plane's live-keyframe bootstrap.
-	*/
-	static DECODER_SEED_BUFFER_SEC = 6;
-	constructor(deviceId, decoderApi, logger, audioCodecApi, localNodeId) {
+	constructor(deviceId, logger, audioCodecApi) {
 		this.deviceId = deviceId;
 		this.numericDeviceId = deviceIdFromBrokerId$1(deviceId);
-		this.decoderApi = decoderApi;
 		this.audioCodecApi = audioCodecApi ?? null;
 		this.logger = logger;
-		this.localNodeId = localNodeId ?? null;
 		this.pipeServer = new StreamPipeServer(logger?.child("pipe-server"));
 		this.rtspRestreamer = new RtspRestreamer(deviceId);
 		if (logger) this.rtspRestreamer.setLogger(logger.child("rtsp"));
@@ -13488,7 +12618,6 @@ var StreamBroker = class StreamBroker {
 			};
 		});
 		this.preBuffer = new EncodedRingBuffer(StreamBroker.DEFAULT_PRE_BUFFER_SEC);
-		this.decoderSeedBuffer = new EncodedRingBuffer(StreamBroker.DECODER_SEED_BUFFER_SEC);
 		this.audioChunkPlane = new AudioChunkPlane(logger?.child("audio-chunk-plane"), () => this.checkDemand());
 		this.rtspRestreamer.onSessionCountChanged(() => this.checkDemand());
 		this.pipeServer.onClientCountChanged(() => this.checkDemand());
@@ -13535,22 +12664,6 @@ var StreamBroker = class StreamBroker {
 		};
 	}
 	/**
-	* Inject a manager-owned resolver for this broker's OWN RTSP restream URL
-	* (`rtsp://127.0.0.1:<port>/<token>[/muted]`). When the source is an RTP
-	* source ({@link isRtpSource}), the frame-handle decoder decodes via PULL
-	* mode from this restream instead of the broker's hand-depacketized AnnexB
-	* push feed — ffmpeg's own RTSP/RTP demuxer does the FU-A reassembly, which
-	* is robust where the AnnexB depacketizer chokes on heavily-fragmented 4K
-	* NALs (Reolink rfc4571 produced 0 decoded frames on the push path; the same
-	* stream decodes at full fps through the RTSP restream): RTP is passed
-	* through to the consumer's demuxer.
-	* Returns `null` before a restream token exists → falls back to the
-	* push path.
-	*/
-	setRestreamUrlResolver(resolver) {
-		this.restreamUrlResolver = resolver;
-	}
-	/**
 	* Inject where the "ffmpeg parser" ingress ({@link startFfmpegSourceReader})
 	* reads the node's pinned ffmpeg: the manager's live config, asked per dial.
 	*/
@@ -13885,18 +12998,11 @@ var StreamBroker = class StreamBroker {
 			clearTimeout(this.pushStallTimer);
 			this.pushStallTimer = void 0;
 		}
-		if (this.frameHandlePlane) {
-			const plane = this.frameHandlePlane;
-			this.frameHandlePlane = null;
-			await plane.dispose();
-		}
 		await this.pipeServer.stop();
 		this.rtspRestreamer.destroy();
 		this.preBuffer.clear();
-		this.decoderSeedBuffer.clear();
 		this.clipBuffer?.clear();
 		this.pendingParamNals = [];
-		this.firstKeyframeReceived = false;
 		this.encodedCallbacks.clear();
 		this.audioChunkPlane.dispose();
 	}
@@ -14147,7 +13253,6 @@ var StreamBroker = class StreamBroker {
 	hasLiveIntent() {
 		if (this.encodedCallbacks.size > 0) return true;
 		if (this.rtpVideoCallbacks.size > 0) return true;
-		if ((this.frameHandlePlane?.subscriberCount ?? 0) > 0) return true;
 		if (this.audioChunkPlane.subscriberCount > 0) return true;
 		if (this.rtspRestreamer.getLiveIntentSessionCount() > 0) return true;
 		if (this.pipeServer.getClientCount() > 0) return true;
@@ -14157,9 +13262,9 @@ var StreamBroker = class StreamBroker {
 	}
 	/**
 	* True when at least one consumer needs DECODED audio. The audio-specific
-	* subset of {@link hasDemand} — deliberately excludes the video
-	* frame-handle plane so a video-only viewer never spins up the
-	* AAC/Opus decode chain. `encodedCallbacks` covers WebRTC (its G.711
+	* subset of {@link hasDemand} — deliberately excludes video-only
+	* consumers so a video-only viewer never spins up the AAC/Opus decode
+	* chain. `encodedCallbacks` covers WebRTC (its G.711
 	* egress needs decoded PCM); `audioChunkPlane` covers the analyzer.
 	*/
 	hasAudioConsumer() {
@@ -14359,9 +13464,7 @@ var StreamBroker = class StreamBroker {
 		this.sentryWindowClosed = false;
 		this.reconcilePrestreamWindow();
 		this.preBuffer.clear();
-		this.decoderSeedBuffer.clear();
 		this.clipBuffer?.clear();
-		this.firstKeyframeReceived = false;
 		this.pendingParamNals = [];
 		this.rtspRestreamer.resetStreamState();
 		this.totalBytes = 0;
@@ -14499,61 +13602,8 @@ var StreamBroker = class StreamBroker {
 		if (packet.type === "video") {
 			this.pipeServer.broadcast(packet.data);
 			if (!this.rtspRestreamer.rtpPassthroughMode) this.rtspRestreamer.pushPacket(packet);
-			if (!this.firstKeyframeReceived && packet.keyframe && packet.isPlaceholder !== true) {
-				this.firstKeyframeReceived = true;
-				this.logger?.info("First keyframe received — decoder can start");
-			}
-		}
-		if (packet.type === "video" && this.firstKeyframeReceived && packet.isPlaceholder !== true) {
-			const plane = this.frameHandlePlane;
-			if (plane) {
-				const decoderPacket = this.decoderPacketWithParamSets(packet);
-				this.decoderSeedBuffer.push(decoderPacket);
-				plane.pushPacket(decoderPacket);
-			} else if (!this.seedRingSkipLogged) {
-				this.seedRingSkipLogged = true;
-				this.logger?.info("decoder seed ring not filled — no frame-handle consumer on this broker", {
-					tags: { deviceId: this.numericDeviceId },
-					meta: { seedSec: StreamBroker.DECODER_SEED_BUFFER_SEC }
-				});
-			}
 		}
 	}
-	/**
-	* Return the packet to feed the decoder plane, prepending the SDP-harvested
-	* SPS/PPS to a keyframe that lacks them in-band.
-	*
-	* The plane seeds a freshly-armed decoder session with the SINGLE keyframe
-	* packet that triggered the arm (`armPendingSessions`), so the parameter sets
-	* MUST travel inside that same packet — a separate param-set packet pushed
-	* just before it reaches only already-live sessions and is lost on the
-	* arming one. Unlike the encoded-subscriber path (`emitSdpParamSetsTo`), the
-	* decoder plane is otherwise never handed `sdpParameterSets`. Cameras that
-	* ship parameter sets ONLY in the SDP (Reolink high-profile native streams)
-	* therefore starve the `ffmpeg -i pipe:0` decoder of SPS/PPS, which loops
-	* `non-existing PPS → no frame` and produces zero decoded frames (verified
-	* live on device 592: WebRTC worked, detection decoded nothing). Only
-	* keyframes actually missing the sets are rewritten — well-behaved cameras
-	* are returned untouched — and the check runs per keyframe so a decoder
-	* restart mid-stream re-primes on the next IDR. The returned object is a
-	* fresh copy; the original `packet` fanned out to the other consumers above
-	* (WebRTC, restreamers, pre-buffer) is never mutated.
-	*/
-	decoderPacketWithParamSets(packet) {
-		if (!packet.keyframe) return packet;
-		const paramSets = this.sdpParameterSets;
-		if (!paramSets || paramSets.length === 0) return packet;
-		if (annexBHasParameterSets(packet.data, packet.codec)) return packet;
-		if (this.streamingDebug || CH_RTP.on) this.logger?.info("Prepending SDP param sets to decoder keyframe (in-band SPS/PPS absent)", { meta: {
-			codec: packet.codec,
-			psCount: paramSets.length,
-			keyframeBytes: packet.data.length
-		} });
-		return {
-			...packet,
-			data: Buffer.concat([concatParameterSetsAnnexB(paramSets), packet.data])
-		};
-	}
 	onEncodedData(callback, attribution = UNKNOWN_ATTRIBUTION) {
 		this.subscriberIdCounter += 1;
 		const entry = {
@@ -14832,7 +13882,7 @@ var StreamBroker = class StreamBroker {
 	*
 	* Every ring this broker owns is sized from it, each fed by the source type
 	* it belongs to: the source-RTP ring (RTSP cameras, the history a join burst
-	* is cut from), the Annex-B `preBuffer` (push sources), and the decoder seed.
+	* is cut from) and the Annex-B `preBuffer` (push sources).
 	* That is the correction this record exists for — the seconds used to size
 	* ONLY the Annex-B ring, which is never fed for an RTP source, so on every
 	* warm camera in this fleet the configured seconds retained nothing while two
@@ -14842,10 +13892,7 @@ var StreamBroker = class StreamBroker {
 		const next = require_restream_intent.prebufferRetentionMs(config);
 		this.setPreBufferEnabled(config.enabled);
 		this.setPreBufferDuration(config.seconds);
-		if (next === this.prebufferMs) return;
 		this.prebufferMs = next;
-		const seedSec = Math.max(StreamBroker.DECODER_SEED_BUFFER_SEC, Math.ceil(next / 1e3) + 2);
-		this.decoderSeedBuffer.setDuration(seedSec);
 	}
 	/**
 	* How far back the ring is kept — the prebuffer, and nothing else.
@@ -14878,33 +13925,6 @@ var StreamBroker = class StreamBroker {
 	getPreRollBudget() {
 		return preRollBudgetBytes(this.getPreRollRetentionMs(), this.bitrateKbps);
 	}
-	/**
-	* The seed replayed into a freshly-armed PUSH-mode decoder session.
-	*
-	* The current GOP (`getPackets()`) while pre-roll is off — today's behaviour —
-	* and the same keyframe-aligned pre-roll window otherwise, cut from the seed
-	* ring's whole retention rather than from its last keyframe. This is the
-	* push/Annex-B counterpart of {@link getRtpPreRollBuffer}: RTP sources decode
-	* in PULL mode off the restream and take their pre-roll as the join burst,
-	* push sources are fed packet by packet and take it here. One selector serves
-	* both, so a fix to the boundary cannot land on only one plane.
-	*/
-	getDecoderSeedPackets() {
-		if (this.prebufferMs <= 0) return this.decoderSeedBuffer.getPackets();
-		const all = this.decoderSeedBuffer.getAllPackets();
-		if (all.length === 0) return [];
-		const newestPts = all[all.length - 1].pts;
-		const marks = [];
-		for (let i = 0; i < all.length; i++) {
-			const packet = all[i];
-			if (packet.keyframe && packet.type === "video") marks.push({
-				index: i,
-				ageMs: newestPts - packet.pts
-			});
-		}
-		const selection = selectPreRollStart(marks, this.prebufferMs);
-		return selection.startIndex < 0 ? [] : all.slice(selection.startIndex);
-	}
 	/** Retained keyframe AUs as ages in ms of media time behind `newestTs`. */
 	rtpPreRollMarks(newestTs) {
 		return this.rtpRingKeyframeMarks.map((mark) => ({
@@ -15038,7 +14058,7 @@ var StreamBroker = class StreamBroker {
 	* does NOT re-emit EncodedPackets; it only derives the per-packet
 	* keyframe/param-set flags the pre-buffer capture needs (via a
 	* flag-only depacketizer that never touches the AnnexB plane), keeping
-	* the AnnexB consumers (decoder, restreamer) single-fed by the provider.
+	* the AnnexB consumers (pipe, restreamer) single-fed by the provider.
 	*
 	* The pre-buffer is captured even with zero subscribers attached — a
 	* viewer that connects mid-GOP must be able to replay the GOP that
@@ -15066,7 +14086,7 @@ var StreamBroker = class StreamBroker {
 	* EncodedPackets via `handleDepacketizedNal`), this callback ONLY sets
 	* `_lastNalKeyframe`/`_lastNalParamSet` — the push provider owns the
 	* AnnexB plane through `pushEncodedPacket`, so re-emitting here would
-	* double-feed the decoder/restreamer. push-rtp has no SDP `onVideoTrack`,
+	* double-feed the pipe/restreamer. push-rtp has no SDP `onVideoTrack`,
 	* so the codec comes from the source declaration (`detectedCodec`, seeded
 	* in `start()`). Dropped on teardown (`resetRtpPipeline`) so a redial
 	* starts with clean FU reassembly state.
@@ -15140,82 +14160,11 @@ var StreamBroker = class StreamBroker {
 		if (released) this.checkDemand();
 		return released;
 	}
-	/**
-	* Resolve the stream descriptor the `FrameHandlePlane` needs to create a
-	* `frameSink: 'shm'` decoder session — codec, numeric device id, log tag,
-	* and (for a pull-mode decoder) the local pipe URL. Returns `null` before
-	* the broker has a source.
-	*/
-	resolveFrameHandleStreamInfo() {
-		const codec = this.detectedCodec ?? this.source?.videoCodec;
-		if (!codec || !this.source) return null;
-		const slash = this.deviceId.indexOf("/");
-		const numericDeviceId = slash >= 0 ? Number.parseInt(this.deviceId.slice(0, slash), 10) : Number.parseInt(this.deviceId, 10);
-		const pullModeUrl = this.isRtpSource() ? this.restreamUrlResolver?.() ?? null : null;
-		return {
-			codec,
-			...Number.isFinite(numericDeviceId) ? { numericDeviceId } : {},
-			tag: `broker:${this.deviceId}`,
-			pullModeUrl
-		};
-	}
-	/** Lazily construct the frame-handle plane, returning `null` with no decoder. */
-	ensureFrameHandlePlane() {
-		if (this.frameHandlePlane) return this.frameHandlePlane;
-		if (!this.decoderApi) {
-			this.logger?.warn("subscribeFrameHandles: no decoder API — frame handles unavailable");
-			return null;
-		}
-		this.frameHandlePlane = new FrameHandlePlane({
-			decoderApi: this.decoderApi,
-			logger: this.logger?.child("frame-handle-plane"),
-			resolveStreamInfo: () => this.resolveFrameHandleStreamInfo(),
-			localNodeId: this.localNodeId,
-			getSeedPackets: () => this.getDecoderSeedPackets(),
-			isDebugEnabled: () => this.streamingDebug
-		});
-		return this.frameHandlePlane;
-	}
-	/**
-	* Subscribe to this broker's shared-memory frame-handle stream — the broker's
-	* decoded-frame surface. The broker spins up (or reuses) a `frameSink: 'shm'`
-	* decoder session producing `input.format` and returns a `subscriptionId`
-	* the consumer polls via `pullFrameHandles`. fps throttling is implicit
-	* (latest-wins ring reads); `input.maxFps` is echoed as a cadence hint.
-	*/
-	async subscribeFrameHandles(input) {
-		const plane = this.ensureFrameHandlePlane();
-		if (!plane) throw new Error("stream-broker: no decoder available for frame-handle subscription");
-		const { subscriptionId, maxFps } = await plane.subscribe({
-			format: input.format,
-			maxFps: input.maxFps,
-			tag: input.tag
-		});
-		this.checkDemand();
-		return {
-			subscriptionId,
-			maxFps
-		};
-	}
-	/** Drain up to `maxCount` `FrameHandle`s for a frame-handle subscription. */
-	pullFrameHandles(subscriptionId, maxCount) {
-		return this.frameHandlePlane?.pullHandles(subscriptionId, maxCount) ?? [];
-	}
-	/** Release a frame-handle subscription. Returns `true` when it existed. */
-	async unsubscribeFrameHandles(subscriptionId) {
-		const plane = this.frameHandlePlane;
-		if (!plane) return false;
-		const released = await plane.unsubscribe(subscriptionId);
-		if (released && plane.subscriberCount === 0) this.checkDemand();
-		return released;
-	}
 	getStats() {
 		return {
 			status: this._suspended ? "idle" : this._status,
 			inputFps: this.encodedInputFps,
-			decodeFps: this.frameHandlePlane?.decodeFps() ?? 0,
 			encodedSubscribers: this.encodedCallbacks.size + this.rtpVideoCallbacks.size,
-			decodedSubscribers: this.frameHandlePlane?.subscriberCount ?? 0,
 			uptimeMs: Date.now() - this.startedAt,
 			bitrateKbps: this.bitrateKbps,
 			idrIntervalMs: this.idrIntervalMs,
@@ -15227,7 +14176,6 @@ var StreamBroker = class StreamBroker {
 			preBufferSec: this.preBuffer.getDuration(),
 			preBufferMs: this.preBuffer.getBufferedDurationMs(),
 			preBufferPackets: this.preBuffer.getPacketCount(),
-			decoderNodeId: this.frameHandlePlane?.decoderNodeIds()[0] ?? null,
 			audio: this.audioTrackInfo ?? null,
 			audioMuted: this.audioMuted,
 			audioMutedDropped: this.audioMutedDropped
@@ -15235,8 +14183,8 @@ var StreamBroker = class StreamBroker {
 	}
 	/**
 	* Per-broker consumer inventory (Phase 10). Returns the live subscriber
-	* list grouped by transport — every RTSP client, decoded-frame
-	* subscriber, and audio-chunk subscriber. Used by the admin UI's
+	* list grouped by transport — every RTSP client, encoded subscriber and
+	* audio-chunk subscriber. Used by the admin UI's
 	* Streams tab and by operators diagnosing "phantom" holders keeping a
 	* broker open.
 	*/
@@ -15270,13 +14218,6 @@ var StreamBroker = class StreamBroker {
 		});
 		return {
 			rtsp: this.rtspRestreamer.listSessionInfos(),
-			decoded: (this.frameHandlePlane?.listSubscribers() ?? []).map((s) => ({
-				tag: s.tag,
-				subscribedAt: s.subscribedAt,
-				maxFps: s.maxFps,
-				framesDelivered: s.framesDelivered,
-				framesDropped: 0
-			})),
 			audio: this.audioChunkPlane.listSubscribers().map((s) => ({
 				tag: s.tag,
 				subscribedAt: s.subscribedAt,
@@ -15290,33 +14231,12 @@ var StreamBroker = class StreamBroker {
 	/**
 	* Force-disconnect a single consumer. Matches by channel:
 	*   - `rtsp`: by `sessionId` (calls `RtspRestreamer.killSession`).
-	*   - `decoded`: by `tag` — releases every shm frame-handle subscription
-	*     whose tag matches (the plane winds the decoder session down once its
-	*     last subscriber leaves).
 	*   - `audio`: by `tag` — drops every audio subscriber whose tag matches,
 	*     then re-evaluates demand.
 	* Returns `true` when at least one consumer was dropped.
 	*/
 	killClient(channel, handle) {
 		if (channel === "rtsp") return this.rtspRestreamer.killSession(handle);
-		if (channel === "decoded") {
-			const plane = this.frameHandlePlane;
-			if (!plane) return false;
-			if (!plane.listSubscribers().some((s) => s.tag === handle)) return false;
-			plane.killByTag(handle).then((killed) => {
-				this.logger?.info("frame-handle subscribers force-disconnected", { meta: {
-					handle,
-					killed
-				} });
-				this.checkDemand();
-			}).catch((err) => {
-				this.logger?.warn("frame-handle killByTag failed", { meta: {
-					handle,
-					error: require_dist.errMsg(err)
-				} });
-			});
-			return true;
-		}
 		const killed = this.audioChunkPlane.killByTag(handle);
 		if (killed === 0) return false;
 		this.logger?.info("audio subscribers force-disconnected", { meta: {
@@ -15570,7 +14490,7 @@ var StreamBroker = class StreamBroker {
 	* Shared RTP-stream callback factory. Used by both the native RTSP
 	* reader and the RFC 4571 reader — they ingest RTP from different
 	* transports but the broker's downstream pipeline (depacketize →
-	* AnnexB → prebuffer / pipe / decoder / restream) is identical.
+	* AnnexB → prebuffer / pipe / restream) is identical.
 	*
 	* `label` is the source-tag we attach to log messages so it's clear
 	* which transport surfaced the event. `onTerminate` is the
@@ -15804,7 +14724,7 @@ var StreamBroker = class StreamBroker {
 	/**
 	* Handle a complete NAL from the RTP depacketizer.
 	* Converts to EncodedPacket and feeds all Annex-B consumers
-	* (prebuffer, pipe server, decoder, restreamers).
+	* (prebuffer, pipe server, restreamers).
 	*
 	* Called synchronously from processPacket — sets _lastNalKeyframe and
 	* _lastNalParamSet so the onVideoRtp callback can forward them to the
@@ -15814,7 +14734,7 @@ var StreamBroker = class StreamBroker {
 	* Pending parameter-set NALs (SPS/PPS for H.264, VPS/SPS/PPS for H.265).
 	* Cameras emit these as separate RTP packets before the IDR/IRAP frame.
 	* We buffer them here and prepend to the next VCL NAL so downstream
-	* consumers (WebRTC, prebuffer, decoder) receive complete access units
+	* consumers (WebRTC, prebuffer, restream) receive complete access units
 	* with a single `EncodedPacket` that contains SPS+PPS+IDR together.
 	*/
 	pendingParamNals = [];
@@ -16171,32 +15091,6 @@ var StreamBroker = class StreamBroker {
 			this._status = "error";
 		}, PUSH_STALL_TIMEOUT_MS);
 	}
-	/**
-	* Moleculer nodeID of a decoder provider hosting one of this broker's shm
-	* frame-plane sessions. `null` when the plane has no session. Used by the
-	* broker-manager's `rotateDecodersOnNode` to drop only the sessions
-	* affected by a per-agent event (e.g. an hwaccel override change).
-	*/
-	getDecoderNodeId() {
-		return this.frameHandlePlane?.decoderNodeIds()[0] ?? null;
-	}
-	/**
-	* Force this broker's shm frame-plane decoder sessions hosted on
-	* `agentNodeId` to rotate — destroy and rebuild so they re-pull the latest
-	* per-agent preferences (hwaccel backend, …). A no-op when the broker has
-	* no frame plane. Subscriptions survive the rotation.
-	*/
-	async rotateDecoderSession(reason, agentNodeId) {
-		const plane = this.frameHandlePlane;
-		if (!plane) return;
-		const target = agentNodeId ?? plane.decoderNodeIds()[0]?.split("/")[0];
-		if (!target) return;
-		this.logger?.info("rotating shm decoder sessions", { meta: {
-			reason,
-			agentNodeId: target
-		} });
-		await plane.rotate(target, reason);
-	}
 	destroyNativeClient() {
 		if (this.nativeClient) {
 			this.nativeClient.destroy();
@@ -16210,7 +15104,7 @@ var StreamBroker = class StreamBroker {
 	* Reolink lib's `createRfc4571TcpServer`). Same downstream pipeline as
 	* the native RTSP reader: SDP arrives out-of-band on the StreamSource,
 	* RTP packets feed the same depacketizer, AnnexB output goes through
-	* the same prebuffer / pipe / decoder paths.
+	* the same prebuffer / pipe / restream paths.
 	*
 	* `source.metadata.sdp` is required and must describe the video
 	* (and optionally audio) track the publisher is multiplexing on the
@@ -17402,15 +16296,9 @@ var StreamBrokerManager = class StreamBrokerManager {
 	streamOfflineReasonByBroker = /* @__PURE__ */ new Map();
 	streamHealthTimer;
 	/**
-	* Routes a frame-handle `subscriptionId` (Phase 5 / D9) back to its owning
-	* brokerId so `pullFrameHandles` / `unsubscribeFrames` resolve in O(1)
-	* without scanning every broker.
-	*/
-	frameSubscriptionBroker = /* @__PURE__ */ new Map();
-	/**
 	* Routes an audio-chunk `subscriptionId` (Phase 5 / D9) back to its owning
 	* brokerId so `pullAudioChunks` / `unsubscribeAudioChunks` resolve in O(1)
-	* without scanning every broker. Mirrors `frameSubscriptionBroker`.
+	* without scanning every broker.
 	*/
 	audioSubscriptionBroker = /* @__PURE__ */ new Map();
 	/**
@@ -17427,7 +16315,6 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* it down on idle / retract. Populated by {@link attachDerivedFeeder}.
 	*/
 	derivedFeeders = /* @__PURE__ */ new Map();
-	staticDecoders;
 	logger;
 	/** Public accessor for same-process callers (e.g. `CameraStreamsProvider.pickStream`)
 	*  that want to emit diagnostics through the manager's logger. Internal callers
@@ -17558,12 +16445,12 @@ var StreamBrokerManager = class StreamBrokerManager {
 	/**
 	* Injected factory for the inner broker a `RemoteEncodedSourceBroker`
 	* drives. Production wraps the real `StreamBroker` — this leg never decodes
-	* locally, so the decoder/audio-codec caps and local-node pin are unused
-	* (mirrors the recommendation in `RemoteEncodedSourceBroker`'s doc comment).
+	* audio locally, so the audio-codec cap is unused (mirrors the
+	* recommendation in `RemoteEncodedSourceBroker`'s doc comment).
 	* Tests substitute a fake via `setRemoteEncodedBrokerFactory` so no real
 	* RTSP dial happens.
 	*/
-	createRemoteEncodedBroker = (deps) => new StreamBroker(deps.brokerId, null, deps.logger, null, null);
+	createRemoteEncodedBroker = (deps) => new StreamBroker(deps.brokerId, deps.logger, null);
 	/**
 	* Transcode-pipeline manager — backs `getStreamWithCodec`. Lazily
 	* created on first acquire, lives until `destroyAll`.
@@ -17615,8 +16502,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		hwAccel: "copy",
 		threadCount: 0
 	};
-	constructor(staticDecoders, logger) {
-		this.staticDecoders = staticDecoders ?? [];
+	constructor(logger) {
 		this.logger = logger;
 		this.rtspProvider = new RtspRestreamProviderImpl(this.rtspServer, logger.child("rtsp-restream"));
 	}
@@ -17883,11 +16769,12 @@ var StreamBrokerManager = class StreamBrokerManager {
 	}
 	/** The decoder addon's answer for this node — before the process quarantine. */
 	async readEgressHwAccel(deviceId, override) {
-		const decoderApi = this.buildDecoderCapApi(deviceId);
 		return require_dist.resolveEgressDecodeHwAccel({
 			readDecoderBackend: async () => {
-				if (!decoderApi) throw new Error("decoder cap not reachable from this broker");
-				return (await decoderApi.getInfo()).probedBestHwaccel ?? "";
+				const api = this.api;
+				if (!api) throw new Error("decoder cap not reachable from this broker");
+				const pin = this.localNodeId ? require_dist.nodePin(this.localNodeId) : void 0;
+				return (await api.decoder.getInfo.query(void 0, pin)).probedBestHwaccel ?? "";
 			},
 			readKernelPreferred: async () => {
 				if (!this.hwaccel) return [];
@@ -17913,173 +16800,9 @@ var StreamBrokerManager = class StreamBrokerManager {
 	async releaseEgressTranscode(input) {
 		return this.getEgressTranscodeManager().release(input);
 	}
-	buildDecoderCapApi(_deviceId) {
-		const localApi = this.buildLocalDecoderCapApi();
-		const apiDecoder = () => {
-			if (!this.api) return null;
-			const decoder = this.api["decoder"];
-			return decoder ? decoder : null;
-		};
-		const pin = this.localNodeId ? require_dist.nodePin(this.localNodeId) : void 0;
-		return {
-			supportsCodec: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.supportsCodec.query(input, pin);
-				if (!localApi) return false;
-				return localApi.supportsCodec(input);
-			},
-			getInfo: async () => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.getInfo.query(void 0, pin);
-				if (!localApi) return {
-					id: "none",
-					name: "No decoder"
-				};
-				return localApi.getInfo();
-			},
-			createSession: async (config) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.createSession.query(config, pin);
-				if (!localApi) throw new Error("No decoder provider available");
-				return localApi.createSession(config);
-			},
-			pushPacket: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.pushPacket.query(input, pin);
-				if (!localApi) return;
-				return localApi.pushPacket(input);
-			},
-			pullFrames: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.pullFrames.query(input, pin);
-				if (!localApi) return [];
-				return localApi.pullFrames(input);
-			},
-			pullHandles: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.pullHandles.query(input, pin);
-				if (!localApi) return [];
-				return localApi.pullHandles(input);
-			},
-			destroySession: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.destroySession.query(input, pin);
-				if (!localApi) return;
-				return localApi.destroySession(input);
-			},
-			openStream: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.openStream.query(input, pin);
-				if (!localApi) return;
-				return localApi.openStream(input);
-			},
-			updateConfig: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.updateConfig.query(input, pin);
-				if (!localApi) return;
-				return localApi.updateConfig(input);
-			},
-			getStats: async (input) => {
-				const proxy = apiDecoder();
-				if (proxy) return proxy.getStats.query(input, pin);
-				if (!localApi) return {
-					inputFps: 0,
-					outputFps: 0,
-					avgDecodeTimeMs: 0,
-					droppedFrames: 0
-				};
-				return localApi.getStats(input);
-			}
-		};
-	}
-	buildLocalDecoderCapApi() {
-		if (this.staticDecoders.length === 0) return null;
-		const FRAME_BUFFER_CAPACITY = 32;
-		const frameBuffers = /* @__PURE__ */ new Map();
-		const sessions = /* @__PURE__ */ new Map();
-		const unsubscribers = /* @__PURE__ */ new Map();
-		let nextId = 0;
-		const resolveDecoder = async (codec) => {
-			for (const p of this.staticDecoders) if (await p.supportsCodec({ codec })) return p;
-			return null;
-		};
-		return {
-			supportsCodec: async (input) => await resolveDecoder(input.codec) !== null,
-			getInfo: async () => {
-				const provider = this.staticDecoders[0];
-				if (!provider) return {
-					id: "none",
-					name: "No decoder"
-				};
-				return {
-					id: provider.id,
-					name: provider.name,
-					isPullMode: provider.isPullMode,
-					priority: provider.priority
-				};
-			},
-			createSession: async (config) => {
-				const provider = await resolveDecoder(config.codec);
-				if (!provider) throw new Error(`No decoder provider for codec "${config.codec}"`);
-				const session = await provider.createSession(config);
-				const sessionId = `dec-${++nextId}`;
-				sessions.set(sessionId, session);
-				const buffer = new require_dist.RingBuffer(FRAME_BUFFER_CAPACITY);
-				frameBuffers.set(sessionId, buffer);
-				const unsub = session.onFrame((frame) => {
-					buffer.push(frame);
-				});
-				unsubscribers.set(sessionId, unsub);
-				return {
-					sessionId,
-					nodeId: "local"
-				};
-			},
-			pushPacket: async (input) => {
-				const session = sessions.get(input.sessionId);
-				if (session) session.pushPacket(input.packet);
-			},
-			pullFrames: async (input) => {
-				const buffer = frameBuffers.get(input.sessionId);
-				if (!buffer) return [];
-				return buffer.drain(input.maxCount);
-			},
-			pullHandles: async () => [],
-			destroySession: async (input) => {
-				const session = sessions.get(input.sessionId);
-				if (session) {
-					const unsub = unsubscribers.get(input.sessionId);
-					if (unsub) unsub();
-					sessions.delete(input.sessionId);
-					frameBuffers.delete(input.sessionId);
-					unsubscribers.delete(input.sessionId);
-					await session.destroy();
-				}
-			},
-			openStream: async (input) => {
-				const session = sessions.get(input.sessionId);
-				if (session?.openStream) await session.openStream(input.url);
-			},
-			updateConfig: async (input) => {
-				const session = sessions.get(input.sessionId);
-				if (session) session.updateConfig(input.config);
-			},
-			getStats: async (input) => {
-				const session = sessions.get(input.sessionId);
-				if (!session) return {
-					inputFps: 0,
-					outputFps: 0,
-					avgDecodeTimeMs: 0,
-					droppedFrames: 0
-				};
-				return session.getStats();
-			}
-		};
-	}
 	/**
-	* Wire the addon's `ctx.api` proxy. Required for the broker to
-	* resolve the `decoder` capability via tRPC — see
-	* `buildDecoderCapApi` for the full rationale.
+	* Wire the addon's `ctx.api` proxy — the broker's route to other caps
+	* (the stream catalog, the decoder's per-node hwaccel probe, …).
 	*/
 	setApiAccess(api, localNodeId, hwaccel) {
 		this.api = api;
@@ -20072,59 +18795,20 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* Resolve the live `StreamBroker` instance for a broker id. In-process
 	* only — a `StreamBroker` is not tRPC-serialisable, so this is reachable
 	* solely from same-process callers (device-scoped providers, the WebRTC
-	* server). Cross-process frame access goes through the shm `subscribeFrames`
-	* surface; cross-process stats through `getBrokerStats` / `listClients`.
+	* server). Cross-process stats go through `getBrokerStats` / `listClients`.
 	*/
 	async getBroker(input) {
 		return this.brokers.get(input.brokerId) ?? null;
 	}
 	/**
-	* Open a `FrameHandle` subscription on a broker — the handle-based
-	* replacement for the live-object `onDecodedFrame` callback. Routed over
-	* tRPC, so a consumer in a different process can subscribe; the consumer
-	* then polls `pullFrameHandles` and feeds each handle to a
-	* `FrameRingReader`.
+	* Drop every `audioSubscriptionBroker` entry pointing at `brokerId`. Called
+	* on broker teardown so a destroyed broker leaves no dangling
+	* `subscriptionId → brokerId` rows (a slow consumer that never calls
+	* `unsubscribeAudioChunks` would otherwise leak a map entry per stream).
 	*/
-	async subscribeFrames(input) {
-		await this.ensureBrokerForId(input.brokerId);
-		const broker = this.brokers.get(input.brokerId);
-		if (!broker) throw new Error(`stream-broker: no broker for "${input.brokerId}"`);
-		const result = await broker.subscribeFrameHandles({
-			format: input.format,
-			maxFps: input.maxFps,
-			tag: input.tag
-		});
-		this.frameSubscriptionBroker.set(result.subscriptionId, input.brokerId);
-		return result;
-	}
-	/** Drain `FrameHandle`s for a subscription opened via `subscribeFrames`. */
-	async pullFrameHandles(input) {
-		const brokerId = this.frameSubscriptionBroker.get(input.subscriptionId);
-		if (!brokerId) return [];
-		const broker = this.brokers.get(brokerId);
-		if (!broker) return [];
-		return broker.pullFrameHandles(input.subscriptionId, input.maxCount);
-	}
-	/**
-	* Drop every `frameSubscriptionBroker` + `audioSubscriptionBroker` entry
-	* pointing at `brokerId`. Called on broker teardown so a destroyed broker
-	* leaves no dangling `subscriptionId → brokerId` rows (a slow consumer that
-	* never calls `unsubscribeFrames` / `unsubscribeAudioChunks` would otherwise
-	* leak a map entry per stream).
-	*/
-	sweepFrameSubscriptions(brokerId) {
-		for (const [subscriptionId, mappedBrokerId] of this.frameSubscriptionBroker) if (mappedBrokerId === brokerId) this.frameSubscriptionBroker.delete(subscriptionId);
+	sweepAudioSubscriptions(brokerId) {
 		for (const [subscriptionId, mappedBrokerId] of this.audioSubscriptionBroker) if (mappedBrokerId === brokerId) this.audioSubscriptionBroker.delete(subscriptionId);
 	}
-	/** Release a frame-handle subscription. */
-	async unsubscribeFrames(input) {
-		const brokerId = this.frameSubscriptionBroker.get(input.subscriptionId);
-		if (!brokerId) return { released: false };
-		this.frameSubscriptionBroker.delete(input.subscriptionId);
-		const broker = this.brokers.get(brokerId);
-		if (!broker) return { released: false };
-		return { released: await broker.unsubscribeFrameHandles(input.subscriptionId) };
-	}
 	/**
 	* Open a decoded audio-chunk subscription on a broker — the poll-based,
 	* tRPC-reachable replacement for the live-object `onDecodedAudioChunk`
@@ -20165,9 +18849,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		if (!broker) return {
 			status: "stopped",
 			inputFps: 0,
-			decodeFps: 0,
 			encodedSubscribers: 0,
-			decodedSubscribers: 0,
 			uptimeMs: 0,
 			bitrateKbps: 0,
 			idrIntervalMs: 0,
@@ -20178,7 +18860,6 @@ var StreamBrokerManager = class StreamBrokerManager {
 			preBufferSec: 0,
 			preBufferMs: 0,
 			preBufferPackets: 0,
-			decoderNodeId: null,
 			audio: null
 		};
 		return broker.getStats();
@@ -20187,7 +18868,6 @@ var StreamBrokerManager = class StreamBrokerManager {
 		const broker = this.brokers.get(input.brokerId);
 		if (!broker) return {
 			rtsp: [],
-			decoded: [],
 			audio: [],
 			encoded: [],
 			pipeClients: 0,
@@ -20200,28 +18880,6 @@ var StreamBrokerManager = class StreamBrokerManager {
 		if (!broker) return { killed: false };
 		return { killed: broker.killClient(input.channel, input.handle) };
 	}
-	async rotateDecodersOnNode(agentNodeId, reason) {
-		let rotated = 0;
-		for (const broker of this.brokers.values()) {
-			if (!(broker.getDecoderNodeId()?.split("/")[0] === agentNodeId)) continue;
-			try {
-				await broker.rotateDecoderSession(reason, agentNodeId);
-				rotated++;
-			} catch (err) {
-				const parsedBrokerId = parseBrokerId(broker.deviceId);
-				this.logger.warn("decoder rotation failed", {
-					...parsedBrokerId ? { tags: { deviceId: parsedBrokerId.deviceId } } : {},
-					meta: {
-						brokerId: broker.deviceId,
-						agentNodeId,
-						reason,
-						error: require_dist.errMsg(err)
-					}
-				});
-			}
-		}
-		return rotated;
-	}
 	/** Raw broker instances — internal use only. */
 	getBrokerInstances() {
 		return [...this.brokers.values()];
@@ -20322,7 +18980,6 @@ var StreamBrokerManager = class StreamBrokerManager {
 		this.brokers.clear();
 		this.streamHealthByBroker.clear();
 		this.streamOfflineReasonByBroker.clear();
-		this.frameSubscriptionBroker.clear();
 		this.audioSubscriptionBroker.clear();
 		await this.rtspServer.stop();
 	}
@@ -22120,8 +20777,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 			camStreamId
 		});
 		const source = this.buildSourceFromCamStream(cam);
-		const broker = new StreamBroker(brokerId, this.buildDecoderCapApi(deviceId), brokerLogger, buildAudioCodecCapApi(this.api), this.localNodeId);
-		broker.setRestreamUrlResolver(() => this.rtspProvider.getEntry(brokerId)?.mutedUrl ?? null);
+		const broker = new StreamBroker(brokerId, brokerLogger, buildAudioCodecCapApi(this.api));
 		this.bindBrokerFfmpeg(broker);
 		if (this.costRegistry !== null) broker.setCostRegistry(this.costRegistry);
 		this.applyPrebufferConfig(broker, deviceId, camStreamId);
@@ -22187,7 +20843,7 @@ var StreamBrokerManager = class StreamBrokerManager {
 		await broker.stop();
 		this.brokers.delete(brokerId);
 		this.sentryFrames.delete(brokerId);
-		this.sweepFrameSubscriptions(brokerId);
+		this.sweepAudioSubscriptions(brokerId);
 		this.rtspProvider.persistTokens();
 		this.syncProfileRestreamers(deviceId);
 	}
@@ -37658,7 +36314,6 @@ var WebrtcSessionProvider = class WebrtcSessionProvider {
 			resolution: null,
 			status: null,
 			inputFps: null,
-			decodeFps: null,
 			bitrateKbps: null
 		});
 		for (const slot of assignedSlots) {
@@ -37678,7 +36333,6 @@ var WebrtcSessionProvider = class WebrtcSessionProvider {
 				resolution: cam?.resolution ?? slot.resolution ?? null,
 				status: stats?.status ?? null,
 				inputFps: stats?.inputFps ?? null,
-				decodeFps: stats?.decodeFps ?? null,
 				bitrateKbps: stats?.bitrateKbps ?? null
 			});
 		}
@@ -37700,7 +36354,6 @@ var WebrtcSessionProvider = class WebrtcSessionProvider {
 				resolution: cam.resolution ?? null,
 				status: stats?.status ?? null,
 				inputFps: stats?.inputFps ?? null,
-				decodeFps: stats?.decodeFps ?? null,
 				bitrateKbps: stats?.bitrateKbps ?? null
 			});
 		}
@@ -38072,7 +36725,7 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 			this.ctx?.logger?.warn?.("event-loop stall — every session in this process froze", { meta: { stallMs } });
 		} });
 		this.loopStallMonitor.start();
-		this.brokerManager = new StreamBrokerManager(void 0, this.ctx.logger);
+		this.brokerManager = new StreamBrokerManager(this.ctx.logger);
 		this.brokerManager.setCostRegistry(this.costRegistry);
 		this.brokerManager.setDefaultPreBufferSec(this.config.defaultPreBufferSec);
 		this.brokerManager.setDefaultJoinBurstMaxSpanMs(this.config.joinBurstMaxSpanMs);
@@ -38194,47 +36847,6 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 			return { rtspTokenRowsDeleted };
 		});
 		await this.brokerManager.startRtspServer(this.config.rtspPort);
-		this.subscribe({ category: require_dist.EventCategory.PipelineAgentHwaccelChanged }, (event) => {
-			const { agentNodeId, reason } = event.data;
-			if (typeof agentNodeId !== "string" || agentNodeId.length === 0) return;
-			const manager = this.brokerManager;
-			if (!manager) return;
-			const reasonLabel = typeof reason === "string" ? reason : "hwaccel-changed";
-			manager.rotateDecodersOnNode(agentNodeId, reasonLabel).then((rotated) => {
-				if (rotated > 0) this.ctx.logger.info("decoders rotated for hwaccel change", {
-					tags: { nodeId: agentNodeId },
-					meta: {
-						rotated,
-						reason: reasonLabel
-					}
-				});
-			}).catch((err) => {
-				this.ctx.logger.warn("hwaccel-driven decoder rotation failed", {
-					tags: { nodeId: agentNodeId },
-					meta: { error: require_dist.errMsg(err) }
-				});
-			});
-		});
-		this.watchCapability(["decoder"], { onDown: (nodeId, capName) => {
-			if (capName !== "decoder") return;
-			const manager = this.brokerManager;
-			if (!manager) return;
-			const reasonLabel = `decoder-down:${nodeId}`;
-			manager.rotateDecodersOnNode(nodeId, reasonLabel).then((rotated) => {
-				if (rotated > 0) this.ctx.logger.info("decoders rotated after provider went down", {
-					tags: { nodeId },
-					meta: {
-						rotated,
-						reason: reasonLabel
-					}
-				});
-			}).catch((err) => {
-				this.ctx.logger.warn("decoder-down rotation failed", {
-					tags: { nodeId },
-					meta: { error: require_dist.errMsg(err) }
-				});
-			});
-		} });
 		const reconcileAll = (reason) => {
 			this.brokerManager?.reconcileAllCatalogs().catch((err) => {
 				this.ctx.logger.warn("catalog reconcile failed", { meta: {
@@ -38710,260 +37322,6 @@ var StreamBrokerAddon = class extends require_dist.BaseAddon {
 	}
 };
 //#endregion
-//#region src/stream-broker/stream-broker/frame-dropper.ts
-var FrameDropper = class {
-	intervalMs;
-	lastPassedAt = -Infinity;
-	constructor(maxFps) {
-		this.intervalMs = maxFps > 0 ? 1e3 / maxFps : 0;
-	}
-	shouldKeep() {
-		if (this.intervalMs === 0) return true;
-		const now = Date.now();
-		if (now - this.lastPassedAt >= this.intervalMs) {
-			this.lastPassedAt = now;
-			return true;
-		}
-		return false;
-	}
-	setMaxFps(maxFps) {
-		this.intervalMs = maxFps > 0 ? 1e3 / maxFps : 0;
-	}
-};
-//#endregion
-//#region src/stream-broker/stream-broker/ffmpeg-decoder-session.ts
-/** Minimal no-op logger for default parameter */
-var noopLogger = {
-	debug() {},
-	info() {},
-	warn() {},
-	error() {},
-	child() {
-		return noopLogger;
-	},
-	withTags() {
-		return noopLogger;
-	}
-};
-var SOI = Buffer.from([255, 216]);
-var EOI = Buffer.from([255, 217]);
-function codecToInputFormat(codec) {
-	switch (codec) {
-		case "h265":
-		case "hevc": return "hevc";
-		case "mjpeg": return "mjpeg";
-		default: return "h264";
-	}
-}
-function buildFfmpegArgs(config) {
-	const inputFormat = codecToInputFormat(config.codec);
-	const args = [
-		...logBannerArgs("error"),
-		"-fflags",
-		"+nobuffer+flush_packets",
-		"-flags",
-		"low_delay",
-		"-probesize",
-		"32",
-		"-analyzeduration",
-		"0",
-		"-f",
-		inputFormat,
-		"-i",
-		"pipe:0"
-	];
-	if (config.scale > 1) args.push("-vf", `scale=iw/${config.scale}:ih/${config.scale}`);
-	args.push("-f", "image2pipe", "-vcodec", "mjpeg", "-q:v", "3", "-threads", "1", "pipe:1");
-	return args;
-}
-var FfmpegDecoderSession = class {
-	config;
-	frameDropper;
-	process = null;
-	frameCallbacks = /* @__PURE__ */ new Set();
-	outputBuffer = Buffer.alloc(0);
-	destroyed = false;
-	logger;
-	/** The pinned ffmpeg to spawn (D540). Required: there is no PATH default. */
-	ffmpegPath;
-	cachedWidth = 0;
-	cachedHeight = 0;
-	inputPackets = 0;
-	outputFrames = 0;
-	droppedFrames = 0;
-	totalDecodeTimeMs = 0;
-	decodeCount = 0;
-	startTime = Date.now();
-	constructor(config, ffmpegPath, logger = noopLogger) {
-		this.config = { ...config };
-		this.ffmpegPath = ffmpegPath;
-		this.logger = logger;
-		this.frameDropper = new FrameDropper(config.maxFps);
-		this.spawnFfmpeg();
-	}
-	spawnFfmpeg() {
-		if (this.destroyed) return;
-		this.killFfmpeg();
-		this.outputBuffer = Buffer.alloc(0);
-		this.cachedWidth = 0;
-		this.cachedHeight = 0;
-		const args = buildFfmpegArgs(this.config);
-		const child = (0, node_child_process.spawn)(this.ffmpegPath, args);
-		this.process = child;
-		child.stdin?.on("error", () => {});
-		child.stdout?.on("data", (chunk) => {
-			if (child === this.process) this.handleOutputData(chunk);
-		});
-		child.stderr?.on("data", (data) => {
-			if (child !== this.process) return;
-			const line = data.toString().trim();
-			if (line) this.logger.debug("ffmpeg stderr", { meta: { line } });
-		});
-		child.on("error", (err) => {
-			if (child !== this.process) return;
-			this.logger.error("FFmpeg decoder spawn error", { meta: { error: err.message } });
-		});
-		child.on("close", (_code, _signal) => {
-			if (child === this.process && !this.destroyed) this.process = null;
-		});
-	}
-	killFfmpeg() {
-		const child = this.process;
-		if (!child) return;
-		this.process = null;
-		child.stdout?.removeAllListeners("data");
-		child.stderr?.removeAllListeners("data");
-		child.removeAllListeners("close");
-		try {
-			child.kill("SIGKILL");
-		} catch {}
-	}
-	handleOutputData(chunk) {
-		this.outputBuffer = Buffer.concat([this.outputBuffer, chunk]);
-		let searchFrom = 0;
-		while (true) {
-			const soiIndex = this.outputBuffer.indexOf(SOI, searchFrom);
-			if (soiIndex === -1) break;
-			const eoiIndex = this.outputBuffer.indexOf(EOI, soiIndex + 2);
-			if (eoiIndex === -1) break;
-			const frameEnd = eoiIndex + 2;
-			const jpegData = this.outputBuffer.subarray(soiIndex, frameEnd);
-			searchFrom = frameEnd;
-			this.emitFrame(Buffer.from(jpegData));
-		}
-		if (searchFrom > 0) this.outputBuffer = Buffer.from(this.outputBuffer.subarray(searchFrom));
-	}
-	emitFrame(data) {
-		const decodeStart = Date.now();
-		if (!this.frameDropper.shouldKeep()) {
-			this.droppedFrames++;
-			return;
-		}
-		const decodeTime = Date.now() - decodeStart;
-		this.totalDecodeTimeMs += decodeTime;
-		this.decodeCount++;
-		this.outputFrames++;
-		if (this.cachedWidth === 0) {
-			const dims = parseJpegDimensions(data);
-			this.cachedWidth = dims.width;
-			this.cachedHeight = dims.height;
-		}
-		const frame = {
-			data,
-			width: this.cachedWidth,
-			height: this.cachedHeight,
-			format: "jpeg",
-			timestamp: Date.now()
-		};
-		for (const cb of this.frameCallbacks) cb(frame);
-	}
-	pushPacket(packet) {
-		if (this.destroyed || !this.process?.stdin) return;
-		this.inputPackets++;
-		try {
-			this.process.stdin.write(packet.data);
-		} catch {}
-	}
-	onFrame(callback) {
-		this.frameCallbacks.add(callback);
-		return () => {
-			this.frameCallbacks.delete(callback);
-		};
-	}
-	updateConfig(update) {
-		const needsRestart = update.scale !== void 0 && update.scale !== this.config.scale || update.outputFormat !== void 0 && update.outputFormat !== this.config.outputFormat || update.codec !== void 0 && update.codec !== this.config.codec;
-		this.config = {
-			...this.config,
-			...update
-		};
-		if (update.maxFps !== void 0) this.frameDropper.setMaxFps(update.maxFps);
-		if (needsRestart) this.spawnFfmpeg();
-	}
-	async destroy() {
-		if (this.destroyed) return;
-		this.destroyed = true;
-		this.killFfmpeg();
-		this.frameCallbacks.clear();
-	}
-	getStats() {
-		const uptimeSec = Math.max((Date.now() - this.startTime) / 1e3, 1);
-		return {
-			inputFps: this.inputPackets / uptimeSec,
-			outputFps: this.outputFrames / uptimeSec,
-			avgDecodeTimeMs: this.decodeCount > 0 ? this.totalDecodeTimeMs / this.decodeCount : 0,
-			droppedFrames: this.droppedFrames
-		};
-	}
-};
-/**
-* Parse JPEG SOF0/SOF2 marker to extract image dimensions.
-* Scans for 0xFF 0xC0 (baseline) or 0xFF 0xC2 (progressive) markers.
-* Returns {width: 0, height: 0} if not found.
-*/
-function parseJpegDimensions(data) {
-	for (let i = 0; i < data.length - 8; i++) if (data[i] === 255 && (data[i + 1] === 192 || data[i + 1] === 194)) {
-		const height = data[i + 5] << 8 | data[i + 6];
-		return {
-			width: data[i + 7] << 8 | data[i + 8],
-			height
-		};
-	}
-	return {
-		width: 0,
-		height: 0
-	};
-}
-//#endregion
-//#region src/stream-broker/stream-broker/ffmpeg-decoder-provider.ts
-var SUPPORTED_CODECS = new Set([
-	"h264",
-	"h265",
-	"hevc",
-	"mjpeg"
-]);
-/**
-* A static decoder provider for stand-alone broker harnesses. Production
-* decodes through the `decoder` cap; this exists for the manual streaming
-* diagnostics. It is handed the pinned ffmpeg (D540) — there is no PATH
-* default for it to fall back to.
-*/
-var FfmpegDecoderProvider = class {
-	ffmpegPath;
-	id = "ffmpeg";
-	name = "FFmpeg Decoder";
-	/** Software decoder — used as fallback when hardware decoders are unavailable. */
-	priority = 50;
-	async supportsCodec(input) {
-		return SUPPORTED_CODECS.has(input.codec);
-	}
-	constructor(ffmpegPath) {
-		this.ffmpegPath = ffmpegPath;
-	}
-	async createSession(config) {
-		return new FfmpegDecoderSession(config, this.ffmpegPath);
-	}
-};
-//#endregion
 //#region src/stream-broker/frame-transport/codecs/length-prefix-codec.ts
 var LENGTH_PREFIX_BYTES = 4;
 /** Hard cap — 2^31-1 to stay safely within uint32 BE range and V8 Buffer limits. */
@@ -39928,8 +38286,6 @@ function fromBase64Url(s) {
 //#region src/stream-broker/index.ts
 var stream_broker_default = StreamBrokerAddon;
 //#endregion
-exports.DecoderSessionProxy = DecoderSessionProxy;
-exports.FfmpegDecoderProvider = FfmpegDecoderProvider;
 exports.InProcessTransport = InProcessTransport;
 exports.LengthPrefixCodec = LengthPrefixCodec;
 exports.StreamBroker = StreamBroker;