@camstack/addon-pipeline 1.2.90 → 1.2.93

package/dist/stream-broker/index.js

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-const require_dist = require("../dist-n4Nbnxx5.js");
+const require_dist = require("../dist-D9To_r_d.js");
 const require_remote_restream = require("../remote-restream-BYbAsgUf.js");
 let node_crypto = require("node:crypto");
 node_crypto = require_dist.__toESM(node_crypto, 1);
@@ -1298,6 +1298,36 @@ function buildDerivedTranscodeArgs(input) {
 		audio
 	};
 }
+//#endregion
+//#region src/stream-broker/fill-empty-profile-slots.ts
+/**
+* When `assignProfile` locks `auto: false` (putting a derived on `low`), a
+* later catalog blip can empty the other slots. Auto-rank must not overwrite
+* the operator's slot, but EMPTY slots should still take unused eligible
+* natives — otherwise the camera stays dark until someone clicks the
+* dropdowns again (618 / 1438).
+*/
+function fillEmptyProfileSlots(current, autoRanked) {
+	const used = /* @__PURE__ */ new Set();
+	for (const profile of require_dist.CAM_PROFILE_ORDER) {
+		const id = current[profile];
+		if (id) used.add(id);
+	}
+	const ranked = [];
+	for (const profile of require_dist.CAM_PROFILE_ORDER) {
+		const id = autoRanked[profile];
+		if (id && !ranked.includes(id)) ranked.push(id);
+	}
+	const next = { ...current };
+	for (const profile of require_dist.CAM_PROFILE_ORDER) {
+		if (next[profile]) continue;
+		const candidate = ranked.find((id) => !used.has(id));
+		if (!candidate) continue;
+		next[profile] = candidate;
+		used.add(candidate);
+	}
+	return next;
+}
 /**
 * Ceiling for a configured pre-roll.
 *
@@ -13715,8 +13745,7 @@ var TranscodePipelineManager = class {
 		const outputArgs = input.outputArgs ?? [];
 		const audioEgress = input.audioEgress === true;
 		const sourceStream = input.profile !== void 0 ? this.resolveTargetedStream(input.deviceId, input.profile) : input.targetResolution !== void 0 ? this.pickClosestSource(input.deviceId, input.targetResolution) ?? this.firstPublished(input.deviceId) : this.firstPublished(input.deviceId);
-		if (input.profile === void 0 && !sourceStream) throw new Error(`getStreamWithCodec: no published stream for device ${input.deviceId}`);
-		if (!sourceStream || !sourceStream.url) throw new Error(`getStreamWithCodec: no assigned source for device ${input.deviceId}`);
+		if (!sourceStream) throw new Error(input.profile === void 0 ? `getStreamWithCodec: no published stream for device ${input.deviceId}` : `getStreamWithCodec: no assigned source for device ${input.deviceId}`);
 		const sourceCodec = normaliseCodec(sourceStream.codec);
 		const outResolution = input.targetResolution ?? sourceStream.resolution ?? {
 			width: 1280,
@@ -13901,11 +13930,17 @@ var TranscodePipelineManager = class {
 	* Throws when the profile has no assignment or the assigned source is not
 	* currently published — a targeted request must not silently fall back to
 	* a different source.
+	*
+	* Publication is "in the catalog", NOT `!!stream.url`. A `derived:*` stream
+	* is broker-owned metadata with no camera pull URL; consumers ride the
+	* broker restream (`resolveSourceUrl`), and the broker starts the transcode
+	* feeder on demand. Requiring a catalog `url` made recording/WebRTC throw
+	* `not published` for a live derived assignment (618, 2026-08-17).
 	*/
 	resolveTargetedStream(deviceId, profile) {
 		const camStreamId = this.resolveProfileSource?.(deviceId, profile) ?? null;
 		if (!camStreamId) throw new Error(`getStreamWithCodec: profile "${profile}" has no assigned source for device ${deviceId}`);
-		const stream = this.cameraStreamLookup(deviceId).find((s) => s.camStreamId === camStreamId && !!s.url);
+		const stream = this.cameraStreamLookup(deviceId).find((s) => s.camStreamId === camStreamId);
 		if (!stream) throw new Error(`getStreamWithCodec: profile "${profile}" source "${camStreamId}" not published for device ${deviceId}`);
 		return stream;
 	}
