@camstack/types 1.2.188 → 1.2.189

package/dist/index.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_sleep = require("./sleep-DXsYD0RX.js");
-const require_event_category = require("./event-category-yW4s1MGD.js");
+const require_sleep = require("./sleep-D7dV-FZB.js");
+const require_event_category = require("./event-category-BVfsrBYA.js");
 const require_canonical_hash = require("./canonical-hash-9lydiEzx.js");
 const require_enums = require("./enums.js");
 const require_err_msg = require("./err-msg-COpsHMw2.js");
@@ -394,6 +394,84 @@ function encodeProfileFromStreamShape(stream) {
 	};
 }
 //#endregion
+//#region src/camera/stream-pick.ts
+/**
+* THE target rule: which of two sizes serves a consumer better.
+*
+* "Prefer at or above the target so the consumer downscales instead of
+* upscaling; among those the SMALLEST, because the extra pixels are thrown
+* away and the decode is not; among the rest the LARGEST, because it is the
+* closest we can get." One sentence, and until now it was written twice — once
+* here in lines, once in `stream-selection.ts` in pixels, for the same two
+* exporters. The two agreed, which is luck, not a property.
+*
+* The `size` is whatever measure the caller ranks by: the cap ranks by LINES
+* (a consumer's requirement is stated in p), the RTSP picker by PIXELS (it
+* compares entries of possibly different aspect). The rule is the same either
+* way and the measure is the caller's business.
+*
+* Returns a sort delta: negative when `a` should come first.
+*/
+function compareToTarget(a, b, target) {
+	const aReaches = a >= target;
+	if (aReaches !== b >= target) return aReaches ? -1 : 1;
+	return aReaches ? a - b : b - a;
+}
+/** `h265` and `hevc` are one codec spelled two ways, and a camera publishes
+*  whichever its vendor felt like. */
+function canonicalCodec(value) {
+	const v = value.toLowerCase().replace(/[.\s-]/g, "");
+	if (v === "hevc" || v === "hvc1" || v === "hev1") return "h265";
+	if (v === "avc" || v === "avc1") return "h264";
+	return v;
+}
+function codecIsAccepted(codec, accept) {
+	if (accept.length === 0) return true;
+	if (codec === void 0) return false;
+	const c = canonicalCodec(codec);
+	return accept.some((a) => canonicalCodec(a) === c);
+}
+function providerRank(camStreamId, preferred) {
+	for (let i = 0; i < preferred.length; i += 1) if (camStreamId.startsWith(preferred[i])) return i;
+	return preferred.length;
+}
+/**
+* Order the candidates and return the winner, or `null` when none qualifies.
+*
+* The order, and every term is there for a measured reason:
+*
+*  1. **A stream we can take AS IS beats one we must re-encode.** A transcode
+*     is a decode plus an encode for as long as the session lasts, and on this
+*     hub a concurrent HEVC decode is what exhausted the VAAPI device.
+*  2. **Provider preference**, unchanged — a native dial beats a relayed one.
+*  3. **The target**, when the consumer named one: the smallest stream that
+*     reaches it, else the tallest that does not. Absent, the caller's
+*     `resolutionPreference` decides, exactly as before.
+*/
+function rankStreams(candidates, ranking) {
+	const usable = candidates.filter((c) => ranking.allowTranscode || codecIsAccepted(c.codec, ranking.acceptCodecs));
+	if (usable.length === 0) return null;
+	const target = ranking.targetHeight;
+	const scored = usable.map((candidate) => ({
+		candidate,
+		transcodes: !codecIsAccepted(candidate.codec, ranking.acceptCodecs),
+		provider: providerRank(candidate.camStreamId, ranking.preferredProviders),
+		height: candidate.height ?? 0
+	}));
+	scored.sort((a, b) => {
+		if (a.transcodes !== b.transcodes) return a.transcodes ? 1 : -1;
+		if (a.provider !== b.provider) return a.provider - b.provider;
+		if (target !== void 0) return compareToTarget(a.height, b.height, target);
+		return ranking.resolutionPreference === "highest" ? b.height - a.height : a.height - b.height;
+	});
+	const winner = scored[0];
+	if (winner === void 0) return null;
+	return {
+		candidate: winner.candidate,
+		transcodes: winner.transcodes
+	};
+}
+//#endregion
 //#region src/ffmpeg/encode-defaults.ts
 /**
 * The shape every live egress starts from: H.264 Baseline 3.1 at 720p25.
@@ -4519,6 +4597,47 @@ function reducePoints(points, bucketMs, origin) {
 }
 //#endregion
 //#region src/stream-selection.ts
+/**
+* Shared stream-selection picker for export addons.
+*
+* Both `addon-export-alexa` and `addon-export-hap` resolve the
+* operator's `streamPreference` setting against the broker's RTSP
+* entries before dialling a camera. Each addon used to roll its own:
+* Alexa had `pickPreferredRtspEntry` under `handlers/`, HAP had an
+* inline `"prefer /mid, then /high, then first"` chain inside its
+* camera-streams mapper. The chains drifted (Alexa honoured
+* `streamPreference`, HAP didn't; only Alexa got the smart
+* resolution-targeted auto-pick) and the cross-addon import rule
+* blocks deduping in either direction.
+*
+* Lifting the picker into `@camstack/types` lets every exporter call
+* the same code path with the consumer's target resolution baked into
+* the call site — Alexa passes 1280×720, HomeKit passes 1920×1080,
+* the picker handles the rest.
+*
+* Selection algorithm:
+*   - pref === '<profile>' → profile-keyed entries (from
+*                         `getProfileRtspEntries`) match on `e.profile`;
+*                         legacy raw entries match on the brokerId
+*                         suffix (`brokerId` ENDS WITH `/${pref}`, shape
+*                         `${deviceId}/${camStreamId}`). Addons store the
+*                         bare profile/camStream id in their
+*                         `ExportDeviceSettings.streamPreference`. Falls
+*                         back to 'auto' when no enabled entry matches
+*                         either way.
+*   - pref === 'auto'   → when `targetResolution` is given, pick the
+*                         entry whose source resolution is closest to
+*                         it (prefer ≥ target so the consumer
+*                         downscales instead of upscaling). Without a
+*                         target, fall back to first-enabled. If no
+*                         entry advertises a resolution at all
+*                         (broker hasn't probed yet), also fall back
+*                         to first-enabled so cold start still serves.
+*
+* Returns `null` when nothing is publishable — callers fold that into
+* the consumer's "no stream" error (Alexa: STREAM_TYPE_UNSUPPORTED;
+* HAP: a thrown error inside `startFfmpegForSession`).
+*/
 function pickPreferredRtspEntry(entries, pref, deviceId, options = {}) {
 	if (entries.length === 0) return null;
 	const prefix = `${deviceId}/`;
@@ -4548,30 +4667,23 @@ function pickPreferredRtspEntry(entries, pref, deviceId, options = {}) {
 	return toPicked(eligible[0]);
 }
 /**
-* Pick the entry whose `resolution` is closest to `target`. Prefer
-* entries ≥ target (downscale is cheap at the consumer; upscale is
-* lossy). Among the rest pick the LARGEST still ≤ target so the
-* consumer gets the best feasible quality. "Closeness" is the
-* `width × height` pixel delta.
+* Pick the entry whose `resolution` is closest to `target`, by the ONE target
+* rule ({@link compareToTarget}): prefer at or above the target so the consumer
+* downscales instead of upscaling; among those the smallest; among the rest the
+* largest.
+*
+* This function used to implement that rule itself, in pixels, while
+* `rankStreams` implemented it again in lines — the same sentence written twice
+* for the same two exporters, agreeing by luck rather than by construction.
+* Only the MEASURE is this picker's own: it compares whole pixel counts because
+* its entries can differ in aspect, where the cap's requirement is stated in p.
 */
 function pickClosestResolution(entries, target) {
 	const targetPixels = target.width * target.height;
-	let bestAbove;
-	let bestBelow;
-	for (const e of entries) {
-		if (e.resolution === void 0) continue;
-		const pixels = e.resolution.width * e.resolution.height;
-		if (pixels >= targetPixels) {
-			if (!bestAbove || pixels < bestAbove.pixels) bestAbove = {
-				entry: e,
-				pixels
-			};
-		} else if (!bestBelow || pixels > bestBelow.pixels) bestBelow = {
-			entry: e,
-			pixels
-		};
-	}
-	return bestAbove?.entry ?? bestBelow?.entry;
+	return [...entries.flatMap((entry) => entry.resolution === void 0 ? [] : [{
+		entry,
+		pixels: entry.resolution.width * entry.resolution.height
+	}])].sort((a, b) => compareToTarget(a.pixels, b.pixels, targetPixels))[0]?.entry;
 }
 //#endregion
 //#region src/types/model-variant-groups.ts
@@ -8199,6 +8311,74 @@ var cameraPipelineConfigCapability = {
 	methods: {}
 };
 //#endregion
+//#region src/capabilities/stream-signals.cap.ts
+/**
+* The signals a device can emit to WAKE its own stream.
+*
+* A camera whose stream is built on demand sleeps until something asks for it,
+* and "something" cannot be a consumer that is merely attached — a Frigate-style
+* puller holds a session open for ever, and treating that as demand would keep
+* a battery camera awake for ever, which is the whole thing the battery is for
+* (D173). So the wake has to come from the CAMERA: an event it noticed by
+* itself, with no stream running.
+*
+* ## The vocabulary is the PROVIDER'S, not ours
+*
+* Like `consumables`, this cap declares no vocabulary of its own. A provider
+* names each signal with a `code` it chooses and a `label` an operator reads.
+* Reolink offers motion and camera-native detection; another provider may offer
+* a tamper, a doorbell press, a PIR, or something no camera in this fleet has
+* yet. A fixed enum here would mean every new signal is a framework release.
+*
+* It is deliberately NOT derived from the caps a device already binds. Whether
+* a camera CAN push firmware motion is expressed by `motionSources` containing
+* `'onboard'`, and whether it does AI on-camera by the `native-object-detection`
+* binding — but both answer "what drives the detection pipeline", which is a
+* different question from "what may wake a sleeping stream". A camera can do
+* the first and not be trusted with the second, and the operator picks per
+* camera. Two questions, two authorities.
+*
+* ## Availability is not permission
+*
+* `listSignals` says what the device CAN emit. Whether a given signal actually
+* wakes the stream is the operator's per-camera choice, held by the broker
+* alongside the cooldown — see the stream-broker cap's wake settings. A
+* provider declaring a signal is not a provider enabling it.
+*/
+/** One signal a device can emit. */
+var StreamSignalSchema = zod.z.object({
+	/** Stable id chosen by the provider, e.g. `'motion'`, `'person'`, `'tamper'`. */
+	code: zod.z.string().min(1),
+	/** What an operator reads in the picker. The provider's own wording. */
+	label: zod.z.string().min(1),
+	/**
+	* Whether the provider recommends this signal ON when a camera is first set
+	* up. A provider knows which of its signals are cheap and reliable; an
+	* operator should not have to discover that by trial. Reolink recommends
+	* both of its own.
+	*/
+	recommended: zod.z.boolean()
+});
+var StreamSignalsStatusSchema = zod.z.object({
+	signals: zod.z.array(StreamSignalSchema),
+	lastFetchedAt: zod.z.number()
+});
+var streamSignalsCapability = {
+	name: "stream-signals",
+	scope: "device",
+	deviceNative: true,
+	mode: "singleton",
+	deviceTypes: Object.values(require_sleep.DeviceType),
+	runtimeState: StreamSignalsStatusSchema,
+	methods: { 
+	/**
+	* What this device can emit. Empty is a valid and common answer — most
+	* cameras have nothing to offer here, and an empty list is what makes the
+	* broker's picker show nothing rather than a false choice.
+	*/
+listSignals: require_sleep.method(zod.z.void(), zod.z.array(StreamSignalSchema).readonly()) }
+};
+//#endregion
 //#region src/capabilities/stream-broker.cap.ts
 /** Stream delivery format. (Relocated from the retired `streaming-engine` cap.) */
 var StreamFormatSchema = zod.z.enum([
@@ -8609,6 +8789,46 @@ var streamBrokerCapability = {
 	mode: "singleton",
 	exposesDeviceSettings: true,
 	methods: {
+		/**
+		* A device reporting that one of ITS OWN signals just fired.
+		*
+		* The provider calls this; nothing polls. The broker then decides whether
+		* to wake the source, and the decision has two terms that must BOTH hold:
+		*
+		*  - the signal is ENABLED for this camera (the operator's per-camera
+		*    choice — a camera may declare a signal the operator does not want
+		*    waking anything), and
+		*  - a consumer is actually attached and waiting on the prestream. Waking
+		*    a camera nobody is watching is the one thing a battery camera must
+		*    never do, and a signal arriving with no consumer is exactly that.
+		*
+		* Reported, never inferred: a signal that fires while the stream is
+		* already up refreshes the hold instead of starting a second one, which is
+		* what makes continuous motion keep a camera awake without stacking
+		* timers.
+		*
+		* `code` is the provider's own, from `streamSignals.listSignals`. An
+		* unknown code is REFUSED rather than treated as a wildcard wake — a
+		* provider and an operator disagreeing about a name must not become a
+		* camera that wakes for everything.
+		*/
+		reportStreamSignal: require_sleep.method(zod.z.object({
+			deviceId: zod.z.number().int().nonnegative(),
+			/** The provider's signal code. */
+			code: zod.z.string().min(1),
+			/** Ms epoch. Absent ⇒ now. */
+			at: zod.z.number().optional()
+		}), zod.z.object({
+			/** Whether the broker acted on it, and if not, why. */
+			accepted: zod.z.boolean(),
+			reason: zod.z.enum([
+				"woke",
+				"hold-extended",
+				"not-enabled",
+				"no-consumer",
+				"unknown-code"
+			])
+		}), { kind: "mutation" }),
 		publishCameraStream: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number().int().nonnegative(),
 			camStreamId: zod.z.string().min(1),
@@ -9086,6 +9306,16 @@ var PickStreamRequirementsSchema = zod.z.object({
 	acceptCodecs: zod.z.array(StreamCodecSchema).readonly().optional(),
 	/** Minimum vertical resolution. Streams shorter than this are dropped. */
 	minHeight: zod.z.number().int().positive().optional(),
+	/**
+	* Maximum vertical resolution. Streams TALLER than this are dropped.
+	*
+	* A consumer can have a ceiling as real as its floor: Alexa documents
+	* 480p to 1080p, and a 4K stream is as unusable to an Echo as a 360p one.
+	* Without this the ceiling had to be re-implemented by every caller — and
+	* one caller implementing it privately is how a second scoring authority
+	* gets born.
+	*/
+	maxHeight: zod.z.number().int().positive().optional(),
 	/** Minimum horizontal resolution. */
 	minWidth: zod.z.number().int().positive().optional(),
 	/**
@@ -9102,7 +9332,22 @@ var PickStreamRequirementsSchema = zod.z.object({
 	* transcoded" guard: if the device is already serving the consumer's
 	* codec end-to-end, there's nothing to optimise.
 	*/
-	requireSiblingCodec: zod.z.array(StreamCodecSchema).readonly().optional()
+	requireSiblingCodec: zod.z.array(StreamCodecSchema).readonly().optional(),
+	/**
+	* Whether a stream the consumer CANNOT decode may still be picked, on the
+	* understanding that it will be transcoded.
+	*
+	* Default `false` — today's behaviour, and the right one for a bypass
+	* question ("is there a stream I can forward untouched?"). Set `true` to
+	* ask the larger question: "what is the best stream for me, transcoding if
+	* I must?" A stream that satisfies `acceptCodecs` always outranks one that
+	* does not, so a passthrough is never lost to a transcode; the answer says
+	* which it is in {@link PickedCamStreamSchema.transcodes}.
+	*
+	* This is what lets one picker serve both the bypass and the full source
+	* choice, instead of a consumer scoring privately when the bypass misses.
+	*/
+	allowTranscode: zod.z.boolean().optional()
 }).readonly();
 var PickStreamPreferencesSchema = zod.z.object({
 	/**
@@ -9116,12 +9361,32 @@ var PickStreamPreferencesSchema = zod.z.object({
 	* picks the tallest stream; `'lowest'` picks the shortest (used by
 	* memory-constrained consumers / Apple Home guest sessions).
 	*/
-	resolutionPreference: zod.z.enum(["highest", "lowest"]).optional()
+	resolutionPreference: zod.z.enum(["highest", "lowest"]).optional(),
+	/**
+	* The height the consumer actually wants to DELIVER.
+	*
+	* Not a constraint — an ordering. With it set, the SMALLEST stream at or
+	* above the target wins, and only if nothing reaches it does the tallest
+	* take over. Pulling 1296 lines to draw 720 on a 1280x800 Echo panel costs
+	* a decode and buys nothing, and `resolutionPreference: 'highest'` cannot
+	* express that: it says "as big as possible", which is a different wish.
+	*
+	* Ignored when absent, so every existing caller keeps its ordering.
+	*/
+	targetHeight: zod.z.number().int().positive().optional()
 }).readonly();
 var PickedCamStreamSchema = zod.z.object({
 	camStreamId: zod.z.string(),
 	codec: zod.z.string().optional(),
 	resolution: require_sleep.CamStreamResolutionSchema.optional(),
+	/**
+	* Whether serving this stream requires a decode + re-encode.
+	*
+	* `false` is a stream the consumer can take as it stands. Only ever `true`
+	* when the caller asked for it with `allowTranscode`, so a caller that did
+	* not ask cannot be handed a cost it never agreed to pay.
+	*/
+	transcodes: zod.z.boolean(),
 	/** One-line explanation of why this stream won — for logs / debug UI. */
 	reason: zod.z.string()
 });
@@ -15917,6 +16182,8 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"device-enabled",
 	"device-battery-low",
 	"device-battery-normal",
+	"device-consumable-low",
+	"device-consumable-normal",
 	"stream-online",
 	"stream-offline",
 	"node-online",
@@ -15935,6 +16202,7 @@ var NcSystemEventKindSchema = zod.z.enum([
 	"addon-updated",
 	"server-updated",
 	"export-completed",
+	"backup-completed",
 	"camera-online",
 	"camera-offline",
 	"camera-disabled",
@@ -17117,10 +17385,22 @@ var NC_CONDITION_CATALOG = [
 				value: "server-updated",
 				label: "Server updated"
 			},
+			{
+				value: "device-consumable-low",
+				label: "Consumable low"
+			},
+			{
+				value: "device-consumable-normal",
+				label: "Consumable replaced"
+			},
 			{
 				value: "export-completed",
 				label: "Export completed"
 			},
+			{
+				value: "backup-completed",
+				label: "Backup completed"
+			},
 			{
 				value: "alarm-arming",
 				label: "Alarm arming (exit delay)"
@@ -26257,10 +26537,28 @@ var webrtcSessionCapability = {
 		getSessionState: require_sleep.method(zod.z.object({
 			deviceId: zod.z.number().int().nonnegative(),
 			sessionId: zod.z.string()
-		}), zod.z.object({ pendingRenegotiation: zod.z.object({
-			target: WebrtcStreamTargetSchema,
-			epoch: zod.z.number()
-		}).nullable() }))
+		}), zod.z.object({
+			pendingRenegotiation: zod.z.object({
+				target: WebrtcStreamTargetSchema,
+				epoch: zod.z.number()
+			}).nullable(),
+			/**
+			* Whether the session still EXISTS.
+			*
+			* A consumer that holds a resource for the life of a session needs to
+			* be able to ask, because a session does not always end the way it
+			* began. Measured on this hub 2026-09-13: an Echo that got stuck never
+			* sent `SessionDisconnected`, so the Alexa exporter's
+			* `releaseEgressTranscode` never ran, and a 2304x1296 HEVC to 720p
+			* H.264 transcode kept running for NOBODY for more than twenty
+			* minutes. The WebRTC session had logged `WebRTC session closed`
+			* minutes earlier — the broker knew; the holder had no way to ask.
+			*
+			* `false` for a session id the provider has never heard of, which is
+			* the same answer as "it ended": either way nothing is holding it up.
+			*/
+			alive: zod.z.boolean()
+		}))
 	},
 	/** BIG PLAN 2: declarative mount hint — read by `@camstack/system` `buildCapRouters`. */
 	mount: { kind: "server-provided" }
@@ -38653,6 +38951,7 @@ var DEVICE_LOCAL_STATE_CAPS = {
 	smoke: smokeCapability,
 	streamCatalog: streamCatalogCapability,
 	streamParams: streamParamsCapability,
+	streamSignals: streamSignalsCapability,
 	switch: switchCapability,
 	tamper: tamperCapability,
 	temperatureSensor: temperatureSensorCapability,
@@ -41797,6 +42096,7 @@ var CAPABILITY_NAMES = {
 	streamBroker: "stream-broker",
 	streamCatalog: "stream-catalog",
 	streamParams: "stream-params",
+	streamSignals: "stream-signals",
 	switch: "switch",
 	system: "system",
 	tamper: "tamper",
@@ -42358,6 +42658,10 @@ var CAPABILITY_ROUTER_KEYS = [
 		key: "streamParams",
 		name: "stream-params"
 	},
+	{
+		key: "streamSignals",
+		name: "stream-signals"
+	},
 	{
 		key: "switch",
 		name: "switch"
@@ -42591,6 +42895,7 @@ var ALL_CAPABILITY_DEFINITIONS = [
 	streamBrokerCapability,
 	streamCatalogCapability,
 	streamParamsCapability,
+	streamSignalsCapability,
 	switchCapability,
 	systemCapability,
 	tamperCapability,
@@ -48035,6 +48340,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamBroker.reportStreamSignal": {
+		capName: "stream-broker",
+		capScope: "system",
+		addonId: null,
+		access: "create"
+	},
 	"streamBroker.restartProfile": {
 		capName: "stream-broker",
 		capScope: "system",
@@ -48119,6 +48430,12 @@ var METHOD_ACCESS_MAP = Object.freeze({
 		addonId: null,
 		access: "create"
 	},
+	"streamSignals.listSignals": {
+		capName: "stream-signals",
+		capScope: "device",
+		addonId: null,
+		access: "view"
+	},
 	"switch.setState": {
 		capName: "switch",
 		capScope: "device",
@@ -48923,6 +49240,7 @@ var KNOWN_CAP_NAMES = [
 	"stream-broker",
 	"stream-catalog",
 	"stream-params",
+	"stream-signals",
 	"switch",
 	"system",
 	"terminal-session",
@@ -48990,6 +49308,7 @@ var DEVICE_CAP_NAMES = [
 	"snapshot",
 	"stream-catalog",
 	"stream-params",
+	"stream-signals",
 	"switch",
 	"update",
 	"vacuum-control",
@@ -50760,6 +51079,11 @@ var METHOD_DEVICE_SELECTORS = Object.freeze({
 		form: "single",
 		optional: false
 	}],
+	"streamBroker.reportStreamSignal": [{
+		name: "deviceId",
+		form: "single",
+		optional: false
+	}],
 	"streamBroker.restartProfile": [{
 		name: "deviceId",
 		form: "single",
@@ -51119,6 +51443,7 @@ var SYSTEM_SCOPE_DEVICE_METHODS = [
 	"streamBroker.produceEventMedia",
 	"streamBroker.publishCameraStream",
 	"streamBroker.renderPreBufferClip",
+	"streamBroker.reportStreamSignal",
 	"streamBroker.restartProfile",
 	"streamBroker.retractCameraStream",
 	"streamBroker.setDeviceAudioMute",
@@ -51158,7 +51483,7 @@ function getCapsByProviderKind(kind) {
 //#region src/generated/runtime-state-durability.ts
 /**
 * Per-cap runtime-state policy, projected from every `*.cap.ts` that declares
-* `runtimeState`. 67 caps: 35 `restored`, 32 `session`.
+* `runtimeState`. 68 caps: 35 `restored`, 33 `session`.
 *
 * A cap absent from this map has no runtime-state slice at all. A cap PRESENT
 * with `durability: 'session'` has one and has decided not to keep it.
@@ -51384,6 +51709,10 @@ var RUNTIME_STATE_POLICY = {
 		durability: "restored",
 		volatileFields: ["lastFetchedAt"]
 	},
+	"stream-signals": {
+		durability: "session",
+		volatileFields: []
+	},
 	"switch": {
 		durability: "restored",
 		volatileFields: ["lastChangedAt"]
@@ -57301,6 +57630,8 @@ exports.StreamProfileConfigSchema = StreamProfileConfigSchema;
 exports.StreamProfileOptionsSchema = StreamProfileOptionsSchema;
 exports.StreamProfilePatchSchema = StreamProfilePatchSchema;
 exports.StreamProfileSchema = StreamProfileSchema;
+exports.StreamSignalSchema = StreamSignalSchema;
+exports.StreamSignalsStatusSchema = StreamSignalsStatusSchema;
 exports.StreamSourceEntrySchema = require_sleep.StreamSourceEntrySchema;
 exports.StreamSourceSchema = require_sleep.StreamSourceSchema;
 exports.SubscribeAudioChunksInputSchema = require_sleep.SubscribeAudioChunksInputSchema;
@@ -57486,12 +57817,14 @@ exports.climateControlCapability = climateControlCapability;
 exports.clusterModelSettingKey = clusterModelSettingKey;
 exports.clusterStepSettingFieldsFor = clusterStepSettingFieldsFor;
 exports.clusterStepSettingKey = clusterStepSettingKey;
+exports.codecIsAccepted = codecIsAccepted;
 exports.collectHydratedFieldEntries = require_sleep.collectHydratedFieldEntries;
 exports.collectHydratedFieldValues = require_sleep.collectHydratedFieldValues;
 exports.collectSecretConfigKeys = collectSecretConfigKeys;
 exports.colorCapability = colorCapability;
 exports.colorForKind = colorForKind;
 exports.commitWatchdogRestart = commitWatchdogRestart;
+exports.compareToTarget = compareToTarget;
 exports.compileExpression = compileExpression;
 exports.compileExpressionSafe = compileExpressionSafe;
 exports.composeSwitchedOff = composeSwitchedOff;
@@ -57750,6 +58083,7 @@ exports.procedureAuthKey = procedureAuthKey;
 exports.ptzAutotrackCapability = ptzAutotrackCapability;
 exports.ptzCapability = ptzCapability;
 exports.pythonScriptForBackend = pythonScriptForBackend;
+exports.rankStreams = rankStreams;
 exports.readClusterStepModels = readClusterStepModels;
 exports.readClusterStepSettings = readClusterStepSettings;
 exports.readDetailCropConvention = readDetailCropConvention;
@@ -57834,6 +58168,7 @@ exports.streamCatalogCapability = streamCatalogCapability;
 exports.streamParamsCapability = streamParamsCapability;
 exports.streamPixels = streamPixels;
 exports.streamQualityLabel = streamQualityLabel;
+exports.streamSignalsCapability = streamSignalsCapability;
 exports.stripRetiredBandPreBufferSec = stripRetiredBandPreBufferSec;
 exports.strippedOfLegacyReadOnly = strippedOfLegacyReadOnly;
 exports.subKindsOf = subKindsOf;