alphatheta-connect 0.26.1 → 0.27.0

package/lib/index.js

@@ -700,14 +700,17 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Control_hostDevice, _Control_beatSocket, _Control_correlationByte;
+var _Control_hostDevice, _Control_beatSocket, _Control_statusSocket, _Control_correlationByte;
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.makePlaystatePacket = void 0;
+exports.makePlaystatePacket = exports.makeLoadTrackPacket = void 0;
 const constants_1 = __webpack_require__(/*! src/constants */ "./src/constants.ts");
 const types_1 = __webpack_require__(/*! src/types */ "./src/types.ts");
 const utils_1 = __webpack_require__(/*! src/utils */ "./src/utils/index.ts");
 const udp_1 = __webpack_require__(/*! src/utils/udp */ "./src/utils/udp.ts");
+const load_1 = __webpack_require__(/*! ./load */ "./src/control/load.ts");
 const stagehand_1 = __webpack_require__(/*! ./stagehand */ "./src/control/stagehand.ts");
+var load_2 = __webpack_require__(/*! ./load */ "./src/control/load.ts");
+Object.defineProperty(exports, "makeLoadTrackPacket", ({ enumerable: true, get: function () { return load_2.makeLoadTrackPacket; } }));
 const STATE_MAP = {
     [types_1.CDJStatus.PlayState.Cued]: 0x01,
     [types_1.CDJStatus.PlayState.Playing]: 0x00,
@@ -728,20 +731,51 @@ const makePlaystatePacket = ({ hostDevice, device, playState }) => Uint8Array.fr
 ]);
 exports.makePlaystatePacket = makePlaystatePacket;
 class Control {
-    constructor(beatSocket, hostDevice) {
+    constructor(beatSocket, hostDevice, statusSocket = null) {
         _Control_hostDevice.set(this, void 0);
         /**
          * The socket used to send control packets
          */
         _Control_beatSocket.set(this, void 0);
+        /**
+         * The socket bound to the status port, which the Load Track command must
+         * leave from: a CDJ-3000 ignores it from any other port. Absent when the
+         * control service was built without one.
+         */
+        _Control_statusSocket.set(this, void 0);
         /**
          * Randomized correlation byte per session for Stagehand commands
          */
         _Control_correlationByte.set(this, void 0);
         __classPrivateFieldSet(this, _Control_beatSocket, beatSocket, "f");
+        __classPrivateFieldSet(this, _Control_statusSocket, statusSocket, "f");
         __classPrivateFieldSet(this, _Control_hostDevice, hostDevice, "f");
         __classPrivateFieldSet(this, _Control_correlationByte, Math.floor(Math.random() * 256), "f");
     }
+    /**
+     * Send one Stagehand transport packet (0x07) carrying `op` with the press /
+     * release flag, for opcodes the named methods do not cover.
+     */
+    async transport(device, op, press) {
+        const p = (0, stagehand_1.makeStagehandTransportPacket)(__classPrivateFieldGet(this, _Control_hostDevice, "f"), op, press, __classPrivateFieldGet(this, _Control_correlationByte, "f"));
+        await (0, udp_1.udpSend)(__classPrivateFieldGet(this, _Control_beatSocket, "f"), p, constants_1.BEAT_PORT, device.ip.address);
+    }
+    /**
+     * Tell a player to load a track, as rekordbox does when a row is dragged
+     * onto a deck: the Load Track command (0x19) from our status port to the
+     * player's. The player answers 0x1a and the load shows in its next status.
+     *
+     * `source` names where the track lives: a device number and its slot (a
+     * player's USB or SD, or the rekordbox slot of a library served over the
+     * link).
+     */
+    async loadTrack(device, trackId, source) {
+        if (__classPrivateFieldGet(this, _Control_statusSocket, "f") === null) {
+            throw new Error('loadTrack needs the status socket; connect through ProlinkNetwork');
+        }
+        const p = (0, load_1.makeLoadTrackPacket)(__classPrivateFieldGet(this, _Control_hostDevice, "f"), device, trackId, source);
+        await (0, udp_1.udpSend)(__classPrivateFieldGet(this, _Control_statusSocket, "f"), p, constants_1.STATUS_PORT, device.ip.address);
+    }
     /**
      * Start or stop a CDJ on the network.
      * Delegates automatically to Stagehand-specific transport control if connected in Stagehand mode.
@@ -807,10 +841,79 @@ class Control {
         await (0, udp_1.udpSend)(__classPrivateFieldGet(this, _Control_beatSocket, "f"), p, constants_1.STATUS_PORT, device.ip.address);
     }
 }
-_Control_hostDevice = new WeakMap(), _Control_beatSocket = new WeakMap(), _Control_correlationByte = new WeakMap();
+_Control_hostDevice = new WeakMap(), _Control_beatSocket = new WeakMap(), _Control_statusSocket = new WeakMap(), _Control_correlationByte = new WeakMap();
 exports["default"] = Control;
 
 
+/***/ },
+
+/***/ "./src/control/load.ts"
+/*!*****************************!*\
+  !*** ./src/control/load.ts ***!
+  \*****************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.LOAD_TRACK_LENGTH = void 0;
+exports.makeLoadTrackPacket = makeLoadTrackPacket;
+const constants_1 = __webpack_require__(/*! src/constants */ "./src/constants.ts");
+const types_1 = __webpack_require__(/*! src/types */ "./src/types.ts");
+const utils_1 = __webpack_require__(/*! src/utils */ "./src/utils/index.ts");
+/**
+ * Byte length of a Load Track command.
+ */
+exports.LOAD_TRACK_LENGTH = 0x58;
+/**
+ * Generates the Load Track command (0x19, 88 bytes), unicast to a player's
+ * status port.
+ *
+ * Byte for byte what rekordbox 7.2 sends a CDJ-3000 (captured 2026-09-13 and
+ * verified live on two CDJ-3000s): the status-style header with a 20-byte
+ * name, `01 01`, our device number, the length `0034` of what follows, our
+ * number again, then the source device, slot and track type, the track ID
+ * big-endian, `32` at 0x33, the destination player counted from zero at
+ * 0x40, and `32` at 0x4b.
+ *
+ * A player only honours the command from the address its keep-alives
+ * announced and from port 50002.
+ */
+function makeLoadTrackPacket(hostDevice, device, trackId, source) {
+    var _a;
+    const packet = new Uint8Array(exports.LOAD_TRACK_LENGTH);
+    // 0-9: magic header
+    packet.set(constants_1.PROLINK_HEADER, 0);
+    // 10: kind 0x19
+    packet[10] = 0x19;
+    // 11-30: device name (20 bytes)
+    packet.set((0, utils_1.buildName)(hostDevice), 11);
+    // 31-35: 01, subtype 01, our number, then the length 0x0034 of what follows
+    packet[31] = 0x01;
+    packet[32] = 0x01;
+    packet[33] = hostDevice.id;
+    packet[34] = 0x00;
+    packet[35] = 0x34;
+    // 36: our number again
+    packet[36] = hostDevice.id;
+    // 40-42: the source device, its slot and the track type
+    packet[40] = source.deviceId;
+    packet[41] = source.slot;
+    packet[42] = (_a = source.trackType) !== null && _a !== void 0 ? _a : types_1.TrackType.RB;
+    // 44-47: the track ID, big-endian
+    packet[44] = (trackId >>> 24) & 0xff;
+    packet[45] = (trackId >>> 16) & 0xff;
+    packet[46] = (trackId >>> 8) & 0xff;
+    packet[47] = trackId & 0xff;
+    packet[0x33] = 0x32;
+    // 0x40: the player to load onto, counted from zero; a player accepts the
+    // command by address regardless
+    packet[0x40] = Math.max(device.id - 1, 0);
+    packet[0x4b] = 0x32;
+    return packet;
+}
+
+
 /***/ },
 
 /***/ "./src/control/stagehand.ts"
