Initial commit of my folder

backend/node_modules/node-osc/dist/test/lib/osc.js

@@ -0,0 +1,424 @@
+'use strict';
+
+var node_buffer = require('node:buffer');
+
+// OSC 1.0 Protocol Implementation
+// Based on http://opensoundcontrol.org/spec-1_0
+
+
+function padString(str) {
+  const nullTerminated = str + '\0';
+  const byteLength = node_buffer.Buffer.byteLength(nullTerminated);
+  const padding = (4 - (byteLength % 4)) % 4;
+  return nullTerminated + '\0'.repeat(padding);
+}
+
+function readString(buffer, offset) {
+  let end = offset;
+  while (end < buffer.length && buffer[end] !== 0) {
+    end++;
+  }
+  if (end >= buffer.length) {
+    throw new Error('Malformed Packet: Missing null terminator for string');
+  }
+  const str = buffer.subarray(offset, end).toString('utf8');
+  // Find next 4-byte boundary
+  const paddedLength = Math.ceil((end - offset + 1) / 4) * 4;
+  return { value: str, offset: offset + paddedLength };
+}
+
+function writeInt32(value) {
+  const buffer = node_buffer.Buffer.alloc(4);
+  buffer.writeInt32BE(value, 0);
+  return buffer;
+}
+
+function readInt32(buffer, offset) {
+  if (offset + 4 > buffer.length) {
+    throw new Error('Malformed Packet: Not enough bytes for int32');
+  }
+  const value = buffer.readInt32BE(offset);
+  return { value, offset: offset + 4 };
+}
+
+function writeFloat32(value) {
+  const buffer = node_buffer.Buffer.alloc(4);
+  buffer.writeFloatBE(value, 0);
+  return buffer;
+}
+
+function readFloat32(buffer, offset) {
+  if (offset + 4 > buffer.length) {
+    throw new Error('Malformed Packet: Not enough bytes for float32');
+  }
+  const value = buffer.readFloatBE(offset);
+  return { value, offset: offset + 4 };
+}
+
+function writeBlob(value) {
+  const length = value.length;
+  const lengthBuffer = writeInt32(length);
+  const padding = 4 - (length % 4);
+  const paddingBuffer = node_buffer.Buffer.alloc(padding === 4 ? 0 : padding);
+  return node_buffer.Buffer.concat([lengthBuffer, value, paddingBuffer]);
+}
+
+function readBlob(buffer, offset) {
+  const lengthResult = readInt32(buffer, offset);
+  const length = lengthResult.value;
+  if (length < 0) {
+    throw new Error('Malformed Packet: Invalid blob length');
+  }
+  if (lengthResult.offset + length > buffer.length) {
+    throw new Error('Malformed Packet: Not enough bytes for blob');
+  }
+  const data = buffer.subarray(lengthResult.offset, lengthResult.offset + length);
+  const padding = 4 - (length % 4);
+  const nextOffset = lengthResult.offset + length + (padding === 4 ? 0 : padding);
+  if (nextOffset > buffer.length) {
+    throw new Error('Malformed Packet: Not enough bytes for blob padding');
+  }
+  return { value: data, offset: nextOffset };
+}
+
+function writeTimeTag(value) {
+  // For now, treat timetag as a double (8 bytes)
+  // OSC timetag is 64-bit: 32-bit seconds since 1900, 32-bit fractional
+  const buffer = node_buffer.Buffer.alloc(8);
+  if (value === 0 || value === null || value === undefined) {
+    // Immediate execution
+    buffer.writeUInt32BE(0, 0);
+    buffer.writeUInt32BE(1, 4);
+  } else if (typeof value === 'number') {
+    // Convert to OSC timetag format
+    const seconds = Math.floor(value);
+    const fraction = Math.floor((value - seconds) * 0x100000000);
+    buffer.writeUInt32BE(seconds + 2208988800, 0); // Add epoch offset (1900 vs 1970)
+    buffer.writeUInt32BE(fraction, 4);
+  } else {
+    // If not a number, write zeros (immediate execution)
+    buffer.writeUInt32BE(0, 0);
+    buffer.writeUInt32BE(1, 4);
+  }
+  return buffer;
+}
+
+function readTimeTag(buffer, offset) {
+  if (offset + 8 > buffer.length) {
+    throw new Error('Malformed Packet: Not enough bytes for timetag');
+  }
+  const seconds = buffer.readUInt32BE(offset);
+  const fraction = buffer.readUInt32BE(offset + 4);
+  
+  let value;
+  if (seconds === 0 && fraction === 1) {
+    // Immediate execution
+    value = 0;
+  } else {
+    // Convert from OSC epoch (1900) to Unix epoch (1970)
+    const unixSeconds = seconds - 2208988800;
+    const fractionalSeconds = fraction / 0x100000000;
+    value = unixSeconds + fractionalSeconds;
+  }
+  
+  return { value, offset: offset + 8 };
+}
+
+function writeMidi(value) {
+  // MIDI message is 4 bytes: port id, status byte, data1, data2
+  const buffer = node_buffer.Buffer.alloc(4);
+  
+  if (node_buffer.Buffer.isBuffer(value)) {
+    if (value.length !== 4) {
+      throw new Error('MIDI message must be exactly 4 bytes');
+    }
+    value.copy(buffer);
+  } else if (typeof value === 'object' && value !== null) {
+    // Allow object format: { port: 0, status: 144, data1: 60, data2: 127 }
+    buffer.writeUInt8(value.port || 0, 0);
+    buffer.writeUInt8(value.status || 0, 1);
+    buffer.writeUInt8(value.data1 || 0, 2);
+    buffer.writeUInt8(value.data2 || 0, 3);
+  } else {
+    throw new Error('MIDI value must be a 4-byte Buffer or object with port, status, data1, data2 properties');
+  }
+  
+  return buffer;
+}
+
+function readMidi(buffer, offset) {
+  if (offset + 4 > buffer.length) {
+    throw new Error('Not enough bytes for MIDI message');
+  }
+  
+  const value = buffer.subarray(offset, offset + 4);
+  return { value, offset: offset + 4 };
+}
+
+function encodeArgument(arg) {
+  if (typeof arg === 'object' && arg.type && arg.value !== undefined) {
+    // Explicit type specification
+    switch (arg.type) {
+      case 'i':
+      case 'integer':
+        return { tag: 'i', data: writeInt32(arg.value) };
+      case 'f':
+      case 'float':
+        return { tag: 'f', data: writeFloat32(arg.value) };
+      case 's':
+      case 'string':
+        return { tag: 's', data: node_buffer.Buffer.from(padString(arg.value)) };
+      case 'b':
+      case 'blob':
+        return { tag: 'b', data: writeBlob(arg.value) };
+      case 'd':
+      case 'double':
+        // For doubles, use float for now (OSC 1.0 doesn't have double)
+        return { tag: 'f', data: writeFloat32(arg.value) };
+      case 'T':
+        return { tag: 'T', data: node_buffer.Buffer.alloc(0) };
+      case 'F':
+        return { tag: 'F', data: node_buffer.Buffer.alloc(0) };
+      case 'boolean':
+        return arg.value ? { tag: 'T', data: node_buffer.Buffer.alloc(0) } : { tag: 'F', data: node_buffer.Buffer.alloc(0) };
+      case 'm':
+      case 'midi':
+        return { tag: 'm', data: writeMidi(arg.value) };
+      default:
+        throw new Error(`Unknown argument type: ${arg.type}`);
+    }
+  }
+  
+  // Infer type from JavaScript type
+  switch (typeof arg) {
+    case 'number':
+      if (Number.isInteger(arg)) {
+        return { tag: 'i', data: writeInt32(arg) };
+      } else {
+        return { tag: 'f', data: writeFloat32(arg) };
+      }
+    case 'string':
+      return { tag: 's', data: node_buffer.Buffer.from(padString(arg)) };
+    case 'boolean':
+      return arg ? { tag: 'T', data: node_buffer.Buffer.alloc(0) } : { tag: 'F', data: node_buffer.Buffer.alloc(0) };
+    default:
+      if (node_buffer.Buffer.isBuffer(arg)) {
+        return { tag: 'b', data: writeBlob(arg) };
+      }
+      throw new Error(`Don't know how to encode argument: ${arg}`);
+  }
+}
+
+function decodeArgument(tag, buffer, offset) {
+  switch (tag) {
+    case 'i':
+      return readInt32(buffer, offset);
+    case 'f':
+      return readFloat32(buffer, offset);
+    case 's':
+      return readString(buffer, offset);
+    case 'b':
+      return readBlob(buffer, offset);
+    case 'T':
+      return { value: true, offset };
+    case 'F':
+      return { value: false, offset };
+    case 'N':
+      return { value: null, offset };
+    case 'm':
+      return readMidi(buffer, offset);
+    default:
+      throw new Error(`I don't understand the argument code ${tag}`);
+  }
+}
+
+/**
+ * Encode an OSC message or bundle to a Buffer.
+ * 
+ * This low-level function converts OSC messages and bundles into binary format
+ * for transmission or storage. Useful for sending OSC over custom transports
+ * (WebSocket, TCP, HTTP), storing to files, or implementing custom OSC routers.
+ * 
+ * @param {Object} message - OSC message or bundle object with oscType property
+ * @returns {Buffer} The encoded OSC data ready for transmission
+ * 
+ * @example
+ * // Encode a message
+ * import { Message, encode } from 'node-osc';
+ * 
+ * const message = new Message('/oscillator/frequency', 440);
+ * const buffer = encode(message);
+ * console.log('Encoded bytes:', buffer.length);
+ * 
+ * @example
+ * // Encode a bundle
+ * import { Bundle, encode } from 'node-osc';
+ * 
+ * const bundle = new Bundle(['/one', 1], ['/two', 2]);
+ * const buffer = encode(bundle);
+ * 
+ * @example
+ * // Send over WebSocket
+ * const buffer = encode(message);
+ * websocket.send(buffer);
+ */
+function encode(message) {
+  if (message.oscType === 'bundle') {
+    return encodeBundleToBuffer(message);
+  } else {
+    return encodeMessageToBuffer(message);
+  }
+}
+
+function encodeMessageToBuffer(message) {
+  // OSC Message format:
+  // Address pattern (padded string)
+  // Type tag string (padded string starting with ,)
+  // Arguments (encoded according to type tags)
+  
+  const address = padString(message.address);
+  const addressBuffer = node_buffer.Buffer.from(address);
+  
+  const encodedArgs = message.args.map(encodeArgument);
+  const typeTags = ',' + encodedArgs.map(arg => arg.tag).join('');
+  const typeTagsBuffer = node_buffer.Buffer.from(padString(typeTags));
+  
+  const argumentBuffers = encodedArgs.map(arg => arg.data);
+  
+  return node_buffer.Buffer.concat([addressBuffer, typeTagsBuffer, ...argumentBuffers]);
+}
+
+function encodeBundleToBuffer(bundle) {
+  // OSC Bundle format:
+  // "#bundle" (padded string)
+  // Timetag (8 bytes)
+  // Elements (each prefixed with size)
+  
+  const bundleString = padString('#bundle');
+  const bundleStringBuffer = node_buffer.Buffer.from(bundleString);
+  
+  const timetagBuffer = writeTimeTag(bundle.timetag);
+  
+  const elementBuffers = bundle.elements.map(element => {
+    let elementBuffer;
+    if (element.oscType === 'bundle') {
+      elementBuffer = encodeBundleToBuffer(element);
+    } else {
+      elementBuffer = encodeMessageToBuffer(element);
+    }
+    const sizeBuffer = writeInt32(elementBuffer.length);
+    return node_buffer.Buffer.concat([sizeBuffer, elementBuffer]);
+  });
+  
+  return node_buffer.Buffer.concat([bundleStringBuffer, timetagBuffer, ...elementBuffers]);
+}
+
+/**
+ * Decode a Buffer containing OSC data into a message or bundle object.
+ * 
+ * This low-level function parses binary OSC data back into JavaScript objects.
+ * Useful for receiving OSC over custom transports, reading from files,
+ * or implementing custom OSC routers.
+ * 
+ * @param {Buffer} buffer - The Buffer containing OSC data
+ * @returns {Object} The decoded OSC message or bundle. Messages have
+ *   {oscType: 'message', address: string, args: Array}, bundles have
+ *   {oscType: 'bundle', timetag: number, elements: Array}
+ * @throws {Error} If the buffer contains malformed OSC data
+ * 
+ * @example
+ * // Decode received data
+ * import { decode } from 'node-osc';
+ * 
+ * const decoded = decode(buffer);
+ * if (decoded.oscType === 'message') {
+ *   console.log('Address:', decoded.address);
+ *   console.log('Arguments:', decoded.args);
+ * }
+ * 
+ * @example
+ * // Round-trip encode/decode
+ * import { Message, encode, decode } from 'node-osc';
+ * 
+ * const original = new Message('/test', 42, 'hello');
+ * const buffer = encode(original);
+ * const decoded = decode(buffer);
+ * console.log(decoded.address); // '/test'
+ */
+function decode(buffer) {
+  // Check if it's a bundle or message
+  if (buffer.length >= 8 && buffer.subarray(0, 8).toString() === '#bundle\0') {
+    return decodeBundleFromBuffer(buffer);
+  } else {
+    return decodeMessageFromBuffer(buffer);
+  }
+}
+
+function decodeMessageFromBuffer(buffer) {
+  let offset = 0;
+  
+  // Read address pattern
+  const addressResult = readString(buffer, offset);
+  const address = addressResult.value;
+  offset = addressResult.offset;
+  
+  // Read type tag string
+  const typeTagsResult = readString(buffer, offset);
+  const typeTags = typeTagsResult.value;
+  offset = typeTagsResult.offset;
+  
+  if (!typeTags.startsWith(',')) {
+    throw new Error('Malformed Packet');
+  }
+  
+  const tags = typeTags.slice(1); // Remove leading comma
+  const args = [];
+  
+  for (const tag of tags) {
+    const argResult = decodeArgument(tag, buffer, offset);
+    args.push({ value: argResult.value });
+    offset = argResult.offset;
+  }
+  
+  return {
+    oscType: 'message',
+    address,
+    args
+  };
+}
+
+function decodeBundleFromBuffer(buffer) {
+  let offset = 8; // Skip "#bundle\0"
+  
+  // Read timetag
+  const timetagResult = readTimeTag(buffer, offset);
+  const timetag = timetagResult.value;
+  offset = timetagResult.offset;
+  
+  const elements = [];
+  
+  while (offset < buffer.length) {
+    // Read element size
+    const sizeResult = readInt32(buffer, offset);
+    const size = sizeResult.value;
+    offset = sizeResult.offset;
+    if (size <= 0 || offset + size > buffer.length) {
+      throw new Error('Malformed Packet');
+    }
+    
+    // Read element data
+    const elementBuffer = buffer.subarray(offset, offset + size);
+    const element = decode(elementBuffer);
+    elements.push(element);
+    offset += size;
+  }
+  
+  return {
+    oscType: 'bundle',
+    timetag,
+    elements
+  };
+}
+
+exports.decode = decode;
+exports.encode = encode;

