artnet2usb-cli 0.2.0

package/dist/main/main.js

@@ -0,0 +1,518 @@
+"use strict";
+const electron = require("electron");
+const path = require("node:path");
+const dgram = require("node:dgram");
+const os = require("node:os");
+const serialport = require("serialport");
+const fs = require("node:fs");
+const ARTNET_PORT = 6454;
+const HEADER = Buffer.from("Art-Net\0", "ascii");
+const OP_DMX = 20480;
+const OP_POLL = 8192;
+const OP_POLL_REPLY = 8448;
+function parseArtDmx(msg) {
+  if (msg.length < 19 || !msg.subarray(0, 8).equals(HEADER)) return null;
+  const opCode = msg.readUInt16LE(8);
+  if (opCode !== OP_DMX) return null;
+  const subUni = msg[14];
+  const net = msg[15];
+  const len = msg[16] << 8 | msg[17];
+  const data = msg.subarray(18, 18 + Math.min(len, 512));
+  return { universe: (net & 127) << 8 | subUni, data };
+}
+function parsePollReply(msg, fallbackIp) {
+  if (msg.length < 26 || !msg.subarray(0, 8).equals(HEADER)) return null;
+  if (msg.readUInt16LE(8) !== OP_POLL_REPLY) return null;
+  const ip = msg.length >= 14 ? `${msg[10]}.${msg[11]}.${msg[12]}.${msg[13]}` : fallbackIp;
+  const shortName = msg.length >= 44 ? msg.subarray(26, 44).toString("ascii").replace(/\0.*$/, "") : "";
+  const longName = msg.length >= 108 ? msg.subarray(44, 108).toString("ascii").replace(/\0.*$/, "") : "";
+  return { ip, shortName, longName };
+}
+function buildArtPoll() {
+  const b = Buffer.alloc(14);
+  HEADER.copy(b, 0);
+  b.writeUInt16LE(OP_POLL, 8);
+  b[10] = 0;
+  b[11] = 14;
+  b[12] = 0;
+  b[13] = 0;
+  return b;
+}
+class ArtNetListener {
+  socket = null;
+  universes = /* @__PURE__ */ new Map();
+  nodes = /* @__PURE__ */ new Map();
+  pollTimer = null;
+  onFrame = null;
+  start(onFrame) {
+    if (this.socket) return;
+    this.onFrame = onFrame ?? null;
+    const sock = dgram.createSocket({ type: "udp4", reuseAddr: true });
+    sock.on("message", (msg, rinfo) => {
+      const dmx = parseArtDmx(msg);
+      if (dmx) {
+        const now = Date.now();
+        let st = this.universes.get(dmx.universe);
+        if (!st) {
+          st = { sourceIp: rinfo.address, lastAt: now, data: Buffer.alloc(512), frames: 0, fps: 0, windowStart: now };
+          this.universes.set(dmx.universe, st);
+        }
+        dmx.data.copy(st.data, 0);
+        st.sourceIp = rinfo.address;
+        st.lastAt = now;
+        st.frames++;
+        if (now - st.windowStart >= 2e3) {
+          st.fps = Math.round(st.frames * 1e3 / (now - st.windowStart));
+          st.frames = 0;
+          st.windowStart = now;
+        }
+        this.onFrame?.(dmx.universe, st.data);
+        return;
+      }
+      const node = parsePollReply(msg, rinfo.address);
+      if (node) this.nodes.set(node.ip, node);
+    });
+    sock.on("error", (err) => console.error("[artnet] socket error", err.message));
+    sock.bind(ARTNET_PORT, () => {
+      try {
+        sock.setBroadcast(true);
+      } catch {
+      }
+      this.sendPoll();
+    });
+    this.socket = sock;
+    this.pollTimer = setInterval(() => this.sendPoll(), 8e3);
+  }
+  sendPoll() {
+    const poll = buildArtPoll();
+    const targets = /* @__PURE__ */ new Set(["255.255.255.255"]);
+    for (const ifaces of Object.values(os.networkInterfaces())) {
+      for (const inf of ifaces ?? []) {
+        if (inf.family === "IPv4" && !inf.internal) {
+          const ip = inf.address.split(".").map(Number);
+          const mask = inf.netmask.split(".").map(Number);
+          targets.add(ip.map((o, i) => o | ~mask[i] & 255).join("."));
+        }
+      }
+    }
+    for (const t of targets) {
+      this.socket?.send(poll, ARTNET_PORT, t, () => {
+      });
+    }
+  }
+  /** Universes seen (entries older than 10s are dropped). */
+  list() {
+    const now = Date.now();
+    const out = [];
+    for (const [universe, st] of this.universes) {
+      if (now - st.lastAt > 1e4) continue;
+      out.push({
+        universe,
+        sourceIp: st.sourceIp,
+        fps: st.fps,
+        lastAt: st.lastAt,
+        channels: st.data.length
+      });
+    }
+    return out.sort((a, b) => a.universe - b.universe);
+  }
+  listNodes() {
+    return [...this.nodes.values()];
+  }
+  /** The universe's latest frame (a copy) — for preview and the output engine. */
+  frameOf(universe) {
+    const st = this.universes.get(universe);
+    return st ? { data: Buffer.from(st.data), lastAt: st.lastAt } : null;
+  }
+  stop() {
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.pollTimer = null;
+    this.socket?.close();
+    this.socket = null;
+  }
+}
+function buildEnttecFrame(dmx) {
+  const payload = Buffer.alloc(513);
+  payload[0] = 0;
+  dmx.copy(payload, 1, 0, Math.min(dmx.length, 512));
+  const frame = Buffer.alloc(payload.length + 5);
+  frame[0] = 126;
+  frame[1] = 6;
+  frame.writeUInt16LE(payload.length, 2);
+  payload.copy(frame, 4);
+  frame[frame.length - 1] = 231;
+  return frame;
+}
+function applyChannelOffset(dmx, offset) {
+  if (!offset) return dmx;
+  const shifted = Buffer.alloc(512);
+  for (let i = 0; i < 512; i++) {
+    const srcIndex = ((i - offset) % 512 + 512) % 512;
+    shifted[i] = srcIndex < dmx.length ? dmx[srcIndex] : 0;
+  }
+  return shifted;
+}
+function deviceUid(p) {
+  const vid = (p.vendorId ?? "?").toLowerCase();
+  const pid = (p.productId ?? "?").toLowerCase();
+  return p.serialNumber ? `${vid}:${pid}:${p.serialNumber}` : `${vid}:${pid}:${p.path}`;
+}
+class DmxOutputEngine {
+  // routeId -> last frame sent
+  constructor(getFrame, getSettings) {
+    this.getFrame = getFrame;
+    this.getSettings = getSettings;
+  }
+  active = /* @__PURE__ */ new Map();
+  // routeId -> output
+  lastFrames = /* @__PURE__ */ new Map();
+  async listDevices() {
+    const ports = await serialport.SerialPort.list();
+    return ports.map((p) => ({
+      uid: deviceUid(p),
+      path: p.path,
+      manufacturer: p.manufacturer,
+      vendorId: p.vendorId,
+      productId: p.productId,
+      serialNumber: p.serialNumber,
+      connected: true
+    }));
+  }
+  isActive(routeId) {
+    return this.active.has(routeId);
+  }
+  statusOf(route) {
+    const a = this.active.get(route.id);
+    return {
+      active: !!a && !a.error,
+      error: a?.error ?? null,
+      framesSent: a?.framesSent ?? 0,
+      frozen: !!a?.frozenFrame
+    };
+  }
+  /** Freeze: locks in the current frame; a second call returns to live. Returns: the new frozen state. */
+  toggleFreeze(route) {
+    const out = this.active.get(route.id);
+    if (!out) return false;
+    if (out.frozenFrame) {
+      out.frozenFrame = null;
+      return false;
+    }
+    const fr = this.getFrame(route.universe);
+    out.frozenFrame = Buffer.from(fr?.data ?? this.lastFrames.get(route.id) ?? Buffer.alloc(512));
+    return true;
+  }
+  /** Start a route: find the device's current port path by uid, open the port, set up the loop. */
+  async start(route) {
+    await this.stop(route.id);
+    const devices = await this.listDevices();
+    const dev = devices.find((d) => d.uid === route.deviceUid);
+    if (!dev) throw new Error("device_not_connected");
+    const baud = route.protocol === "open-dmx" ? 25e4 : 57600;
+    const port = new serialport.SerialPort({
+      path: dev.path,
+      baudRate: baud,
+      dataBits: 8,
+      stopBits: 2,
+      parity: "none",
+      autoOpen: false
+    });
+    await new Promise((resolve, reject) => {
+      port.open((err) => err ? reject(err) : resolve());
+    });
+    const hz = Math.max(1, Math.min(44, route.hz));
+    const out = { port, timer: null, framesSent: 0, error: null, writing: false, frozenFrame: null };
+    out.timer = setInterval(() => void this.tick(route, out), Math.round(1e3 / hz));
+    port.on("error", (err) => {
+      out.error = err.message;
+    });
+    port.on("close", () => {
+      out.error = out.error ?? "port_closed";
+    });
+    this.active.set(route.id, out);
+  }
+  currentFrame(route) {
+    const settings = this.getSettings();
+    const fr = this.getFrame(route.universe);
+    const fresh = fr && Date.now() - fr.lastAt <= settings.signalLossMs;
+    if (fresh) {
+      this.lastFrames.set(route.id, fr.data);
+      return fr.data;
+    }
+    if (settings.onSignalLoss === "blackout") return Buffer.alloc(512);
+    return this.lastFrames.get(route.id) ?? null;
+  }
+  async tick(route, out) {
+    if (out.writing || !out.port.isOpen) return;
+    const raw = out.frozenFrame ?? this.currentFrame(route);
+    if (!raw) return;
+    const dmx = applyChannelOffset(raw, route.channelOffset ?? 0);
+    out.writing = true;
+    try {
+      if (route.protocol === "enttec-pro") {
+        await new Promise(
+          (resolve, reject) => out.port.write(buildEnttecFrame(dmx), (err) => err ? reject(err) : resolve())
+        );
+      } else {
+        await new Promise((resolve, reject) => out.port.flush((e) => e ? reject(e) : resolve()));
+        await new Promise((resolve, reject) => out.port.set({ brk: true }, (e) => e ? reject(e) : resolve()));
+        await new Promise((r) => setTimeout(r, 1));
+        await new Promise((resolve, reject) => out.port.set({ brk: false }, (e) => e ? reject(e) : resolve()));
+        await new Promise((r) => setTimeout(r, 1));
+        const frame = Buffer.alloc(513);
+        frame[0] = 0;
+        dmx.copy(frame, 1, 0, Math.min(dmx.length, 512));
+        await new Promise((resolve, reject) => out.port.write(frame, (err) => err ? reject(err) : resolve()));
+        await new Promise((resolve, reject) => out.port.drain((err) => err ? reject(err) : resolve()));
+      }
+      out.framesSent++;
+      out.error = null;
+    } catch (err) {
+      out.error = err instanceof Error ? err.message : String(err);
+    } finally {
+      out.writing = false;
+    }
+  }
+  async stop(routeId) {
+    const out = this.active.get(routeId);
+    if (!out) return;
+    clearInterval(out.timer);
+    this.active.delete(routeId);
+    this.lastFrames.delete(routeId);
+    if (out.port.isOpen) {
+      await new Promise((resolve) => out.port.close(() => resolve()));
+    }
+  }
+  async stopAll() {
+    for (const id of [...this.active.keys()]) await this.stop(id);
+  }
+}
+const DEFAULTS = {
+  deviceNames: {},
+  routes: [],
+  settings: { onSignalLoss: "hold", signalLossMs: 3e3 }
+};
+let Store$1 = class Store {
+  file;
+  state;
+  constructor(configDir) {
+    this.file = path.join(configDir, "config.json");
+    this.state = this.load();
+  }
+  load() {
+    try {
+      const raw = JSON.parse(fs.readFileSync(this.file, "utf8"));
+      return {
+        deviceNames: raw.deviceNames ?? {},
+        routes: Array.isArray(raw.routes) ? raw.routes : [],
+        settings: { ...DEFAULTS.settings, ...raw.settings ?? {} }
+      };
+    } catch {
+      return structuredClone(DEFAULTS);
+    }
+  }
+  save() {
+    try {
+      fs.mkdirSync(path.dirname(this.file), { recursive: true });
+      fs.writeFileSync(this.file, JSON.stringify(this.state, null, 2));
+    } catch (err) {
+      console.error("[store] failed to save", err);
+    }
+  }
+  get deviceNames() {
+    return this.state.deviceNames;
+  }
+  setDeviceName(uid, name) {
+    if (name.trim()) this.state.deviceNames[uid] = name.trim().slice(0, 60);
+    else delete this.state.deviceNames[uid];
+    this.save();
+  }
+  get routes() {
+    return this.state.routes;
+  }
+  upsertRoute(route) {
+    const i = this.state.routes.findIndex((r) => r.id === route.id);
+    if (i >= 0) this.state.routes[i] = route;
+    else this.state.routes.push(route);
+    this.save();
+  }
+  removeRoute(id) {
+    this.state.routes = this.state.routes.filter((r) => r.id !== id);
+    this.save();
+  }
+  get settings() {
+    return this.state.settings;
+  }
+  setSettings(s) {
+    this.state.settings = s;
+    this.save();
+  }
+};
+function isWritableDir(dir) {
+  const probe = path.join(dir, `.artnet2usb-write-probe-${process.pid}`);
+  try {
+    fs.writeFileSync(probe, "");
+    fs.unlinkSync(probe);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolvePortableConfigDir(exeSideDir2, fallbackDir) {
+  if (!exeSideDir2) return fallbackDir;
+  try {
+    if (fs.existsSync(path.join(exeSideDir2, "config.json"))) return exeSideDir2;
+  } catch {
+    return fallbackDir;
+  }
+  return isWritableDir(exeSideDir2) ? exeSideDir2 : fallbackDir;
+}
+function exeSideDir() {
+  if (process.env.PORTABLE_EXECUTABLE_DIR) return process.env.PORTABLE_EXECUTABLE_DIR;
+  if (process.env.APPIMAGE) return path.dirname(process.env.APPIMAGE);
+  if (!electron.app.isPackaged) return null;
+  if (process.platform === "darwin") {
+    return path.resolve(process.execPath, "..", "..", "..", "..");
+  }
+  return path.dirname(process.execPath);
+}
+class Store2 extends Store$1 {
+  constructor() {
+    super(resolvePortableConfigDir(exeSideDir(), electron.app.getPath("userData")));
+  }
+}
+let win = null;
+const listener = new ArtNetListener();
+let store;
+let engine;
+let previewUniverse = null;
+let lastPreviewPush = 0;
+function createWindow() {
+  win = new electron.BrowserWindow({
+    width: 980,
+    height: 680,
+    minWidth: 760,
+    minHeight: 520,
+    backgroundColor: "#101d22",
+    title: "Relackout ArtNet 2 USB",
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/preload.js"),
+      contextIsolation: true,
+      nodeIntegration: false
+    }
+  });
+  win.setMenuBarVisibility(false);
+  if (process.env.ELECTRON_RENDERER_URL) {
+    void win.loadURL(process.env.ELECTRON_RENDERER_URL);
+  } else {
+    void win.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+  win.webContents.setWindowOpenHandler(({ url }) => {
+    void electron.shell.openExternal(url);
+    return { action: "deny" };
+  });
+}
+async function buildState() {
+  const names = store.deviceNames;
+  const connected = await engine.listDevices();
+  const devices = connected.map((d) => ({ ...d, name: names[d.uid] }));
+  for (const [uid, name] of Object.entries(names)) {
+    if (!devices.some((d) => d.uid === uid)) {
+      devices.push({ uid, path: "—", name, connected: false });
+    }
+  }
+  const routes = store.routes.map((r) => ({ ...r, ...engine.statusOf(r) }));
+  return {
+    universes: listener.list(),
+    nodes: listener.listNodes(),
+    devices,
+    routes,
+    settings: store.settings
+  };
+}
+function registerIpc() {
+  electron.ipcMain.handle("state:get", () => buildState());
+  electron.ipcMain.handle("devices:rename", (_e, uid, name) => {
+    store.setDeviceName(uid, name);
+    return buildState();
+  });
+  electron.ipcMain.handle("routes:upsert", async (_e, route) => {
+    store.upsertRoute(route);
+    if (engine.isActive(route.id)) {
+      await engine.stop(route.id);
+      if (route.enabled) await engine.start(route).catch(() => {
+      });
+    }
+    return buildState();
+  });
+  electron.ipcMain.handle("routes:remove", async (_e, id) => {
+    await engine.stop(id);
+    store.removeRoute(id);
+    return buildState();
+  });
+  electron.ipcMain.handle("routes:start", async (_e, id) => {
+    const route = store.routes.find((r) => r.id === id);
+    if (!route) throw new Error("route_not_found");
+    try {
+      await engine.start(route);
+      store.upsertRoute({ ...route, enabled: true });
+    } catch (err) {
+      throw new Error(err instanceof Error ? err.message : String(err));
+    }
+    return buildState();
+  });
+  electron.ipcMain.handle("routes:freeze", (_e, id) => {
+    const route = store.routes.find((r) => r.id === id);
+    if (!route) throw new Error("route_not_found");
+    engine.toggleFreeze(route);
+    return buildState();
+  });
+  electron.ipcMain.handle("routes:stop", async (_e, id) => {
+    await engine.stop(id);
+    const route = store.routes.find((r) => r.id === id);
+    if (route) store.upsertRoute({ ...route, enabled: false });
+    return buildState();
+  });
+  electron.ipcMain.handle("settings:set", (_e, s) => {
+    store.setSettings(s);
+    return buildState();
+  });
+  electron.ipcMain.handle("preview:set", (_e, universe) => {
+    previewUniverse = universe;
+    if (universe != null) {
+      const fr = listener.frameOf(universe);
+      if (fr) win?.webContents.send("preview:frame", universe, [...fr.data]);
+    }
+    return true;
+  });
+  electron.ipcMain.handle("app:openExternal", (_e, url) => {
+    if (/^https?:\/\//.test(url)) void electron.shell.openExternal(url);
+  });
+}
+void electron.app.whenReady().then(async () => {
+  store = new Store2();
+  engine = new DmxOutputEngine(
+    (u) => listener.frameOf(u),
+    () => store.settings
+  );
+  listener.start((universe, data) => {
+    if (universe === previewUniverse && win && Date.now() - lastPreviewPush > 50) {
+      lastPreviewPush = Date.now();
+      win.webContents.send("preview:frame", universe, [...data]);
+    }
+  });
+  registerIpc();
+  createWindow();
+  for (const r of store.routes) {
+    if (r.enabled) await engine.start(r).catch(() => {
+    });
+  }
+  electron.app.on("activate", () => {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+electron.app.on("window-all-closed", () => {
+  void engine?.stopAll();
+  listener.stop();
+  electron.app.quit();
+});

package/dist-cli/app/artnet.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtNetListener = void 0;
+exports.parseArtDmx = parseArtDmx;
+exports.parsePollReply = parsePollReply;
+exports.buildArtPoll = buildArtPoll;
+const node_dgram_1 = __importDefault(require("node:dgram"));
+const node_os_1 = __importDefault(require("node:os"));
+/**
+ * Art-Net listener: passively watches for ArtDMX packets on UDP 6454
+ * (discovery + live data) and queries nodes via ArtPoll. No library, built
+ * to spec:
+ *  - Header: 'Art-Net\0' + OpCode (LE)
+ *  - ArtDMX 0x5000: [seq, phys, SubUni, Net, LenHi, LenLo, data...]
+ *  - ArtPoll 0x2000 / ArtPollReply 0x2100
+ */
+const ARTNET_PORT = 6454;
+const HEADER = Buffer.from('Art-Net\0', 'ascii');
+const OP_DMX = 0x5000;
+const OP_POLL = 0x2000;
+const OP_POLL_REPLY = 0x2100;
+/** Parses an ArtDMX packet; returns null if it's not Art-Net / not ArtDMX. (Pure — unit tested.) */
+function parseArtDmx(msg) {
+    // 18-byte header + at least 1 channel
+    if (msg.length < 19 || !msg.subarray(0, 8).equals(HEADER))
+        return null;
+    const opCode = msg.readUInt16LE(8);
+    if (opCode !== OP_DMX)
+        return null;
+    const subUni = msg[14];
+    const net = msg[15];
+    const len = (msg[16] << 8) | msg[17];
+    const data = msg.subarray(18, 18 + Math.min(len, 512));
+    return { universe: ((net & 0x7f) << 8) | subUni, data };
+}
+/** Node info parsed from an ArtPollReply. */
+function parsePollReply(msg, fallbackIp) {
+    if (msg.length < 26 || !msg.subarray(0, 8).equals(HEADER))
+        return null;
+    if (msg.readUInt16LE(8) !== OP_POLL_REPLY)
+        return null;
+    const ip = msg.length >= 14 ? `${msg[10]}.${msg[11]}.${msg[12]}.${msg[13]}` : fallbackIp;
+    const shortName = msg.length >= 44 ? msg.subarray(26, 44).toString('ascii').replace(/\0.*$/, '') : '';
+    const longName = msg.length >= 108 ? msg.subarray(44, 108).toString('ascii').replace(/\0.*$/, '') : '';
+    return { ip, shortName, longName };
+}
+function buildArtPoll() {
+    const b = Buffer.alloc(14);
+    HEADER.copy(b, 0);
+    b.writeUInt16LE(OP_POLL, 8);
+    b[10] = 0; // ProtVerHi
+    b[11] = 14; // ProtVerLo
+    b[12] = 0; // TalkToMe
+    b[13] = 0; // Priority
+    return b;
+}
+class ArtNetListener {
+    socket = null;
+    universes = new Map();
+    nodes = new Map();
+    pollTimer = null;
+    onFrame = null;
+    start(onFrame) {
+        if (this.socket)
+            return;
+        this.onFrame = onFrame ?? null;
+        const sock = node_dgram_1.default.createSocket({ type: 'udp4', reuseAddr: true });
+        sock.on('message', (msg, rinfo) => {
+            const dmx = parseArtDmx(msg);
+            if (dmx) {
+                const now = Date.now();
+                let st = this.universes.get(dmx.universe);
+                if (!st) {
+                    st = { sourceIp: rinfo.address, lastAt: now, data: Buffer.alloc(512), frames: 0, fps: 0, windowStart: now };
+                    this.universes.set(dmx.universe, st);
+                }
+                dmx.data.copy(st.data, 0);
+                st.sourceIp = rinfo.address;
+                st.lastAt = now;
+                st.frames++;
+                if (now - st.windowStart >= 2000) {
+                    st.fps = Math.round((st.frames * 1000) / (now - st.windowStart));
+                    st.frames = 0;
+                    st.windowStart = now;
+                }
+                this.onFrame?.(dmx.universe, st.data);
+                return;
+            }
+            const node = parsePollReply(msg, rinfo.address);
+            if (node)
+                this.nodes.set(node.ip, node);
+        });
+        sock.on('error', (err) => console.error('[artnet] socket error', err.message));
+        sock.bind(ARTNET_PORT, () => {
+            try {
+                sock.setBroadcast(true);
+            }
+            catch {
+                /* if the platform doesn't allow it, discovery still works passively */
+            }
+            this.sendPoll();
+        });
+        this.socket = sock;
+        this.pollTimer = setInterval(() => this.sendPoll(), 8000);
+    }
+    sendPoll() {
+        const poll = buildArtPoll();
+        const targets = new Set(['255.255.255.255']);
+        for (const ifaces of Object.values(node_os_1.default.networkInterfaces())) {
+            for (const inf of ifaces ?? []) {
+                if (inf.family === 'IPv4' && !inf.internal) {
+                    const ip = inf.address.split('.').map(Number);
+                    const mask = inf.netmask.split('.').map(Number);
+                    targets.add(ip.map((o, i) => o | (~mask[i] & 0xff)).join('.'));
+                }
+            }
+        }
+        for (const t of targets) {
+            this.socket?.send(poll, ARTNET_PORT, t, () => { });
+        }
+    }
+    /** Universes seen (entries older than 10s are dropped). */
+    list() {
+        const now = Date.now();
+        const out = [];
+        for (const [universe, st] of this.universes) {
+            if (now - st.lastAt > 10_000)
+                continue;
+            out.push({
+                universe,
+                sourceIp: st.sourceIp,
+                fps: st.fps,
+                lastAt: st.lastAt,
+                channels: st.data.length
+            });
+        }
+        return out.sort((a, b) => a.universe - b.universe);
+    }
+    listNodes() {
+        return [...this.nodes.values()];
+    }
+    /** The universe's latest frame (a copy) — for preview and the output engine. */
+    frameOf(universe) {
+        const st = this.universes.get(universe);
+        return st ? { data: Buffer.from(st.data), lastAt: st.lastAt } : null;
+    }
+    stop() {
+        if (this.pollTimer)
+            clearInterval(this.pollTimer);
+        this.pollTimer = null;
+        this.socket?.close();
+        this.socket = null;
+    }
+}
+exports.ArtNetListener = ArtNetListener;