alphatheta-connect 0.22.0 → 0.23.0

package/lib/cli.js

@@ -10806,7 +10806,8 @@ function udpClose(conn) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MAX_DEVICE_ID = exports.REMOTEDB_MAX_DEVICE_ID = void 0;
+exports.DEFAULT_MIXER_PLAYER_CEILING = exports.MIXER_PLAYER_CEILING = exports.MAX_DEVICE_ID = exports.REMOTEDB_MAX_DEVICE_ID = void 0;
+exports.playerNumberCeiling = playerNumberCeiling;
 exports.pickAvailableDeviceId = pickAvailableDeviceId;
 /**
  * The highest device ID a CDJ will answer remotedb queries from.
@@ -10819,6 +10820,100 @@ exports.REMOTEDB_MAX_DEVICE_ID = 6;
  * The highest device ID the prolink protocol allows.
  */
 exports.MAX_DEVICE_ID = 32;
+/**
+ * `DeviceType.Mixer`, inlined so this module stays free of runtime imports —
+ * it is re-exported into consumers' test environments, where pulling in the
+ * whole type module (and its ip-address dependency) is dead weight.
+ */
+const MIXER_DEVICE_TYPE = 0x03;
+/**
+ * How many player numbers each mixer can hand out.
+ *
+ * Players take their number from the mixer channel they are plugged into, so
+ * an N-channel mixer only ever produces players 1..N — and N+1 is the lowest
+ * number that no player on that rig can claim.
+ *
+ * These are physical channel counts, deliberately NOT the `channelCount` in
+ * the app's own capability table, which caps the DJM-V10 at 4 for its mixer
+ * signal model. Capping here would put us on player 5 of a 6-channel rig,
+ * which is the collision this table exists to avoid.
+ */
+exports.MIXER_PLAYER_CEILING = {
+    // 6-channel flagships — no player number in 1-6 is safe on these
+    'DJM-V10': 6,
+    'DJM-V10-LF': 6,
+    // 4-channel
+    'DJM-A9': 4,
+    'DJM-900NXS2': 4,
+    'DJM-900NXS': 4,
+    'DJM-900SRT': 4,
+    'DJM-850': 4,
+    'DJM-800': 4,
+    'DJM-750MK2': 4,
+    'DJM-750': 4,
+    'DJM-TOUR1': 4,
+    'DJM-2000NXS': 4,
+    'DJM-2000': 4,
+    EUPHONIA: 4,
+    // 3-channel (2026)
+    'DJM-V5': 3,
+    // 2-channel
+    'DJM-450': 2,
+    'DJM-350': 2,
+    'DJM-250MK2': 2,
+    // All-in-ones: their built-in players occupy numbers too, so the ceiling is
+    // however many decks the unit announces rather than its mixer channel count
+    'XDJ-XZ': 4,
+    'XDJ-AZ': 4,
+    'XDJ-RX3': 2,
+    'XDJ-RX2': 2,
+    'XDJ-RX': 2,
+    'XDJ-AN': 2,
+    'OPUS-QUAD': 4,
+};
+/**
+ * What to assume about a mixer whose model we do not recognise.
+ *
+ * Four is both the most common layout and the choice that keeps remotedb
+ * metadata working: assuming six would push us to player 7 on every mixer
+ * released after this table was written, silently losing metadata for
+ * unanalyzed and streaming tracks. A six-channel unit we failed to recognise
+ * may later claim the number we took, which the announcer's conflict handling
+ * resolves by moving us.
+ */
+exports.DEFAULT_MIXER_PLAYER_CEILING = 4;
+/**
+ * The highest player number the discovered gear can hand out, or undefined
+ * when nothing on the network implies one.
+ *
+ * Undefined means we have no mixer to reason from — players may have been
+ * numbered by hand anywhere in 1-6, and there is no better guess available.
+ */
+function playerNumberCeiling(devices) {
+    let ceiling;
+    for (const device of devices) {
+        const known = exports.MIXER_PLAYER_CEILING[device.name.trim().toUpperCase()];
+        const value = known !== null && known !== void 0 ? known : (device.type === MIXER_DEVICE_TYPE ? exports.DEFAULT_MIXER_PLAYER_CEILING : undefined);
+        if (value !== undefined && (ceiling === undefined || value > ceiling)) {
+            ceiling = value;
+        }
+    }
+    return ceiling;
+}
+const descending = (from, to) => {
+    const ids = [];
+    for (let id = from; id >= to; id--) {
+        ids.push(id);
+    }
+    return ids;
+};
+const ascending = (from, to) => {
+    const ids = [];
+    for (let id = from; id <= to; id++) {
+        ids.push(id);
+    }
+    return ids;
+};
 /**
  * Pick a device ID that no device on the network is currently using.
  *
@@ -10829,20 +10924,22 @@ exports.MAX_DEVICE_ID = 32;
  * Returns null when every ID from 1 to 32 is occupied, in which case there is
  * no safe ID and the caller must not join the network.
  */