backend/node_modules/node-osc/dist/test/test-bundle.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+tap.test('bundle: verbose bundle', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(2);
+
+  t.teardown(() => {
+    server.close();
+    client.close();
+  });
+
+  server.on('bundle', (bundle) => {
+    t.same(bundle.elements[0], ['/one', 1]);
+    t.same(bundle.elements[1], ['/two', 2]);
+  });
+
+  client.send(new nodeOsc.Bundle(1, {
+    address: '/one',
+    args: [
+      1
+    ]
+  }, {
+    address: '/two',
+    args: [
+      2
+    ]
+  }));
+});
+
+tap.test('bundle: array syntax', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(2);
+
+  t.teardown(() => {
+    server.close();
+    client.close();
+  });
+
+  server.on('bundle', (bundle) => {
+    t.same(bundle.elements[0], ['/one', 1]);
+    t.same(bundle.elements[1], ['/two', 2]);
+  });
+
+  client.send(new nodeOsc.Bundle(
+    ['/one', 1],
+    ['/two', 2]
+  ));
+});
+
+tap.test('bundle: nested bundle', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(4);
+
+  t.teardown(() => {
+    server.close();
+    client.close();
+  });
+
+  const payload = new nodeOsc.Bundle(
+    ['/one', 1],
+    ['/two', 2],
+    ['/three', 3]
+  );
+  
+  payload.append(new nodeOsc.Bundle(10,
+    ['/four', 4]
+  ));
+
+  server.on('bundle', (bundle) => {
+    t.same(bundle.elements[0], ['/one', 1]);
+    t.same(bundle.elements[1], ['/two', 2]);
+    t.same(bundle.elements[2], ['/three', 3]);
+    t.same(bundle.elements[3].elements[0], ['/four', 4]);
+  });
+
+  client.send(payload);
+});

