mediasoup 3.20.7 → 3.20.9

package/npm-scripts.mjs

@@ -8,7 +8,9 @@ import * as tar from 'tar';
 import pkg from './package.json' with { type: 'json' };
 
 const IS_WINDOWS = os.platform() === 'win32';
-const MAYOR_VERSION = pkg.version.split('.')[0];
+// Main Git branch is 'v' concatenated with the major SEMVER number of the
+// "version" field in package.json.
+const MAIN_BRANCH = `v${pkg.version.split('.')[0]}`;
 const PYTHON = getPython();
 const PIP_INVOKE_DIR = path.resolve('worker/pip_invoke');
 const WORKER_RELEASE_DIR = 'worker/out/Release';
@@ -17,8 +19,6 @@ const WORKER_RELEASE_BIN = IS_WINDOWS
 	: 'mediasoup-worker';
 const WORKER_RELEASE_BIN_PATH = `${WORKER_RELEASE_DIR}/${WORKER_RELEASE_BIN}`;
 const WORKER_PREBUILD_DIR = 'worker/prebuild';
-const GH_OWNER = 'versatica';
-const GH_REPO = 'mediasoup';
 
 // Paths for ESLint to check.
 const ESLINT_PATHS = [
@@ -27,6 +27,7 @@ const ESLINT_PATHS = [
 	'knip.config.mjs',
 	'node/src',
 	'npm-scripts.mjs',
+	'rust-scripts.mjs',
 	'worker/scripts',
 ];
 
@@ -47,6 +48,7 @@ const PRETTIER_PATHS = [
 	'node/src',
 	'npm-scripts.mjs',
 	'package.json',
+	'rust-scripts.mjs',
 	'tsconfig.json',
 	'worker/scripts',
 ];
@@ -137,13 +139,13 @@ async function run() {
 		}
 
 		case 'typescript:build': {
-			buildTypescript({ force: true });
+			buildTypescript({ force: true, args: taskArgs });
 
 			break;
 		}
 
 		case 'typescript:watch': {
-			watchTypescript();
+			watchTypescript({ args: taskArgs });
 
 			break;
 		}
@@ -215,7 +217,7 @@ async function run() {
 		}
 
 		case 'test:node': {
-			testNode();
+			testNode({ args: taskArgs });
 
 			break;
 		}
@@ -227,7 +229,7 @@ async function run() {
 		}
 
 		case 'coverage:node': {
-			coverageNode();
+			coverageNode({ args: taskArgs });
 
 			break;
 		}
@@ -245,7 +247,7 @@ async function run() {
 		}
 
 		case 'release': {
-			await release();
+			await release({ args: taskArgs });
 
 			break;
 		}
@@ -317,7 +319,7 @@ function deleteNodeLib() {
 	fs.rmSync('node/lib', { recursive: true, force: true });
 }
 
-function buildTypescript({ force }) {
+function buildTypescript({ force, args = '' }) {
 	// Skip JavaScript code generation if the output already exists, unless forced.
 	if (!force && fs.existsSync('node/lib')) {
 		return;
@@ -327,15 +329,15 @@ function buildTypescript({ force }) {
 
 	deleteNodeLib();
 
-	executeCmd(`tsc ${taskArgs}`);
+	executeCmd(`tsc ${args}`);
 }
 
-function watchTypescript() {
+function watchTypescript({ args = '' } = {}) {
 	logInfo('watchTypescript()');
 
 	deleteNodeLib();
 
-	executeCmd(`tsc --watch ${taskArgs}`);
+	executeCmd(`tsc --watch ${args}`);
 }
 
 function buildWorker() {
@@ -487,10 +489,10 @@ function flatcWorker() {
 	executeCmd(`"${PYTHON}" -m invoke -r worker flatc`);
 }
 
-function testNode() {
+function testNode({ args = '' } = {}) {
 	logInfo('testNode()');
 
-	executeCmd(`jest --silent false --detectOpenHandles ${taskArgs}`);
+	executeCmd(`jest --silent false --detectOpenHandles ${args}`);
 }
 
 function testWorker() {
@@ -501,10 +503,10 @@ function testWorker() {
 	executeCmd(`"${PYTHON}" -m invoke -r worker test`);
 }
 
-function coverageNode() {
+function coverageNode({ args = '' } = {}) {
 	logInfo('coverageNode()');
 
-	executeCmd(`jest --coverage ${taskArgs}`);
+	executeCmd(`jest --coverage ${args}`);
 	executeCmd('open-cli coverage/lcov-report/index.html');
 }
 
@@ -542,6 +544,18 @@ function publishDryRun() {
 async function checkRelease() {
 	logInfo('checkRelease()');
 
+	// Verify that CHANGELOG.md has an entry for the new version (and grab its
+	// changes, used as the GitHub release body) before the slow build steps.
+	let versionChanges;
+
+	try {
+		versionChanges = await getVersionChanges();
+	} catch (error) {
+		logError(error.message);
+
+		exitWithError();
+	}
+
 	installNodeDeps();
 	await flatcNode({ force: true });
 	buildTypescript({ force: true });
@@ -553,41 +567,55 @@ async function checkRelease() {
 	// Validate packaging (the `files` list in package.json) before the
 	// irreversible release steps (git push, GitHub release, npm publish).
 	publishDryRun();
+
+	return { versionChanges };
 }
 
-async function release() {
+async function release({ args = '' } = {}) {
 	logInfo('release()');
 
-	let octokit;
-	let versionChanges;
+	const version = args.trim();
 
-	try {
-		octokit = await getOctokit();
-		versionChanges = await getVersionChanges();
-	} catch (error) {
-		logError(error.message);
+	if (!/^\d+\.\d+\.\d+$/.test(version)) {
+		logError(
+			`release() | a SEMVER 'x.y.z' argument is required, but got '${version}'`
+		);
+
+		exitWithError();
+	}
+
+	// Must be on the main branch.
+	const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+		encoding: 'utf-8',
+	}).trim();
+
+	if (branch !== MAIN_BRANCH) {
+		logError(
+			`release() | must be on '${MAIN_BRANCH}' branch, but it is on '${branch}' branch`
+		);
 
 		exitWithError();
 	}
 
+	// Clean working tree required before bumping the version.
+	checkGitClean();
+
+	// Lint, test, build, publish dry-run, and verify the CHANGELOG entry (of the
+	// previous version still in package.json, which is harmless).
 	await checkRelease();
-	executeCmd(`git commit -am '${pkg.version}'`);
-	executeCmd(`git tag -a ${pkg.version} -m '${pkg.version}'`);
-	executeCmd(`git push origin v${MAYOR_VERSION}`);
-	executeCmd(`git push origin '${pkg.version}'`);
-
-	logInfo('creating release in GitHub');
-
-	await octokit.repos.createRelease({
-		owner: GH_OWNER,
-		repo: GH_REPO,
-		name: pkg.version,
-		body: versionChanges,
-		tag_name: pkg.version,
-		draft: false,
-	});
 
-	executeInteractiveCmd('npm publish');
+	// Bump the version in package.json + package-lock.json and in CHANGELOG.md.
+	executeCmd(`npm version ${version} --no-git-tag-version`);
+	await updateChangelog(version);
+
+	// Commit the bump, tag it, and push both. The pushed tag triggers
+	// mediasoup-npm-publish.yaml, which checks, creates the GitHub release and
+	// publishes to NPM; on its success mediasoup-worker-prebuild.yaml builds and
+	// uploads the prebuilt binaries.
+	executeCmd(`git commit -am 'version ${version}'`);
+	executeCmd(`git tag -a ${version} -m '${version}'`);
+	executeCmd(`git push origin ${MAIN_BRANCH}`);
+	executeCmd(`git push origin '${version}'`);
 }
 
 function ensureDir(dir) {
@@ -757,19 +785,21 @@ async function downloadPrebuiltWorker() {
 	});
 }
 
-async function getOctokit() {
-	if (!process.env.GITHUB_TOKEN) {
-		throw new Error('missing GITHUB_TOKEN environment variable');
-	}
+function checkGitClean() {
+	logInfo('checkGitClean()');
 
-	// NOTE: Load dep on demand since it's a devDependency.
-	const { Octokit } = await import('@octokit/rest');
-
-	const octokit = new Octokit({
-		auth: process.env.GITHUB_TOKEN,
+	const status = execSync('git status --porcelain', {
+		encoding: 'utf-8',
+		stdio: ['ignore', 'pipe', 'ignore'],
 	});
 
-	return octokit;
+	if (status.trim()) {
+		logError(
+			'checkGitClean() | Git working tree is not clean, commit or stash your changes first'
+		);
+
+		exitWithError();
+	}
 }
 
 async function getVersionChanges() {
@@ -785,9 +815,26 @@ async function getVersionChanges() {
 		const entry = entries[idx];
 
 		if (entry.type === 'heading' && entry.text === pkg.version) {
-			const changes = entries[idx + 1].raw;
+			// Collect every token after the matching heading until the next heading.
+			// NOTE: We cannot just use `entries[idx + 1].raw` because `marked`
+			// inserts a `space` token between the heading and its content.
+			let changes = '';
+
+			for (let next = idx + 1; next < entries.length; ++next) {
+				if (entries[next].type === 'heading') {
+					break;
+				}
+
+				changes += entries[next].raw;
+			}
+
+			changes = changes.trim();
 
-			return changes;
+			if (changes) {
+				return changes;
+			}
+
+			break;
 		}
 	}
 
@@ -797,6 +844,35 @@ async function getVersionChanges() {
 	);
 }
 
+async function updateChangelog(version) {
+	logInfo(`updateChangelog() [version:${version}]`);
+
+	// NOTE: Load dep on demand since it's a devDependency.
+	const marked = await import('marked');
+
+	const changelog = fs.readFileSync('./CHANGELOG.md', { encoding: 'utf-8' });
+	const tokens = marked.lexer(changelog);
+
+	// Locate the top "### NEXT" heading.
+	const nextHeading = tokens.find(
+		token =>
+			token.type === 'heading' && token.depth === 3 && token.text === 'NEXT'
+	);
+
+	if (!nextHeading) {
+		throw new Error("no '### NEXT' heading found in CHANGELOG.md");
+	}
+
+	// Insert "### <version>" right below "### NEXT" (keeping the empty "### NEXT"
+	// for future unreleased changes), preserving the heading's trailing newlines.
+	const updatedChangelog = changelog.replace(
+		nextHeading.raw,
+		`### NEXT\n\n### ${version}${nextHeading.raw.slice('### NEXT'.length)}`
+	);
+
+	fs.writeFileSync('./CHANGELOG.md', updatedChangelog);
+}
+
 function executeCmd(command) {
 	logInfo(`executeCmd(): ${command}`);
 
@@ -809,11 +885,12 @@ function executeCmd(command) {
 	}
 }
 
-function executeInteractiveCmd(command) {
-	logInfo(`executeInteractiveCmd(): ${command}`);
+// eslint-disable-next-line no-unused-vars
+function executeInteractiveCmd(command, { cwd } = {}) {
+	logInfo(`executeInteractiveCmd(): ${command}${cwd ? ` [cwd:${cwd}]` : ''}`);
 
 	try {
-		execSync(command, { stdio: 'inherit', env: process.env });
+		execSync(command, { cwd, stdio: 'inherit', env: process.env });
 	} catch (error) {
 		logError(`executeInteractiveCmd() failed, exiting: ${error}`);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mediasoup",
-	"version": "3.20.7",
+	"version": "3.20.9",
 	"description": "Cutting Edge WebRTC Video Conferencing",
 	"contributors": [
 		"Iñaki Baz Castillo <ibc@aliax.net> (https://inakibaz.me)",
@@ -98,7 +98,9 @@
 		"coverage:node": "node npm-scripts.mjs coverage:node",
 		"publish:dry-run": "node npm-scripts.mjs publish:dry-run",
 		"release:check": "node npm-scripts.mjs release:check",
-		"release": "node npm-scripts.mjs release"
+		"release": "node npm-scripts.mjs release",
+		"release:rust:check": "node rust-scripts.mjs release:check",
+		"release:rust": "node rust-scripts.mjs release"
 	},
 	"dependencies": {
 		"debug": "^4.4.3",
@@ -114,13 +116,13 @@
 		"@types/debug": "^4.1.13",
 		"@types/ini": "^4.1.1",
 		"@types/jest": "^30.0.0",
-		"@types/node": "^25.9.3",
+		"@types/node": "^26.0.0",
 		"eslint": "^10.5.0",
 		"eslint-config-prettier": "^10.1.8",
 		"eslint-plugin-jest": "^29.15.2",
 		"eslint-plugin-prettier": "^5.5.6",
 		"globals": "^17.6.0",
-		"ini": "^6.0.0",
+		"ini": "^7.0.0",
 		"jest": "^30.4.2",
 		"knip": "^6.17.1",
 		"marked": "^18.0.5",

package/worker/fbs/webRtcServer.fbs

@@ -12,17 +12,11 @@ table IceUserNameFragment {
     web_rtc_transport_id: string (required);
 }
 
-table TupleHash {
-    tuple_hash: uint64;
-    web_rtc_transport_id: string (required);
-}
-
 table DumpResponse {
     id: string (required);
     udp_sockets: [IpPort] (required);
     tcp_servers: [IpPort] (required);
     web_rtc_transport_ids: [string] (required);
     local_ice_username_fragments: [IceUserNameFragment] (required);
-    tuple_hashes: [TupleHash] (required);
 }
 

package/worker/include/RTC/TransportTuple.hpp

@@ -23,28 +23,60 @@ namespace RTC
 			TCP = 2
 		};
 
+		class TupleKey
+		{
+		private:
+			friend class TransportTuple;
+			friend class TupleKeyHash;
+
+		public:
+			TupleKey() = default;
+			TupleKey(Protocol protocol, const void* udpSocketOrTcpConnection, const struct sockaddr* udpRemoteAddr)
+			  : protocol(protocol),
+			    udpSocketOrTcpConnection(udpSocketOrTcpConnection),
+			    udpRemoteAddr(udpRemoteAddr) {};
+
+			bool operator==(const TupleKey& other) const noexcept;
+			bool operator!=(const TupleKey& other) const noexcept
+			{
+				return !(*this == other);
+			};
+
+		private:
+			Protocol protocol{ Protocol::UDP };
+			// The local endpoint is identified by object pointer identity: the
+			// UdpSocket or the TcpConnection. For TCP the connection alone identifies
+			// the whole tuple, so `udpRemoteAddr` is unused.
+			const void* udpSocketOrTcpConnection{ nullptr };
+			const struct sockaddr* udpRemoteAddr{ nullptr };
+		};
+
+		struct TupleKeyHash
+		{
+			size_t operator()(const TupleKey& key) const noexcept;
+		};
+
 		static Protocol ProtocolFromFbs(FBS::Transport::Protocol protocol);
 		static FBS::Transport::Protocol ProtocolToFbs(Protocol protocol);
-		static uint64_t GenerateFnv1aHash(const uint8_t* data, size_t size);
 
 	public:
 		TransportTuple(RTC::UdpSocket* udpSocket, const struct sockaddr* udpRemoteAddr)
 		  : udpSocket(udpSocket),
 		    udpRemoteAddr(const_cast<struct sockaddr*>(udpRemoteAddr)),
-		    protocol(Protocol::UDP)
+		    protocol(Protocol::UDP),
+		    tupleKey(Protocol::UDP, udpSocket, udpRemoteAddr)
 		{
-			GenerateHash();
 		}
 
 		explicit TransportTuple(RTC::TcpConnection* tcpConnection)
-		  : tcpConnection(tcpConnection), protocol(Protocol::TCP)
+		  : tcpConnection(tcpConnection),
+		    protocol(Protocol::TCP),
+		    tupleKey(Protocol::TCP, tcpConnection, nullptr)
 		{
-			GenerateHash();
 		}
 
 		explicit TransportTuple(const TransportTuple* tuple)
-		  : hash(tuple->hash),
-		    udpSocket(tuple->udpSocket),
+		  : udpSocket(tuple->udpSocket),
 		    udpRemoteAddr(tuple->udpRemoteAddr),
 		    tcpConnection(tuple->tcpConnection),
 		    localAnnouncedAddress(tuple->localAnnouncedAddress),
@@ -54,6 +86,10 @@ namespace RTC
 			{
 				StoreUdpRemoteAddress();
 			}
+			else
+			{
+				this->tupleKey = TupleKey(this->protocol, this->tcpConnection, nullptr);
+			}
 		}
 
 	public:
@@ -70,11 +106,32 @@ namespace RTC
 			this->udpRemoteAddrStorage = Utils::IP::CopyAddress(this->udpRemoteAddr);
 			this->udpRemoteAddr =
 			  reinterpret_cast<struct sockaddr*>(std::addressof(this->udpRemoteAddrStorage));
+			this->tupleKey = TupleKey(this->protocol, this->udpSocket, this->udpRemoteAddr);
 		}
 
 		bool Compare(const TransportTuple* tuple) const
 		{
-			return this->hash == tuple->hash;
+			if (this->protocol != tuple->protocol)
+			{
+				return false;
+			}
+
+			switch (this->protocol)
+			{
+				case Protocol::UDP:
+				{
+					return (
+					  this->udpSocket == tuple->udpSocket &&
+					  Utils::IP::CompareAddresses(this->udpRemoteAddr, tuple->udpRemoteAddr));
+				}
+
+				case Protocol::TCP:
+				{
+					return (this->tcpConnection == tuple->tcpConnection);
+				}
+			}
+
+			return true;
 		}
 
 		void SetLocalAnnouncedAddress(std::string& localAnnouncedAddress)
@@ -147,12 +204,10 @@ namespace RTC
 			}
 		}
 
-	private:
-		void SetHash();
-		void GenerateHash();
-
-	public:
-		uint64_t hash{ 0u };
+		const TupleKey& GetTupleKey() const
+		{
+			return this->tupleKey;
+		}
 
 	private:
 		// Passed by argument.
@@ -163,6 +218,7 @@ namespace RTC
 		// Others.
 		struct sockaddr_storage udpRemoteAddrStorage{};
 		Protocol protocol;
+		TupleKey tupleKey;
 	};
 } // namespace RTC
 

package/worker/include/RTC/WebRtcServer.hpp

@@ -10,6 +10,7 @@
 #include "RTC/UdpSocket.hpp"
 #include "RTC/WebRtcTransport.hpp"
 #include "SharedInterface.hpp"
+#include "TransportTuple.hpp"
 #include <flatbuffers/flatbuffers.h>
 #include <ankerl/unordered_dense.h>
 #include <string>
@@ -118,8 +119,10 @@ namespace RTC
 		ankerl::unordered_dense::set<RTC::WebRtcTransport*> webRtcTransports;
 		// Map of WebRtcTransports indexed by local ICE usernameFragment.
 		ankerl::unordered_dense::map<std::string, RTC::WebRtcTransport*> mapLocalIceUsernameFragmentWebRtcTransport;
-		// Map of WebRtcTransports indexed by TransportTuple.hash.
-		ankerl::unordered_dense::map<uint64_t, RTC::WebRtcTransport*> mapTupleWebRtcTransport;
+		// Map of WebRtcTransports indexed by TransportTuple::TupleKey.
+		ankerl::unordered_dense::
+		  map<RTC::TransportTuple::TupleKey, RTC::WebRtcTransport*, RTC::TransportTuple::TupleKeyHash>
+		    mapTupleWebRtcTransport;
 		// Whether the destructor has been called.
 		bool closing{ false };
 	};

package/worker/include/Utils.hpp

@@ -264,6 +264,12 @@ namespace Utils
 
 		static void WriteRandomBytes(uint8_t* buffer, size_t len);
 
+		static void HashCombine(size_t& seed, size_t value)
+		{
+			// The implementation is the same as boost::hash_combine().
+			seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+		};
+
 	private:
 		static thread_local std::mt19937_64 rng;
 		static thread_local EVP_MAC* mac;

package/worker/src/RTC/PortManager.cpp

@@ -797,11 +797,6 @@ namespace RTC
 		const auto protocolBits = static_cast<uint8_t>(key.protocol);
 		const auto familyBits   = static_cast<uint16_t>(key.bindAddr.ss_family);
 
-		auto hashCombine = [](size_t& seed, size_t value)
-		{
-			seed ^= value + 0x9e3779b9 + (seed << 6) + (seed >> 2);
-		};
-
 		size_t seed = 0;
 
 		switch (key.bindAddr.ss_family)
@@ -810,11 +805,12 @@ namespace RTC
 			{
 				const auto* in = reinterpret_cast<const sockaddr_in*>(std::addressof(key.bindAddr));
 
-				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint32_t>{}(in->sin_addr.s_addr));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(
+				  seed, ankerl::unordered_dense::hash<uint32_t>{}(in->sin_addr.s_addr));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
 
 				break;
 			}
@@ -830,22 +826,22 @@ namespace RTC
 				std::memcpy(std::addressof(hi), addr, sizeof(uint64_t));
 				std::memcpy(std::addressof(lo), addr + sizeof(uint64_t), sizeof(uint64_t));
 
-				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(hi));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(lo));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(hi));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint64_t>{}(lo));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
 
 				break;
 			}
 
 			default:
 			{
-				hashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
-				hashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint8_t>{}(protocolBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(familyBits));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.minPort));
+				Utils::Crypto::HashCombine(seed, ankerl::unordered_dense::hash<uint16_t>{}(key.maxPort));
 
 				break;
 			}

package/worker/src/RTC/SeqManager.cpp

@@ -187,7 +187,10 @@ namespace RTC
 	template<typename T, uint8_t N>
 	T SeqManager<T, N>::GetMaxOutput() const
 	{
-		return this->maxOutput;
+		// 'maxOutput' is stored in the offset-less space (as 'base' and comparisons
+		// use it), so apply 'initialOutput' here, just like `Input()` does before
+		// returning the output to the caller.
+		return (this->maxOutput + this->initialOutput) & SeqManager::MaxValue;
 	}
 
 	/*

package/worker/src/RTC/SimpleProducerStreamManager.cpp

@@ -97,7 +97,6 @@ namespace RTC
 
 		MS_ASSERT(this->externallyManagedBitrate, "bitrate is not externally managed");
 		MS_ASSERT(this->kind == RTC::Media::Kind::VIDEO, "should be video");
-		MS_ASSERT(IsActive(), "should be active");
 
 		// If this is not the first time this method is called within the same
 		// iteration, return 0 since a video Simple consumer does not keep state
@@ -109,7 +108,12 @@ namespace RTC
 
 		this->managingBitrate = true;
 
-		if (!this->producerRtpStream)
+		// Do nothing if the producer stream is not active. NOTE: This may happen
+		// because Consumer::GetBitratePriority() does not account for the producer
+		// stream presence/score, so the Transport may still ask us to increase.
+		if (
+		  !this->producerRtpStream || (this->producerRtpStream->GetScore() == 0u &&
+		                               this->producerRtpStream->HasRtpInactivityCheckEnabled()))
 		{
 			return 0u;
 		}
@@ -134,7 +138,6 @@ namespace RTC
 
 		MS_ASSERT(this->externallyManagedBitrate, "bitrate is not externally managed");
 		MS_ASSERT(this->kind == RTC::Media::Kind::VIDEO, "should be video");
-		MS_ASSERT(IsActive(), "should be active");
 
 		this->managingBitrate = false;