@nolag/queue 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1078 @@
+'use strict';
+
+var jsSdk = require('@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;
+    }
+}
+
+/** Valid state transitions for job lifecycle */
+const VALID_TRANSITIONS = {
+    pending: ['claimed'],
+    claimed: ['active'],
+    active: ['completed', 'failed'],
+    failed: ['pending'], // retry path
+};
+/**
+ * In-memory job store with deduplication, filtering, and state-transition validation.
+ */
+class JobStore {
+    constructor(maxSize) {
+        this._jobs = new Map();
+        this._maxSize = maxSize;
+    }
+    /**
+     * Add a job to the store.
+     * Returns true if added, false if already present (dedup).
+     */
+    add(job) {
+        if (this._jobs.has(job.id))
+            return false;
+        // Evict oldest entry if at capacity
+        if (this._jobs.size >= this._maxSize) {
+            const firstKey = this._jobs.keys().next().value;
+            if (firstKey !== undefined) {
+                this._jobs.delete(firstKey);
+            }
+        }
+        this._jobs.set(job.id, job);
+        return true;
+    }
+    /**
+     * Get a job by ID.
+     */
+    get(id) {
+        return this._jobs.get(id);
+    }
+    /**
+     * Get all jobs, optionally filtered.
+     */
+    getAll(filter) {
+        const jobs = Array.from(this._jobs.values());
+        if (!filter)
+            return jobs;
+        return jobs.filter((job) => {
+            if (filter.status !== undefined && job.status !== filter.status)
+                return false;
+            if (filter.type !== undefined && job.type !== filter.type)
+                return false;
+            if (filter.priority !== undefined && job.priority !== filter.priority)
+                return false;
+            return true;
+        });
+    }
+    /**
+     * Transition a job to a new status with optional data update.
+     * Validates the state transition. Returns updated job or null if invalid.
+     */
+    updateStatus(id, status, data) {
+        const job = this._jobs.get(id);
+        if (!job)
+            return null;
+        const allowed = VALID_TRANSITIONS[job.status];
+        if (!allowed || !allowed.includes(status))
+            return null;
+        const now = Date.now();
+        const updated = {
+            ...job,
+            status,
+            updatedAt: now,
+            ...data,
+        };
+        if (status === 'completed' || status === 'failed') {
+            updated.completedAt = now;
+        }
+        this._jobs.set(id, updated);
+        return updated;
+    }
+    /**
+     * Update the progress percentage (0–100) for a job.
+     * Returns the updated job or null if not found.
+     */
+    updateProgress(id, progress) {
+        const job = this._jobs.get(id);
+        if (!job)
+            return null;
+        const clamped = Math.min(100, Math.max(0, progress));
+        const updated = { ...job, progress: clamped, updatedAt: Date.now() };
+        this._jobs.set(id, updated);
+        return updated;
+    }
+    /**
+     * Number of jobs currently in 'pending' status.
+     */
+    get pendingCount() {
+        let count = 0;
+        for (const job of this._jobs.values()) {
+            if (job.status === 'pending')
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Number of jobs currently in 'active' status.
+     */
+    get activeCount() {
+        let count = 0;
+        for (const job of this._jobs.values()) {
+            if (job.status === 'active')
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Check if a job with the given ID exists.
+     */
+    has(id) {
+        return this._jobs.has(id);
+    }
+    /**
+     * Total number of jobs in the store.
+     */
+    get size() {
+        return this._jobs.size;
+    }
+    /**
+     * Clear all jobs from the store.
+     */
+    clear() {
+        this._jobs.clear();
+    }
+}
+
+/**
+ * Tracks all known queue workers (local and remote).
+ */
+class WorkerManager {
+    constructor() {
+        this._workers = new Map();
+    }
+    /**
+     * Add or replace a worker entry.
+     */
+    addWorker(worker) {
+        this._workers.set(worker.workerId, worker);
+    }
+    /**
+     * Remove a worker by workerId.
+     * Returns the removed worker, or null if not found.
+     */
+    removeWorker(workerId) {
+        const worker = this._workers.get(workerId) ?? null;
+        this._workers.delete(workerId);
+        return worker;
+    }
+    /**
+     * Get a worker by workerId.
+     */
+    getWorker(workerId) {
+        return this._workers.get(workerId);
+    }
+    /**
+     * Get all tracked workers.
+     */
+    getAll() {
+        return Array.from(this._workers.values());
+    }
+    /**
+     * Increment the active job count for a worker.
+     * Returns the updated worker or null if not found.
+     */
+    incrementActiveJobs(workerId) {
+        const worker = this._workers.get(workerId);
+        if (!worker)
+            return null;
+        const updated = { ...worker, activeJobs: worker.activeJobs + 1 };
+        this._workers.set(workerId, updated);
+        return updated;
+    }
+    /**
+     * Decrement the active job count for a worker (floor 0).
+     * Returns the updated worker or null if not found.
+     */
+    decrementActiveJobs(workerId) {
+        const worker = this._workers.get(workerId);
+        if (!worker)
+            return null;
+        const updated = {
+            ...worker,
+            activeJobs: Math.max(0, worker.activeJobs - 1),
+        };
+        this._workers.set(workerId, updated);
+        return updated;
+    }
+    /**
+     * Check whether a worker can accept more work (activeJobs < concurrency).
+     */
+    canAcceptWork(workerId) {
+        const worker = this._workers.get(workerId);
+        if (!worker)
+            return false;
+        return worker.activeJobs < worker.concurrency;
+    }
+    /**
+     * Clear all tracked workers.
+     */
+    clear() {
+        this._workers.clear();
+    }
+}
+
+/**
+ * Maps actorTokenId ↔ QueueWorker, filtering self.
+ */
+class PresenceManager {
+    constructor(localActorId) {
+        this._workers = new Map();
+        this._actorToWorkerId = new Map();
+        this._localActorId = localActorId;
+    }
+    /**
+     * Add or update a worker from presence data.
+     * Returns the QueueWorker if it's a remote worker, null if it's self.
+     */
+    addFromPresence(actorTokenId, presence, joinedAt) {
+        const isLocal = actorTokenId === this._localActorId;
+        // Skip self
+        if (isLocal)
+            return null;
+        const existing = this._actorToWorkerId.get(actorTokenId);
+        const workerId = presence.workerId || existing || actorTokenId;
+        const worker = {
+            workerId,
+            actorTokenId,
+            role: presence.role,
+            activeJobs: presence.activeJobs ?? 0,
+            concurrency: presence.concurrency ?? 1,
+            metadata: presence.metadata,
+            joinedAt: joinedAt || Date.now(),
+            isLocal: false,
+        };
+        this._workers.set(workerId, worker);
+        this._actorToWorkerId.set(actorTokenId, workerId);
+        return worker;
+    }
+    /**
+     * Remove a worker by actorTokenId.
+     * Returns the removed worker, or null if not found / is self.
+     */
+    removeByActorId(actorTokenId) {
+        if (actorTokenId === this._localActorId)
+            return null;
+        const workerId = this._actorToWorkerId.get(actorTokenId);
+        if (!workerId)
+            return null;
+        const worker = this._workers.get(workerId) ?? null;
+        this._workers.delete(workerId);
+        this._actorToWorkerId.delete(actorTokenId);
+        return worker;
+    }
+    /**
+     * Get a worker by workerId.
+     */
+    getWorker(workerId) {
+        return this._workers.get(workerId);
+    }
+    /**
+     * Get a worker by actorTokenId.
+     */
+    getWorkerByActorId(actorTokenId) {
+        const workerId = this._actorToWorkerId.get(actorTokenId);
+        return workerId ? this._workers.get(workerId) : undefined;
+    }
+    /**
+     * Get all remote workers.
+     */
+    getAll() {
+        return Array.from(this._workers.values());
+    }
+    /**
+     * Get the workers Map (readonly view).
+     */
+    get workers() {
+        return this._workers;
+    }
+    /**
+     * Clear all tracked workers.
+     */
+    clear() {
+        this._workers.clear();
+        this._actorToWorkerId.clear();
+    }
+}
+
+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);
+    };
+}
+
+/** Default app name for NoLag queue SDK */
+const DEFAULT_APP_NAME = 'queue';
+/** Default maximum number of jobs to cache in memory */
+const DEFAULT_MAX_JOB_CACHE = 1000;
+/** Default maximum number of attempts before a job is permanently failed */
+const DEFAULT_MAX_ATTEMPTS = 3;
+/** Topic name for job lifecycle messages within a queue room */
+const TOPIC_JOBS = 'jobs';
+/** Topic name for job progress updates within a queue room */
+const TOPIC_PROGRESS = '_progress';
+/** Lobby ID for global online presence */
+const LOBBY_ID = 'online';
+
+/**
+ * QueueRoom — a single named queue with job lifecycle, progress tracking, and worker presence.
+ *
+ * Created via `NoLagQueue.joinQueue(name)`. Do not instantiate directly.
+ */
+class QueueRoom extends EventEmitter {
+    /** @internal */
+    constructor(name, roomContext, localWorkerId, options, log) {
+        super();
+        this.name = name;
+        this._roomContext = roomContext;
+        this._localWorkerId = localWorkerId;
+        this._options = options;
+        this._log = log;
+        this._jobStore = new JobStore(options.maxJobCache);
+        this._workerManager = new WorkerManager();
+        this._presenceManager = new PresenceManager(''); // local actor set after connect
+    }
+    /** @internal Set the local actor ID once connected */
+    _setLocalActorId(actorId) {
+        this._presenceManager = new PresenceManager(actorId);
+    }
+    // ============ Producer Methods ============
+    /**
+     * Add a new job to the queue. Only producers should call this.
+     */
+    addJob(opts) {
+        const now = Date.now();
+        const job = {
+            id: generateId(),
+            type: opts.type,
+            payload: opts.payload,
+            priority: opts.priority ?? 'normal',
+            status: 'pending',
+            progress: 0,
+            attempts: 0,
+            maxAttempts: opts.maxAttempts ?? DEFAULT_MAX_ATTEMPTS,
+            createdBy: this._localWorkerId,
+            createdAt: now,
+            updatedAt: now,
+            isReplay: false,
+        };
+        this._jobStore.add(job);
+        this._log('Job added:', job.id, job.type);
+        this._roomContext.emit(TOPIC_JOBS, { event: 'jobAdded', job }, { echo: true });
+        this.emit('jobAdded', job);
+        return job;
+    }
+    // ============ Worker Methods ============
+    /**
+     * Claim a pending job. Only workers should call this.
+     */
+    claimJob(jobId) {
+        const updated = this._jobStore.updateStatus(jobId, 'claimed', {
+            claimedBy: this._localWorkerId,
+        });
+        if (!updated)
+            return null;
+        this._log('Job claimed:', jobId, 'by', this._localWorkerId);
+        this._roomContext.emit(TOPIC_JOBS, { event: 'jobClaimed', job: updated }, { echo: true });
+        this.emit('jobClaimed', updated);
+        return updated;
+    }
+    /**
+     * Report progress on an active job (0–100).
+     */
+    reportProgress(jobId, progress) {
+        const job = this._jobStore.updateProgress(jobId, progress);
+        if (!job)
+            return;
+        const progressEvent = {
+            jobId,
+            progress: job.progress,
+            workerId: this._localWorkerId,
+            timestamp: Date.now(),
+        };
+        this._log('Job progress:', jobId, job.progress + '%');
+        this._roomContext.emit(TOPIC_PROGRESS, progressEvent, { echo: true });
+        this.emit('jobProgress', progressEvent);
+    }
+    /**
+     * Mark a claimed/active job as completed with an optional result.
+     */
+    completeJob(jobId, result) {
+        // Transition claimed → active → completed in one step for simplicity
+        let updated = this._jobStore.updateStatus(jobId, 'active');
+        if (!updated) {
+            // Already active — go straight to completed
+            updated = this._jobStore.get(jobId) ?? null;
+        }
+        if (!updated)
+            return null;
+        const completed = this._jobStore.updateStatus(jobId, 'completed', { result });
+        if (!completed)
+            return null;
+        this._log('Job completed:', jobId);
+        this._roomContext.emit(TOPIC_JOBS, { event: 'jobCompleted', job: completed }, { echo: true });
+        this.emit('jobCompleted', completed);
+        return completed;
+    }
+    /**
+     * Mark an active job as failed with an optional error message.
+     * Automatically retries if attempts < maxAttempts.
+     */
+    failJob(jobId, error) {
+        const job = this._jobStore.get(jobId);
+        if (!job)
+            return null;
+        // Move to active if still claimed
+        if (job.status === 'claimed') {
+            this._jobStore.updateStatus(jobId, 'active');
+        }
+        const nextAttempts = job.attempts + 1;
+        const failed = this._jobStore.updateStatus(jobId, 'failed', {
+            error,
+            attempts: nextAttempts,
+        });
+        if (!failed)
+            return null;
+        this._log('Job failed:', jobId, 'attempts:', nextAttempts, '/', failed.maxAttempts);
+        this._roomContext.emit(TOPIC_JOBS, { event: 'jobFailed', job: failed }, { echo: true });
+        this.emit('jobFailed', failed);
+        // Auto-retry if under maxAttempts
+        if (nextAttempts < failed.maxAttempts) {
+            const retried = this._jobStore.updateStatus(jobId, 'pending');
+            if (retried) {
+                this._log('Job retrying:', jobId, 'attempt', nextAttempts + 1);
+                this._roomContext.emit(TOPIC_JOBS, { event: 'jobRetrying', job: retried }, { echo: true });
+                this.emit('jobRetrying', retried);
+            }
+        }
+        return failed;
+    }
+    // ============ Monitor / Query Methods ============
+    /**
+     * Get a single job by ID.
+     */
+    getJob(id) {
+        return this._jobStore.get(id);
+    }
+    /**
+     * Get all jobs, optionally filtered.
+     */
+    getJobs(filter) {
+        return this._jobStore.getAll(filter);
+    }
+    /**
+     * Number of pending jobs.
+     */
+    get pendingCount() {
+        return this._jobStore.pendingCount;
+    }
+    /**
+     * Number of active jobs.
+     */
+    get activeCount() {
+        return this._jobStore.activeCount;
+    }
+    /**
+     * All workers currently in this queue room.
+     */
+    get workers() {
+        return this._presenceManager.workers;
+    }
+    /**
+     * Get all workers in this queue room.
+     */
+    getWorkers() {
+        return this._presenceManager.getAll();
+    }
+    // ============ Internal (called by NoLagQueue) ============
+    /** @internal Subscribe to jobs and progress topics, attach listeners */
+    _subscribe() {
+        this._log('Room subscribe:', this.name);
+        // Workers use load balancing so each job event is delivered to only ONE worker
+        // (round-robin across all workers in the same group). Producers and monitors
+        // receive all messages so they can track full queue state.
+        if (this._options.role === 'worker') {
+            const group = this._options.loadBalanceGroup ?? `queue-workers-${this.name}`;
+            this._log('Subscribing with load balance, group:', group);
+            this._roomContext.subscribe(TOPIC_JOBS, { loadBalance: true, loadBalanceGroup: group });
+        }
+        else {
+            this._roomContext.subscribe(TOPIC_JOBS);
+        }
+        this._roomContext.subscribe(TOPIC_PROGRESS);
+        this._roomContext.on(TOPIC_JOBS, (data) => {
+            this._handleJobMessage(data);
+        });
+        this._roomContext.on(TOPIC_PROGRESS, (data) => {
+            this._handleProgressMessage(data);
+        });
+    }
+    /** @internal Set presence and fetch room members */
+    _activate() {
+        this._log('Room activate:', this.name);
+        this._setPresence();
+        this._roomContext.fetchPresence().then((actors) => {
+            this._log('Room presence fetched:', this.name, actors.length, 'actors');
+            for (const actor of actors) {
+                if (actor.presence) {
+                    const worker = this._presenceManager.addFromPresence(actor.actorTokenId, actor.presence, actor.joinedAt);
+                    if (worker) {
+                        this._workerManager.addWorker(worker);
+                        this.emit('workerJoined', worker);
+                    }
+                }
+            }
+        }).catch((err) => {
+            this._log('Failed to fetch room presence:', err);
+        });
+    }
+    /** @internal Re-set presence after reconnect */
+    _updateLocalPresence() {
+        this._setPresence();
+    }
+    /** @internal Handle a presence:join event */
+    _handlePresenceJoin(actorTokenId, presenceData) {
+        const worker = this._presenceManager.addFromPresence(actorTokenId, presenceData);
+        if (worker) {
+            this._log('Worker joined queue:', this.name, worker.workerId);
+            this._workerManager.addWorker(worker);
+            this.emit('workerJoined', worker);
+        }
+    }
+    /** @internal Handle a presence:leave event */
+    _handlePresenceLeave(actorTokenId) {
+        const worker = this._presenceManager.removeByActorId(actorTokenId);
+        if (worker) {
+            this._log('Worker left queue:', this.name, worker.workerId);
+            this._workerManager.removeWorker(worker.workerId);
+            this.emit('workerLeft', worker);
+        }
+    }
+    /** @internal Handle a presence:update event */
+    _handlePresenceUpdate(actorTokenId, presenceData) {
+        const worker = this._presenceManager.addFromPresence(actorTokenId, presenceData);
+        if (worker) {
+            this._workerManager.addWorker(worker);
+        }
+    }
+    /** @internal Unsubscribe and clean up */
+    _cleanup() {
+        this._log('Room cleanup:', this.name);
+        this._roomContext.unsubscribe(TOPIC_JOBS);
+        this._roomContext.unsubscribe(TOPIC_PROGRESS);
+        this._roomContext.off(TOPIC_JOBS);
+        this._roomContext.off(TOPIC_PROGRESS);
+        this._jobStore.clear();
+        this._workerManager.clear();
+        this._presenceManager.clear();
+        this.removeAllListeners();
+    }
+    // ============ Private ============
+    _handleJobMessage(data) {
+        const msg = data;
+        if (!msg?.event || !msg?.job)
+            return;
+        const { event, job } = msg;
+        this._log('Job message:', event, job.id);
+        switch (event) {
+            case 'jobAdded':
+                if (this._jobStore.add(job)) {
+                    this.emit('jobAdded', job);
+                }
+                break;
+            case 'jobClaimed': {
+                const existing = this._jobStore.get(job.id);
+                if (existing) {
+                    this._jobStore.updateStatus(job.id, 'claimed', { claimedBy: job.claimedBy });
+                    const updated = this._jobStore.get(job.id);
+                    this.emit('jobClaimed', updated);
+                }
+                break;
+            }
+            case 'jobCompleted': {
+                const existing = this._jobStore.get(job.id);
+                if (existing) {
+                    // Sync final state directly since remote already processed transitions
+                    const synced = { ...existing, ...job };
+                    this._jobStore.add(synced);
+                    this.emit('jobCompleted', synced);
+                }
+                break;
+            }
+            case 'jobFailed': {
+                const existing = this._jobStore.get(job.id);
+                if (existing) {
+                    const synced = { ...existing, ...job };
+                    this._jobStore.add(synced);
+                    this.emit('jobFailed', synced);
+                }
+                break;
+            }
+            case 'jobRetrying': {
+                const existing = this._jobStore.get(job.id);
+                if (existing) {
+                    const synced = { ...existing, ...job };
+                    this._jobStore.add(synced);
+                    this.emit('jobRetrying', synced);
+                }
+                break;
+            }
+        }
+    }
+    _handleProgressMessage(data) {
+        const progress = data;
+        if (!progress?.jobId)
+            return;
+        this._jobStore.updateProgress(progress.jobId, progress.progress);
+        this._log('Job progress update:', progress.jobId, progress.progress + '%');
+        this.emit('jobProgress', progress);
+    }
+    _setPresence() {
+        const presenceData = {
+            workerId: this._localWorkerId,
+            role: this._options.role,
+            activeJobs: 0,
+            concurrency: this._options.concurrency,
+            metadata: this._options.metadata,
+        };
+        this._roomContext.setPresence(presenceData);
+    }
+}
+
+/**
+ * NoLagQueue — high-level real-time job queue SDK built on @nolag/js-sdk.
+ *
+ * Provides job lifecycle management, progress tracking, worker management,
+ * and global presence tracking — all framework-agnostic via events.
+ *
+ * @example
+ * ```typescript
+ * import { NoLagQueue } from '@nolag/queue';
+ *
+ * const queue = new NoLagQueue(token, { role: 'worker', concurrency: 2 });
+ *
+ * queue.on('connected', () => console.log('Connected!'));
+ *
+ * await queue.connect();
+ *
+ * const room = queue.joinQueue('image-processing');
+ * room.on('jobAdded', (job) => {
+ *   room.claimJob(job.id);
+ *   // process...
+ *   room.reportProgress(job.id, 50);
+ *   room.completeJob(job.id, { output: 'result' });
+ * });
+ * ```
+ */
+class NoLagQueue extends EventEmitter {
+    constructor(token, options = {}) {
+        super();
+        this._client = null;
+        this._localWorker = null;
+        this._queues = new Map();
+        this._lobby = null;
+        this._onlineWorkers = new Map();
+        this._actorToWorkerId = new Map();
+        this._token = token;
+        this._workerId = options.workerId ?? generateId();
+        this._options = {
+            workerId: this._workerId,
+            role: options.role ?? 'monitor',
+            concurrency: options.concurrency ?? 1,
+            metadata: options.metadata,
+            appName: options.appName ?? DEFAULT_APP_NAME,
+            url: options.url,
+            maxJobCache: options.maxJobCache ?? DEFAULT_MAX_JOB_CACHE,
+            debug: options.debug ?? false,
+            reconnect: options.reconnect ?? true,
+            queues: options.queues ?? [],
+            loadBalanceGroup: options.loadBalanceGroup,
+        };
+        this._log = createLogger('NoLagQueue', this._options.debug);
+    }
+    // ============ Public Properties ============
+    /** Whether the underlying connection is established */
+    get connected() {
+        return this._client?.connected ?? false;
+    }
+    /** The local worker's info (available after connect) */
+    get localWorker() {
+        return this._localWorker;
+    }
+    /** All currently joined queue rooms */
+    get queues() {
+        return this._queues;
+    }
+    // ============ 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 = jsSdk.NoLag(this._token, clientOptions);
+        // Wire client lifecycle events
+        this._client.on('connect', () => {
+            this._log('Connected');
+            if (this._queues.size > 0) {
+                this._log('Reconnected — restoring queues...');
+                this._restoreQueues();
+                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 worker record
+        this._localWorker = {
+            workerId: this._workerId,
+            actorTokenId: this._client.actorId,
+            role: this._options.role,
+            activeJobs: 0,
+            concurrency: this._options.concurrency,
+            metadata: this._options.metadata,
+            joinedAt: Date.now(),
+            isLocal: true,
+        };
+        this._log('Local worker:', this._localWorker.workerId, '→', this._localWorker.actorTokenId);
+        // Set up lobby for global presence
+        await this._setupLobby();
+        // Emit connected now that _localWorker and lobby are ready
+        this.emit('connected');
+        // Deferred lobby refetch to catch workers who joined during the setup window
+        setTimeout(() => {
+            if (this._lobby && this._client?.connected) {
+                this._lobby.fetchPresence().then((state) => {
+                    this._hydrateOnlineWorkers(state);
+                }).catch(() => { });
+            }
+        }, 2000);
+    }
+    /**
+     * Disconnect from NoLag and clean up all queue rooms.
+     */
+    disconnect() {
+        this._log('Disconnecting...');
+        // Clean up queue rooms
+        for (const name of [...this._queues.keys()]) {
+            this.leaveQueue(name);
+        }
+        // Unsubscribe from lobby
+        this._lobby?.unsubscribe();
+        this._lobby = null;
+        // Disconnect client
+        this._client?.disconnect();
+        this._client = null;
+        // Clear state
+        this._onlineWorkers.clear();
+        this._actorToWorkerId.clear();
+        this._localWorker = null;
+    }
+    // ============ Queue Management ============
+    /**
+     * Join a queue room. Creates, subscribes, and activates it.
+     * Returns an existing room if already joined.
+     */
+    joinQueue(name) {
+        if (!this._client || !this._localWorker) {
+            throw new Error('Not connected — call connect() first');
+        }
+        let room = this._queues.get(name);
+        if (!room) {
+            room = this._subscribeQueue(name);
+            room._activate();
+        }
+        return room;
+    }
+    /**
+     * Leave a queue room. Fully unsubscribes and removes it.
+     */
+    leaveQueue(name) {
+        const room = this._queues.get(name);
+        if (!room)
+            return;
+        this._log('Leaving queue:', name);
+        room._cleanup();
+        this._queues.delete(name);
+    }
+    /**
+     * Get all joined queue rooms.
+     */
+    getQueues() {
+        return Array.from(this._queues.values());
+    }
+    // ============ Global Presence ============
+    /**
+     * Get all workers currently online across all queue rooms.
+     */
+    getOnlineWorkers() {
+        return Array.from(this._onlineWorkers.values());
+    }
+    // ============ Private: Queue Setup ============
+    _subscribeQueue(name) {
+        if (!this._client || !this._localWorker) {
+            throw new Error('Not connected — call connect() first');
+        }
+        this._log('Subscribing queue:', name);
+        const roomContext = this._client.setApp(this._options.appName).setRoom(name);
+        const room = new QueueRoom(name, roomContext, this._workerId, this._options, createLogger(`QueueRoom:${name}`, this._options.debug));
+        room._setLocalActorId(this._localWorker.actorTokenId);
+        this._queues.set(name, room);
+        room._subscribe();
+        return room;
+    }
+    // ============ Private: Room Presence ============
+    _handleRoomPresenceJoin(data) {
+        if (data.actorTokenId === this._localWorker?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.workerId)
+            return;
+        const worker = this._presenceToWorker(data.actorTokenId, presenceData);
+        this._actorToWorkerId.set(data.actorTokenId, worker.workerId);
+        if (!this._onlineWorkers.has(worker.workerId)) {
+            this._onlineWorkers.set(worker.workerId, worker);
+            this.emit('workerOnline', worker);
+        }
+        // Route to all queue rooms
+        for (const room of this._queues.values()) {
+            room._handlePresenceJoin(data.actorTokenId, presenceData);
+        }
+    }
+    _handleRoomPresenceLeave(data) {
+        if (data.actorTokenId === this._localWorker?.actorTokenId)
+            return;
+        // Route to all queue rooms
+        for (const room of this._queues.values()) {
+            room._handlePresenceLeave(data.actorTokenId);
+        }
+    }
+    _handleRoomPresenceUpdate(data) {
+        if (data.actorTokenId === this._localWorker?.actorTokenId)
+            return;
+        const presenceData = data.presence;
+        if (!presenceData?.workerId)
+            return;
+        if (this._onlineWorkers.has(presenceData.workerId)) {
+            const worker = this._presenceToWorker(data.actorTokenId, presenceData);
+            this._onlineWorkers.set(worker.workerId, worker);
+        }
+        // Route to all queue rooms
+        for (const room of this._queues.values()) {
+            room._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._hydrateOnlineWorkers(initialState);
+            this._log('Lobby subscribed, online workers:', this._onlineWorkers.size);
+        }
+        catch (err) {
+            this._log('Lobby subscription failed:', err);
+        }
+    }
+    _handleLobbyJoin(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localWorker?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.workerId)
+            return;
+        const worker = this._presenceToWorker(actorId, presenceData);
+        this._actorToWorkerId.set(actorId, worker.workerId);
+        if (!this._onlineWorkers.has(worker.workerId)) {
+            this._onlineWorkers.set(worker.workerId, worker);
+            this.emit('workerOnline', worker);
+        }
+    }
+    _handleLobbyLeave(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localWorker?.actorTokenId)
+            return;
+        const presenceData = data;
+        const workerId = presenceData?.workerId
+            || this._actorToWorkerId.get(actorId)
+            || this._findWorkerIdByActorId(actorId);
+        if (workerId) {
+            const worker = this._onlineWorkers.get(workerId);
+            if (worker) {
+                this._onlineWorkers.delete(workerId);
+                this._actorToWorkerId.delete(actorId);
+                this.emit('workerOffline', worker);
+            }
+        }
+    }
+    _handleLobbyUpdate(event) {
+        const { actorId, data } = event;
+        if (actorId === this._localWorker?.actorTokenId)
+            return;
+        const presenceData = data;
+        if (!presenceData.workerId)
+            return;
+        const worker = this._presenceToWorker(actorId, presenceData);
+        this._onlineWorkers.set(worker.workerId, worker);
+    }
+    _hydrateOnlineWorkers(state) {
+        for (const roomId of Object.keys(state)) {
+            const roomPresence = state[roomId];
+            for (const actorId of Object.keys(roomPresence)) {
+                if (actorId === this._localWorker?.actorTokenId)
+                    continue;
+                const raw = roomPresence[actorId];
+                const presenceData = (raw?.presence ?? raw);
+                if (presenceData?.workerId) {
+                    const worker = this._presenceToWorker(actorId, presenceData);
+                    this._actorToWorkerId.set(actorId, worker.workerId);
+                    if (!this._onlineWorkers.has(worker.workerId)) {
+                        this._onlineWorkers.set(worker.workerId, worker);
+                        this.emit('workerOnline', worker);
+                    }
+                }
+            }
+        }
+    }
+    // ============ Private: Helpers ============
+    _presenceToWorker(actorTokenId, data) {
+        return {
+            workerId: data.workerId,
+            actorTokenId,
+            role: data.role,
+            activeJobs: data.activeJobs ?? 0,
+            concurrency: data.concurrency ?? 1,
+            metadata: data.metadata,
+            joinedAt: Date.now(),
+            isLocal: false,
+        };
+    }
+    _findWorkerIdByActorId(actorTokenId) {
+        for (const worker of this._onlineWorkers.values()) {
+            if (worker.actorTokenId === actorTokenId)
+                return worker.workerId;
+        }
+        return undefined;
+    }
+    _restoreQueues() {
+        // On reconnect, js-sdk auto-restores subscriptions.
+        // Re-set presence on all active queue rooms.
+        for (const room of this._queues.values()) {
+            room._updateLocalPresence();
+        }
+        // Re-fetch lobby presence
+        this._lobby?.fetchPresence().then((state) => {
+            this._onlineWorkers.clear();
+            this._actorToWorkerId.clear();
+            this._hydrateOnlineWorkers(state);
+        }).catch((err) => {
+            this._log('Failed to re-fetch lobby presence:', err);
+        });
+    }
+}
+
+exports.EventEmitter = EventEmitter;
+exports.JobStore = JobStore;
+exports.NoLagQueue = NoLagQueue;
+exports.PresenceManager = PresenceManager;
+exports.QueueRoom = QueueRoom;
+exports.WorkerManager = WorkerManager;
+//# sourceMappingURL=index.cjs.map