@@ -827,59 +930,75 @@ exports.makeStagehandPrefWritePacket = makeStagehandPrefWritePacket;
 const constants_1 = __webpack_require__(/*! src/constants */ "./src/constants.ts");
 const utils_1 = __webpack_require__(/*! src/utils */ "./src/utils/index.ts");
 /**
- * Generates a Stagehand transport control packet (0x07, 56 bytes)
+ * The name field of a Stagehand unicast frame: 19 bytes, one shorter than the
+ * broadcast frames' 20, so the bytes that follow it sit at offset 30.
+ */
+function buildUnicastName(device) {
+    return (0, utils_1.buildName)(device).subarray(0, 19);
+}
+/**
+ * Generates a Stagehand transport control packet (0x07, 48 bytes).
+ *
+ * Byte for byte what the iPad app sends a CDJ-3000 (captured 2026-05-23,
+ * `stagehand-allproto-20260523T142615.pcap`, pinned in the tests): the
+ * unicast header `03 01 00`, a byte that varies per command, the length
+ * `0030`, then `3a`, `01`, the opcode and the press flag each in their own
+ * 16-bit slot.
  *
  * @param hostDevice - The Stagehand device posing as sender
- * @param op - The command opcode (e.g. 0x0f, 0x14, 0x18, 0x1a, 0x1b)
+ * @param op - The command opcode (e.g. 0x0f, 0x14, 0x18, 0x19, 0x1a, 0x1b)
  * @param press - Whether the action is press (true) or release (false)
- * @param correlationByte - The randomized per-session correlation byte
+ * @param correlationByte - The per-session correlation byte
  */
 function makeStagehandTransportPacket(hostDevice, op, press, correlationByte) {
-    const packet = new Uint8Array(56);
+    const packet = new Uint8Array(48);
     // 0-9: magic header
     packet.set(constants_1.PROLINK_HEADER, 0);
     // 10: opcode 0x07
     packet[10] = 0x07;
-    // 11-30: device name
-    packet.set((0, utils_1.buildName)(hostDevice), 11);
-    // 31: 0x01
+    // 11-29: device name
+    packet.set(buildUnicastName(hostDevice), 11);
+    // 30-32: unicast header 03 01 00
+    packet[30] = 0x03;
     packet[31] = 0x01;
-    // 32: 0x03
-    packet[32] = 0x03;
+    packet[32] = 0x00;
     // 33: per-session correlation byte
     packet[33] = correlationByte;
-    // 34-35: remaining length 0x0030 (48 bytes)
+    // 34-35: packet length 0x0030 (48 bytes)
     packet[34] = 0x00;
     packet[35] = 0x30;
-    // 40: Stagehand sub-id 0x3a
-    packet[40] = 0x3a;
-    // 44: command opcode
-    packet[44] = op;
-    // 46: press/release flag
-    packet[46] = press ? 0x01 : 0x00;
+    // 39: Stagehand sub-id 0x3a
+    packet[39] = 0x3a;
+    // 41: 0x01
+    packet[41] = 0x01;
+    // 43: command opcode
+    packet[43] = op;
+    // 45: press/release flag
+    packet[45] = press ? 0x01 : 0x00;
     return packet;
 }
 /**
- * Generates a Stagehand preference write packet (0x6b, 124 bytes)
+ * Generates a Stagehand preference write packet (0x6b, 116 bytes).
+ *
+ * As captured from the iPad app (same capture as the transport packet): the
+ * unicast header `03 01 00 3a`, the length `0050`, the write flag, then the
+ * preference slots.
  *
  * @param hostDevice - The Stagehand device posing as sender
  * @param options - The preferences to write (onAir, quantize)
  */
 function makeStagehandPrefWritePacket(hostDevice, options) {
-    const packet = new Uint8Array(124);
+    const packet = new Uint8Array(116);
     // 0-9: magic header
     packet.set(constants_1.PROLINK_HEADER, 0);
     // 10: opcode 0x6b
     packet[10] = 0x6b;
-    // 11-30: device name
-    const name = (0, utils_1.buildName)(hostDevice);
-    // Trailing byte 30 (which is offset 30, meaning index 19 of name) is set to 0x03
-    name[19] = 0x03;
-    packet.set(name, 11);
-    // 31: 0x01 (subscription-id-a constant)
+    // 11-29: device name
+    packet.set(buildUnicastName(hostDevice), 11);
+    // 30-32: unicast header 03 01 00
+    packet[30] = 0x03;
     packet[31] = 0x01;
-    // 32: 0x03 (constant)
-    packet[32] = 0x03;
+    packet[32] = 0x00;
     // 33: Stagehand sub-id constant 0x3a
     packet[33] = 0x3a;
     // 34-35: body length 0x0050 (80 bytes)
@@ -2137,10 +2256,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.noopLogger = exports.REMOTEDB_MAX_DEVICE_ID = exports.playerNumberCeiling = exports.pickRemoteDbQueryId = exports.pickAvailableDeviceId = exports.MIXER_PLAYER_CEILING = exports.MAX_DEVICE_ID = exports.DEFAULT_MIXER_PLAYER_CEILING = exports.OneLibraryAdapter = exports.fetchFile = exports.loadAnlz = exports.isMetadataExtractionSupported = exports.extractMetadataFromDevice = exports.extractFullMetadata = exports.PictureType = exports.isArtworkExtractionSupported = exports.extractArtworkFromDevice = exports.extractArtwork = exports.PositionEmitter = void 0;
+exports.noopLogger = exports.REMOTEDB_MAX_DEVICE_ID = exports.playerNumberCeiling = exports.pickRemoteDbQueryId = exports.pickAvailableDeviceId = exports.MIXER_PLAYER_CEILING = exports.MAX_DEVICE_ID = exports.DEFAULT_MIXER_PLAYER_CEILING = exports.OneLibraryAdapter = exports.fetchFile = exports.loadAnlz = exports.isMetadataExtractionSupported = exports.extractMetadataFromDevice = exports.extractFullMetadata = exports.PictureType = exports.isArtworkExtractionSupported = exports.extractArtworkFromDevice = exports.extractArtwork = exports.PositionEmitter = exports.createRemoteServer = exports.Control = void 0;
+var control_1 = __webpack_require__(/*! ./control */ "./src/control/index.ts");
+Object.defineProperty(exports, "Control", ({ enumerable: true, get: function () { return __importDefault(control_1).default; } }));
 __exportStar(__webpack_require__(/*! ./entities */ "./src/entities.ts"), exports);
 __exportStar(__webpack_require__(/*! ./mixstatus */ "./src/mixstatus/index.ts"), exports);
 __exportStar(__webpack_require__(/*! ./network */ "./src/network.ts"), exports);
+__exportStar(__webpack_require__(/*! ./remote */ "./src/remote/index.ts"), exports);
+__exportStar(__webpack_require__(/*! ./remote/hue */ "./src/remote/hue.ts"), exports);
+var server_1 = __webpack_require__(/*! ./remote/server */ "./src/remote/server.ts");
+Object.defineProperty(exports, "createRemoteServer", ({ enumerable: true, get: function () { return server_1.createServer; } }));
 var position_1 = __webpack_require__(/*! ./status/position */ "./src/status/position.ts");
 Object.defineProperty(exports, "PositionEmitter", ({ enumerable: true, get: function () { return __importDefault(position_1).default; } }));
 // Passive mode (pcap-based monitoring without announcing a VCDJ)
@@ -7252,9 +7377,9 @@ class ProlinkNetwork {
         // Create unified database
         const database = new db_1.default(localdb, remotedb, __classPrivateFieldGet(this, _ProlinkNetwork_deviceManager, "f"), __classPrivateFieldGet(this, _ProlinkNetwork_logger, "f"));
         // Create controller service
-        const control = new control_1.default(__classPrivateFieldGet(this, _ProlinkNetwork_beatSocket, "f"), vcdj);
+        const control = new control_1.default(__classPrivateFieldGet(this, _ProlinkNetwork_beatSocket, "f"), vcdj, __classPrivateFieldGet(this, _ProlinkNetwork_statusSocket, "f"));
         __classPrivateFieldSet(this, _ProlinkNetwork_state, types_1.NetworkState.Connected, "f");
-        __classPrivateFieldSet(this, _ProlinkNetwork_connection, { announcer, heartbeat, control, remotedb, localdb, database }, "f");
+        __classPrivateFieldSet(this, _ProlinkNetwork_connection, { vcdj, announcer, heartbeat, control, remotedb, localdb, database }, "f");
         tx.finish();
     }
     /**
@@ -7341,6 +7466,15 @@ class ProlinkNetwork {
     get positionEmitter() {
         return __classPrivateFieldGet(this, _ProlinkNetwork_state, "f") === types_1.NetworkState.Connected ? __classPrivateFieldGet(this, _ProlinkNetwork_positionEmitter, "f") : null;
     }
+    /**
+     * The device this network announces itself as, once connected: the
+     * `hostDevice` the status emitter's media query and the control service
+     * send from.
+     */
+    get virtualDevice() {
+        var _a, _b;
+        return (_b = (_a = __classPrivateFieldGet(this, _ProlinkNetwork_connection, "f")) === null || _a === void 0 ? void 0 : _a.vcdj) !== null && _b !== void 0 ? _b : null;
+    }
     /**
      * Get the {@link Control} service. This service can be used to control the
      * Playstate of CDJs on the network.
@@ -10551,6 +10685,773 @@ _PassiveStatusEmitter_emitter = new WeakMap(), _PassiveStatusEmitter_adapter = n
 exports["default"] = PassiveStatusEmitter;
 
 
+/***/ },
+
+/***/ "./src/remote/hue.ts"
+/*!***************************!*\
+  !*** ./src/remote/hue.ts ***!
+  \***************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Hue_instances, _Hue_config, _Hue_url;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Hue = exports.HueNoGroupError = exports.HueUnconfiguredError = exports.HueError = void 0;
+exports.hueConfigPath = hueConfigPath;
+exports.loadHueConfig = loadHueConfig;
+exports.saveHueConfig = saveHueConfig;
+exports.pairHue = pairHue;
+exports.discoverHueBridge = discoverHueBridge;
+/**
+ * The Hue bridge: the room or zone the booth's gear is plugged into, switched
+ * as one group over the bridge's v1 API (plain HTTP, no certificate dance).
+ *
+ * The application key comes from `hue pair`, which asks the bridge for one
+ * while its link button is pressed, and is kept in a config file.
+ */
+const fs_1 = __webpack_require__(/*! fs */ "fs");
+const os_1 = __webpack_require__(/*! os */ "os");
+const path_1 = __importDefault(__webpack_require__(/*! path */ "path"));
+class HueError extends Error {
+}
+exports.HueError = HueError;
+/**
+ * Raised when nothing has been paired and the environment names no bridge.
+ */
+class HueUnconfiguredError extends HueError {
+    constructor() {
+        super('Hue is not configured: run `alphatheta-remote hue pair` (or set HUE_BRIDGE and HUE_APP_KEY)');
+    }
+}
+exports.HueUnconfiguredError = HueUnconfiguredError;
+/**
+ * Raised when the bridge has no group by the name asked for.
+ */
+class HueNoGroupError extends HueError {
+    constructor(name, groups) {
+        const have = groups.map(g => JSON.stringify(g.name)).join(', ');
+        super(`no Hue group named ${JSON.stringify(name)}; the bridge has: ${have}`);
+    }
+}
+exports.HueNoGroupError = HueNoGroupError;
+const REQUEST_TIMEOUT = 10000;
+function hueConfigPath() {
+    var _a, _b;
+    const base = (_a = process.env.XDG_CONFIG_HOME) !== null && _a !== void 0 ? _a : path_1.default.join((_b = process.env.HOME) !== null && _b !== void 0 ? _b : '.', '.config');
+    return path_1.default.join(base, 'alphatheta-remote', 'hue.json');
+}
+/**
+ * The environment first (`HUE_BRIDGE`, `HUE_APP_KEY`), then the file `hue
+ * pair` wrote; `null` when neither is there.
+ */
+async function loadHueConfig() {
+    const { HUE_BRIDGE, HUE_APP_KEY } = process.env;
+    if (HUE_BRIDGE && HUE_APP_KEY) {
+        return { bridge: HUE_BRIDGE, appKey: HUE_APP_KEY };
+    }
+    try {
+        const text = await fs_1.promises.readFile(hueConfigPath(), 'utf8');
+        const parsed = JSON.parse(text);
+        if (typeof parsed.bridge !== 'string' || typeof parsed.appKey !== 'string') {
+            throw new HueError(`${hueConfigPath()}: expected {bridge, appKey}`);
+        }
+        return { bridge: parsed.bridge, appKey: parsed.appKey };
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return null;
+        }
+        throw e;
+    }
+}
+async function saveHueConfig(config) {
+    const file = hueConfigPath();
+    await fs_1.promises.mkdir(path_1.default.dirname(file), { recursive: true });
+    await fs_1.promises.writeFile(file, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    return file;
+}
+async function request(url, init) {
+    const response = await fetch(url, {
+        ...init,
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT),
+    });
+    if (!response.ok) {
+        throw new HueError(`hue bridge: HTTP ${response.status} ${await response.text()}`);
+    }
+    return (await response.json());
+}
+/**
+ * A v1 reply is a list of `{success: …}` / `{error: …}` items; any error
+ * item fails the call.
+ */
+function bridgeErrors(reply) {
+    if (!Array.isArray(reply)) {
+        return;
+    }
+    const errors = reply
+        .map(item => { var _a; return (_a = item === null || item === void 0 ? void 0 : item.error) === null || _a === void 0 ? void 0 : _a.description; })
+        .filter((d) => typeof d === 'string');
+    if (errors.length > 0) {
+        throw new HueError(`hue bridge answered: ${errors.join('; ')}`);
+    }
+}
+class Hue {
+    constructor(config) {
+        _Hue_instances.add(this);
+        _Hue_config.set(this, void 0);
+        __classPrivateFieldSet(this, _Hue_config, config, "f");
+    }
+    get bridge() {
+        return __classPrivateFieldGet(this, _Hue_config, "f").bridge;
+    }
+    /**
+     * Every room and zone on the bridge, by name.
+     */
+    async groups() {
+        const raw = await request(__classPrivateFieldGet(this, _Hue_instances, "m", _Hue_url).call(this, 'groups'));
+        bridgeErrors(raw);
+        return Object.entries(raw)
+            .map(([id, g]) => {
+            var _a, _b, _c, _d, _e;
+            return ({
+                id,
+                name: g.name,
+                type: g.type,
+                lights: (_a = g.lights) !== null && _a !== void 0 ? _a : [],
+                allOn: (_c = (_b = g.state) === null || _b === void 0 ? void 0 : _b.all_on) !== null && _c !== void 0 ? _c : false,
+                anyOn: (_e = (_d = g.state) === null || _d === void 0 ? void 0 : _d.any_on) !== null && _e !== void 0 ? _e : false,
+            });
+        })
+            .sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /**
+     * The group called `name`, matched without regard to case.
+     */
+    async groupNamed(name) {
+        const groups = await this.groups();
+        const wanted = name.trim().toLowerCase();
+        const group = groups.find(g => g.name.trim().toLowerCase() === wanted);
+        if (group === undefined) {
+            throw new HueNoGroupError(name, groups);
+        }
+        return group;
+    }
+    /**
+     * Switch every light (and plug) in the group.
+     */
+    async setGroupOn(groupId, on) {
+        const reply = await request(__classPrivateFieldGet(this, _Hue_instances, "m", _Hue_url).call(this, `groups/${groupId}/action`), {
+            method: 'PUT',
+            body: JSON.stringify({ on }),
+        });
+        bridgeErrors(reply);
+    }
+}
+exports.Hue = Hue;
+_Hue_config = new WeakMap(), _Hue_instances = new WeakSet(), _Hue_url = function _Hue_url(tail) {
+    return `http://${__classPrivateFieldGet(this, _Hue_config, "f").bridge}/api/${__classPrivateFieldGet(this, _Hue_config, "f").appKey}/${tail}`;
+};
+/**
+ * Ask the bridge for an application key. The bridge only issues one in the
+ * thirty seconds after its link button is pressed, so this asks once a second
+ * until it does or `waitMs` runs out.
+ */
+async function pairHue(bridge, waitMs = 60000) {
+    var _a, _b, _c, _d;
+    const deadline = Date.now() + waitMs;
+    // The bridge takes `<application>#<device>` with the device name at most
+    // 19 characters, so the host's name is cut at its first dot and there.
+    const host = (0, os_1.hostname)().split('.')[0].slice(0, 19);
+    const body = JSON.stringify({ devicetype: `alphatheta-remote#${host}` });
+    for (;;) {
+        const reply = await request(`http://${bridge}/api`, { method: 'POST', body });
+        const key = (_b = (_a = reply === null || reply === void 0 ? void 0 : reply[0]) === null || _a === void 0 ? void 0 : _a.success) === null || _b === void 0 ? void 0 : _b.username;
+        if (typeof key === 'string') {
+            return { bridge, appKey: key };
+        }
+        const linkButtonNotPressed = ((_d = (_c = reply === null || reply === void 0 ? void 0 : reply[0]) === null || _c === void 0 ? void 0 : _c.error) === null || _d === void 0 ? void 0 : _d.type) === 101;
+        if (!linkButtonNotPressed) {
+            bridgeErrors(reply);
+        }
+        if (Date.now() >= deadline) {
+            throw new HueError('hue bridge: link button was not pressed in time');
+        }
+        await new Promise(r => setTimeout(r, 1000));
+    }
+}
+/**
+ * Where the bridge is: `HUE_BRIDGE`, else Signify's discovery service, which
+ * lists the bridges that have phoned home from this public address.
+ */
+async function discoverHueBridge() {
+    var _a;
+    if (process.env.HUE_BRIDGE) {
+        return process.env.HUE_BRIDGE;
+    }
+    const found = await request('https://discovery.meethue.com');
+    const bridge = (_a = found[0]) === null || _a === void 0 ? void 0 : _a.internalipaddress;
+    if (bridge === undefined) {
+        throw new HueError('no Hue bridge found; set HUE_BRIDGE to its address');
+    }
+    return bridge;
+}
+
+
+/***/ },
+
+/***/ "./src/remote/index.ts"
+/*!*****************************!*\
+  !*** ./src/remote/index.ts ***!
+  \*****************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Remote_instances, _Remote_network, _Remote_statuses, _Remote_cueOp, _Remote_status_get, _Remote_control_get, _Remote_me_get;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.Remote = exports.CueUnknownError = exports.NoPlayerError = exports.RemoteError = exports.TransportOp = void 0;
+/**
+ * The remote: on the Pro DJ Link network as a Stagehand, the way the iPad app
+ * joins, driving players with the transport packets the app's Sound Check
+ * sends and remembering the last status each player reported. The REST API
+ * over it is in `./server`.
+ */
+const os_1 = __webpack_require__(/*! os */ "os");
+const network_1 = __webpack_require__(/*! src/network */ "./src/network.ts");
+const types_1 = __webpack_require__(/*! src/types */ "./src/types.ts");
+const utils_1 = __webpack_require__(/*! src/utils */ "./src/utils/index.ts");
+/**
+ * The Stagehand transport opcodes (packet 0x07) the iPad app was captured
+ * sending, besides play (0x0f then 0x14 pressed) and pause (0x14 released),
+ * which `Control` sends itself. These are held while pressed.
+ */
+exports.TransportOp = {
+    SkipForward: 0x18,
+    SkipBackward: 0x19,
+    SeekForward: 0x1a,
+    SeekBackward: 0x1b,
+};
+/**
+ * The device numbers the Stagehand app was seen using: 141..=211.
+ */
+const STAGEHAND_FIRST_NUMBER = 141;
+const STAGEHAND_NUMBER_COUNT = 71;
+const TAP_MS = 100;
+class RemoteError extends Error {
+}
+exports.RemoteError = RemoteError;
+class NoPlayerError extends RemoteError {
+    constructor(number) {
+        super(`no player ${number} on the link`);
+    }
+}
+exports.NoPlayerError = NoPlayerError;
+class CueUnknownError extends RemoteError {
+    constructor() {
+        super('cue has no known Stagehand opcode; set the cue opcode once one is found (probe with POST /players/<n>/op)');
+    }
+}
+exports.CueUnknownError = CueUnknownError;
+function resolveIface(hint) {
+    const all = (0, os_1.networkInterfaces)();
+    for (const [name, infos] of Object.entries(all)) {
+        for (const info of infos !== null && infos !== void 0 ? infos : []) {
+            if (info.family !== 'IPv4' || info.internal) {
+                continue;
+            }
+            if (name === hint || info.address === hint) {
+                return info;
+            }
+        }
+    }
+    const available = Object.entries(all)
+        .flatMap(([name, infos]) => (infos !== null && infos !== void 0 ? infos : [])
+        .filter(i => i.family === 'IPv4' && !i.internal)
+        .map(i => `${name}:${i.address}`))
+        .join(', ');
+    throw new RemoteError(`no interface "${hint}"; available: ${available}`);
+}
+/**
+ * A device number that does not change between runs. A CDJ-3000 keeps one
+ * record per peer address and ignores a later claim from that address under
+ * another number or MAC until it reboots, so a random number per run may
+ * never be served.
+ */
+function numberFor(iface) {
+    var _a;
+    const mac = iface.mac.split(':').map(b => parseInt(b, 16));
+    const last = (_a = mac[5]) !== null && _a !== void 0 ? _a : 0;
+    return STAGEHAND_FIRST_NUMBER + (last % STAGEHAND_NUMBER_COUNT);
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+class Remote {
+    constructor(network, cueOp) {
+        _Remote_instances.add(this);
+        _Remote_network.set(this, void 0);
+        _Remote_statuses.set(this, new Map());
+        _Remote_cueOp.set(this, void 0);
+        __classPrivateFieldSet(this, _Remote_network, network, "f");
+        __classPrivateFieldSet(this, _Remote_cueOp, cueOp, "f");
+        __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_status_get).on('status', s => __classPrivateFieldGet(this, _Remote_statuses, "f").set(s.deviceId, s));
+    }
+    /**
+     * Join the link and start collecting status. Resolves once the Stagehand
+     * join sequence is through and keep-alives are running.
+     */
+    static async join(opts = {}) {
+        var _a, _b, _c;
+        const network = await (0, network_1.bringOnlineStagehand)({
+            logger: opts.logger,
+        });
+        let iface;
+        if (opts.iface !== undefined) {
+            iface = resolveIface(opts.iface);
+        }
+        else {
+            (_a = opts.logger) === null || _a === void 0 ? void 0 : _a.info('waiting for a player to pick the interface');
+            const dm = network.deviceManager;
+            const first = await new Promise(resolve => dm.once('connected', resolve));
+            const match = (0, utils_1.getMatchingInterface)(first.ip);
+            if (match === null) {
+                throw new RemoteError(`no local interface matches ${first.ip.address}`);
+            }
+            iface = match;
+        }
+        network.configure({ iface, vcdjId: (_b = opts.number) !== null && _b !== void 0 ? _b : numberFor(iface) });
+        network.connect();
+        if (!network.isConnected()) {
+            throw new RemoteError('failed to connect to the link');
+        }
+        await network.startupReady;
+        const me = network.virtualDevice;
+        (_c = opts.logger) === null || _c === void 0 ? void 0 : _c.info(`on the link as "${me === null || me === void 0 ? void 0 : me.name}" #${me === null || me === void 0 ? void 0 : me.id} at ${iface.address}`);
+        return new Remote(network, opts.cueOp);
+    }
+    get network() {
+        return __classPrivateFieldGet(this, _Remote_network, "f");
+    }
+    /**
+     * Our own device as announced.
+     */
+    get me() {
+        return __classPrivateFieldGet(this, _Remote_network, "f").virtualDevice;
+    }
+    /**
+     * Every device heard on the link, by number.
+     */
+    get devices() {
+        return [...__classPrivateFieldGet(this, _Remote_network, "f").deviceManager.devices.values()].sort((a, b) => a.id - b.id);
+    }
+    /**
+     * The players, with the last status each one sent.
+     */
+    get players() {
+        return this.devices
+            .filter(d => d.type === types_1.DeviceType.CDJ)
+            .map(d => ({
+            number: d.id,
+            name: d.name,
+            ip: d.ip.address,
+            status: __classPrivateFieldGet(this, _Remote_statuses, "f").get(d.id),
+        }));
+    }
+    player(number) {
+        const device = __classPrivateFieldGet(this, _Remote_network, "f").deviceManager.devices.get(number);
+        if (device === undefined || device.type !== types_1.DeviceType.CDJ) {
+            throw new NoPlayerError(number);
+        }
+        return device;
+    }
+    play(number) {
+        return __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_control_get).play(this.player(number));
+    }
+    pause(number) {
+        return __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_control_get).pause(this.player(number));
+    }
+    /**
+     * Press and release the cue button, once its opcode is known.
+     */
+    cue(number) {
+        if (__classPrivateFieldGet(this, _Remote_cueOp, "f") === undefined) {
+            throw new CueUnknownError();
+        }
+        return this.tap(number, __classPrivateFieldGet(this, _Remote_cueOp, "f"), TAP_MS);
+    }
+    /**
+     * Hold fast-forward for `holdMs`.
+     */
+    fastForward(number, holdMs) {
+        return this.tap(number, exports.TransportOp.SeekForward, holdMs);
+    }
+    /**
+     * Hold rewind for `holdMs`.
+     */
+    rewind(number, holdMs) {
+        return this.tap(number, exports.TransportOp.SeekBackward, holdMs);
+    }
+    skipForward(number) {
+        return this.tap(number, exports.TransportOp.SkipForward, TAP_MS);
+    }
+    skipBackward(number) {
+        return this.tap(number, exports.TransportOp.SkipBackward, TAP_MS);
+    }
+    /**
+     * One transport packet: `op` pressed or released.
+     */
+    transport(number, op, press) {
+        return __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_control_get).transport(this.player(number), op, press);
+    }
+    /**
+     * Press `op`, hold it for `holdMs`, release it.
+     */
+    async tap(number, op, holdMs) {
+        await this.transport(number, op, true);
+        await sleep(holdMs);
+        await this.transport(number, op, false);
+    }
+    /**
+     * What is in a player's USB and SD slots, as the player answers a media
+     * query; a slot it does not answer for is left out.
+     */
+    async media(number) {
+        const device = this.player(number);
+        const slots = [];
+        for (const slot of [types_1.MediaSlot.USB, types_1.MediaSlot.SD]) {
+            try {
+                slots.push(await __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_status_get).queryMediaSlot({ hostDevice: __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_me_get), device, slot }));
+            }
+            catch {
+                // an empty slot is not answered for
+            }
+        }
+        return slots;
+    }
+    /**
+     * Tell a player to load a track from `source` (another player's stick, or a
+     * library served over the link).
+     */
+    loadTrack(number, trackId, source) {
+        return __classPrivateFieldGet(this, _Remote_instances, "a", _Remote_control_get).loadTrack(this.player(number), trackId, source);
+    }
+    async leave() {
+        __classPrivateFieldGet(this, _Remote_network, "f").disconnect();
+        await __classPrivateFieldGet(this, _Remote_network, "f").close();
+    }
+}
+exports.Remote = Remote;
+_Remote_network = new WeakMap(), _Remote_statuses = new WeakMap(), _Remote_cueOp = new WeakMap(), _Remote_instances = new WeakSet(), _Remote_status_get = function _Remote_status_get() {
+    const emitter = __classPrivateFieldGet(this, _Remote_network, "f").statusEmitter;
+    if (emitter === null) {
+        throw new RemoteError('not connected to the link');
+    }
+    return emitter;
+}, _Remote_control_get = function _Remote_control_get() {
+    const control = __classPrivateFieldGet(this, _Remote_network, "f").control;
+    if (control === null) {
+        throw new RemoteError('not connected to the link');
+    }
+    return control;
+}, _Remote_me_get = function _Remote_me_get() {
+    const me = __classPrivateFieldGet(this, _Remote_network, "f").virtualDevice;
+    if (me === null) {
+        throw new RemoteError('not connected to the link');
+    }
+    return me;
+};
+
+
+/***/ },
+
+/***/ "./src/remote/server.ts"
+/*!******************************!*\
+  !*** ./src/remote/server.ts ***!
+  \******************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createServer = createServer;
+/**
+ * The REST API over a {@link Remote}. JSON in and out; every error is
+ * `{"error": "…"}` with a status that says whose fault it was.
+ *
+ *   GET  /                       who we are, every device heard, the booth's power
+ *   GET  /players                the players with their last status
+ *   GET  /players/{n}/media      what is in the player's USB and SD slots
+ *   POST /players/{n}/play
+ *   POST /players/{n}/pause
+ *   POST /players/{n}/cue
+ *   POST /players/{n}/ff         {"hold_ms": 500}   hold fast-forward, then release
+ *   POST /players/{n}/rew        {"hold_ms": 500}
+ *   POST /players/{n}/skip       {"direction": "forward" | "backward"}
+ *   POST /players/{n}/op         {"op": 26, "press": true}   one raw transport packet
+ *   POST /players/{n}/load       {"track_id": 1, "source": {"device": 2, "slot": "usb"}}
+ *   GET  /booth                  the Hue group and whether it is on
+ *   PUT  /booth                  {"on": true}
+ *   POST /booth/on
+ *   POST /booth/off
+ *   GET  /hue/groups             every room and zone the bridge has
+ */
+const http_1 = __importDefault(__webpack_require__(/*! http */ "http"));
+const types_1 = __webpack_require__(/*! src/types */ "./src/types.ts");
+const hue_1 = __webpack_require__(/*! ./hue */ "./src/remote/hue.ts");
+const index_1 = __webpack_require__(/*! ./index */ "./src/remote/index.ts");
+class HttpError extends Error {
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const MAX_HOLD_MS = 30000;
+const DEFAULT_HOLD_MS = 500;
+const SLOTS = {
+    rekordbox: types_1.MediaSlot.RB,
+    rb: types_1.MediaSlot.RB,
+    usb: types_1.MediaSlot.USB,
+    sd: types_1.MediaSlot.SD,
+};
+function statusOf(e) {
+    if (e instanceof HttpError) {
+        return e.status;
+    }
+    if (e instanceof index_1.NoPlayerError || e instanceof hue_1.HueNoGroupError) {
+        return 404;
+    }
+    if (e instanceof index_1.CueUnknownError || e instanceof hue_1.HueUnconfiguredError) {
+        return 501;
+    }
+    return 502;
+}
+async function readJson(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(chunk);
+    }
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    if (text === '') {
+        return {};
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (e) {
+        throw new HttpError(400, `body is not JSON: ${e.message}`);
+    }
+}
+function integer(value, name, min = 0, max = Number.MAX_SAFE_INTEGER) {
+    if (typeof value !== 'number' ||
+        !Number.isInteger(value) ||
+        value < min ||
+        value > max) {
+        throw new HttpError(400, `${name} must be an integer in ${min}..${max}`);
+    }
+    return value;
+}
+function holdMs(body) {
+    if (body.hold_ms === undefined) {
+        return DEFAULT_HOLD_MS;
+    }
+    return integer(body.hold_ms, 'hold_ms', 0, MAX_HOLD_MS);
+}
+function createServer({ remote, hue, boothGroup, logger }) {
+    const needHue = () => {
+        if (hue === null) {
+            throw new hue_1.HueUnconfiguredError();
+        }
+        return hue;
+    };
+    const boothState = async () => {
+        const group = await needHue().groupNamed(boothGroup);
+        return {
+            group: group.name,
+            id: group.id,
+            type: group.type,
+            on: group.anyOn,
+            all_on: group.allOn,
+            lights: group.lights,
+        };
+    };
+    const setBooth = async (on) => {
+        const bridge = needHue();
+        const group = await bridge.groupNamed(boothGroup);
+        await bridge.setGroupOn(group.id, on);
+        logger === null || logger === void 0 ? void 0 : logger.info(`booth "${group.name}" switched ${on ? 'on' : 'off'}`);
+        return { group: group.name, on };
+    };
+    const ok = { ok: true };
+    const route = async (method, path, body) => {
+        var _a, _b;
+        const parts = path.split('/').filter(p => p !== '');
+        if (parts.length === 0 && method === 'GET') {
+            const me = remote.me;
+            const booth = await boothState().catch(e => ({
+                group: boothGroup,
+                error: e.message,
+            }));
+            return {
+                stagehand: me && { name: me.name, number: me.id, ip: me.ip.address },
+                devices: remote.devices.map(d => ({
+                    number: d.id,
+                    name: d.name,
+                    type: d.type,
+                    ip: d.ip.address,
+                })),
+                players: remote.players,
+                booth,
+            };
+        }
+        if (parts[0] === 'players') {
+            if (parts.length === 1 && method === 'GET') {
+                return remote.players;
+            }
+            const n = parseInt(parts[1], 10);
+            if (!Number.isInteger(n)) {
+                throw new HttpError(404, `no route ${method} ${path}`);
+            }
+            const action = parts[2];
+            if (parts.length !== 3) {
+                throw new HttpError(404, `no route ${method} ${path}`);
+            }
+            if (method === 'GET' && action === 'media') {
+                return remote.media(n);
+            }
+            if (method !== 'POST') {
+                throw new HttpError(405, `${method} not allowed on ${path}`);
+            }
+            switch (action) {
+                case 'play':
+                    await remote.play(n);
+                    return ok;
+                case 'pause':
+                    await remote.pause(n);
+                    return ok;
+                case 'cue':
+                    await remote.cue(n);
+                    return ok;
+                case 'ff':
+                    await remote.fastForward(n, holdMs(await body()));
+                    return ok;
+                case 'rew':
+                    await remote.rewind(n, holdMs(await body()));
+                    return ok;
+                case 'skip': {
+                    const { direction } = await body();
+                    if (direction === 'forward') {
+                        await remote.skipForward(n);
+                    }
+                    else if (direction === 'backward') {
+                        await remote.skipBackward(n);
+                    }
+                    else {
+                        throw new HttpError(400, 'direction must be "forward" or "backward"');
+                    }
+                    return ok;
+                }
+                case 'op': {
+                    const b = await body();
+                    await remote.transport(n, integer(b.op, 'op', 0, 255), b.press !== false);
+                    return ok;
+                }
+                case 'load': {
+                    const b = await body();
+                    const trackId = integer(b.track_id, 'track_id', 1, 0xffffffff);
+                    const source = (_a = b.source) !== null && _a !== void 0 ? _a : {};
+                    const device = integer(source.device, 'source.device', 1, 255);
+                    const slotName = String((_b = source.slot) !== null && _b !== void 0 ? _b : 'rekordbox').toLowerCase();
+                    const slot = SLOTS[slotName];
+                    if (slot === undefined) {
+                        throw new HttpError(400, 'source.slot must be "rekordbox", "usb" or "sd"');
+                    }
+                    await remote.loadTrack(n, trackId, { deviceId: device, slot });
+                    return ok;
+                }
+                default:
+                    throw new HttpError(404, `no route ${method} ${path}`);
+            }
+        }
+        if (parts[0] === 'booth') {
+            if (parts.length === 1) {
+                if (method === 'GET') {
+                    return boothState();
+                }
+                if (method === 'PUT') {
+                    const { on } = await body();
+                    if (typeof on !== 'boolean') {
+                        throw new HttpError(400, 'on must be true or false');
+                    }
+                    return setBooth(on);
+                }
+            }
+            if (parts.length === 2 && method === 'POST') {
+                if (parts[1] === 'on') {
+                    return setBooth(true);
+                }
+                if (parts[1] === 'off') {
+                    return setBooth(false);
+                }
+            }
+        }
+        if (parts[0] === 'hue' &&
+            parts[1] === 'groups' &&
+            parts.length === 2 &&
+            method === 'GET') {
+            return needHue().groups();
+        }
+        throw new HttpError(404, `no route ${method} ${path}`);
+    };
+    return http_1.default.createServer(async (req, res) => {
+        var _a, _b;
+        const method = (_a = req.method) !== null && _a !== void 0 ? _a : 'GET';
+        const path = ((_b = req.url) !== null && _b !== void 0 ? _b : '/').split('?')[0];
+        const send = (status, payload) => {
+            res.writeHead(status, { 'content-type': 'application/json' });
+            res.end(`${JSON.stringify(payload)}\n`);
+        };
+        try {
+            send(200, await route(method, path, () => readJson(req)));
+        }
+        catch (e) {
+            const status = statusOf(e);
+            const message = e instanceof Error ? e.message : String(e);
+            if (status >= 500) {
+                logger === null || logger === void 0 ? void 0 : logger.warn(`${method} ${path}: ${message}`);
+            }
+            send(status, { error: message });
+        }
+    });
+}
+
+
 /***/ },
 
 /***/ "./src/remotedb/constants.ts"
@@ -14468,6 +15369,17 @@ module.exports = require("fs");
 
 /***/ },
 
+/***/ "http"
+/*!***********************!*\
+  !*** external "http" ***!
+  \***********************/
+(module) {
+
+"use strict";
+module.exports = require("http");
+
+/***/ },
+
 /***/ "ip-address"
 /*!*****************************!*\
   !*** external "ip-address" ***!