-function pickAvailableDeviceId(usedIds, { preferRemoteDb = false } = {}) {
+function pickAvailableDeviceId(usedIds, { preferRemoteDb = false, playerCeiling } = {}) {
     var _a;
     const used = new Set(usedIds);
-    const remoteDbRange = [];
-    for (let id = exports.REMOTEDB_MAX_DEVICE_ID; id >= 1; id--) {
-        remoteDbRange.push(id);
-    }
-    const highRange = [];
-    for (let id = exports.REMOTEDB_MAX_DEVICE_ID + 1; id <= exports.MAX_DEVICE_ID; id++) {
-        highRange.push(id);
-    }
+    const aboveThePlayers = playerCeiling === undefined
+        ? descending(exports.REMOTEDB_MAX_DEVICE_ID, 1)
+        : ascending(playerCeiling + 1, exports.REMOTEDB_MAX_DEVICE_ID);
+    const outsideRemoteDb = ascending(exports.REMOTEDB_MAX_DEVICE_ID + 1, exports.MAX_DEVICE_ID);
+    // Numbers a player on this rig could be assigned. Last resort: better to
+    // contend for a slot than not to join at all, and the announcer moves us if
+    // the player that owns it shows up.
+    const amongThePlayers = playerCeiling === undefined
+        ? []
+        : descending(Math.min(playerCeiling, exports.REMOTEDB_MAX_DEVICE_ID), 1);
     const search = preferRemoteDb
-        ? [...remoteDbRange, ...highRange]
-        : [...highRange, ...remoteDbRange];
+        ? [...aboveThePlayers, ...outsideRemoteDb, ...amongThePlayers]
+        : [...outsideRemoteDb, ...aboveThePlayers, ...amongThePlayers];
     return (_a = search.find(id => !used.has(id))) !== null && _a !== void 0 ? _a : null;
 }
 
@@ -11276,9 +11373,14 @@ _Announcer_announceSocket = new WeakMap(), _Announcer_deviceManager = new WeakMa
     // Stay in whichever range we were already in. Dropping out of 1-6 would
     // silently lose remotedb metadata for unanalyzed and streaming tracks, so
     // a conflict on player 5 looks for another free player number first.
-    const usedIds = [...__classPrivateFieldGet(this, _Announcer_deviceManager, "f").devices.values()].map(d => d.id);
-    const newId = (0, device_id_1.pickAvailableDeviceId)(usedIds, {
+    //
+    // The mixer decides which of those numbers are actually safe: a player can
+    // only be assigned a number its mixer has a channel for, so anything above
+    // that is out of reach of the rig that just contested us.
+    const devices = [...__classPrivateFieldGet(this, _Announcer_deviceManager, "f").devices.values()];
+    const newId = (0, device_id_1.pickAvailableDeviceId)(devices.map(d => d.id), {
         preferRemoteDb: __classPrivateFieldGet(this, _Announcer_vcdj, "f").id <= device_id_1.REMOTEDB_MAX_DEVICE_ID,
+        playerCeiling: (0, device_id_1.playerNumberCeiling)(devices),
     });
     if (newId === null) {
         __classPrivateFieldGet(this, _Announcer_logger, "f").error('No available device IDs. All 32 slots are occupied.');