backend/node_modules/node-osc/dist/test/test-client.js

@@ -0,0 +1,292 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+tap.test('client: with array', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  client.send(['/test', 0, 1, 'testing', true], (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
+tap.test('client: array is not mutated when sent', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(3);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+    // Verify the original array was not mutated
+    t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  });
+
+  client.send(originalArray, (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
+tap.test('client: with string', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test'], `We should receive expected payload: ${msg}`);
+  });
+
+  client.send('/test', (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
+tap.test('client: with Message object', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 3, 'lol', false], `we received the payload: ${msg}`);
+  });
+
+  client.send({
+    address: '/test',
+    args: [
+      1,
+      2,
+      3,
+      'lol',
+      false
+    ]
+  }, (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
+tap.test('client: with Bundle object', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 3, 'lol', false], `we received the payload: ${msg}`);
+  });
+
+  client.send({
+    address: '/test',
+    args: [
+      1,
+      2,
+      3,
+      'lol',
+      false
+    ]
+  }, (err) => {
+    t.error(err, 'there should be no error');
+    client.close();
+  });
+});
+
+tap.test('client: failure', async (t) => {
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+
+  t.plan(2);
+
+  t.throws(() => {
+    client.send(123, (err) => {
+      t.error(err, 'there should be no error');
+    });
+  });
+  client.close();
+  client.send('/boom', (err) => {
+    t.equal(err.code, 'ERR_SOCKET_DGRAM_NOT_RUNNING');
+  });
+});
+
+tap.test('client: close with callback', async (t) => {
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+
+  t.plan(1);
+
+  client.close((err) => {
+    t.error(err, 'close should not error');
+  });
+});
+
+tap.test('client: send bundle with non-numeric timetag', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('bundle', (bundle) => {
+    oscServer.close();
+    t.equal(bundle.timetag, 0, 'should receive immediate execution timetag as 0');
+    t.ok(bundle.elements.length > 0, 'should have elements');
+    client.close();
+  });
+
+  // Send bundle with non-numeric timetag (will be encoded as immediate execution)
+  const bundle = {
+    oscType: 'bundle',
+    timetag: 'immediate', // Non-numeric, will trigger the else branch in writeTimeTag
+    elements: [
+      {
+        oscType: 'message',
+        address: '/test1',
+        args: [{ type: 'i', value: 42 }]
+      }
+    ]
+  };
+  
+  client.send(bundle);
+});
+
+tap.test('client: send bundle with null timetag', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('bundle', (bundle) => {
+    oscServer.close();
+    t.equal(bundle.timetag, 0, 'should receive immediate execution timetag as 0');
+    t.ok(bundle.elements.length > 0, 'should have elements');
+    client.close();
+  });
+
+  // Send bundle with null timetag (will be encoded as immediate execution)
+  const bundle = {
+    oscType: 'bundle',
+    timetag: null, // Null, will trigger the else branch in writeTimeTag
+    elements: [
+      {
+        oscType: 'message',
+        address: '/test2',
+        args: [{ type: 's', value: 'hello' }]
+      }
+    ]
+  };
+  
+  client.send(bundle);
+});
+
+tap.test('client: send message with float type arg', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.equal(msg[0], '/float-test', 'should receive address');
+    t.ok(Math.abs(msg[1] - 9.876) < 0.001, 'should receive float value');
+    client.close();
+  });
+
+  // Send raw message with 'float' type to hit that case label
+  client.send({
+    oscType: 'message',
+    address: '/float-test',
+    args: [{ type: 'float', value: 9.876 }]
+  });
+});
+
+tap.test('client: send message with blob type arg', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.equal(msg[0], '/blob-test', 'should receive address');
+    t.ok(Buffer.isBuffer(msg[1]), 'should receive blob as buffer');
+    client.close();
+  });
+
+  // Send raw message with 'blob' type to hit that case label
+  client.send({
+    oscType: 'message',
+    address: '/blob-test',
+    args: [{ type: 'blob', value: Buffer.from([0xAA, 0xBB]) }]
+  });
+});
+
+tap.test('client: send message with double type arg', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.equal(msg[0], '/double-test', 'should receive address');
+    t.ok(Math.abs(msg[1] - 1.23456789) < 0.001, 'should receive double value as float');
+    client.close();
+  });
+
+  // Send raw message with 'double' type to hit that case label
+  client.send({
+    oscType: 'message',
+    address: '/double-test',
+    args: [{ type: 'double', value: 1.23456789 }]
+  });
+});
+
+tap.test('client: send message with midi type arg', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.equal(msg[0], '/midi-test', 'should receive address');
+    t.ok(Buffer.isBuffer(msg[1]), 'should receive MIDI as buffer');
+    client.close();
+  });
+
+  // Send raw message with 'midi' type to hit that case label
+  client.send({
+    oscType: 'message',
+    address: '/midi-test',
+    args: [{ type: 'midi', value: Buffer.from([0x00, 0x90, 0x40, 0x60]) }]
+  });
+});

