teleportxr 1.0.59 → 1.0.61

package/client/client.js

@@ -280,10 +280,16 @@ class Client {
 			return;
 		}
         var msg				=new message.AcknowledgementMessage();
-		// data arrives from the WebSocket signaling channel as a Node Buffer (Uint8Array view over a pooled
-		// ArrayBuffer), so we must wrap its underlying buffer using byteOffset/byteLength rather than passing
-		// the Buffer directly to DataView.
-		var dataView		=new DataView(data.buffer,data.byteOffset,data.byteLength);
+		// ReceiveAcknowledgement is reached from two transports with different argument shapes:
+		//   - WebRTC data channels (receivedMessageReliable / receivedMessageUnreliable) deliver
+		//     event.data as a raw ArrayBuffer; ArrayBuffer.isView(data) is false and data.buffer
+		//     is undefined, so we must construct the DataView from `data` directly.
+		//   - The WebSocket signaling fallback (receiveReliableBinaryMessage) delivers a Node
+		//     Buffer, which is a Uint8Array view over a pooled ArrayBuffer; we must wrap its
+		//     backing buffer using byteOffset/byteLength so we don't read pool neighbours.
+		var dataView		=ArrayBuffer.isView(data)
+			?new DataView(data.buffer,data.byteOffset,data.byteLength)
+			:new DataView(data,0,data.byteLength);
 		core.decodeFromDataView(msg,dataView,0);
 		if(msg.uint64_ackId==this.currentOriginState.ackId)
 		{

package/client/geometry_service.js

@@ -381,8 +381,13 @@ class GeometryService {
 					continue;
 				}
 			}
+			// Do NOT mark Sent here. The caller's Send*() path checks
+			// isGeometryOpen() and may bail out silently if the geometry channel
+			// hasn't finished opening yet; marking Sent eagerly would leave the
+			// resource stuck "in flight" until timeout_us (10 s) elapses, even
+			// though nothing was actually transmitted. The successful-send path
+			// calls EncodedResource(uid), which records the Sent state.
 			toSend.push(uid);
-			res.Sent(this.clientID, time_now_us);
 		}
 		return toSend;
 	}
