@camstack/addon-pipeline 1.2.219 → 1.2.221

package/dist/stream-broker/index.mjs

@@ -1,10 +1,10 @@
 import { r as __toESM } from "../chunk-DnnnRqeS.mjs";
-import { A as addonWidgetsSourceCapability, Bt as invocationFromEncodeProfile, C as RATE_CONTROL_RELAXED, F as cameraStreamsCapability, Ft as webrtcSessionCapability, Gt as DeviceFeature, H as deriveBatteryPresence, Ht as BOOT_RECOVERY_BACKOFF_MS, I as createHwAccelCache, It as errMsg, K as egressTranscodeSharingKey, Kt as DeviceType, L as createLogChannelsProvider, Lt as AUDIO_PRESETS, Mt as streamBrokerCapability, O as RingBuffer, P as batteryCapability, Qt as nodePin, Tt as resolveEgressDecodeHwAccel, Ut as BaseAddon, Vt as isSoftwareDecode, Wt as CAM_PROFILE_ORDER, Xt as makeProfileBrokerId, Yt as isEvent, Zt as makeSourceBrokerId, an as boolean, at as logChannelsCapability, cn as literal, en as parseProfileBrokerId, fn as record, h as EncodeProfileSchema, hn as EventCategory, i as BatteryStatusSchema, in as array, it as loadContributionCapability, ln as number, mn as union, on as discriminatedUnion, pn as string, q as egressTransportFromRequest, qt as createEvent, rn as _enum, st as maskUrlCredentials, un as object, w as RATE_CONTROL_TIGHT, z as declareLogChannel, zt as buildFfmpegArgs$1 } from "../dist-CKK0CBUW.mjs";
-import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-CrNBWFbA.mjs";
+import { $t as makeProfileBrokerId, B as declareLogChannel, Bt as buildFfmpegArgs$1, Et as resolveEgressDecodeHwAccel, F as batteryCapability, Gt as CAM_PROFILE_ORDER, Ht as isSoftwareDecode, I as cameraStreamsCapability, It as webrtcSessionCapability, J as egressTransportFromRequest, Kt as DeviceFeature, L as createHwAccelCache, Lt as errMsg, Nt as streamBrokerCapability, Qt as isEvent, R as createLogChannelsProvider, Rt as AUDIO_PRESETS, T as RATE_CONTROL_TIGHT, U as deriveBatteryPresence, Ut as BOOT_RECOVERY_BACKOFF_MS, Vt as invocationFromEncodeProfile, Wt as BaseAddon, Xt as expandAudioChunkToF32le, Yt as createEvent, _n as union, at as loadContributionCapability, cn as boolean, ct as maskUrlCredentials, dn as literal, en as makeSourceBrokerId, fn as number, gn as string, h as EncodeProfileSchema, hn as record, i as BatteryStatusSchema, j as addonWidgetsSourceCapability, k as RingBuffer, ln as discriminatedUnion, on as _enum, ot as logChannelsCapability, pn as object, q as egressTranscodeSharingKey, qt as DeviceType, rn as parseProfileBrokerId, sn as array, tn as nodePin, v as G711_SCALE_CORRECTION_DB, vn as EventCategory, w as RATE_CONTROL_RELAXED } from "../dist-CEFC3PkP.mjs";
+import { i as NO_COST_CLAIM, n as Fmp4FragmentChild, r as Fmp4FragmentPlane, t as ChildCostRegistry } from "../node-DR3fHqUq.mjs";
 import { c as PREBUFFER_MAX_MS, d as resolvePrebuffer, i as parseRestreamPath, l as capPreRollRequestMs, n as NO_DECLARATION, u as prebufferRetentionMs } from "../restream-intent-DWe2kInY.mjs";
 import { n as profileForStreamId } from "../remote-restream-BeHi78PZ.mjs";
 import { n as RowMapStore, t as retireRootKeys } from "../retire-root-keys-DZvlso2l.mjs";
-import { i as require_mp4box_all, n as demuxSegmentPreferJs, r as runFfmpegOnce, t as demuxSegmentFullJs } from "../segment-demux-js-D2o9ShNL.mjs";
+import { i as require_mp4box_all, n as demuxSegmentPreferJs, r as runFfmpegOnce, t as demuxSegmentFullJs } from "../segment-demux-js-CddDwD69.mjs";
 import { createRequire } from "node:module";
 import * as os from "node:os";
 import { networkInterfaces, tmpdir } from "node:os";