backend/node_modules/node-osc/dist/test/test-decode.js

@@ -0,0 +1,144 @@
+'use strict';
+
+var tap = require('tap');
+var decode = require('#decode');
+
+tap.test('decode: valid', (t) => {
+  const buf = Buffer.from('/test\0\0\0,s\0,testing\0');
+  t.same(decode(buf), ['/test', 'testing'], 'should be empty array');
+  t.end();
+});
+
+tap.test('decode: valid', (t) => {
+  const buf = Buffer.from('/test\0\0\0,s\0,testing\0');
+  t.same(decode(buf), ['/test', 'testing'], 'should be empty array');
+  t.end();
+});
+
+tap.test('decode: malformed packet', (t) => {
+  t.throws(() => {
+    const buf = Buffer.from('/test\0\0');
+    decode(buf);
+  }, /Malformed Packet/);
+  t.end();
+});
+
+tap.test('decode: invalid typetags', (t) => {
+  t.throws(() => {
+    const buf = Buffer.from('/test\0\0\0,R\0');
+    decode(buf);
+  }, /I don't understand the argument code R/);
+  t.end();
+});
+
+tap.test('decode: malformed OSC structure', (t) => {
+  // Try to create a scenario that might trigger the "else" case in decode
+  // This tests an edge case where the buffer might be parsed but not create a valid OSC structure
+  t.throws(() => {
+    // Create a buffer that's too short to be valid
+    const buf = Buffer.from('\0\0\0\0');
+    decode(buf);
+  }, /Malformed Packet/);
+  t.end();
+});
+
+tap.test('decode: corrupted buffer', (t) => {
+  // Test with a buffer that could potentially cause fromBuffer to return unexpected results
+  t.throws(() => {
+    // Create a malformed buffer that might not parse correctly
+    const buf = Buffer.from('invalid');
+    decode(buf);
+  }, /(Malformed Packet|Cannot read|out of range)/);
+  t.end();
+});
+
+// This test attempts to exercise edge cases in the decode function
+tap.test('decode: edge case with manually crafted invalid structure', (t) => {
+  // Since the decode function has a defensive else clause, let's try to trigger it
+  // by creating a buffer that might result in an unexpected object structure
+  
+  // Try with an empty buffer
+  t.throws(() => {
+    const buf = Buffer.alloc(0);
+    decode(buf);
+  }, /(Malformed Packet|Cannot read|out of range)/);
+  
+  // Try with a buffer containing only null bytes
+  t.throws(() => {
+    const buf = Buffer.alloc(16, 0);
+    decode(buf);
+  }, /(Malformed Packet|Cannot read|out of range)/);
+  
+  t.end();
+});
+
+tap.test('decode: malformed structure with unexpected oscType', async (t) => {
+  // Test the defensive else clause by providing a custom fromBuffer function
+  // that returns an object with an invalid oscType
+  
+  const mockFromBuffer = () => ({
+    oscType: 'invalid',
+    data: 'test'
+  });
+  
+  t.throws(() => {
+    decode(Buffer.from('test'), mockFromBuffer);
+  }, /Malformed Packet/, 'should throw for invalid oscType');
+  
+  // Test with undefined oscType
+  const mockFromBufferUndefined = () => ({
+    data: 'test'
+    // missing oscType property
+  });
+  
+  t.throws(() => {
+    decode(Buffer.from('test'), mockFromBufferUndefined);
+  }, /Malformed Packet/, 'should throw for undefined oscType');
+  
+  // Test with null oscType
+  const mockFromBufferNull = () => ({
+    oscType: null,
+    data: 'test'
+  });
+  
+  t.throws(() => {
+    decode(Buffer.from('test'), mockFromBufferNull);
+  }, /Malformed Packet/, 'should throw for null oscType');
+  
+  t.end();
+});
+
+tap.test('decode: message without args defaults to empty array', (t) => {
+  const mockFromBuffer = () => ({
+    oscType: 'message',
+    address: '/test'
+  });
+
+  t.same(
+    decode(Buffer.from('test'), mockFromBuffer),
+    ['/test'],
+    'should default args to empty array'
+  );
+  t.end();
+});
+
+tap.test('decode: bundle element must be message or bundle', (t) => {
+  const mockFromBuffer = () => ({
+    oscType: 'bundle',
+    elements: [
+      {
+        oscType: 'message',
+        address: '/ok',
+        args: []
+      },
+      {
+        oscType: 'nope'
+      }
+    ]
+  });
+
+  t.throws(() => {
+    decode(Buffer.from('test'), mockFromBuffer);
+  }, /Malformed Packet/, 'should throw for invalid bundle element');
+  t.end();
+});

backend/node_modules/node-osc/dist/test/test-e2e.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+function flaky() {
+  return process.release.lts === 'Dubnium' && process.platform === 'win32';
+}
+
+function skip(t) {
+  t.skip(`flaky ~ ${t.name}`);
+  t.end();
+}
+
+tap.test('osc: argument message no callback', async (t) => {
+  if (flaky()) return skip(t);
+
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  t.teardown(() => {
+    oscServer.close();
+    client.close();
+  });
+
+  oscServer.on('message', (msg) => {
+    t.same(msg, ['/test', 1, 2, 'testing'], 'We should receive expected payload');
+  });
+
+  client.send('/test', 1, 2, 'testing');
+});
+
+tap.test('osc: client with callback and message as arguments', async (t) => {
+  if (flaky()) return skip(t);
+
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  t.teardown(() => {
+    oscServer.close();
+    client.close();
+  });
+
+  oscServer.on('message', (msg) => {
+    t.same(msg, ['/test', 1, 2, 'testing'], 'We should receive expected payload');
+  });
+
+  client.send('/test', 1, 2, 'testing', (err) => {
+    t.error(err, 'there should be no error');
+  });
+});

backend/node_modules/node-osc/dist/test/test-error-handling.js

@@ -0,0 +1,117 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+tap.test('server: socket error event is emitted', async (t) => {
+  t.plan(1);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  
+  oscServer.on('error', (err) => {
+    t.ok(err, 'error event should be emitted');
+    oscServer.close();
+  });
+  
+  // Simulate a socket error
+  oscServer._sock.emit('error', new Error('test socket error'));
+});
+
+tap.test('server: error listener can be added before listening', async (t) => {
+  t.plan(2);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  
+  oscServer.on('error', (err) => {
+    t.ok(err, 'error event should be emitted');
+    t.equal(err.message, 'socket test error', 'error message should match');
+  });
+  
+  t.teardown(() => {
+    oscServer.close();
+  });
+  
+  // Simulate a socket error
+  oscServer._sock.emit('error', new Error('socket test error'));
+});
+
+tap.test('client: socket error event is emitted', (t) => {
+  t.plan(1);
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+  
+  client.on('error', (err) => {
+    t.ok(err, 'error event should be emitted');
+    client.close();
+  });
+  
+  // Simulate a socket error
+  client._sock.emit('error', new Error('test client error'));
+});
+
+tap.test('client: error listener can be added at construction', (t) => {
+  t.plan(2);
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+  
+  client.on('error', (err) => {
+    t.ok(err, 'error event should be emitted');
+    t.equal(err.message, 'client socket error', 'error message should match');
+  });
+  
+  t.teardown(() => {
+    client.close();
+  });
+  
+  // Simulate a socket error
+  client._sock.emit('error', new Error('client socket error'));
+});
+
+tap.test('client: is an EventEmitter instance', (t) => {
+  t.plan(1);
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+  
+  t.ok(typeof client.on === 'function', 'client should have EventEmitter methods');
+  
+  client.close();
+});
+
+tap.test('server: multiple error listeners can be attached', async (t) => {
+  t.plan(2);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  
+  oscServer.on('error', (err) => {
+    t.ok(err, 'first listener should receive error');
+  });
+  
+  oscServer.on('error', (err) => {
+    t.ok(err, 'second listener should receive error');
+  });
+  
+  t.teardown(() => {
+    oscServer.close();
+  });
+  
+  // Simulate a socket error
+  oscServer._sock.emit('error', new Error('multi listener test'));
+});
+
+tap.test('client: multiple error listeners can be attached', (t) => {
+  t.plan(2);
+  const client = new nodeOsc.Client('127.0.0.1', 9999);
+  
+  client.on('error', (err) => {
+    t.ok(err, 'first listener should receive error');
+  });
+  
+  client.on('error', (err) => {
+    t.ok(err, 'second listener should receive error');
+  });
+  
+  t.teardown(() => {
+    client.close();
+  });
+  
+  // Simulate a socket error
+  client._sock.emit('error', new Error('multi listener test'));
+});

backend/node_modules/node-osc/dist/test/test-message.js

@@ -0,0 +1,403 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+function round(num) {
+  return Math.round(num * 100) / 100;
+}
+
+tap.test('message: basic usage', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  m.append('testing');
+  m.append(123);
+  m.append([456, 789]);
+  
+  server.on('message', (msg) => {
+    const expected = ['/address', 'testing', 123, 456, 789];
+    t.same(msg, expected, `We reveived the payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: multiple args', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+  
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+  
+  const m = new nodeOsc.Message('/address', 'testing', 123, true);
+
+  server.on('message', (msg) => {
+    const expected = ['/address', 'testing', 123, true];
+    t.same(msg, expected, `We reveived the payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: object', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  m.append({
+    type: 'string',
+    value: 'test'
+  });
+  m.append({
+    type: 'double',
+    value: 100
+  });
+
+  server.on('message', (msg) => {
+    const expected = ['/address', 'test', 100];
+    t.same(msg, expected, `We reveived the payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: float', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(2);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  m.append(3.14);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      3.14
+    ];
+    t.equal(msg[0], expected[0], `We reveived the payload: ${msg}`);
+    t.equal(round(msg[1]), expected[1], 'pie please');
+  });
+
+  client.send(m);
+});
+
+tap.test('message: alias messages', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(5);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  m.append({
+    type: 'i',
+    value: 123
+  });
+  m.append({
+    type: 'f',
+    value: 3.14
+  });
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      123,
+      3.14
+    ];
+    t.equal(msg[0], expected[0], `We reveived the payload: ${msg}`);
+    t.equal(msg[1], expected[1], 'easy as abc');
+    t.ok(Number.isInteger(msg[1]), 'the first value is an int');
+    t.equal(round(msg[2]), expected[2], 'pie please');
+    t.ok(msg[2] % 1 !== 0, 'the second value is a float');
+  });
+
+  client.send(m);
+});
+
+tap.test('message: boolean', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+  const m = new nodeOsc.Message('/address');
+  m.append(true);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      true
+    ];
+    t.same(msg, expected, `We reveived the payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: blob', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.from('test');
+  m.append({
+    type: 'blob',
+    value: buf
+  });
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We reveived the payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: Buffer as blob', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.from('test buffer data');
+  // Directly append Buffer without wrapping in object
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the buffer payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+// test('message: timetag', (t) => {
+//   const oscServer = new osc.Server(3333, '127.0.0.1');
+//   const client = new osc.Client('127.0.0.1', 3333);
+//   const m = new osc.Message('/address');
+//
+//   oscServer.on('message', (msg) => {
+//     const expected = [
+//       '/address'
+//     ];
+//     t.same(msg, expected, `We reveived the payload: ${msg}`);
+//     oscServer.close();
+//     t.end();
+//   });
+//
+//   client.send(m, () => {
+//     client.close();
+//   });
+// });
+
+tap.test('message: Buffer with multiple arguments', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(6);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf1 = Buffer.from('first');
+  const buf2 = Buffer.from('second');
+
+  m.append('string');
+  m.append(42);
+  m.append(buf1);
+  m.append(3.14);
+  m.append(buf2);
+
+  server.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.equal(msg[1], 'string', 'String matches');
+    t.equal(msg[2], 42, 'Integer matches');
+    t.same(msg[3], buf1, 'First buffer matches');
+    t.equal(round(msg[4]), 3.14, 'Float matches');
+    t.same(msg[5], buf2, 'Second buffer matches');
+  });
+
+  client.send(m);
+});
+
+tap.test('message: Buffer in constructor', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const buf = Buffer.from('constructor buffer');
+  const m = new nodeOsc.Message('/address', 'test', buf, 123);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      'test',
+      buf,
+      123
+    ];
+    t.same(msg, expected, `We received the constructor buffer payload: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: Buffer in array', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf1 = Buffer.from('array1');
+  const buf2 = Buffer.from('array2');
+
+  m.append([buf1, 'string', buf2, 456]);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf1,
+      'string',
+      buf2,
+      456
+    ];
+    t.same(msg, expected, `We received the array with buffers: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: empty Buffer', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.from('');
+  
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    const expected = [
+      '/address',
+      buf
+    ];
+    t.same(msg, expected, `We received the empty buffer: ${msg}`);
+  });
+
+  client.send(m);
+});
+
+tap.test('message: large Buffer', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(4);
+  t.teardown(async () => {
+    await server.close();
+    await client.close();
+  });
+
+  const m = new nodeOsc.Message('/address');
+  const buf = Buffer.alloc(1024, 'x');
+  
+  m.append(buf);
+
+  server.on('message', (msg) => {
+    t.equal(msg[0], '/address', 'Address matches');
+    t.ok(Buffer.isBuffer(msg[1]), 'Second element is a Buffer');
+    t.equal(msg[1].length, 1024, 'Buffer size matches');
+    t.same(msg[1], buf, 'Buffer content matches');
+  });
+
+  client.send(m);
+});
+
+tap.test('message: error', (t) => {
+  const m = new nodeOsc.Message('/address');
+  t.plan(2);
+  t.throws(() => {
+    m.append({
+      lol: 'it broken'
+    });
+  }, /don't know how to encode object/);
+  t.throws(() => {
+    m.append(undefined);
+  }, /don't know how to encode/);
+});

backend/node_modules/node-osc/dist/test/test-promises.js

@@ -0,0 +1,314 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+tap.test('client: send with promise - array', async (t) => {
+  const server = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(server, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', server.port);
+
+  t.plan(1);
+
+  server.on('message', (msg) => {
+    server.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(['/test', 0, 1, 'testing', true]);
+  await client.close();
+});
+
+tap.test('client: array is not mutated when sent with promise', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(2);
+
+  const originalArray = ['/test', 0, 1, 'testing', true];
+  const expectedArray = ['/test', 0, 1, 'testing', true];
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 0, 1, 'testing', true], 'We should receive expected payload');
+  });
+
+  await client.send(originalArray);
+  
+  // Verify the original array was not mutated
+  t.same(originalArray, expectedArray, 'Original array should not be mutated');
+  
+  await client.close();
+});
+
+tap.test('client: send with promise - string', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+
+  await client.send('/test');
+  await client.close();
+});
+
+tap.test('client: send with promise - message object', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 3, 'lol', false], 'we received the payload');
+  });
+
+  await client.send({
+    address: '/test',
+    args: [1, 2, 3, 'lol', false]
+  });
+  await client.close();
+});
+
+tap.test('client: send with promise - multiple args', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  oscServer.on('message', (msg) => {
+    oscServer.close();
+    t.same(msg, ['/test', 1, 2, 'testing'], 'We should receive expected payload');
+  });
+
+  await client.send('/test', 1, 2, 'testing');
+  await client.close();
+});
+
+tap.test('client: send promise rejection on closed socket', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  await client.close();
+  await oscServer.close();
+
+  try {
+    await client.send('/boom');
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'ERR_SOCKET_DGRAM_NOT_RUNNING', 'Should reject with correct error code');
+  }
+});
+
+tap.test('client: async/await usage', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  const messagePromise = node_events.once(oscServer, 'message');
+
+  await client.send('/async-test', 42, 'hello');
+  const [receivedMessage] = await messagePromise;
+  
+  t.same(receivedMessage, ['/async-test', 42, 'hello'], 'Message received via async/await');
+
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('server: close with promise', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+
+  await oscServer.close();
+  t.pass('Server closed successfully with promise');
+});
+
+tap.test('server: no callback still emits listening event', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+  t.pass('listening event emitted');
+
+  await oscServer.close();
+});
+
+tap.test('client and server: full async/await workflow', async (t) => {
+  t.plan(3);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+
+  // Wait for server to be ready
+  await node_events.once(oscServer, 'listening');
+  t.pass('Server started');
+
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+  t.pass('Client created');
+
+  // Set up message handler
+  const messageReceived = node_events.once(oscServer, 'message');
+
+  // Send message and wait for it to be received
+  await client.send('/workflow', 'test', 123);
+  const [msg] = await messageReceived;
+  t.same(msg, ['/workflow', 'test', 123], 'Message received correctly');
+
+  // Clean up
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('client: multiple sends with promises', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+  t.plan(3);
+
+  const messages = [];
+  oscServer.on('message', (msg) => {
+    messages.push(msg);
+  });
+
+  await client.send('/msg1', 1);
+  await client.send('/msg2', 2);
+  await client.send('/msg3', 3);
+
+  // Give a little time for all messages to be received
+  await new Promise((resolve) => setTimeout(resolve, 100));
+
+  t.equal(messages.length, 3, 'Received all three messages');
+  t.same(messages[0], ['/msg1', 1], 'First message correct');
+  t.same(messages[2], ['/msg3', 3], 'Last message correct');
+
+  await client.close();
+  await oscServer.close();
+});
+
+tap.test('client: close promise rejection on error', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', t.context.port);
+
+  t.plan(1);
+
+  // Mock the socket's close method to simulate an error
+  const originalClose = client._sock.close.bind(client._sock);
+  
+  // Set up teardown to ensure socket is properly closed
+  t.teardown(() => {
+    // Restore original close method first
+    client._sock.close = originalClose;
+    // Then close the socket
+    try {
+      client._sock.close(() => {});
+    } catch {
+      // Socket might already be closed, that's ok
+    }
+  });
+  
+  client._sock.close = function(cb) {
+    // Simulate an error being passed to callback
+    if (cb) {
+      const err = new Error('Mock close error');
+      err.code = 'MOCK_ERROR';
+      setImmediate(() => cb(err));
+    }
+  };
+
+  try {
+    await oscServer.close();
+    await client.close();
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'MOCK_ERROR', 'Should reject with mock error');
+  }
+});
+
+tap.test('server: close promise rejection on error', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+
+  t.plan(1);
+
+  await node_events.once(oscServer, 'listening');
+
+  // Mock the socket's close method to simulate an error
+  const originalClose = oscServer._sock.close.bind(oscServer._sock);
+  
+  // Set up teardown to ensure socket is properly closed
+  t.teardown(() => {
+    // Restore original close method first
+    oscServer._sock.close = originalClose;
+    // Then close the socket
+    try {
+      oscServer._sock.close(() => {});
+    } catch {
+      // Socket might already be closed, that's ok
+    }
+  });
+  
+  oscServer._sock.close = function(cb) {
+    // Simulate an error being passed to callback
+    if (cb) {
+      const err = new Error('Mock close error');
+      err.code = 'MOCK_ERROR';
+      setImmediate(() => cb(err));
+    }
+  };
+
+  try {
+    await oscServer.close();
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'MOCK_ERROR', 'Should reject with mock error');
+  }
+});
+
+tap.test('client: send promise rejection on send error', async (t) => {
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(1);
+
+  // Mock the socket's send method to simulate an error
+  const originalSend = client._sock.send;
+  client._sock.send = function(msg, offset, length, port, address, callback) {
+    // Simulate an error being passed to callback
+    const err = new Error('Mock send error');
+    err.code = 'MOCK_SEND_ERROR';
+    if (callback) {
+      setImmediate(() => callback(err));
+    }
+  };
+
+  t.teardown(async () => {
+    client._sock.send = originalSend;
+    await client.close();
+    await oscServer.close();
+  });
+
+  try {
+    await client.send('/test', 'data');
+    t.fail('Should have thrown an error');
+  } catch (err) {
+    t.equal(err.code, 'MOCK_SEND_ERROR', 'Should reject with mock send error');
+  }
+});

