teleportxr 1.0.60 → 1.0.62

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/package.json

@@ -16,7 +16,7 @@
   },
   "name": "teleportxr",
   "description": "Teleport Spatial Server on node.js",
-  "version": "1.0.60",
+  "version": "1.0.62",
   "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);
+});