@mertushka/webrtc-node 0.1.0-alpha.0 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mertushka/webrtc-node",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.0",
   "description": "W3C-style RTCPeerConnection and RTCDataChannel for Node.js, backed by libdatachannel.",
   "author": "mertushka",
   "homepage": "https://github.com/mertushka/webrtc-node#readme",

package/scripts/check-native-integration.js

@@ -64,11 +64,26 @@ forbidMatch("NAN namespace usage", addon, /\bNan::/);
 forbidMatch("non-Node-API module initializer", addon, /\bNODE_MODULE\s*\(/);
 
 const callbackCallMatches = [...addon.matchAll(/\bcallback\.Call\s*\(/g)];
-if (callbackCallMatches.length !== 1) {
+if (callbackCallMatches.length !== 3) {
   fail(
-    `expected exactly one callback.Call site inside EventDispatcher::Dispatch, found ${callbackCallMatches.length}`,
+    `expected exactly three callback.Call sites inside EventDispatcher dispatch paths, found ${callbackCallMatches.length}`,
   );
 }
+requireMatch(
+  "single native event callback dispatch",
+  addon,
+  /callback\.Call\s*\(\s*\{\s*EventToObject/,
+);
+requireMatch(
+  "batched native event callback dispatch",
+  addon,
+  /callback\.Call\s*\(\s*\{\s*batch\s*\}\s*\)/,
+);
+requireMatch(
+  "direct native event callback dispatch",
+  addon,
+  /DispatchDirect[\s\S]*callback\.Call\s*\(\s*\{\s*EventToObject/,
+);
 
 const cmakePinMatch = /set\s*\(\s*LIBDATACHANNEL_PINNED_COMMIT\s+"([0-9a-f]{40})"/i.exec(cmake);
 if (!cmakePinMatch) fail("CMake libdatachannel pin is missing");

package/scripts/install-native.js

@@ -87,6 +87,7 @@ function runBuild() {
 
 async function main() {
   const buildFromSource = envFlag("npm_config_build_from_source");
+  const prebuildOnly = envFlag("WEBRTC_NODE_PREBUILD_ONLY");
   if (!buildFromSource && hasNativeAddon()) return;
 
   if (isSourceCheckout() && !buildFromSource) {
@@ -101,6 +102,10 @@ async function main() {
       throw new Error(`downloaded archive did not provide ${moduleName}`);
     } catch (error) {
       console.warn(`Prebuilt binary unavailable for ${targetTuple()}: ${error.message}`);
+      if (prebuildOnly) {
+        console.error("Prebuild-only install requested; refusing to build from source.");
+        process.exit(1);
+      }
     }
   }
 

package/scripts/run-docker-linux-ci.ps1

@@ -1,73 +1,73 @@
-param(
-  [string]$NodeImage = "node:20-bookworm",
-  [string]$ArtifactsDir = "ci-artifacts/docker-linux-node20",
-  [switch]$SkipWpt,
-  [string[]]$WptSelector = @(),
-  [int]$WptExpectedTotal = 0
-)
-
-$ErrorActionPreference = "Stop"
-
-$root = Resolve-Path (Join-Path $PSScriptRoot "..")
-$artifactPath = Join-Path $root $ArtifactsDir
-New-Item -ItemType Directory -Force $artifactPath | Out-Null
-
-$rootForDocker = $root.Path -replace "\\", "/"
-$artifactForDocker = (Resolve-Path $artifactPath).Path -replace "\\", "/"
-$wptSelectorArgs = ($WptSelector | ForEach-Object {
-  if ($_.Contains("'")) {
-    throw "WPT selector cannot contain a single quote: $_"
-  }
-  "'$_'"
-}) -join " "
-$wptTestCommand = if ($WptSelector.Count -gt 0) {
-  "npm run wpt:test -- $wptSelectorArgs"
-} else {
-  "npm run wpt:test"
-}
-$wptCheckCommand = if ($WptSelector.Count -gt 0) {
-  $expectedTotal = if ($WptExpectedTotal -gt 0) { $WptExpectedTotal } else { $WptSelector.Count }
-  "WPT_EXPECTED_TOTAL=$expectedTotal npm run wpt:check:strict"
-} else {
-  "npm run wpt:check:strict"
-}
-$wptReportCommand = if ($WptSelector.Count -gt 0) {
-  "true"
-} else {
-  "npm run wpt:report -- --output /out/wpt-report.md && RUNNER_OS=Linux RUNNER_ARCH=X64 node scripts/write-ci-evidence.js --results /out/wpt-results.json --output /out/ci-evidence.json"
-}
-$wptCommand = if ($SkipWpt) {
-  "npm run wpt:selection:check"
-} else {
-  "npm run wpt:selection:check && WPT_TEST_TIMEOUT_MS=180000 WPT_WORKER_TIMEOUT_MS=600000 WPT_WORKER_DELAY_MS=2000 WPT_CLEANUP_DELAY_MS=3000 $wptTestCommand 2>&1 | tee /out/wpt-output.txt && cp wpt-results.json /out/wpt-results.json && $wptCheckCommand && $wptReportCommand"
-}
-
-docker run --rm `
-  -v "${rootForDocker}:/src:ro" `
-  -v "${artifactForDocker}:/out" `
-  $NodeImage `
-  bash -lc "set -euo pipefail; mkdir -p /tmp/webrtc-node; tar -C /src --exclude='./build' --exclude='./node_modules' --exclude='./.git' --exclude='./wpt-results.json' --exclude='./wpt-report.md' --exclude='./ci-artifacts' -cf - . | tar -C /tmp/webrtc-node -xf -; cd /tmp/webrtc-node; if [ -f /etc/apt/sources.list.d/debian.sources ]; then sed -i '0,/URIs: http:\/\/deb.debian.org\/debian$/s//URIs: http:\/\/snapshot.debian.org\/archive\/debian\/20260421T000000Z/' /etc/apt/sources.list.d/debian.sources; sed -i '0,/URIs: http:\/\/deb.debian.org\/debian-security$/s//URIs: http:\/\/snapshot.debian.org\/archive\/debian-security\/20260421T000000Z/' /etc/apt/sources.list.d/debian.sources; fi; for attempt in 1 2 3; do if apt-get -o Acquire::Check-Valid-Until=false update >/out/apt-update.txt 2>&1 && apt-get install -y cmake ninja-build libssl-dev >/out/apt-install.txt 2>&1; then break; fi; if [ ""`$attempt"" = 3 ]; then exit 1; fi; sleep `$((attempt * 10)); done; npm ci 2>&1 | tee /out/npm-ci.txt; npm run check; npm run native:check; npm run build 2>&1 | tee /out/build-output.txt; npm test; npm run api:check; npm run types:check; npm run wpt:ensure; set +e; ${wptCommand}; wpt_status=`$?; set -e; cp wpt-results.json /out/wpt-results.json 2>/dev/null || true; cp wpt-manifest.json /out/wpt-manifest.json; npm run wpt:manifest > /out/wpt-manifest.txt; exit `$wpt_status"
-
-$dockerExitCode = $LASTEXITCODE
-
-if (-not $SkipWpt) {
-  $resultsPath = Join-Path $artifactPath "wpt-results.json"
-  if (-not (Test-Path $resultsPath)) {
-    throw "Docker CI did not produce $resultsPath"
-  }
-
-  $results = Get-Content -Raw -Path $resultsPath | ConvertFrom-Json
-  if ([int]$results.fail -gt 0) {
-    throw "Docker CI WPT subset failed: $($results.pass)/$($results.total) passed"
-  }
-  $retried = @($results.results | Where-Object {
-    ($_.PSObject.Properties.Name -contains "retries") -and [int]$_.retries -gt 0
-  }).Count
-  if ($retried -gt 0) {
-    throw "Docker CI WPT subset required retries: $retried"
-  }
-}
-
-if ($dockerExitCode -ne 0) {
-  throw "Docker CI failed with exit code $dockerExitCode"
-}
+param(
+  [string]$NodeImage = "node:20-bookworm",
+  [string]$ArtifactsDir = "ci-artifacts/docker-linux-node20",
+  [switch]$SkipWpt,
+  [string[]]$WptSelector = @(),
+  [int]$WptExpectedTotal = 0
+)
+
+$ErrorActionPreference = "Stop"
+
+$root = Resolve-Path (Join-Path $PSScriptRoot "..")
+$artifactPath = Join-Path $root $ArtifactsDir
+New-Item -ItemType Directory -Force $artifactPath | Out-Null
+
+$rootForDocker = $root.Path -replace "\\", "/"
+$artifactForDocker = (Resolve-Path $artifactPath).Path -replace "\\", "/"
+$wptSelectorArgs = ($WptSelector | ForEach-Object {
+  if ($_.Contains("'")) {
+    throw "WPT selector cannot contain a single quote: $_"
+  }
+  "'$_'"
+}) -join " "
+$wptTestCommand = if ($WptSelector.Count -gt 0) {
+  "npm run wpt:test -- $wptSelectorArgs"
+} else {
+  "npm run wpt:test"
+}
+$wptCheckCommand = if ($WptSelector.Count -gt 0) {
+  $expectedTotal = if ($WptExpectedTotal -gt 0) { $WptExpectedTotal } else { $WptSelector.Count }
+  "WPT_EXPECTED_TOTAL=$expectedTotal npm run wpt:check:strict"
+} else {
+  "npm run wpt:check:strict"
+}
+$wptReportCommand = if ($WptSelector.Count -gt 0) {
+  "true"
+} else {
+  "npm run wpt:report -- --output /out/wpt-report.md && RUNNER_OS=Linux RUNNER_ARCH=X64 node scripts/write-ci-evidence.js --results /out/wpt-results.json --output /out/ci-evidence.json"
+}
+$wptCommand = if ($SkipWpt) {
+  "npm run wpt:selection:check"
+} else {
+  "npm run wpt:selection:check && WPT_TEST_TIMEOUT_MS=180000 WPT_WORKER_TIMEOUT_MS=600000 WPT_WORKER_DELAY_MS=2000 WPT_CLEANUP_DELAY_MS=3000 $wptTestCommand 2>&1 | tee /out/wpt-output.txt && cp wpt-results.json /out/wpt-results.json && $wptCheckCommand && $wptReportCommand"
+}
+
+docker run --rm `
+  -v "${rootForDocker}:/src:ro" `
+  -v "${artifactForDocker}:/out" `
+  $NodeImage `
+  bash -lc "set -euo pipefail; mkdir -p /tmp/webrtc-node; tar -C /src --exclude='./build' --exclude='./node_modules' --exclude='./.git' --exclude='./wpt-results.json' --exclude='./wpt-report.md' --exclude='./ci-artifacts' -cf - . | tar -C /tmp/webrtc-node -xf -; cd /tmp/webrtc-node; if [ -f /etc/apt/sources.list.d/debian.sources ]; then sed -i '0,/URIs: http:\/\/deb.debian.org\/debian$/s//URIs: http:\/\/snapshot.debian.org\/archive\/debian\/20260421T000000Z/' /etc/apt/sources.list.d/debian.sources; sed -i '0,/URIs: http:\/\/deb.debian.org\/debian-security$/s//URIs: http:\/\/snapshot.debian.org\/archive\/debian-security\/20260421T000000Z/' /etc/apt/sources.list.d/debian.sources; fi; for attempt in 1 2 3; do if apt-get -o Acquire::Check-Valid-Until=false update >/out/apt-update.txt 2>&1 && apt-get install -y cmake ninja-build libssl-dev >/out/apt-install.txt 2>&1; then break; fi; if [ ""`$attempt"" = 3 ]; then exit 1; fi; sleep `$((attempt * 10)); done; npm ci 2>&1 | tee /out/npm-ci.txt; npm run check; npm run native:check; npm run build 2>&1 | tee /out/build-output.txt; npm test; npm run api:check; npm run types:check; npm run wpt:ensure; set +e; ${wptCommand}; wpt_status=`$?; set -e; cp wpt-results.json /out/wpt-results.json 2>/dev/null || true; cp wpt-manifest.json /out/wpt-manifest.json; npm run wpt:manifest > /out/wpt-manifest.txt; exit `$wpt_status"
+
+$dockerExitCode = $LASTEXITCODE
+
+if (-not $SkipWpt) {
+  $resultsPath = Join-Path $artifactPath "wpt-results.json"
+  if (-not (Test-Path $resultsPath)) {
+    throw "Docker CI did not produce $resultsPath"
+  }
+
+  $results = Get-Content -Raw -Path $resultsPath | ConvertFrom-Json
+  if ([int]$results.fail -gt 0) {
+    throw "Docker CI WPT subset failed: $($results.pass)/$($results.total) passed"
+  }
+  $retried = @($results.results | Where-Object {
+    ($_.PSObject.Properties.Name -contains "retries") -and [int]$_.retries -gt 0
+  }).Count
+  if ($retried -gt 0) {
+    throw "Docker CI WPT subset required retries: $retried"
+  }
+}
+
+if ($dockerExitCode -ne 0) {
+  throw "Docker CI failed with exit code $dockerExitCode"
+}

package/src/native/addon.cc

@@ -292,7 +292,7 @@ struct NativeEvent {
 	std::string error;
 	bool binary = false;
 	std::string text;
-	std::vector<uint8_t> bytes;
+	rtc::binary bytes;
 };
 
 struct EventDispatcher : public std::enable_shared_from_this<EventDispatcher> {
@@ -303,6 +303,29 @@ struct EventDispatcher : public std::enable_shared_from_this<EventDispatcher> {
 	~EventDispatcher() { Close(); }
 
 	void Emit(NativeEvent event) {
+		if (event.target != "datachannel" || event.type != "message") {
+			EmitDirect(std::move(event));
+			return;
+		}
+
+		bool scheduleDispatch = false;
+		std::lock_guard<std::mutex> lock(lifecycleMutex);
+		if (!active.load()) {
+			return;
+		}
+
+		pendingEvents.push_back(std::move(event));
+		if (!dispatchScheduled) {
+			dispatchScheduled = true;
+			scheduleDispatch = true;
+		}
+		if (!scheduleDispatch)
+			return;
+
+		QueueDispatchLocked();
+	}
+
+	void EmitDirect(NativeEvent event) {
 		auto *queued = new NativeEvent(std::move(event));
 		std::lock_guard<std::mutex> lock(lifecycleMutex);
 		if (!active.load()) {
@@ -310,13 +333,15 @@ struct EventDispatcher : public std::enable_shared_from_this<EventDispatcher> {
 			return;
 		}
 
-		napi_status status = tsfn.NonBlockingCall(queued, Dispatch);
+		napi_status status = tsfn.NonBlockingCall(queued, DispatchDirect);
 		if (status != napi_ok)
 			delete queued;
 	}
 
 	void Close() {
 		std::lock_guard<std::mutex> lock(lifecycleMutex);
+		pendingEvents.clear();
+		dispatchScheduled = false;
 		if (active.exchange(false))
 			tsfn.Release();
 	}
@@ -325,10 +350,76 @@ private:
 	EventDispatcher(Napi::Env env, Napi::Function callback)
 	    : tsfn(Napi::ThreadSafeFunction::New(env, callback, "webrtc-node events", 0, 1)) {}
 
-	static void Dispatch(Napi::Env env, Napi::Function callback, NativeEvent *event);
+	void Drain(Napi::Env env, Napi::Function callback) {
+		std::vector<NativeEvent> events;
+		{
+			std::lock_guard<std::mutex> lock(lifecycleMutex);
+			if (pendingEvents.empty()) {
+				dispatchScheduled = false;
+				return;
+			}
+			events.swap(pendingEvents);
+		}
+
+		if (events.size() == 1) {
+			callback.Call({EventToObject(env, events.front())});
+		} else {
+			Napi::Array batch = Napi::Array::New(env, events.size());
+			for (uint32_t i = 0; i < events.size(); ++i)
+				batch.Set(i, EventToObject(env, events[i]));
+			callback.Call({batch});
+		}
+
+		std::lock_guard<std::mutex> lock(lifecycleMutex);
+		if (!active.load() || pendingEvents.empty()) {
+			dispatchScheduled = false;
+			return;
+		}
+		QueueDispatchLocked();
+	}
+
+	void QueueDispatchLocked() {
+		auto *dispatcher = new std::shared_ptr<EventDispatcher>(shared_from_this());
+		napi_status status = tsfn.NonBlockingCall(dispatcher, DispatchQueued);
+		if (status != napi_ok) {
+			dispatchScheduled = false;
+			pendingEvents.clear();
+			delete dispatcher;
+		}
+	}
+
+	static void DispatchQueued(Napi::Env env, Napi::Function callback,
+	                           std::shared_ptr<EventDispatcher> *dispatcher) {
+		std::shared_ptr<EventDispatcher> scoped = std::move(*dispatcher);
+		delete dispatcher;
+		scoped->Drain(env, callback);
+	}
+
+	static void DispatchDirect(Napi::Env env, Napi::Function callback, NativeEvent *event) {
+		std::unique_ptr<NativeEvent> scoped(event);
+		callback.Call({EventToObject(env, *scoped)});
+	}
+
+	static Napi::Value MessagePayloadToValue(Napi::Env env, NativeEvent &event) {
+		if (!event.binary)
+			return Napi::String::New(env, event.text);
+
+		if (event.bytes.empty())
+			return Napi::ArrayBuffer::New(env, 0);
+
+		auto *bytes = new rtc::binary(std::move(event.bytes));
+		return Napi::ArrayBuffer::New(
+		    env, bytes->data(), bytes->size(),
+		    [](Napi::Env, void *, rtc::binary *finalizedBytes) { delete finalizedBytes; },
+		    bytes);
+	}
+
+	static Napi::Object EventToObject(Napi::Env env, NativeEvent &event);
 
 	std::atomic<bool> active{true};
 	std::mutex lifecycleMutex;
+	std::vector<NativeEvent> pendingEvents;
+	bool dispatchScheduled = false;
 	Napi::ThreadSafeFunction tsfn;
 };
 
@@ -452,10 +543,7 @@ private:
 					event.text = std::get<std::string>(std::move(data));
 				} else {
 					event.binary = true;
-					const auto &binary = std::get<rtc::binary>(data);
-					event.bytes.reserve(binary.size());
-					for (std::byte value : binary)
-						event.bytes.push_back(std::to_integer<uint8_t>(value));
+					event.bytes = std::move(std::get<rtc::binary>(data));
 				}
 				self->Emit(std::move(event));
 			}
@@ -619,49 +707,40 @@ private:
 
 Napi::FunctionReference NativeDataChannel::constructor;
 
-void EventDispatcher::Dispatch(Napi::Env env, Napi::Function callback, NativeEvent *event) {
-	std::unique_ptr<NativeEvent> scoped(event);
-
+Napi::Object EventDispatcher::EventToObject(Napi::Env env, NativeEvent &event) {
 	Napi::Object object = Napi::Object::New(env);
-	object.Set("target", scoped->target);
-	object.Set("type", scoped->type);
-	if (scoped->channelId)
-		object.Set("channelId", scoped->channelId);
-	if (!scoped->state.empty())
-		object.Set("state", scoped->state);
-	if (!scoped->descriptionType.empty()) {
+	object.Set("target", event.target);
+	object.Set("type", event.type);
+	if (event.channelId)
+		object.Set("channelId", event.channelId);
+	if (!event.state.empty())
+		object.Set("state", event.state);
+	if (!event.descriptionType.empty()) {
 		Napi::Object description = Napi::Object::New(env);
-		description.Set("type", scoped->descriptionType);
-		description.Set("sdp", scoped->sdp);
+		description.Set("type", event.descriptionType);
+		description.Set("sdp", event.sdp);
 		object.Set("description", description);
 	}
-	if (!scoped->candidate.empty() || !scoped->mid.empty()) {
+	if (!event.candidate.empty() || !event.mid.empty()) {
 		Napi::Object candidate = Napi::Object::New(env);
-		candidate.Set("candidate", scoped->candidate);
-		if (!scoped->mid.empty())
-			candidate.Set("sdpMid", scoped->mid);
+		candidate.Set("candidate", event.candidate);
+		if (!event.mid.empty())
+			candidate.Set("sdpMid", event.mid);
 		object.Set("candidate", candidate);
 	}
-	if (!scoped->error.empty())
-		object.Set("error", scoped->error);
-	if (scoped->type == "message") {
-		object.Set("binary", scoped->binary);
-		if (scoped->binary) {
-			Napi::ArrayBuffer buffer = Napi::ArrayBuffer::New(env, scoped->bytes.size());
-			if (!scoped->bytes.empty())
-				std::memcpy(buffer.Data(), scoped->bytes.data(), scoped->bytes.size());
-			object.Set("data", buffer);
-		} else {
-			object.Set("data", scoped->text);
-		}
+	if (!event.error.empty())
+		object.Set("error", event.error);
+	if (event.type == "message") {
+		object.Set("binary", event.binary);
+		object.Set("data", MessagePayloadToValue(env, event));
 	}
-	if (scoped->channel) {
-		object.Set("channel", NativeDataChannel::NewInstance(env, scoped->channel));
-		object.Set("channelId", scoped->channel->id);
+	if (event.channel) {
+		object.Set("channel", NativeDataChannel::NewInstance(env, event.channel));
+		object.Set("channelId", event.channel->id);
 		object.Set("channelReadyState", "open");
 	}
 
-	callback.Call({object});
+	return object;
 }
 
 Napi::Object CandidateToObject(Napi::Env env, const rtc::Candidate &candidate) {
@@ -674,7 +753,9 @@ Napi::Object CandidateToObject(Napi::Env env, const rtc::Candidate &candidate) {
 rtc::Configuration ParseConfiguration(const Napi::CallbackInfo &info) {
 	rtc::Configuration config;
 	config.disableAutoNegotiation = true;
-	config.disableAutoGathering = false;
+	config.disableAutoGathering = true;
+	// Standard Ethernet MTU avoids the conservative default without requiring an API extension.
+	config.mtu = 1500;
 
 	if (info.Length() == 0 || !info[0].IsObject())
 		return config;