backend/node_modules/node-osc/dist/test/test-server.js

@@ -0,0 +1,102 @@
+'use strict';
+
+var node_events = require('node:events');
+var tap = require('tap');
+var nodeOsc = require('node-osc');
+
+tap.test('server: create and close', async (t) => {
+  t.plan(1);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  oscServer.close((err) => {
+    t.error(err);
+  });
+});
+
+tap.test('server: listen to message', async (t) => {
+  const oscServer = new nodeOsc.Server(0);
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(3);
+
+  t.teardown(() => {
+    oscServer.close();
+    client.close();
+  });
+
+  oscServer.on('message', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+  
+  oscServer.on('/test', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+
+  client.send('/test', (err) => {
+    t.error(err, 'there should be no error');
+  });
+});
+
+tap.test('server: no defined host', async (t) => {
+  const oscServer = new nodeOsc.Server(0);
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.plan(3);
+
+  t.teardown(() => {
+    oscServer.close();
+    client.close();
+  });
+
+  oscServer.on('message', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+  
+  oscServer.on('/test', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+
+  client.send('/test', (err) => {
+    t.error(err, 'there should be no error');
+  });
+});
+
+tap.test('server: callback as second arg', async (t) => {
+  t.plan(4);
+  const oscServer = new nodeOsc.Server(0, () => {
+    t.ok('callback called');
+  });
+  await node_events.once(oscServer, 'listening');
+  const client = new nodeOsc.Client('127.0.0.1', oscServer.port);
+
+  t.teardown(() => {
+    oscServer.close();
+    client.close();
+  });
+
+  oscServer.on('message', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+  
+  oscServer.on('/test', (msg) => {
+    t.same(msg, ['/test'], 'We should receive expected payload');
+  });
+
+  client.send('/test', (err) => {
+    t.error(err, 'there should be no error');
+  });
+});
+
+tap.test('server: bad message', async (t) => {
+  t.plan(2);
+  const oscServer = new nodeOsc.Server(0, '127.0.0.1');
+  await node_events.once(oscServer, 'listening');
+  t.throws(() => {
+    oscServer._sock.emit('message', 'whoops');
+  }, /can't decode incoming message:/);
+  oscServer.close((err) => {
+    t.error(err);
+  });
+});

backend/node_modules/node-osc/dist/test/test-types.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var tap = require('tap');
+var node_child_process = require('node:child_process');
+var node_path = require('node:path');
+var node_url = require('node:url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const __dirname$1 = node_url.fileURLToPath(new URL('.', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('test-types.js', document.baseURI).href))));
+
+// Only run in ESM mode (not when transpiled to CJS in dist/)
+// Normalize path separators for cross-platform compatibility
+const normalizedPath = __dirname$1.replace(/\\/g, '/');
+const isESM = !normalizedPath.includes('/dist/');
+
+tap.test('types: TypeScript compilation', (t) => {
+  let tsconfigPath;
+  const testRoot = node_path.resolve(__dirname$1, isESM ? '.': '../../test');
+  if (isESM) {
+    tsconfigPath = node_path.join(testRoot, 'fixtures', 'types', 'tsconfig-esm.test.json');
+  }
+  else {
+    tsconfigPath = node_path.join(testRoot, 'fixtures', 'types', 'tsconfig-cjs.test.json');
+  }
+  
+  try {
+    // Run TypeScript compiler
+    const cmd = 'npx tsc --project "' + tsconfigPath + '"';
+    node_child_process.execSync(cmd, { 
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      cwd: node_path.join(testRoot, 'fixtures', 'types')
+    });
+    t.pass('TypeScript types compile successfully');
+  } catch (error) {
+    t.fail('TypeScript compilation failed: ' + error.message);
+    if (error.stdout) console.log('STDOUT:', error.stdout);
+    if (error.stderr) console.log('STDERR:', error.stderr);
+  }
+
+  t.end();
+});