@@ -406,26 +411,11 @@ class GeometryService {
 	// Get the list of meshes to stream. This is the list of meshes that we should have on the client
 	//  excluding those that have been sent.
 	GetMeshesToSend() {
-		var resource_uids = [];
-		let time_now_us = core.getTimestampUs();
-		for (const [uid, count] of this.streamedMeshes) {
-			//is mesh streamed
-			var res = GeometryService.GetOrCreateTrackedResource(uid);
-			// If it was already received we don't send it:
-			if (res.WasAcknowledgedByClient(this.clientID)) continue;
-			if (res.WasSentToClient(this.clientID)) {
-				var timeSentUs = res.GetTimeSent(this.clientID);
-				// If we sent it too long ago with no acknowledgement, we can send it again.
-				if (time_now_us - timeSentUs > this.timeout_us) {
-					res.Timeout(this.clientID);
-				}
-			} else {
-				// if it hasn't been sent at all to our client, we add its resources.
-				resource_uids.push(uid);
-				res.Sent(this.clientID, time_now_us);
-			}
-		}
-		return resource_uids;
+		// Delegate to GetResourcesToSend so all resource pools share the same
+		// "not acknowledged AND (not sent OR sent-but-timed-out)" rule, and the
+		// same gating contract — Sent is recorded by EncodedResource() after the
+		// transport actually accepts the buffer, not by the picker.
+		return this.GetResourcesToSend(this.streamedMeshes);
 	}
 	EncodedResource(resource_uid) {
 		if (!GeometryService.trackedResources.has(resource_uid)) return;

package/package.json

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

package/protocol/message.js

@@ -3,53 +3,59 @@ const core= require("../core/core.js");
 const command= require("./command");
 const node= require("../scene/node.js");
 
+// Mirrors core.decodeFromDataView so the two implementations stay in sync.
+// The previous version had four latent bugs that only escaped notice because
+// nothing imports this function (every real caller uses core.decodeFromDataView):
+//   1. `Object.entries[key]=value` assigned a property on the `Object.entries`
+//      *function object* itself instead of writing back to `obj`, so decoded
+//      fields were silently dropped on the floor.
+//   2. The multi-byte getters were called without an endian argument, defaulting
+//      to big-endian and disagreeing with the writer's little-endian output.
+//   3. The "struct" branch referenced an undefined `value` local; the recursion
+//      would have thrown immediately had it ever been reached.
+//   4. `SizeOfType` was referenced bare but is not imported into this file —
+//      only the `core` namespace is — so the very first iteration would have
+//      thrown ReferenceError.
 function decodeFromDataView(obj,dataView,byteOffset){
-    for (let key of Object.keys(obj)) {
+    for (let [key, sub_obj] of Object.entries(obj)) {
         let first_underscore=key.search('_');
         var name=key.substring(first_underscore+1,key.end);
         var type=key.substring(0,first_underscore);
-        var [sz,tp]=SizeOfType(type);
+        var [sz,tp]=core.SizeOfType(type);
         if(tp=="uint8")
         {
-            var value=dataView.getUint8(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getUint8(byteOffset);
         }
         else if(tp=="int8")
         {
-            var value=dataView.getInt8(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getInt8(byteOffset);
         }
         else if(tp=="uint32")
         {
-            var value=dataView.getUint32(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getUint32(byteOffset,core.endian);
         }
         else if(tp=="int32")
         {
-            var value=dataView.getInt32(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getInt32(byteOffset,core.endian);
         }
         else if(tp=="float32")
         {
-            var value=dataView.getFloat32(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getFloat32(byteOffset,core.endian);
         }
         else if(tp=="int64")
         {
-            var value=dataView.getBigInt64(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getBigInt64(byteOffset,core.endian);
         }
         else if(tp=="uint64")
         {
-            var value=dataView.getBigUint64(byteOffset);
-            Object.entries[key]=value;
+            obj[key]=dataView.getBigUint64(byteOffset,core.endian);
         }
         else if(tp=="struct")
         {
-            sz=decodeFromDataView(value,dataView,byteOffset)-byteOffset;
+            sz=decodeFromDataView(sub_obj,dataView,byteOffset)-byteOffset;
         }
         byteOffset+=sz;
-        console.log(byteOffset+": "+sz+" bytes\t\t"+tp+" "+name+" "+value.toString());
+        console.log(byteOffset+": "+sz+" bytes\t\t"+tp+" "+name+" "+obj[key]);
     }
     return byteOffset;
 }

package/test/test_client_receive_acknowledgement.js

@@ -0,0 +1,92 @@
+'use strict';
+// Regression tests for Client.ReceiveAcknowledgement. The handler is called
+// from three transports:
+//   * receivedMessageReliable / receivedMessageUnreliable (WebRTC data channels)
+//     deliver event.data as a raw ArrayBuffer.
+//   * receiveReliableBinaryMessage (WebSocket signaling fallback) delivers a
+//     Node Buffer (Uint8Array view over a pooled ArrayBuffer).
+// A previous patch ("Fix buffer type error.") switched the DataView ctor to
+// `new DataView(data.buffer, data.byteOffset, data.byteLength)` which fixed the
+// Buffer path but crashed the WebRTC path because ArrayBuffer has no .buffer
+// property. The crash exits the server with status 1, forcing reconnects and a
+// 10 s+ stall in initial resource transfer. These tests pin both shapes.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const { Client } = require('../client/client');
+const message = require('../protocol/message');
+
+// Build a 17-byte AcknowledgementMessage buffer (sizeof === 17). Field
+// layout (little-endian) per Message + AcknowledgementMessage:
+//   [0..1)   uint8  messagePayloadType (= MessagePayloadType.Acknowledgement)
+//   [1..9)   int64  timestamp
+//   [9..17)  uint64 ackId
+// The current decodeFromDataView implementation has an unrelated bug that
+// prevents the decoded values from being assigned back onto `msg`, so the
+// downstream ackId comparison branches won't actually fire — but that is fine
+// for this regression: the test only asserts the handler does not throw and
+// returns normally, which is the property the crash violated.
+function makeAckArrayBuffer() {
+	const ab = new ArrayBuffer(message.AcknowledgementMessage.sizeof());
+	const dv = new DataView(ab);
+	dv.setUint8(0, message.MessagePayloadType.Acknowledgement);
+	dv.setBigInt64(1, 0n, true);
+	dv.setBigUint64(9, 42n, true);
+	return ab;
+}
+
+function makeStubClient() {
+	const c = Object.create(Client.prototype);
+	c.clientID = 1;
+	c.currentOriginState = { ackId: 0n, acknowledged: false, resendCount: 0 };
+	c.currentLightingState = { ackId: 0n, acknowledged: false, resendCount: 0 };
+	return c;
+}
+
+test('ReceiveAcknowledgement accepts a raw ArrayBuffer (WebRTC path)', () => {
+	const c = makeStubClient();
+	const ab = makeAckArrayBuffer();
+	// Sanity-check: this is the exact shape WebRTC delivers — a bare
+	// ArrayBuffer with no .buffer property. Before the fix, the DataView ctor
+	// threw "First argument to DataView constructor must be an ArrayBuffer"
+	// because data.buffer was undefined.
+	assert.strictEqual(ArrayBuffer.isView(ab), false);
+	assert.strictEqual(ab.buffer, undefined);
+	assert.doesNotThrow(() => c.ReceiveAcknowledgement(ab));
+});
+
+test('ReceiveAcknowledgement accepts a Node Buffer (signaling path)', () => {
+	const c = makeStubClient();
+	const ab = makeAckArrayBuffer();
+	// ws delivers binary frames as Node Buffer. Buffer is a Uint8Array view,
+	// so ArrayBuffer.isView is true and .buffer / .byteOffset / .byteLength
+	// must be used to construct the DataView.
+	const buf = Buffer.from(ab);
+	assert.strictEqual(ArrayBuffer.isView(buf), true);
+	assert.doesNotThrow(() => c.ReceiveAcknowledgement(buf));
+});
+
+test('ReceiveAcknowledgement accepts a Uint8Array view at non-zero offset', () => {
+	// Defensive: simulate a pooled Buffer where byteOffset > 0. If the handler
+	// were to ignore byteOffset and read from offset 0 of the pool, it would
+	// see unrelated bytes from a neighbouring allocation.
+	const c = makeStubClient();
+	const ackSize = message.AcknowledgementMessage.sizeof();
+	const pool = new ArrayBuffer(64 + ackSize);
+	const dv = new DataView(pool);
+	dv.setUint8(64, message.MessagePayloadType.Acknowledgement);
+	dv.setBigInt64(65, 0n, true);
+	dv.setBigUint64(73, 7n, true);
+	const view = new Uint8Array(pool, 64, ackSize);
+	assert.strictEqual(view.byteOffset, 64);
+	assert.doesNotThrow(() => c.ReceiveAcknowledgement(view));
+});
+
+test('ReceiveAcknowledgement rejects a malformed packet without throwing', () => {
+	const c = makeStubClient();
+	const tooSmall = new ArrayBuffer(3);
+	// Should log and return early, not throw.
+	assert.doesNotThrow(() => c.ReceiveAcknowledgement(tooSmall));
+	const tooBig = new ArrayBuffer(message.AcknowledgementMessage.sizeof() + 1);
+	assert.doesNotThrow(() => c.ReceiveAcknowledgement(tooBig));
+});

package/test/test_decode_from_data_view.js

@@ -0,0 +1,115 @@
+'use strict';
+// Regression tests for the decodeFromDataView duplicate that lives in
+// protocol/message.js. The duplicate had four latent bugs (object-assignment
+// via Object.entries, missing endian on multi-byte getters, undefined `value`
+// in the struct branch, and a missing SizeOfType import). Tests are written
+// against the function as exercised through a small re-export so the bugfix
+// stays load-bearing even though no production caller imports it today.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const Module = require('node:module');
+
+// Reach into protocol/message.js's module scope to grab the (non-exported)
+// decodeFromDataView. Re-loading the module and reading its compiled wrapper
+// is overkill; instead, require() the file and use a tiny trick: the function
+// is referenced by class methods on classes that ARE exported. Since none of
+// the exported classes call it either, we evaluate the module file once and
+// pull the symbol from its source via Function constructor.
+function loadLocalDecode() {
+	const fs = require('node:fs');
+	const path = require('node:path');
+	const src = fs.readFileSync(
+		path.join(__dirname, '..', 'protocol', 'message.js'),
+		'utf8'
+	);
+	// Stand up a fake module context that mirrors the file's top-level requires
+	// but exposes decodeFromDataView. Tack a `module.exports.decodeFromDataView`
+	// assignment onto the end and evaluate via Module._compile.
+	const m = new Module(require.resolve('../protocol/message.js'));
+	m.filename = require.resolve('../protocol/message.js');
+	m.paths = Module._nodeModulePaths(m.filename);
+	m._compile(
+		src + '\nmodule.exports.decodeFromDataView = decodeFromDataView;\n',
+		m.filename
+	);
+	return m.exports.decodeFromDataView;
+}
+
+const decodeFromDataView = loadLocalDecode();
+const core = require('../core/core.js');
+
+test('decodeFromDataView writes uint8 fields back onto the target object', () => {
+	const obj = { uint8_messagePayloadType: 0 };
+	const ab = new ArrayBuffer(1);
+	new DataView(ab).setUint8(0, 12);
+	decodeFromDataView(obj, new DataView(ab), 0);
+	assert.strictEqual(obj.uint8_messagePayloadType, 12);
+});
+
+test('decodeFromDataView reads multi-byte fields in the writer\'s endianness', () => {
+	// The writer (core.encodeIntoDataView) uses core.endian (little-endian).
+	// Pre-fix, the local decoder omitted the endian argument and would have
+	// read big-endian, so 42n encoded LE as 2a 00 00 00 00 00 00 00 would
+	// decode as 0x2a00000000000000n. Pin the round-trip.
+	const obj = { uint64_ackId: 0n };
+	const ab = new ArrayBuffer(8);
+	new DataView(ab).setBigUint64(0, 42n, core.endian);
+	decodeFromDataView(obj, new DataView(ab), 0);
+	assert.strictEqual(obj.uint64_ackId, 42n);
+});
+
+test('decodeFromDataView round-trips a full Message-shaped payload', () => {
+	// The Message base class is { uint8_messagePayloadType, int64_timestamp }
+	// plus one trailing uint64. Build the layout directly so we don't depend
+	// on the (separately tested) core encoder.
+	const obj = {
+		uint8_messagePayloadType: 0,
+		int64_timestamp: 0n,
+		uint64_ackId: 0n,
+	};
+	const ab = new ArrayBuffer(17);
+	const dv = new DataView(ab);
+	dv.setUint8(0, 12);
+	dv.setBigInt64(1, -7n, core.endian);
+	dv.setBigUint64(9, 0xdeadbeefn, core.endian);
+	const endOffset = decodeFromDataView(obj, new DataView(ab), 0);
+	assert.strictEqual(endOffset, 17);
+	assert.strictEqual(obj.uint8_messagePayloadType, 12);
+	assert.strictEqual(obj.int64_timestamp, -7n);
+	assert.strictEqual(obj.uint64_ackId, 0xdeadbeefn);
+});
+
+test('decodeFromDataView recurses into nested struct fields', () => {
+	// "struct" is the catch-all branch in SizeOfType — anything not in the
+	// primitive list is treated as a nested object whose own keys follow the
+	// type_name convention. Pre-fix, this branch referenced an undefined
+	// `value` and would have thrown TypeError on the very first struct field.
+	const obj = {
+		struct_inner: { uint8_kind: 0, uint32_value: 0 },
+		uint8_trailer: 0,
+	};
+	const ab = new ArrayBuffer(6);
+	const dv = new DataView(ab);
+	dv.setUint8(0, 3);
+	dv.setUint32(1, 0x11223344, core.endian);
+	dv.setUint8(5, 0xff);
+	const endOffset = decodeFromDataView(obj, new DataView(ab), 0);
+	assert.strictEqual(endOffset, 6);
+	assert.strictEqual(obj.struct_inner.uint8_kind, 3);
+	assert.strictEqual(obj.struct_inner.uint32_value, 0x11223344);
+	assert.strictEqual(obj.uint8_trailer, 0xff);
+});
+
+test('decodeFromDataView does not mutate Object.entries itself', () => {
+	// Pin the most embarrassing of the pre-fix bugs: `Object.entries[key]=value`
+	// wrote properties onto the global Object.entries function. After the fix,
+	// decoding must leave Object.entries untouched.
+	const before = Object.getOwnPropertyNames(Object.entries);
+	const obj = { uint8_x: 0 };
+	const ab = new ArrayBuffer(1);
+	new DataView(ab).setUint8(0, 99);
+	decodeFromDataView(obj, new DataView(ab), 0);
+	const after = Object.getOwnPropertyNames(Object.entries);
+	assert.deepStrictEqual(after, before);
+});

package/test/test_geometry_service_send_gate.js

@@ -0,0 +1,120 @@
+'use strict';
+// Regression tests for GeometryService.GetResourcesToSend / GetMeshesToSend /
+// GetNodesToSend. Before the fix, the picker eagerly called res.Sent(now) for
+// every uid it returned. Combined with Client.SendNode's "channel not open"
+// silent short-circuit, this caused all initial resources to be marked Sent
+// during the first UpdateStreaming tick (which fires ~150 ms before the
+// geometry data channel finishes opening). On the next tick, every resource
+// looked "in flight" and was skipped, and they then sat idle for the full
+// 10 s timeout_us window before being retried — visible in production as a
+// ~10 s gap between WebRTC connect and the first geometry chunk reaching the
+// client.
+//
+// The fix: GetResourcesToSend / GetMeshesToSend must NOT mark Sent. Sent is
+// recorded by EncodedResource(uid), called from Send*() only after the
+// transport actually accepts the buffer.
+
+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);
+}
+
+function seed(svc, pool, uid) {
+	// Ensure the uid is in the static trackedResources map and in the per-client
+	// pool, mimicking what AddOrRemoveNodeAndResources / UpdateNodesToStream do.
+	GeometryService.GetOrCreateTrackedResource(uid);
+	pool.set(uid, 1);
+}
+
+test('GetResourcesToSend returns uid but does NOT mark it Sent', () => {
+	const svc = makeService(101);
+	const pool = new Map();
+	seed(svc, pool, 9n);
+
+	const toSend = svc.GetResourcesToSend(pool);
+	assert.deepStrictEqual(toSend, [9n]);
+
+	const res = GeometryService.GetOrCreateTrackedResource(9n);
+	// WasSentToClient returns the underlying bitset bit (0 / 1), not a boolean.
+	assert.ok(!res.WasSentToClient(101),
+		'picker must not record Sent — that is the transport layer\'s job');
+});
+
+test('GetResourcesToSend keeps returning the same uid across ticks until EncodedResource is called', () => {
+	// This is the exact scenario the production stall hit: the geometry data
+	// channel is not yet open, SendNode bails out silently, EncodedResource is
+	// never invoked. Every subsequent tick must re-offer the uid.
+	const svc = makeService(102);
+	const pool = new Map();
+	seed(svc, pool, 11n);
+
+	for (let tick = 0; tick < 5; tick++) {
+		const toSend = svc.GetResourcesToSend(pool);
+		assert.deepStrictEqual(toSend, [11n],
+			`tick ${tick}: uid must reappear because no successful send was recorded`);
+	}
+});
+
+test('GetResourcesToSend stops returning a uid once EncodedResource records the send', () => {
+	const svc = makeService(103);
+	const pool = new Map();
+	seed(svc, pool, 13n);
+
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), [13n]);
+	// Simulate Client.SendNode → sendGeometry returned true → EncodedResource.
+	svc.EncodedResource(13n);
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), [],
+		'after a successful send the uid must not be re-offered until timeout or Timeout()');
+});
+
+test('GetResourcesToSend re-offers a uid after timeout_us elapses without acknowledgement', () => {
+	const svc = makeService(104);
+	svc.timeout_us = 1000; // 1 ms timeout for the test
+	const pool = new Map();
+	seed(svc, pool, 17n);
+
+	// First tick: picker returns the uid; transport marks it Sent via EncodedResource.
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), [17n]);
+	svc.EncodedResource(17n);
+	// Immediately after: still in flight, must not be re-offered.
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), []);
+
+	// Manually age the Sent timestamp past the timeout window.
+	// core.getTimestampUs() returns a plain Number (microtime.now() - start),
+	// matching the type used in GetResourcesToSend's arithmetic.
+	const res = GeometryService.GetOrCreateTrackedResource(17n);
+	res.sent_server_time_us.set(104, res.GetTimeSent(104) - (svc.timeout_us + 1));
+
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), [17n],
+		'after timeout the uid must be re-offered for retransmission');
+});
+
+test('GetResourcesToSend skips uids the client has already acknowledged', () => {
+	const svc = makeService(105);
+	const pool = new Map();
+	seed(svc, pool, 19n);
+
+	svc.EncodedResource(19n);
+	svc.ConfirmResource(19n);
+	assert.deepStrictEqual(svc.GetResourcesToSend(pool), []);
+});
+
+test('GetMeshesToSend follows the same no-eager-Sent contract', () => {
+	// The mesh picker used to mark Sent inline; verify it now defers to the
+	// transport like the other resource pools.
+	const svc = makeService(106);
+	seed(svc, svc.streamedMeshes, 23n);
+
+	for (let tick = 0; tick < 3; tick++) {
+		assert.deepStrictEqual(svc.GetMeshesToSend(), [23n],
+			`tick ${tick}: mesh uid must reappear until EncodedResource is called`);
+	}
+	svc.EncodedResource(23n);
+	assert.deepStrictEqual(svc.GetMeshesToSend(), []);
+});