@@ -14571,6 +14606,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		return this.transcodeManager;
 	}
 	async getStreamWithCodec(input) {
+		if (input.profile !== void 0) {
+			const camStreamId = this.assignments.get(input.deviceId)?.map[input.profile];
+			if (camStreamId) await this.ensureDerivedReady(input.deviceId, camStreamId);
+		}
 		const source = await this.getTranscodeManager().acquire(input);
 		if (input.hostname !== void 0 && input.hostname.length > 0) return {
 			...source,
@@ -15237,8 +15276,14 @@ var StreamBrokerManager = class StreamBrokerManager {
 	*/
 	async ensureBrokerForWebrtcSession(deviceId, brokerId, camStreamId, tier) {
 		if (this.disabledDevices.has(deviceId)) return;
-		if (this.brokers.has(brokerId)) return;
 		if (this.remoteBrokerAdapters.has(brokerId)) return;
+		if (camStreamId !== void 0) {
+			if ((this.cameraStreams.get(deviceId)?.get(camStreamId))?.kind === "derived") {
+				await this.ensureDerivedReady(deviceId, camStreamId);
+				if (this.brokers.has(brokerId)) return;
+			}
+		}
+		if (this.brokers.has(brokerId)) return;
 		if (camStreamId === void 0) return;
 		const published = this.cameraStreams.get(deviceId)?.get(camStreamId);
 		if (published !== void 0 && published.kind !== "derived") {
@@ -15593,7 +15638,16 @@ var StreamBrokerManager = class StreamBrokerManager {
 				camStreamId: input.sourceCamStreamId
 			} : void 0);
 			if (!derivedSource || !encodeProfile) throw new Error("kind: 'derived' requires a source (profile|camStream) + encodeProfile");
-			if (this.cameraStreams.get(deviceId)?.get(camStreamId)) return { success: true };
+			const existingDerived = this.cameraStreams.get(deviceId)?.get(camStreamId);
+			if (existingDerived) {
+				this.cameraStreams.get(deviceId)?.set(camStreamId, {
+					...existingDerived,
+					derivedSource,
+					encodeProfile
+				});
+				await this.ensureDerivedReady(deviceId, camStreamId);
+				return { success: true };
+			}
 			if (derivedSource.kind === "camStream") {
 				const sourceBrokerId = brokerIdFor(deviceId, derivedSource.camStreamId);
 				if (!this.brokers.has(sourceBrokerId)) throw new Error(`SOURCE_NOT_FOUND: ${sourceBrokerId}`);
@@ -15619,11 +15673,14 @@ var StreamBrokerManager = class StreamBrokerManager {
 				order,
 				deviceFeatures: deviceFeaturesArr,
 				autoEligible: input.autoEligible ?? false,
-				brokerOwned: true
+				brokerOwned: true,
+				derivedSource,
+				encodeProfile
 			};
 			derivedStreamMap.set(camStreamId, derivedCam);
 			await this.ensureBroker(deviceId, camStreamId);
 			this.attachDerivedFeeder(deviceId, camStreamId, derivedSource, encodeProfile);
+			await this.reconcileAutoAssignment(deviceId, "publish", true);
 			this.emitCamStreamsChanged(deviceId);
 			return { success: true };
 		}
@@ -17784,14 +17841,15 @@ var StreamBrokerManager = class StreamBrokerManager {
 	*
 	* Streams marked `autoEligible: false` are skipped — they remain
 	* published (visible + manually assignable via `assignProfile`) but
-	* never become the default. If every stream is non-eligible the
-	* algorithm degrades gracefully and considers them all (so a device
-	* with only ineligible streams still gets some default assignment).
+	* never become the default. If every stream is non-eligible the map
+	* stays empty: ranking ineligible streams (a derived that beat the
+	* catalog to boot) parked a transcode on `high` and left the natives
+	* around it (618, 2026-08-17).
 	*/
 	computeInitialAssignment(streams) {
-		if (streams.length === 0) return {};
 		const eligible = streams.filter((s) => s.autoEligible);
-		const ranked = [...eligible.length > 0 ? eligible : streams].toSorted((a, b) => {
+		if (eligible.length === 0) return {};
+		const ranked = [...eligible].toSorted((a, b) => {
 			const aPx = a.resolution ? a.resolution.width * a.resolution.height : -1;
 			const bPx = b.resolution ? b.resolution.width * b.resolution.height : -1;
 			if (aPx !== bPx) return bPx - aPx;
@@ -17814,13 +17872,19 @@ var StreamBrokerManager = class StreamBrokerManager {
 	* `publishCameraStream` so a multi-stream catalog publish can upsert
 	* every stream first and rank ONCE (no transient intermediate
 	* assignment). When the device's assignment is operator-locked
-	* (`auto === false`) the existing map is re-applied unchanged.
+	* (`auto === false`) occupied slots stay put (a derived on `low` must
+	* not be kicked off). Empty slots refill from unused natives when the
+	* device has a derived stream (618 / 1438) or the whole map is empty —
+	* a camera without deriveds still honours an operator unassign.
 	*/
 	async reconcileAutoAssignment(deviceId, reason, streamAdded = false) {
 		const current = this.assignments.get(deviceId);
 		const streams = [...this.cameraStreams.get(deviceId)?.values() ?? []].toSorted((a, b) => a.order - b.order);
 		const isAuto = current?.auto ?? true;
-		const newMap = !current || isAuto && this.wouldChangeAutoMap(current.map, streams) ? this.computeInitialAssignment(streams) : current.map;
+		const ranked = this.computeInitialAssignment(streams);
+		const hasDerived = streams.some((s) => s.kind === "derived");
+		const lockedEmpty = current !== void 0 && !isAuto && require_dist.CAM_PROFILE_ORDER.every((profile) => current.map[profile] === void 0);
+		const newMap = !current ? ranked : isAuto ? this.wouldChangeAutoMap(current.map, streams) ? ranked : current.map : hasDerived || lockedEmpty ? fillEmptyProfileSlots(current.map, ranked) : current.map;
 		await this.applyAssignmentUpdate(deviceId, newMap, {
 			auto: isAuto,
 			reason,
@@ -18219,6 +18283,10 @@ var StreamBrokerManager = class StreamBrokerManager {
 		if (!existingToken) this.rtspProvider.persistTokens();
 		await this.fanOutRegistration(deviceId, brokerId, cam, broker);
 		this.syncProfileRestreamers(deviceId);
+		if (cam.kind === "derived") {
+			const def = this.resolveDerivedDef(deviceId, camStreamId);
+			if (def) this.attachDerivedFeeder(deviceId, camStreamId, def.source, def.encodeProfile);
+		}
 	}
 	/**
 	* Tear down the broker for a `(deviceId, camStreamId)` pair. No-op
@@ -18250,6 +18318,40 @@ var StreamBrokerManager = class StreamBrokerManager {
 		this.syncProfileRestreamers(deviceId);
 	}
 	/**
+	* Ensure a derived stream's push broker exists AND its transcode feeder is
+	* attached. Consumers (recording `getStreamWithCodec`, WebRTC session setup,
+	* profile restream DESCRIBE) address the PROFILE; the broker is responsible
+	* for starting the derived. No-op for non-derived camStreams.
+	*/
+	async ensureDerivedReady(deviceId, camStreamId) {
+		if ((this.cameraStreams.get(deviceId)?.get(camStreamId))?.kind !== "derived") return;
+		const def = this.resolveDerivedDef(deviceId, camStreamId);
+		if (!def) return;
+		await this.ensureBroker(deviceId, camStreamId);
+		this.attachDerivedFeeder(deviceId, camStreamId, def.source, def.encodeProfile);
+	}
+	/**
+	* Source + encode profile for a derived camStream. Prefers the fields stored
+	* on the catalog entry at publish; falls back to the persisted device
+	* override (`derivedStreams[<name>]`) so a consumer can re-attach after a
+	* broker release even if the in-memory record predates those fields.
+	*/
+	resolveDerivedDef(deviceId, camStreamId) {
+		const published = this.cameraStreams.get(deviceId)?.get(camStreamId);
+		if (published?.derivedSource && published.encodeProfile) return {
+			source: published.derivedSource,
+			encodeProfile: published.encodeProfile
+		};
+		if (!camStreamId.startsWith("derived:")) return null;
+		const name = camStreamId.slice(8);
+		const def = this.deviceOverrides.get(deviceId)?.derivedStreams?.[name];
+		if (!def?.source || !def.encodeProfile) return null;
+		return {
+			source: def.source,
+			encodeProfile: def.encodeProfile
+		};
+	}
+	/**
 	* Attach the on-demand transcode-feeder lifecycle to a freshly-minted derived
 	* push broker. The feeder runs ONLY while the derived broker is consumed — it
 	* is spawned on the broker's demand edge (`onDemandChange(true)`) and torn
@@ -25006,6 +25108,22 @@ var RecordedFeeder = class {
 	}
 };
 //#endregion
+//#region src/stream-broker/recorded/playback-profile-fallback.ts
+/**
+* Recorded playback is pinned to one profile (no adaptive ladder). When the
+* viewer asks for `mid` (auto/adaptive default) but the camera only kept
+* `high` — typical of events-mode — locate must try the other tiers before
+* reporting a gap.
+*/
+var PLAYBACK_PROFILE_FALLBACK_ORDER = [
+	"high",
+	"mid",
+	"low"
+];
+function profileSearchOrder(requested) {
+	return [requested, ...PLAYBACK_PROFILE_FALLBACK_ORDER.filter((p) => p !== requested)];
+}
+//#endregion
 //#region src/stream-broker/recorded/timeline-session.ts
 /**
 * Per-viewer coordinator over one broker WebRTC session. Owns the playback mode
@@ -25052,17 +25170,14 @@ var TimelineSession = class {
 	async handleControl(msg) {
 		this.emitLiveProfile();
 		switch (msg.t) {
-			case "playRecorded": {
-				const profileChanged = msg.profile !== this.profile;
-				this.profile = msg.profile;
-				await (this.mode === "recorded" && this.feeder && !profileChanged ? this.feeder : this.enterRecorded()).seek(msg.epoch, { travelFromMs: this.lastPositionMs });
+			case "playRecorded":
+				await this.playAt(msg.epoch, msg.profile, { travelFromMs: this.lastPositionMs });
 				break;
-			}
 			case "seek":
-				await (this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).seek(msg.epoch, { travelFromMs: this.lastPositionMs });
+				await this.playAt(msg.epoch, this.profile, { travelFromMs: this.lastPositionMs });
 				break;
 			case "scrubCommit":
-				await (this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).seek(msg.epoch);
+				await this.playAt(msg.epoch, this.profile);
 				break;
 			case "scrubStart":
 				(this.mode === "recorded" && this.feeder ? this.feeder : this.enterRecorded()).beginScrub();
@@ -25108,6 +25223,29 @@ var TimelineSession = class {
 		this.feeder = feeder;
 		return feeder;
 	}
+	/**
+	* Play recorded footage at `epochMs`. If `locate` is wired and the requested
+	* profile has no segment, try high → mid → low so events-mode cameras that
+	* only kept one tier still play.
+	*/
+	async playAt(epochMs, requestedProfile, opts) {
+		const profile = await this.resolveProfile(requestedProfile, epochMs);
+		const profileChanged = profile !== this.profile;
+		this.profile = profile;
+		const feeder = this.mode === "recorded" && this.feeder && !profileChanged ? this.feeder : this.enterRecorded();
+		if (opts) await feeder.seek(epochMs, opts);
+		else await feeder.seek(epochMs);
+	}
+	async resolveProfile(requested, epochMs) {
+		const locate = this.deps.locate;
+		if (!locate) return requested;
+		for (const profile of profileSearchOrder(requested)) if ((await locate({
+			deviceId: this.deps.deviceId,
+			profile,
+			epochMs
+		})).kind === "segment") return profile;
+		return requested;
+	}
 	goLive() {
 		this.feeder?.dispose();
 		this.feeder = null;
@@ -32786,6 +32924,30 @@ async function demuxSegmentAudioOpusPreferJs(bytes, opts = {}) {
 	}
 }
 //#endregion
+//#region src/stream-broker/webrtc/prefer-live-adaptive-candidates.ts
+function isDerivedBrokerId(brokerId) {
+	const slash = brokerId.indexOf("/");
+	if (slash < 0) return false;
+	return brokerId.slice(slash + 1).startsWith("derived:");
+}
+/**
+* Adaptive live walks every registered broker for a device. When no profile
+* slot is bound, Map insertion order wins — and a derived materialized at
+* boot is often first, so the picture attaches to a transcode whose source
+* profile is empty (618, 2026-08-17).
+*
+* Prefer brokers that currently own a profile tier. If none do, drop
+* unassigned deriveds so a native pull can win. If the derived is the only
+* broker, keep it (better a stream than a throw).
+*/
+function preferLiveAdaptiveCandidates(candidates) {
+	if (candidates.length <= 1) return [...candidates];
+	const assigned = candidates.filter((c) => c.tier !== null);
+	if (assigned.length > 0) return assigned;
+	const natives = candidates.filter((c) => !isDerivedBrokerId(c.brokerId));
+	return natives.length > 0 ? natives : [...candidates];
+}
+//#endregion
 //#region src/stream-broker/webrtc/broker-webrtc-server.ts
 /**
 * Broker-integrated WebRTC server.
@@ -33741,6 +33903,7 @@ var BrokerWebrtcServer = class {
 			timeline = new TimelineSession({
 				session,
 				deviceId,
+				locate: locateRecorded,
 				...initialLiveProfile !== null ? { initialLiveProfile } : {},
 				warm: readGop ? (profile, epochMs) => {
 					warmFragment({
@@ -34110,12 +34273,13 @@ var BrokerWebrtcServer = class {
 				broker
 			});
 		}
-		if (candidates.length === 0) return `${deviceKey}/high`;
-		if (candidates.length === 1) return candidates[0].brokerId;
+		const pool = preferLiveAdaptiveCandidates(candidates);
+		if (pool.length === 0) return `${deviceKey}/high`;
+		if (pool.length === 1) return pool[0].brokerId;
 		const adaptiveDeviceIdTag = Number(deviceKey.split("/")[0]);
 		const deviceIdTag = Number.isFinite(adaptiveDeviceIdTag) ? { tags: { deviceId: adaptiveDeviceIdTag } } : {};
 		if (hints.prefersTier === "high" || hints.prefersTier === "mid" || hints.prefersTier === "low") {
-			const explicit = candidates.find((c) => c.tier === hints.prefersTier);
+			const explicit = pool.find((c) => c.tier === hints.prefersTier);
 			if (explicit) {
 				this.logger.info("Adaptive source selected (prefersTier exact)", {
 					...deviceIdTag,
@@ -34129,7 +34293,7 @@ var BrokerWebrtcServer = class {
 				return explicit.brokerId;
 			}
 			for (const tier of SMALLEST_FIRST_TIER_PREFERENCE) {
-				const match = candidates.find((c) => c.tier === tier);
+				const match = pool.find((c) => c.tier === tier);
 				if (match) {
 					this.logger.info("Adaptive source selected (prefersTier fallback → smallest available)", {
 						...deviceIdTag,
@@ -34146,7 +34310,7 @@ var BrokerWebrtcServer = class {
 		}
 		if (!(hints.viewportWidth !== void 0 || hints.viewportHeight !== void 0 || hints.downlinkMbps !== void 0)) {
 			for (const tier of TIER_PREFERENCE) {
-				const match = candidates.find((c) => c.tier === tier);
+				const match = pool.find((c) => c.tier === tier);
 				if (match) {
 					this.logger.info("Adaptive source selected (no client hints — tier preference)", {
 						...deviceIdTag,
@@ -34159,12 +34323,12 @@ var BrokerWebrtcServer = class {
 					return match.brokerId;
 				}
 			}
-			return candidates[0].brokerId;
+			return pool[0].brokerId;
 		}
-		let bestId = candidates[0].brokerId;
-		let bestTier = candidates[0].tier;
+		let bestId = pool[0].brokerId;
+		let bestTier = pool[0].tier;
 		let bestScore = Infinity;
-		for (const c of candidates) {
+		for (const c of pool) {
 			const score = scoreBroker(c.tier, c.broker, hints);
 			const cRank = c.tier ? TIER_PREFERENCE.indexOf(c.tier) : TIER_PREFERENCE.length;
 			const bestRank = bestTier ? TIER_PREFERENCE.indexOf(bestTier) : TIER_PREFERENCE.length;