teleportxr 1.0.94 → 1.0.95

package/client/client.js

@@ -125,6 +125,13 @@ class Client {
 		else
 		{
 			this.webRtcConnected=false;
+			// Rebaseline the connect-attempt clock so hasWebRtcConnectionTimedOut() gives the
+			// low-level WebRtcConnection.reconnect() (webrtcconnection.js) a fresh
+			// WEBRTC_CONNECT_TIMEOUT_MS window to recover, instead of comparing against the
+			// original connection-start time from potentially many seconds/minutes earlier —
+			// which would otherwise make any post-connect ICE failure time out almost instantly
+			// on the next UpdateStreaming() tick and force-disconnect the client mid-reconnect.
+			this.webRtcConnectionInitiatedAtMs=Date.now();
 			if (this.webRtcConnection)
 			{
 				try { this.webRtcConnection.stopSceneAudio(); } catch (e) {}

package/client/geometry_service.js

@@ -111,14 +111,22 @@ class GeometryService {
 		// this client should stream node uid.
 		var res = GeometryService.GetOrCreateTrackedResource(uid);
 		var index = clientIDToIndex.get(this.clientID);
+		if (res.clientNeeds.get(index)) {
+			// Already streaming for this client — nothing to do.
+			return;
+		}
 		res.clientNeeds.set(index, true);
 		// Add to the list of nodes this client should eventually receive:
 		this.nodesToStreamEventually.add(uid);
 	}
 	UnstreamNode(uid) {
 		var index = clientIDToIndex.get(this.clientID);
-		if (GeometryService.trackedResources.has(uid)) {
-			var res = GeometryService.GetOrCreateTrackedResource(uid);
+		var res = GeometryService.trackedResources.get(uid);
+		if (res) {
+			if (!res.clientNeeds.get(index)) {
+				// Already unstreamed for this client — nothing to do.
+				return;
+			}
 			res.clientNeeds.set(index, false);
 		}
 		// Should certainly be in this set:

package/connections/webrtcconnection.js

@@ -226,6 +226,14 @@ class WebRtcConnection extends EventEmitter
 			const pc = this.peerConnection;
 			try
 			{
+				// Hand the client the same ICE server list (including any TURN entries) this
+				// connection is using, so the client doesn't need TURN credentials hardcoded
+				// or locally configured — this server is the single source of truth. Sent
+				// before the offer so it's ready by the time the client builds its
+				// RTCConfiguration.
+				const iceServersMessage = JSON.stringify({"teleport-signal-type": "ice-servers", "iceServers": this.iceServers});
+				this.sendConfigMessage(this.id, iceServersMessage);
+
 				const offer = await pc.createOffer();
 				if (this.peerConnection !== pc) return;
 				// Rename each node-audio m-line's mid to the emitting node's uid

package/package.json

@@ -16,7 +16,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.94",
+  "version": "1.0.95",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/simul/teleport-nodejs.git"

package/test/test_geometry_service_stream_idempotent.js

@@ -0,0 +1,94 @@
+'use strict';
+// Regression tests for GeometryService.StreamNode / UnstreamNode idempotency.
+//
+// Before this fix, UnstreamNode unconditionally rewrote the clientNeeds bit,
+// deleted from nodesToStreamEventually/streamedNodes, and logged — even when
+// the node was already unstreamed for this client. A caller that re-evaluates
+// a streaming decision every tick (e.g. distance-based visibility in
+// teleport-nodejs-server-example's CustomClient.ProcessNodePoses) would then
+// log and touch shared state on every tick it stayed on one side of the
+// threshold, rather than only on the actual transition. StreamNode had the
+// same gap in the other direction. Both now return early — no state writes,
+// no log — when the call would not change anything.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { GeometryService } = require('../client/geometry_service');
+
+function makeService(clientID) {
+	// Reset the static trackedResources map between tests so uids don't leak
+	// across cases.
+	GeometryService.trackedResources = new Map();
+	return new GeometryService(clientID);
+}
+
+test('UnstreamNode logs and clears state on the real transition, then is silent on repeat calls', () => {
+	const svc = makeService(201);
+	svc.StreamNode(31n);
+	const res = GeometryService.GetOrCreateTrackedResource(31n);
+	assert.ok(res.IsNeededByClient(201));
+
+	const originalLog = console.log;
+	const logs = [];
+	console.log = (...args) => logs.push(args.join(''));
+	try {
+		svc.UnstreamNode(31n);
+		assert.ok(!res.IsNeededByClient(201));
+		assert.strictEqual(logs.length, 1, 'the first UnstreamNode call for a streamed node must log once');
+
+		svc.UnstreamNode(31n);
+		svc.UnstreamNode(31n);
+		assert.strictEqual(logs.length, 1,
+			'repeated UnstreamNode calls while already unstreamed must not log again');
+	} finally {
+		console.log = originalLog;
+	}
+});
+
+test('UnstreamNode is a no-op on the redundant path: it must not re-touch nodesToStreamEventually/streamedNodes', () => {
+	const svc = makeService(202);
+	svc.StreamNode(33n);
+	svc.UnstreamNode(33n);
+
+	// Simulate some other subsystem re-adding bookkeeping for this uid after
+	// the real unstream, so a later no-op UnstreamNode call would visibly
+	// disturb it if the guard were missing.
+	svc.nodesToStreamEventually.add(33n);
+	svc.streamedNodes.set(33n, 1);
+
+	svc.UnstreamNode(33n);
+	assert.ok(svc.nodesToStreamEventually.has(33n),
+		'a redundant UnstreamNode call (already unstreamed) must not delete from nodesToStreamEventually');
+	assert.ok(svc.streamedNodes.has(33n),
+		'a redundant UnstreamNode call (already unstreamed) must not delete from streamedNodes');
+});
+
+test('StreamNode is idempotent: a second call for an already-needed node does not resurrect nodesToStreamEventually', () => {
+	const svc = makeService(203);
+	svc.StreamNode(41n);
+	assert.ok(svc.nodesToStreamEventually.has(41n));
+
+	// Simulate the resource having been picked up and removed from the
+	// "eventually" queue by UpdateNodesToStream, as happens in production.
+	svc.nodesToStreamEventually.delete(41n);
+
+	// A redundant StreamNode call (client still needs it) must not re-add it —
+	// only the real transition (need false -> true) should do that.
+	svc.StreamNode(41n);
+	assert.ok(!svc.nodesToStreamEventually.has(41n),
+		'redundant StreamNode call must not resurrect nodesToStreamEventually for an already-needed node');
+});
+
+test('StreamNode after UnstreamNode is a real transition and does re-add to nodesToStreamEventually', () => {
+	const svc = makeService(204);
+	svc.StreamNode(43n);
+	svc.UnstreamNode(43n);
+	svc.nodesToStreamEventually.delete(43n); // UnstreamNode already does this; assert the starting state.
+	assert.ok(!svc.nodesToStreamEventually.has(43n));
+
+	svc.StreamNode(43n);
+	assert.ok(svc.nodesToStreamEventually.has(43n),
+		'StreamNode must still re-add the uid on an actual false -> true transition');
+	const res = GeometryService.GetOrCreateTrackedResource(43n);
+	assert.ok(res.IsNeededByClient(204));
+});

package/test/test_webrtc_connection_timeout.js

@@ -95,6 +95,25 @@ test('ClientManager.disconnectClient removes client from map', () => {
 	assert.strictEqual(cm.clients.has(42), false, 'client must be removed from the map');
 });
 
+test('streamingConnectionStateChanged rebaselines the connect-attempt clock on post-connect failure', () => {
+	// Simulate a client that connected a long time ago (well past the timeout window),
+	// then later has its ICE connection fail. Before the fix, hasWebRtcConnectionTimedOut()
+	// would compare against the original, stale webRtcConnectionInitiatedAtMs and report an
+	// immediate timeout, force-disconnecting the client before its own reconnect logic
+	// (WebRtcConnection.reconnect(), in webrtcconnection.js) gets a chance to run.
+	const c = makeStubClient({
+		webRtcConnectionInitiatedAtMs: Date.now() - 100000, // original connect attempt, long ago
+	});
+	c.webRtcConnected = true;
+	c.webRtcConnectedAtMs = Date.now() - 90000;
+
+	c.streamingConnectionStateChanged('failed');
+
+	assert.strictEqual(c.webRtcConnected, false, 'webRtcConnected must be false after a failure');
+	assert.strictEqual(c.hasWebRtcConnectionTimedOut(), false,
+		'must not report a timeout immediately after rebaselining, so reconnect gets a fresh window');
+});
+
 test('ClientManager.UpdateStreaming removes timed-out clients', async () => {
 	const cm = new ClientManager();
 	const clientsRemoved = [];