@nolag/iot 0.1.0

package/dist/index.mjs

@@ -0,0 +1,968 @@
+import { NoLag } from '@nolag/js-sdk';
+
+/**
+ * Tiny typed event emitter — framework-agnostic base for NoLag SDKs.
+ *
+ * EventMap is a record of event name → tuple of handler arguments.
+ */
+class EventEmitter {
+    constructor() {
+        this._handlers = new Map();
+    }
+    on(event, handler) {
+        if (!this._handlers.has(event)) {
+            this._handlers.set(event, new Set());
+        }
+        this._handlers.get(event).add(handler);
+        return this;
+    }
+    off(event, handler) {
+        if (handler) {
+            this._handlers.get(event)?.delete(handler);
+        }
+        else {
+            this._handlers.delete(event);
+        }
+        return this;
+    }
+    removeAllListeners() {
+        this._handlers.clear();
+        return this;
+    }
+    emit(event, ...args) {
+        const handlers = this._handlers.get(event);
+        if (!handlers)
+            return;
+        for (const handler of handlers) {
+            try {
+                handler(...args);
+            }
+            catch (e) {
+                console.error(`Error in ${String(event)} handler:`, e);
+            }
+        }
+    }
+    listenerCount(event) {
+        return this._handlers.get(event)?.size ?? 0;
+    }
+}
+
+/**
+ * Maps actorTokenId ↔ Device, filtering self.
+ */
+class PresenceManager {
+    constructor(localActorId) {
+        this._devices = new Map();
+        this._actorToDeviceId = new Map();
+        this._localActorId = localActorId;
+    }
+    /**
+     * Add or update a device from presence data.
+     * Returns the Device if it's a remote device, null if it's self.
+     */
+    addFromPresence(actorTokenId, presence, joinedAt) {
+        const isLocal = actorTokenId === this._localActorId;
+        // Skip self
+        if (isLocal)
+            return null;
+        const existing = this._actorToDeviceId.get(actorTokenId);
+        const deviceId = presence.deviceId || existing || actorTokenId;
+        const device = {
+            deviceId,
+            actorTokenId,
+            deviceName: presence.deviceName,
+            role: presence.role,
+            metadata: presence.metadata,
+            joinedAt: joinedAt ?? Date.now(),
+            isLocal: false,
+        };
+        this._devices.set(deviceId, device);
+        this._actorToDeviceId.set(actorTokenId, deviceId);
+        return device;
+    }
+    /**
+     * Remove a device by actorTokenId.
+     * Returns the removed device, or null if not found / is self.
+     */
+    removeByActorId(actorTokenId) {
+        if (actorTokenId === this._localActorId)
+            return null;
+        const deviceId = this._actorToDeviceId.get(actorTokenId);
+        if (!deviceId)
+            return null;
+        const device = this._devices.get(deviceId) ?? null;
+        this._devices.delete(deviceId);
+        this._actorToDeviceId.delete(actorTokenId);
+        return device;
+    }
+    /**
+     * Get a device by deviceId.
+     */
+    getDevice(deviceId) {
+        return this._devices.get(deviceId);
+    }
+    /**
+     * Get a device by actorTokenId.
+     */
+    getDeviceByActorId(actorTokenId) {
+        const deviceId = this._actorToDeviceId.get(actorTokenId);
+        return deviceId ? this._devices.get(deviceId) : undefined;
+    }
+    /**
+     * Get all remote devices.
+     */
+    getAll() {
+        return Array.from(this._devices.values());
+    }
+    /**
+     * Get the devices Map (readonly view).
+     */
+    get devices() {
+        return this._devices;
+    }
+    /**
+     * Clear all tracked devices.
+     */
+    clear() {
+        this._devices.clear();
+        this._actorToDeviceId.clear();
+    }
+}
+
+/**
+ * Per-device, per-sensor time-series buffer.
+ *
+ * Readings are stored under a composite key `${deviceId}:${sensorId}` and
+ * bounded to `maxPoints` entries per key (oldest entries are dropped first).
+ */
+class TelemetryStore {
+    constructor(maxPoints) {
+        this._store = new Map();
+        this._ids = new Set();
+        this._maxPoints = maxPoints;
+    }
+    // ============ Public API ============
+    /**
+     * Add a telemetry reading to the store.
+     * Returns false if the reading id is a duplicate (idempotent).
+     */
+    add(reading) {
+        if (this._ids.has(reading.id))
+            return false;
+        const key = this._key(reading.deviceId, reading.sensorId);
+        if (!this._store.has(key)) {
+            this._store.set(key, []);
+        }
+        const bucket = this._store.get(key);
+        bucket.push(reading);
+        // Enforce per-key cap
+        if (bucket.length > this._maxPoints) {
+            bucket.splice(0, bucket.length - this._maxPoints);
+        }
+        this._ids.add(reading.id);
+        return true;
+    }
+    /**
+     * Retrieve readings, optionally filtered by deviceId and/or sensorId.
+     *
+     * - No args → all readings across all devices and sensors
+     * - deviceId only → all readings for that device across all sensors
+     * - deviceId + sensorId → readings for that exact device/sensor pair
+     */
+    getAll(deviceId, sensorId) {
+        if (deviceId !== undefined && sensorId !== undefined) {
+            return [...(this._store.get(this._key(deviceId, sensorId)) ?? [])];
+        }
+        const results = [];
+        for (const [key, bucket] of this._store.entries()) {
+            if (deviceId !== undefined && !key.startsWith(`${deviceId}:`))
+                continue;
+            results.push(...bucket);
+        }
+        return results;
+    }
+    /**
+     * Get the most recent reading for a specific device/sensor pair.
+     */
+    getLatest(deviceId, sensorId) {
+        const bucket = this._store.get(this._key(deviceId, sensorId));
+        if (!bucket || bucket.length === 0)
+            return undefined;
+        return bucket[bucket.length - 1];
+    }
+    /**
+     * Check whether a reading id already exists in the store.
+     */
+    has(id) {
+        return this._ids.has(id);
+    }
+    /**
+     * Total number of readings across all device/sensor buckets.
+     */
+    get size() {
+        let total = 0;
+        for (const bucket of this._store.values()) {
+            total += bucket.length;
+        }
+        return total;
+    }
+    /**
+     * Clear all stored readings and ids.
+     */
+    clear() {
+        this._store.clear();
+        this._ids.clear();
+    }
+    // ============ Private ============
+    _key(deviceId, sensorId) {
+        return `${deviceId}:${sensorId}`;
+    }
+}
+
+function generateId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return crypto.randomUUID();
+    }
+    return 'xxxx-xxxx-xxxx-xxxx'.replace(/x/g, () => Math.floor(Math.random() * 16).toString(16));
+}
+function createLogger(prefix, enabled) {
+    if (!enabled) {
+        return (..._args) => { };
+    }
+    return (...args) => {
+        console.log(`[${prefix}]`, ...args);
+    };
+}
+
+/**
+ * Command dispatch with ack tracking and per-command timeout.
+ *
+ * Controllers call `send()` to dispatch a command and await the result.
+ * Devices call `ack()` to acknowledge receipt and report completion/failure.
+ */
+class CommandManager {
+    constructor(defaultTimeout) {
+        this._pending = new Map();
+        this._commands = new Map();
+        this._defaultTimeout = defaultTimeout;
+    }
+    // ============ Public API ============
+    /**
+     * Dispatch a command to a target device.
+     *
+     * Returns a Promise that resolves once the device acks with 'acked' or
+     * 'completed', or rejects on 'failed' status or timeout.
+     */
+    send(targetDeviceId, command, params, sentBy, timeout) {
+        const id = generateId();
+        const now = Date.now();
+        const cmd = {
+            id,
+            targetDeviceId,
+            command,
+            params,
+            status: 'pending',
+            sentBy,
+            sentAt: now,
+        };
+        this._commands.set(id, cmd);
+        const promise = new Promise((resolve, reject) => {
+            const ms = timeout ?? this._defaultTimeout;
+            const timer = setTimeout(() => {
+                const entry = this._pending.get(id);
+                if (!entry)
+                    return;
+                entry.command.status = 'timeout';
+                this._commands.set(id, entry.command);
+                this._pending.delete(id);
+                reject(new Error(`Command "${command}" (${id}) timed out after ${ms}ms`));
+            }, ms);
+            this._pending.set(id, { command: cmd, resolve, reject, timer });
+        });
+        // Prevent unhandled rejection warnings when dispose() rejects orphaned commands.
+        // Callers who await/catch send() still see the rejection normally.
+        promise.catch(() => { });
+        return promise;
+    }
+    /**
+     * Acknowledge a command from the device side.
+     *
+     * `status` must be one of 'acked', 'completed', or 'failed'.
+     * Returns the updated DeviceCommand, or null if the command is unknown or
+     * already settled.
+     */
+    ack(commandId, status, result) {
+        const entry = this._pending.get(commandId);
+        if (!entry)
+            return null;
+        clearTimeout(entry.timer);
+        this._pending.delete(commandId);
+        const now = Date.now();
+        const cmd = entry.command;
+        cmd.status = status;
+        if (status === 'acked') {
+            cmd.ackedAt = now;
+        }
+        else if (status === 'completed') {
+            cmd.ackedAt = cmd.ackedAt ?? now;
+            cmd.completedAt = now;
+            cmd.result = result;
+        }
+        else if (status === 'failed') {
+            cmd.ackedAt = cmd.ackedAt ?? now;
+            cmd.error = typeof result === 'string' ? result : 'Command failed';
+        }
+        this._commands.set(commandId, cmd);
+        if (status === 'acked' || status === 'completed') {
+            entry.resolve(cmd);
+        }
+        else {
+            entry.reject(new Error(cmd.error ?? 'Command failed'));
+        }
+        return cmd;
+    }
+    /**
+     * Get a command by id (includes settled commands).
+     */
+    get(commandId) {
+        return this._commands.get(commandId);
+    }
+    /**
+     * Get all commands currently in 'pending' status.
+     */
+    getPending() {
+        return Array.from(this._pending.values()).map((e) => e.command);
+    }
+    /**
+     * Clear all pending timers and reject all outstanding promises.
+     * Call this when the group or client is torn down.
+     */
+    dispose() {
+        for (const [id, entry] of this._pending.entries()) {
+            clearTimeout(entry.timer);
+            entry.command.status = 'timeout';
+            this._commands.set(id, entry.command);
+            entry.reject(new Error(`Command "${entry.command.command}" (${id}) was disposed`));
+        }
+        this._pending.clear();
+    }
+}
+
+/** Default app name for NoLag IoT SDK */
+const DEFAULT_APP_NAME = 'iot';
+/** Maximum telemetry readings to retain per device/sensor key */
+const DEFAULT_MAX_TELEMETRY_POINTS = 1000;
+/** Default command acknowledgement timeout in milliseconds */
+const DEFAULT_COMMAND_TIMEOUT = 30000;
+/** Topic name for telemetry readings */
+const TOPIC_TELEMETRY = 'telemetry';
+/** Topic name for dispatched commands */
+const TOPIC_COMMANDS = 'commands';
+/** Topic name for command acknowledgements */
+const TOPIC_CMD_ACK = '_cmd_ack';
+/** Lobby ID for global online presence */
+const LOBBY_ID = 'online';
+
+/**
+ * DeviceGroup — a single IoT group for telemetry streaming and command dispatch.
+ *
+ * Created via `NoLagIoT.joinGroup(name)`. Do not instantiate directly.
+ */
+class DeviceGroup extends EventEmitter {
+    /** @internal */
+    constructor(name, roomContext, localDevice, options, log) {
+        super();
+        this._receivedCommands = new Map();
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localDevice = localDevice;
+        this._options = options;
+        this._log = log;
+        this._presenceManager = new PresenceManager(localDevice.actorTokenId);
+        this._telemetryStore = new TelemetryStore(options.maxTelemetryPoints);
+        this._commandManager = new CommandManager(options.commandTimeout);
+    }
+    // ============ Public Properties ============
+    /** All remote devices currently in this group */
+    get devices() {
+        return this._presenceManager.devices;
+    }
+    // ============ Telemetry ============
+    /**
+     * Publish a telemetry reading from this device.
+     */
+    sendTelemetry(sensorId, value, opts = {}) {
+        const reading = {
+            id: generateId(),
+            deviceId: this._localDevice.deviceId,
+            sensorId,
+            value,
+            unit: opts.unit,
+            tags: opts.tags,
+            timestamp: Date.now(),
+            isReplay: false,
+        };
+        this._log('Sending telemetry:', sensorId, '=', value);
+        this._roomContext.emit(TOPIC_TELEMETRY, reading, { echo: false });
+        // Store locally so the sender also has it in the buffer
+        this._telemetryStore.add(reading);
+        return reading;
+    }
+    /**
+     * Retrieve buffered telemetry readings, optionally filtered by device/sensor.
+     */
+    getTelemetry(deviceId, sensorId) {
+        return this._telemetryStore.getAll(deviceId, sensorId);
+    }
+    // ============ Commands ============
+    /**
+     * Dispatch a command to a target device.
+     * Resolves when the device acks the command, rejects on failure or timeout.
+     */
+    sendCommand(targetDeviceId, command, params) {
+        this._log('Sending command:', command, '→', targetDeviceId);
+        const promise = this._commandManager.send(targetDeviceId, command, params, this._localDevice.deviceId, this._options.commandTimeout);
+        // We need the command id to publish it — grab it from pending after send
+        const pending = this._commandManager.getPending();
+        const cmd = pending[pending.length - 1];
+        if (cmd) {
+            this._roomContext.emit(TOPIC_COMMANDS, cmd, { echo: false, filter: targetDeviceId });
+        }
+        return promise;
+    }
+    /**
+     * Acknowledge a command on the device side.
+     * Typically called by the device after receiving a command event.
+     */
+    ackCommand(commandId, status, result) {
+        this._log('Acking command:', commandId, status);
+        const ack = {
+            commandId,
+            status,
+            result,
+            ackedBy: this._localDevice.deviceId,
+            ackedAt: Date.now(),
+        };
+        // Route ack back to the controller that sent the command
+        const cmd = this._receivedCommands.get(commandId) || this._commandManager.get(commandId);
+        const ackFilter = cmd?.sentBy;
+        this._receivedCommands.delete(commandId);
+        this._roomContext.emit(TOPIC_CMD_ACK, ack, { echo: false, ...(ackFilter ? { filter: ackFilter } : {}) });
+        // Also settle locally if this device is the one that sent the command
+        this._commandManager.ack(commandId, status, result);
+    }
+    // ============ Devices ============
+    /**
+     * Get all remote devices in this group.
+     */
+    getDevices() {
+        return this._presenceManager.getAll();
+    }
+    /**
+     * Get a specific device by deviceId.
+     */
+    getDevice(deviceId) {
+        return this._presenceManager.getDevice(deviceId);
+    }
+    // ============ Internal (called by NoLagIoT) ============
+    /** @internal Subscribe to all group topics and attach listeners */
+    _subscribe() {
+        this._log('Group subscribe:', this.name);
+        this._roomContext.subscribe(TOPIC_TELEMETRY);
+        // Commands: devices subscribe with their deviceId as filter so they only
+        // receive commands targeted at them. Controllers subscribe as wildcard
+        // to observe all commands.
+        if (this._options.role === 'device') {
+            this._roomContext.subscribe(TOPIC_COMMANDS, { filters: [this._localDevice.deviceId] });
+        }
+        else {
+            this._roomContext.subscribe(TOPIC_COMMANDS);
+        }
+        // Acks: controllers subscribe with their deviceId as filter so they only
+        // receive acks for commands they sent. Devices subscribe as wildcard.
+        if (this._options.role === 'controller') {
+            this._roomContext.subscribe(TOPIC_CMD_ACK, { filters: [this._localDevice.deviceId] });
+        }
+        else {
+            this._roomContext.subscribe(TOPIC_CMD_ACK);
+        }
+        this._roomContext.on(TOPIC_TELEMETRY, (data) => {
+            this._handleIncomingTelemetry(data);
+        });
+        this._roomContext.on(TOPIC_COMMANDS, (data) => {
+            this._handleIncomingCommand(data);
+        });
+        this._roomContext.on(TOPIC_CMD_ACK, (data) => {
+            this._handleIncomingCmdAck(data);
+        });
+    }
+    /** @internal Set presence and fetch existing group members */
+    _activate() {
+        this._log('Group activate:', this.name);
+        this._setPresence();
+        this._roomContext.fetchPresence().then((actors) => {
+            this._log('Group presence fetched:', this.name, actors.length, 'actors');
+            for (const actor of actors) {
+                if (actor.presence) {
+                    const device = this._presenceManager.addFromPresence(actor.actorTokenId, actor.presence, actor.joinedAt);
+                    if (device) {
+                        this.emit('deviceJoined', device);
+                    }
+                }
+            }
+        }).catch((err) => {
+            this._log('Failed to fetch group presence:', err);
+        });
+    }
+    /** @internal Re-set presence after reconnect */
+    _updateLocalPresence() {
+        this._setPresence();
+    }
+    /** @internal Handle a presence:join event */
+    _handlePresenceJoin(actorTokenId, presenceData) {
+        const device = this._presenceManager.addFromPresence(actorTokenId, presenceData);
+        if (device) {
+            this._log('Device joined group:', this.name, device.deviceId);
+            this.emit('deviceJoined', device);
+        }
+    }
+    /** @internal Handle a presence:leave event */
+    _handlePresenceLeave(actorTokenId) {
+        const device = this._presenceManager.removeByActorId(actorTokenId);
+        if (device) {
+            this._log('Device left group:', this.name, device.deviceId);
+            this.emit('deviceLeft', device);
+        }
+    }
+    /** @internal Handle a presence:update event */
+    _handlePresenceUpdate(actorTokenId, presenceData) {
+        this._presenceManager.addFromPresence(actorTokenId, presenceData);
+    }
+    /** @internal Unsubscribe and clean up */
+    _cleanup() {
+        this._log('Group cleanup:', this.name);
+        this._roomContext.unsubscribe(TOPIC_TELEMETRY);
+        this._roomContext.unsubscribe(TOPIC_COMMANDS);
+        this._roomContext.unsubscribe(TOPIC_CMD_ACK);
+        this._roomContext.off(TOPIC_TELEMETRY);
+        this._roomContext.off(TOPIC_COMMANDS);
+        this._roomContext.off(TOPIC_CMD_ACK);
+        this._commandManager.dispose();
+        this._receivedCommands.clear();
+        this._presenceManager.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleIncomingTelemetry(data) {
+        const reading = data;
+        this._log('Received telemetry:', reading.sensorId, '=', reading.value, 'from', reading.deviceId);
+        const isNew = this._telemetryStore.add(reading);
+        if (!isNew)
+            return; // duplicate — skip
+        this.emit('telemetry', reading);
+    }
+    _handleIncomingCommand(data) {
+        const cmd = data;
+        // Controllers observe all commands but don't process them as targets
+        if (this._options.role === 'controller')
+            return;
+        this._log('Received command:', cmd.command, 'from', cmd.sentBy);
+        this._receivedCommands.set(cmd.id, cmd);
+        this.emit('command', cmd);
+    }
+    _handleIncomingCmdAck(data) {
+        const ack = data;
+        this._log('Received command ack:', ack.commandId, ack.status);
+        const cmd = this._commandManager.ack(ack.commandId, ack.status, ack.result);
+        if (cmd) {
+            this.emit('commandAck', cmd);
+        }
+    }
+    _setPresence() {
+        const presenceData = {
+            deviceId: this._localDevice.deviceId,
+            deviceName: this._localDevice.deviceName,
+            role: this._localDevice.role,
+            metadata: this._localDevice.metadata,
+        };
+        this._roomContext.setPresence(presenceData);
+    }
+}
+
+/**
+ * NoLagIoT — high-level IoT telemetry and command dispatch SDK built on @nolag/js-sdk.
+ *
+ * Provides device presence, real-time telemetry streaming, and command dispatch
+ * with ack tracking — all framework-agnostic via events.
+ *
+ * @example
+ * ```typescript
+ * import { NoLagIoT } from '@nolag/iot';
+ *
+ * const iot = new NoLagIoT(token, { deviceId: 'sensor-01', role: 'device', debug: true });
+ *
+ * iot.on('connected', () => console.log('Connected!'));
+ * await iot.connect();
+ *
+ * const group = iot.joinGroup('factory-floor');
+ * group.on('command', (cmd) => {
+ *   console.log('Received command:', cmd.command);
+ *   group.ackCommand(cmd.id, 'completed', { ok: true });
+ * });
+ *
+ * // Send telemetry every second
+ * setInterval(() => {
+ *   group.sendTelemetry('temperature', 22.5, { unit: '°C' });
+ * }, 1000);
+ * ```
+ */
+class NoLagIoT extends EventEmitter {
+    constructor(token, options = {}) {
+        super();
+        this._client = null;
+        this._localDevice = null;
+        this._groups = new Map();
+        this._lobby = null;
+        this._onlineDevices = new Map();
+        this._actorToDeviceId = new Map();
+        this._token = token;
+        this._deviceId = options.deviceId ?? generateId();
+        this._options = {
+            deviceId: this._deviceId,
+            deviceName: options.deviceName,
+            role: options.role ?? 'device',
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            url: options.url,
+            maxTelemetryPoints: options.maxTelemetryPoints ?? DEFAULT_MAX_TELEMETRY_POINTS,
+            commandTimeout: options.commandTimeout ?? DEFAULT_COMMAND_TIMEOUT,
+            debug: options.debug ?? false,
+            reconnect: options.reconnect ?? true,
+            groups: options.groups ?? [],
+        };
+        this._log = createLogger('NoLagIoT', this._options.debug);
+    }
+    // ============ Public Properties ============
+    /** Whether the underlying connection is established */
+    get connected() {
+        return this._client?.connected ?? false;
+    }
+    /** The local device info (available after connect) */
+    get localDevice() {
+        return this._localDevice;
+    }
+    /** All currently joined groups */
+    get groups() {
+        return this._groups;
+    }
+    // ============ Lifecycle ============
+    /**
+     * Connect to NoLag and set up global presence.
+     */
+    async connect() {
+        this._log('Connecting...');
+        const clientOptions = {
+            debug: this._options.debug,
+            reconnect: this._options.reconnect,
+        };
+        if (this._options.url) {
+            clientOptions.url = this._options.url;
+        }
+        this._client = NoLag(this._token, clientOptions);
+        // Wire client lifecycle events
+        this._client.on('connect', () => {
+            this._log('Connected');
+            if (this._groups.size > 0) {
+                this._log('Reconnected — restoring groups...');
+                this._restoreGroups();
+                this.emit('reconnected');
+            }
+        });
+        this._client.on('disconnect', (reason) => {
+            this._log('Disconnected:', reason);
+            this.emit('disconnected', reason);
+        });
+        this._client.on('reconnect', () => {
+            this._log('Reconnecting...');
+        });
+        this._client.on('error', (error) => {
+            this._log('Error:', error);
+            this.emit('error', error);
+        });
+        // Connect
+        await this._client.connect();
+        // Wire room-level presence events
+        this._client.on('presence:join', (data) => {
+            this._handleRoomPresenceJoin(data);
+        });
+        this._client.on('presence:leave', (data) => {
+            this._handleRoomPresenceLeave(data);
+        });
+        this._client.on('presence:update', (data) => {
+            this._handleRoomPresenceUpdate(data);
+        });
+        // Create local device record
+        this._localDevice = {
+            deviceId: this._deviceId,
+            actorTokenId: this._client.actorId,
+            deviceName: this._options.deviceName,
+            role: this._options.role,
+            metadata: this._options.metadata,
+            joinedAt: Date.now(),
+            isLocal: true,
+        };
+        this._log('Local device:', this._localDevice.deviceId, '→', this._localDevice.actorTokenId);
+        // Set up lobby for global presence
+        await this._setupLobby();
+        // Emit connected now that _localDevice and lobby are ready
+        this.emit('connected');
+        // Auto-join configured groups
+        for (const groupName of this._options.groups) {
+            this.joinGroup(groupName);
+        }
+        // Deferred lobby refetch to catch devices that joined during setup window
+        setTimeout(() => {
+            if (this._lobby && this._client?.connected) {
+                this._lobby.fetchPresence().then((state) => {
+                    this._hydrateOnlineDevices(state);
+                }).catch(() => { });
+            }
+        }, 2000);
+    }
+    /**
+     * Disconnect from NoLag and clean up all groups.
+     */
+    disconnect() {
+        this._log('Disconnecting...');
+        // Clean up groups
+        for (const name of [...this._groups.keys()]) {
+            this.leaveGroup(name);
+        }
+        // Unsubscribe from lobby
+        this._lobby?.unsubscribe();
+        this._lobby = null;
+        // Disconnect client
+        this._client?.disconnect();
+        this._client = null;
+        // Clear state
+        this._onlineDevices.clear();
+        this._actorToDeviceId.clear();
+        this._localDevice = null;
+    }
+    // ============ Group Management ============
+    /**
+     * Join a device group. Creates, subscribes, and activates it.
+     * Returns an existing group if already joined.
+     */
+    joinGroup(name) {
+        if (!this._client || !this._localDevice) {
+            throw new Error('Not connected — call connect() first');
+        }
+        let group = this._groups.get(name);
+        if (!group) {
+            group = this._subscribeGroup(name);
+            group._activate();
+        }
+        return group;
+    }
+    /**
+     * Leave a device group. Fully unsubscribes and removes it.
+     */
+    leaveGroup(name) {
+        const group = this._groups.get(name);
+        if (!group)
+            return;
+        this._log('Leaving group:', name);
+        group._cleanup();
+        this._groups.delete(name);
+    }
+    /**
+     * Get all joined groups.
+     */
+    getGroups() {
+        return Array.from(this._groups.values());
+    }
+    // ============ Global Presence ============
+    /**
+     * Get all devices currently online across all groups.
+     */
+    getOnlineDevices() {
+        return Array.from(this._onlineDevices.values());
+    }
+    // ============ Private: Group Setup ============
+    _subscribeGroup(name) {
+        if (!this._client || !this._localDevice) {
+            throw new Error('Not connected — call connect() first');
+        }
+        this._log('Subscribing group:', name);
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const group = new DeviceGroup(name, roomContext, this._localDevice, this._options, createLogger(`DeviceGroup:${name}`, this._options.debug));
+        this._groups.set(name, group);
+        group._subscribe();
+        return group;
+    }
+    // ============ Private: Room Presence ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localDevice?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.deviceId)
+            return;
+        const device = this._presenceToDevice(data.actorTokenId, presenceData);
+        this._actorToDeviceId.set(data.actorTokenId, device.deviceId);
+        if (!this._onlineDevices.has(device.deviceId)) {
+            this._onlineDevices.set(device.deviceId, device);
+            this.emit('deviceOnline', device);
+        }
+        // Route to all groups
+        for (const group of this._groups.values()) {
+            group._handlePresenceJoin(data.actorTokenId, presenceData);
+        }
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._localDevice?.actorTokenId)
+            return;
+        // Route to all groups
+        for (const group of this._groups.values()) {
+            group._handlePresenceLeave(data.actorTokenId);
+        }
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._localDevice?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.deviceId)
+            return;
+        if (this._onlineDevices.has(presenceData.deviceId)) {
+            const device = this._presenceToDevice(data.actorTokenId, presenceData);
+            this._onlineDevices.set(device.deviceId, device);
+        }
+        // Route to all groups
+        for (const group of this._groups.values()) {
+            group._handlePresenceUpdate(data.actorTokenId, presenceData);
+        }
+    }
+    // ============ Private: Lobby ============
+    async _setupLobby() {
+        if (!this._client)
+            return;
+        this._lobby = this._client.setApp(this._options.appName).setLobby(LOBBY_ID);
+        const lobbyHandler = (type) => (data) => {
+            const event = data;
+            if (type === 'join')
+                this._handleLobbyJoin(event);
+            else if (type === 'leave')
+                this._handleLobbyLeave(event);
+            else
+                this._handleLobbyUpdate(event);
+        };
+        this._client.on('lobbyPresence:join', lobbyHandler('join'));
+        this._client.on('lobbyPresence:leave', lobbyHandler('leave'));
+        this._client.on('lobbyPresence:update', lobbyHandler('update'));
+        try {
+            const initialState = await this._lobby.subscribe();
+            this._hydrateOnlineDevices(initialState);
+            this._log('Lobby subscribed, online devices:', this._onlineDevices.size);
+        }
+        catch (err) {
+            this._log('Lobby subscription failed:', err);
+        }
+    }
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localDevice?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.deviceId)
+            return;
+        const device = this._presenceToDevice(actorId, presenceData);
+        this._actorToDeviceId.set(actorId, device.deviceId);
+        if (!this._onlineDevices.has(device.deviceId)) {
+            this._onlineDevices.set(device.deviceId, device);
+            this.emit('deviceOnline', device);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localDevice?.actorTokenId)
+            return;
+        const presenceData = data;
+        const deviceId = presenceData?.deviceId
+            || this._actorToDeviceId.get(actorId)
+            || this._findDeviceIdByActorId(actorId);
+        if (deviceId) {
+            const device = this._onlineDevices.get(deviceId);
+            if (device) {
+                this._onlineDevices.delete(deviceId);
+                this._actorToDeviceId.delete(actorId);
+                this.emit('deviceOffline', device);
+            }
+        }
+    }
+    _handleLobbyUpdate(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localDevice?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.deviceId)
+            return;
+        const device = this._presenceToDevice(actorId, presenceData);
+        this._onlineDevices.set(device.deviceId, device);
+    }
+    _hydrateOnlineDevices(state) {
+        for (const roomId of Object.keys(state)) {
+            const roomPresence = state[roomId];
+            for (const actorId of Object.keys(roomPresence)) {
+                if (actorId === this._localDevice?.actorTokenId)
+                    continue;
+                const raw = roomPresence[actorId];
+                const presenceData = (raw?.presence ?? raw);
+                if (presenceData?.deviceId) {
+                    const device = this._presenceToDevice(actorId, presenceData);
+                    this._actorToDeviceId.set(actorId, device.deviceId);
+                    if (!this._onlineDevices.has(device.deviceId)) {
+                        this._onlineDevices.set(device.deviceId, device);
+                        this.emit('deviceOnline', device);
+                    }
+                }
+            }
+        }
+    }
+    // ============ Private: Helpers ============
+    _presenceToDevice(actorTokenId, data) {
+        return {
+            deviceId: data.deviceId,
+            actorTokenId,
+            deviceName: data.deviceName,
+            role: data.role,
+            metadata: data.metadata,
+            joinedAt: Date.now(),
+            isLocal: false,
+        };
+    }
+    _findDeviceIdByActorId(actorTokenId) {
+        for (const device of this._onlineDevices.values()) {
+            if (device.actorTokenId === actorTokenId)
+                return device.deviceId;
+        }
+        return undefined;
+    }
+    _restoreGroups() {
+        // On reconnect, js-sdk auto-restores subscriptions.
+        // Re-set presence on all active groups.
+        for (const group of this._groups.values()) {
+            group._updateLocalPresence();
+        }
+        // Re-fetch lobby presence
+        this._lobby?.fetchPresence().then((state) => {
+            this._onlineDevices.clear();
+            this._actorToDeviceId.clear();
+            this._hydrateOnlineDevices(state);
+        }).catch((err) => {
+            this._log('Failed to re-fetch lobby presence:', err);
+        });
+    }
+}
+
+export { CommandManager, DeviceGroup, EventEmitter, NoLagIoT, PresenceManager, TelemetryStore };
+//# sourceMappingURL=index.mjs.map