@@ -8377,112 +8377,74 @@ function depacketizeRfc3640(payload, opts = {
 }
 //#endregion
 //#region src/stream-broker/rtsp/audio-rtp-decoder.ts
-/** Target sample rate for decoded audio (matches ffmpeg path). */
-var TARGET_SAMPLE_RATE = 16e3;
-var CHUNK_SAMPLES = TARGET_SAMPLE_RATE * 500 / 1e3;
+/** G.711 is 8 kHz by definition (RFC 3551): the plane carries that rate. */
+var G711_SAMPLE_RATE = 8e3;
+/** One G.711 byte is one sample, so samples and bytes are the same count. */
+var CHUNK_BYTES = G711_SAMPLE_RATE * 500 / 1e3;
+/** The chunk `format` each RTP codec produces. */
+var CODEC_FORMAT = {
+	PCMU: "pcmu",
+	PCMA: "pcma"
+};
 /**
-* Decodes G.711 audio RTP packets into PCM f32le chunks.
+* Chunks G.711 audio RTP payloads into ~0.5 s coded chunks at 8 kHz.
 *
-* Buffers decoded samples and emits DecodedAudioChunk when enough
-* samples accumulate (~0.5s), matching the ffmpeg audio output cadence.
+* Buffers payload bytes and emits a `DecodedAudioChunk` carrying the source
+* codec once ~0.5 s has accumulated (4000 bytes).
 */
 var AudioRtpDecoder = class {
-	codec;
+	format;
 	onChunk;
 	buffer;
 	bufferOffset = 0;
 	constructor(codec, onChunk) {
-		this.codec = codec;
+		this.format = CODEC_FORMAT[codec];
 		this.onChunk = onChunk;
-		this.buffer = new Float32Array(CHUNK_SAMPLES);
+		this.buffer = Buffer.allocUnsafe(CHUNK_BYTES);
 	}
 	/**
-	* Process a raw RTP packet (header + payload).
-	* Strips the 12-byte RTP header, decodes G.711 payload, upsamples 8→16kHz.
+	* Process a raw RTP packet (header + payload). Strips the 12-byte RTP header
+	* and appends the payload bytes verbatim, emitting whenever a chunk fills.
+	* A payload larger than the remaining room spans chunks.
 	*/
 	processPacket(rtpData) {
 		if (rtpData.length <= 12) return;
 		const payload = rtpData.subarray(12);
-		const decode = this.codec === "PCMU" ? decodeUlaw : decodeAlaw;
-		for (let i = 0; i < payload.length; i++) {
-			const current = decode(payload[i]);
-			const next = i + 1 < payload.length ? decode(payload[i + 1]) : current;
-			this.pushSample(current);
-			this.pushSample((current + next) * .5);
+		let consumed = 0;
+		while (consumed < payload.length) {
+			const room = CHUNK_BYTES - this.bufferOffset;
+			const take = Math.min(room, payload.length - consumed);
+			payload.copy(this.buffer, this.bufferOffset, consumed, consumed + take);
+			this.bufferOffset += take;
+			consumed += take;
+			if (this.bufferOffset >= CHUNK_BYTES) this.emit();
 		}
 	}
-	/** Flush any remaining buffered samples as a partial chunk. */
+	/** Flush any remaining buffered bytes as a partial chunk. */
 	flush() {
 		if (this.bufferOffset === 0) return;
-		const data = Buffer.from(this.buffer.buffer, this.buffer.byteOffset, this.bufferOffset * 4);
-		this.onChunk({
-			data: Buffer.from(data),
-			sampleRate: TARGET_SAMPLE_RATE,
-			channels: 1,
-			timestamp: Date.now()
-		});
-		this.bufferOffset = 0;
+		this.emit();
 	}
-	/** Reset the decoder state. */
+	/** Reset the chunker state. */
 	reset() {
 		this.bufferOffset = 0;
 	}
-	pushSample(sample) {
-		this.buffer[this.bufferOffset++] = sample;
-		if (this.bufferOffset >= CHUNK_SAMPLES) {
-			const data = Buffer.from(this.buffer.buffer, this.buffer.byteOffset, CHUNK_SAMPLES * 4);
-			this.onChunk({
-				data: Buffer.from(data),
-				sampleRate: TARGET_SAMPLE_RATE,
-				channels: 1,
-				timestamp: Date.now()
-			});
-			this.bufferOffset = 0;
-		}
+	/**
+	* Emit what is buffered and start a fresh chunk. The bytes are COPIED out:
+	* the accumulator is reused, and the plane holds every queued chunk by
+	* reference until its consumer polls.
+	*/
+	emit() {
+		this.onChunk({
+			data: Buffer.from(this.buffer.subarray(0, this.bufferOffset)),
+			sampleRate: G711_SAMPLE_RATE,
+			channels: 1,
+			timestamp: Date.now(),
+			format: this.format
+		});
+		this.bufferOffset = 0;
 	}
 };
-/** μ-law compressed byte → normalized float [-1.0, 1.0]. */
-function decodeUlaw(byte) {
-	return ULAW_TABLE[byte];
-}
-/** A-law compressed byte → normalized float [-1.0, 1.0]. */
-function decodeAlaw(byte) {
-	return ALAW_TABLE[byte];
-}
-/**
-* Build the μ-law decode table (ITU-T G.711).
-* Each of the 256 possible byte values maps to a 16-bit PCM sample,
-* which we normalize to [-1.0, 1.0] for f32le output.
-*/
-function buildUlawTable() {
-	const table = new Float32Array(256);
-	for (let i = 0; i < 256; i++) {
-		const complemented = ~i & 255;
-		const sign = (complemented & 128) !== 0 ? -1 : 1;
-		const exponent = complemented >> 4 & 7;
-		table[i] = sign * ((2 * (complemented & 15) + 33 << exponent) - 33) / 32768;
-	}
-	return table;
-}
-/**
-* Build the A-law decode table (ITU-T G.711).
-*/
-function buildAlawTable() {
-	const table = new Float32Array(256);
-	for (let i = 0; i < 256; i++) {
-		const xored = i ^ 85;
-		const sign = (xored & 128) !== 0 ? -1 : 1;
-		const exponent = xored >> 4 & 7;
-		const mantissa = xored & 15;
-		let magnitude;
-		if (exponent === 0) magnitude = 2 * mantissa + 1;
-		else magnitude = 2 * mantissa + 33 << exponent - 1;
-		table[i] = sign * magnitude / 32768;
-	}
-	return table;
-}
-var ULAW_TABLE = buildUlawTable();
-var ALAW_TABLE = buildAlawTable();
 //#endregion
 //#region src/stream-broker/rtsp/ffmpeg-source-reader.ts
 /**
@@ -9480,6 +9442,47 @@ function extractQuoted(header, key) {
 */
 var AUDIO_QUEUE_CAPACITY = 64;
 /**
+* How long a subscription may go without a `pull` before the plane releases it
+* (D461).
+*
+* Until 2026-09-11 the one subscriber was `pipeline-orchestrator`, which the
+* hub restarts alongside the broker, and an abandoned subscription was a
+* theoretical leak. D461 moved the poller into `audio-analyzer`, which may sit
+* on another node and may die without the orchestrator's detach ever
+* arriving — and on THIS plane an orphan is not merely a queue nobody drains.
+* `subscriberCount` is what `hasDemand()` reads, so one orphan pins the
+* broker's source dial and its decode session open for the broker's whole
+* life: a camera nobody is listening to, kept streaming and decoding by a dead
+* process.
+*
+* The bound has to clear the longest LEGITIMATE gap between two polls. The
+* poller awaits its consumer per chunk, and the consumer is now the classifier
+* itself, whose `classify` carries a 30 s timeout — so a gap of tens of
+* seconds is healthy. Two minutes is past every one of those and well past the
+* ~30 s of audio the FIFO can hold, so a subscription this idle has already
+* lost audio and cannot be serving anyone.
+*/
+var AUDIO_SUBSCRIPTION_IDLE_MS = 12e4;
+/** `format` is optional on the wire and its absence means `f32le` (D455). */
+function formatOf(chunk) {
+	return chunk.format ?? "f32le";
+}
+/**
+* Build the f32le twin of a coded chunk. Everything but `data` and `format`
+* is carried over — the rate, the channel count and the timestamp describe the
+* audio, not its encoding.
+*/
+function expandChunk(chunk, sourceFormat) {
+	const bytes = expandAudioChunkToF32le(chunk.data, sourceFormat);
+	return {
+		data: Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+		sampleRate: chunk.sampleRate,
+		channels: chunk.channels,
+		timestamp: chunk.timestamp,
+		format: "f32le"
+	};
+}
+/**
 * Owns the broker's decoded audio-chunk subscriptions. The broker feeds every
 * decoded `DecodedAudioChunk` into `fanout`; each subscription's poll loop
 * drains its own FIFO queue via `pull`.
@@ -9487,8 +9490,12 @@ var AUDIO_QUEUE_CAPACITY = 64;
 var AudioChunkPlane = class {
 	logger;
 	subscriptions = /* @__PURE__ */ new Map();
-	constructor(logger) {
+	/** Last `reapIdle` sweep — the lease is checked on a cadence, not per chunk. */
+	lastReapAt = Date.now();
+	onSubscriptionsReaped;
+	constructor(logger, onSubscriptionsReaped) {
 		this.logger = logger;
+		this.onSubscriptionsReaped = onSubscriptionsReaped;
 	}
 	/** Number of active audio-chunk subscriptions — surfaced as audio demand. */
 	get subscriberCount() {
@@ -9505,12 +9512,16 @@ var AudioChunkPlane = class {
 			tag: input?.tag ?? "unknown",
 			subscribedAt: Date.now(),
 			queue: new RingBuffer(AUDIO_QUEUE_CAPACITY),
-			chunksDelivered: 0
+			accept: new Set(input?.accept ?? []),
+			servedKey: null,
+			chunksDelivered: 0,
+			lastPulledAt: Date.now()
 		};
 		this.subscriptions.set(subscriptionId, subscription);
 		this.logger?.info("audio-chunk subscription added", { meta: {
 			subscriptionId,
-			tag: subscription.tag
+			tag: subscription.tag,
+			accept: input?.accept ?? []
 		} });
 		return { subscriptionId };
 	}
@@ -9522,10 +9533,44 @@ var AudioChunkPlane = class {
 	pull(subscriptionId, maxCount) {
 		const subscription = this.subscriptions.get(subscriptionId);
 		if (!subscription) return [];
+		subscription.lastPulledAt = Date.now();
 		const chunks = subscription.queue.drain(maxCount);
 		subscription.chunksDelivered += chunks.length;
 		return chunks;
 	}
+	/**
+	* Release every subscription nobody has drained for
+	* {@link AUDIO_SUBSCRIPTION_IDLE_MS}, and NAME each one (D461, D427).
+	*
+	* The lease is the net under the ownership split: the subscriber lives in a
+	* process the orchestrator does not supervise, so a missed `detachDevice`
+	* has to be survivable rather than trusted. It is deliberately driven from
+	* `fanout` — the plane has no clock of its own, and the moment a dead
+	* consumer costs anything is the moment there is a chunk to put in its
+	* queue. A plane with nothing flowing has nothing to reclaim.
+	*
+	* Returns the ids released so the broker can re-evaluate its demand; an
+	* orphan that is dropped but still counted would have fixed nothing.
+	*/
+	reapIdle(now = Date.now()) {
+		const reaped = [];
+		for (const subscription of [...this.subscriptions.values()]) {
+			const idleMs = now - subscription.lastPulledAt;
+			if (idleMs < 12e4) continue;
+			this.subscriptions.delete(subscription.id);
+			reaped.push(subscription.id);
+			this.logger?.warn("audio-chunk subscription REAPED — nobody drained it", { meta: {
+				subscriptionId: subscription.id,
+				tag: subscription.tag,
+				idleMs,
+				leaseMs: AUDIO_SUBSCRIPTION_IDLE_MS,
+				queued: subscription.queue.size,
+				chunksDelivered: subscription.chunksDelivered,
+				hint: "the consumer process died without detaching — its subscription was holding this broker in demand"
+			} });
+		}
+		return reaped;
+	}
 	/** Release a subscription. Returns `true` when a known subscription was released. */
 	unsubscribe(subscriptionId) {
 		const existed = this.subscriptions.delete(subscriptionId);
@@ -9536,9 +9581,67 @@ var AudioChunkPlane = class {
 	* Fan one decoded `DecodedAudioChunk` into every active subscription's FIFO
 	* queue. A full queue drops its oldest chunk (bounded safety valve for a
 	* stalled consumer). No-op when there are no subscriptions.
+	*
+	* ## The format each subscription gets (D455)
+	*
+	* The decoder now hands this plane the SOURCE bytes — one G.711 byte per
+	* sample instead of four f32le ones — because the plane crosses hub-main
+	* twice on its way to the analyzer and every leg was paying the expansion.
+	* A subscription receives those bytes only if it DECLARED it can read them;
+	* otherwise the plane expands to `f32le` here, which is byte-for-byte what
+	* every consumer received before this existed.
+	*
+	* The expansion is done ONCE per fanout and shared by every subscription
+	* that needs it: the chunk is immutable and the queue holds references.
 	*/
 	fanout(chunk) {
-		for (const subscription of this.subscriptions.values()) subscription.queue.push(chunk);
+		this.maybeReap();
+		const sourceFormat = formatOf(chunk);
+		let expanded = null;
+		for (const subscription of this.subscriptions.values()) {
+			if (sourceFormat === "f32le" || subscription.accept.has(sourceFormat)) {
+				this.noteServed(subscription, sourceFormat, sourceFormat);
+				subscription.queue.push(chunk);
+				continue;
+			}
+			expanded ??= expandChunk(chunk, sourceFormat);
+			this.noteServed(subscription, sourceFormat, "f32le");
+			subscription.queue.push(expanded);
+		}
+	}
+	/**
+	* Run the idle-lease sweep on a cadence rather than on every chunk. A quarter
+	* of the lease bounds how long an orphan outlives its bound by, and keeps
+	* the per-chunk cost of `fanout` a single clock read.
+	*/
+	maybeReap() {
+		const now = Date.now();
+		if (now - this.lastReapAt < 12e4 / 4) return;
+		this.lastReapAt = now;
+		if (this.reapIdle(now).length > 0) this.onSubscriptionsReaped?.();
+	}
+	/**
+	* Say what a subscription is being served — once, and again on every change.
+	*
+	* The audio decision of a relay is never silent (D427). Two things this line
+	* answers that nothing else can: a consumer receiving a format it did not
+	* expect (the failure that would otherwise surface as a level of +43 dBFS
+	* with no cause), and a leg still paying 4x because its consumer declared no
+	* `accept` — `expanded: true` is the byte cost, named where it is incurred.
+	*/
+	noteServed(subscription, sourceFormat, servedFormat) {
+		const key = `${sourceFormat}>${servedFormat}`;
+		if (subscription.servedKey === key) return;
+		const previous = subscription.servedKey;
+		subscription.servedKey = key;
+		this.logger?.info("audio-chunk subscription serving", { meta: {
+			subscriptionId: subscription.id,
+			tag: subscription.tag,
+			sourceFormat,
+			servedFormat,
+			expanded: servedFormat !== sourceFormat,
+			previous
+		} });
 	}
 	/** Diagnostic snapshot of every active audio-chunk subscription. */
 	listSubscribers() {
@@ -11836,7 +11939,7 @@ 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.audioChunkPlane = new AudioChunkPlane(logger?.child("audio-chunk-plane"), () => this.checkDemand());
 		this.rtspRestreamer.onSessionCountChanged(() => this.checkDemand());
 		this.pipeServer.onClientCountChanged(() => this.checkDemand());
 	}
@@ -13191,7 +13294,10 @@ var StreamBroker = class StreamBroker {
 	subscribeAudioChunks(options) {
 		const tag = options?.tag;
 		if (!tag) this.logger?.warn(`subscribeAudioChunks called without tag — listClients will show 'unknown'`);
-		const result = this.audioChunkPlane.subscribe({ tag });
+		const result = this.audioChunkPlane.subscribe({
+			tag,
+			accept: options?.accept
+		});
 		this.checkDemand();
 		return result;
 	}
@@ -13671,16 +13777,19 @@ var StreamBroker = class StreamBroker {
 				const codecUpper = audioTrack.codec.toUpperCase();
 				this.audioCodec = codecUpper;
 				const supportedNative = codecUpper === "PCMU" || codecUpper === "PCMA";
-				this.logger?.info("audio: track detected", { meta: {
-					codec: audioTrack.codec,
-					codecUpper,
-					clockRate: audioTrack.clockRate,
-					channels: audioTrack.channels,
-					fmtpKeys: Object.keys(audioTrack.fmtp),
-					hasConfigHex: "config" in audioTrack.fmtp || "CONFIG" in audioTrack.fmtp,
-					audioCodecApiAvailable: this.audioCodecApi !== null,
-					supportedNative
-				} });
+				this.logger?.info("audio: track detected", {
+					tags: { deviceId: this.numericDeviceId },
+					meta: {
+						codec: audioTrack.codec,
+						codecUpper,
+						clockRate: audioTrack.clockRate,
+						channels: audioTrack.channels,
+						fmtpKeys: Object.keys(audioTrack.fmtp),
+						hasConfigHex: "config" in audioTrack.fmtp || "CONFIG" in audioTrack.fmtp,
+						audioCodecApiAvailable: this.audioCodecApi !== null,
+						supportedNative
+					}
+				});
 				let supported = supportedNative;
 				let effectiveSampleRate = audioTrack.clockRate;
 				let effectiveChannels = audioTrack.channels;
@@ -13688,11 +13797,17 @@ var StreamBroker = class StreamBroker {
 					this.audioRtpDecoder = new AudioRtpDecoder(codecUpper, (chunk) => {
 						this.audioChunkPlane.fanout(chunk);
 					});
-					this.logger?.info("native: audio decoder initialized", { meta: {
-						codec: codecUpper,
-						sampleRate: audioTrack.clockRate,
-						channels: audioTrack.channels
-					} });
+					this.logger?.info("native: audio decoder initialized", {
+						tags: { deviceId: this.numericDeviceId },
+						meta: {
+							codec: codecUpper,
+							sampleRate: audioTrack.clockRate,
+							channels: audioTrack.channels,
+							planeSampleRate: G711_SAMPLE_RATE,
+							planeFormat: codecUpper === "PCMA" ? "pcma" : "pcmu",
+							preD459LevelDeficitDb: Math.round(G711_SCALE_CORRECTION_DB[codecUpper === "PCMA" ? "PCMA" : "PCMU"] * 100) / 100
+						}
+					});
 				} else if (this.audioCodecApi) {
 					const capCfg = this.buildAudioCodecSessionConfig(audioTrack);
 					if (capCfg) {
@@ -17469,7 +17584,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		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 = broker.subscribeAudioChunks({ tag: input.tag });
+		const result = broker.subscribeAudioChunks({
+			tag: input.tag,
+			accept: input.accept
+		});
 		this.audioSubscriptionBroker.set(result.subscriptionId, input.brokerId);
 		return result;
 	}

package/dist/stream-broker/remoteEntry.js

@@ -30,7 +30,7 @@ async function d(e) {
 	}
 }
 async function f() {
-	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-DN_IoShh.mjs")).catch((e) => {
+	return l ||= d(() => import("./_virtual_mf-localSharedImportMap___mfe_internal__addon_stream_broker_widgets-D5XnLZWR.mjs")).catch((e) => {
 		throw l = void 0, e;
 	}), l;
 }

package/dist/worker-protocol-B2MfQLlu.js

@@ -0,0 +1,184 @@
+//#region src/session-decode/native-lease-knobs.ts
+/** Every knob, in the order the spawn line names them. */
+var NATIVE_LEASE_KNOB_NAMES = [
+	"holdFrames",
+	"budgetMb",
+	"activityMs",
+	"admission",
+	"tileBudgetMb",
+	"sceneBudgetMb"
+];
+/** The numeric knobs — every knob but `admission`. */
+var NATIVE_LEASE_NUMBER_KNOBS = [
+	"holdFrames",
+	"budgetMb",
+	"activityMs",
+	"tileBudgetMb",
+	"sceneBudgetMb"
+];
+var KNOB_SOURCES = [
+	"setting",
+	"env",
+	"default"
+];
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isAdmission(value) {
+	return value === "all" || value === "inferred";
+}
+function isKnobSource(value) {
+	return typeof value === "string" && KNOB_SOURCES.some((s) => s === value);
+}
+/**
+* Shape guard for the wire. The parent already bounded every value through the
+* knob's own Zod schema; what is checked here is what a store constructor would
+* otherwise turn into a silent misconfiguration — a non-integer, a negative
+* budget, a hold of zero (a worker that holds nothing can crop nothing), an
+* admission word that is neither mode, a source that names no level.
+*/
+function isWorkerLeaseKnobs(value) {
+	if (!isRecord$1(value) || !isRecord$1(value.values) || !isRecord$1(value.sources)) return false;
+	const { values, sources } = value;
+	for (const knob of NATIVE_LEASE_NUMBER_KNOBS) if (!isNonNegativeInteger(values[knob])) return false;
+	if (!isNonNegativeInteger(values.holdFrames) || values.holdFrames < 1) return false;
+	if (!isAdmission(values.admission)) return false;
+	return NATIVE_LEASE_KNOB_NAMES.every((knob) => isKnobSource(sources[knob]));
+}
+/**
+* The one-line spawn diagnostic. Names the effective value AND its source for
+* every knob: without the source, a log saying `holdFrames=8` cannot distinguish
+* "the operator's setting arrived" from "someone left a shell variable set", and
+* a setting that silently fails to arrive is exactly the failure the source
+* field exists to make visible.
+*/
+function formatNativeLeaseKnobs(resolved) {
+	const part = (knob) => `${knob}=${resolved.values[knob]} source=${resolved.sources[knob]}`;
+	return `native lease knobs — ${NATIVE_LEASE_KNOB_NAMES.map(part).join("; ")}`;
+}
+//#endregion
+//#region src/session-decode/worker-protocol.ts
+/**
+* Typed IPC protocol between the per-session decode coordinator (Task 3 —
+* `child_process.fork`s the worker) and the decode-worker child
+* (`decode-worker-child.ts`, Task 2). Pure module: no node-av, no
+* `process.on`/`process.send` here — those live in `decode-worker-child.ts`,
+* which documents why raw IPC is sanctioned for that file.
+*
+* The protocol is a request/response pull: the parent asks for the next
+* frame (`pull`), gets back metadata + an opaque `frameId`, then asks for
+* pixel bytes for that id with an optional ROI (`toBuffer`). No shared
+* memory, no `/dev/shm` — frames travel as IPC messages only.
+*/
+/**
+* Classify a worker diagnostic line into a {@link WorkerLogLevel}. Failure /
+* fault lines surface at `warn` (visible at the default log level so a
+* native-crop failure is finally seen in `addons.getLogs`); routine
+* provenance / transition / lifecycle lines stay `debug`. Pure + exported so
+* the mapping is unit-testable without spawning a worker.
+*/
+function logLevelForLine(line) {
+	return /\b(fail(?:ed|ure)?|error|exception|unhandled rejection|corrupt|EIO|EINVAL)\b/i.test(line) ? "warn" : "debug";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value);
+}
+function isWorkerFrameFormat(value) {
+	return value === "rgb" || value === "gray";
+}
+function isWorkerBufferFormat(value) {
+	return isWorkerFrameFormat(value) || value === "jpeg";
+}
+function isWorkerLogLevel(value) {
+	return value === "debug" || value === "info" || value === "warn" || value === "error";
+}
+function isWorkerCropRegion(value) {
+	return isRecord(value) && isFiniteNumber(value.left) && isFiniteNumber(value.top) && isFiniteNumber(value.width) && isFiniteNumber(value.height);
+}
+function isWorkerResizeTarget(value) {
+	return isRecord(value) && isFiniteNumber(value.width) && isFiniteNumber(value.height);
+}
+function isFrameImageOptions(value) {
+	if (!isRecord(value)) return false;
+	if (value.crop !== void 0 && !isWorkerCropRegion(value.crop)) return false;
+	if (value.resize !== void 0 && !isWorkerResizeTarget(value.resize)) return false;
+	if (value.format !== void 0 && !isWorkerBufferFormat(value.format)) return false;
+	return true;
+}
+function isNormalizedBbox(value) {
+	return isRecord(value) && isFiniteNumber(value.x) && isFiniteNumber(value.y) && isFiniteNumber(value.w) && isFiniteNumber(value.h);
+}
+function isVideoFrameSource(value) {
+	return isRecord(value) && typeof value.restreamUrl === "string" && isFiniteNumber(value.deviceId) && typeof value.codec === "string";
+}
+function isVideoFrameGenOptions(value) {
+	if (!isRecord(value)) return false;
+	if (value.fps !== void 0 && !isFiniteNumber(value.fps)) return false;
+	if (value.format !== void 0 && !isWorkerFrameFormat(value.format)) return false;
+	if (value.preRollMs !== void 0 && !isFiniteNumber(value.preRollMs)) return false;
+	if (value.preRollMaxFrames !== void 0 && !isFiniteNumber(value.preRollMaxFrames)) return false;
+	return true;
+}
+/** Discriminated-union guard for {@link WorkerRequest} — no `as` casts. */
+function isWorkerRequest(value) {
+	if (!isRecord(value)) return false;
+	switch (value.kind) {
+		case "start": return isVideoFrameSource(value.source) && isVideoFrameGenOptions(value.opts) && isWorkerLeaseKnobs(value.lease);
+		case "pull": return true;
+		case "toBuffer": return isFiniteNumber(value.frameId) && (value.opts === void 0 || isFrameImageOptions(value.opts));
+		case "nativeCrop": return isFiniteNumber(value.requestId) && isFiniteNumber(value.frameId) && isNormalizedBbox(value.bbox) && (value.maxWidth === void 0 || isFiniteNumber(value.maxWidth));
+		case "cutTiles": return isFiniteNumber(value.frameId) && Array.isArray(value.bboxes) && value.bboxes.every(isNormalizedBbox);
+		case "releaseNativeLease":
+		case "markInferred": return isFiniteNumber(value.frameId);
+		case "stop": return true;
+		default: return false;
+	}
+}
+/** Discriminated-union guard for {@link WorkerReply} — no `as` casts. */
+function isWorkerReply(value) {
+	if (!isRecord(value)) return false;
+	switch (value.kind) {
+		case "frame": return isFiniteNumber(value.frameId) && isFiniteNumber(value.timestamp) && isFiniteNumber(value.width) && isFiniteNumber(value.height) && isWorkerFrameFormat(value.format) && (value.capturedAt === void 0 || isFiniteNumber(value.capturedAt)) && (value.preRoll === void 0 || typeof value.preRoll === "boolean");
+		case "buffer": return isFiniteNumber(value.frameId) && value.bytes instanceof Uint8Array;
+		case "nativeCropResult": return isFiniteNumber(value.requestId) && value.bytes instanceof Uint8Array && isFiniteNumber(value.width) && isFiniteNumber(value.height) && (value.source === void 0 || value.source === "lease" || value.source === "tile");
+		case "nativeCropMiss": return isFiniteNumber(value.requestId) && (value.reason === void 0 || typeof value.reason === "string");
+		case "ended": return true;
+		case "ready": return typeof value.warm === "boolean";
+		case "error": return typeof value.message === "string" && (value.frameId === void 0 || isFiniteNumber(value.frameId));
+		case "log": return isWorkerLogLevel(value.level) && typeof value.message === "string";
+		case "preRollReport": return isFiniteNumber(value.offered) && isFiniteNumber(value.inferred) && isFiniteNumber(value.dropped) && isRecord(value.droppedByReason) && isFiniteNumber(value.strideMs) && typeof value.subsampled === "boolean" && isFiniteNumber(value.spanMs);
+		case "dialTiming": return isFiniteNumber(value.hwContextMs) && isFiniteNumber(value.demuxerOpenMs) && isFiniteNumber(value.decoderCreateMs) && isFiniteNumber(value.firstDecodeMs) && typeof value.streamInfoProbed === "boolean";
+		default: return false;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "formatNativeLeaseKnobs", {
+	enumerable: true,
+	get: function() {
+		return formatNativeLeaseKnobs;
+	}
+});
+Object.defineProperty(exports, "isWorkerReply", {
+	enumerable: true,
+	get: function() {
+		return isWorkerReply;
+	}
+});
+Object.defineProperty(exports, "isWorkerRequest", {
+	enumerable: true,
+	get: function() {
+		return isWorkerRequest;
+	}
+});
+Object.defineProperty(exports, "logLevelForLine", {
+	enumerable: true,
+	get: function() {
+		return logLevelForLine;
+	}
+});