@itookit/dsht 0.5.1 → 0.5.2

package/dist/transport/client.js

@@ -22,7 +22,7 @@ export class RemoteError extends Error {
         this.details = error.details;
     }
 }
-/** A single authenticated host connection; close before reconnecting or exiting. */
+/** One client lifetime. Peer disconnects allow reconnect; close permanently ends the lifetime. */
 export class Client {
     timeoutMs;
     base;
@@ -31,6 +31,7 @@ export class Client {
     socket;
     listeners = new Map();
     lifetime = new AbortController();
+    closeTask;
     constructor(base, timeoutMs = 15_000) {
         this.timeoutMs = timeoutMs;
         this.base = new URL(base);
@@ -117,13 +118,17 @@ export class Client {
     }
     /** Connect the physical mux. A disconnected instance may reconnect with its cookie. */
     async connect() {
+        this.lifetime.signal.throwIfAborted();
         if (this.socket)
             throw new Error('Mux is already connected');
         const url = new URL('/api/remote.mux', this.base);
         url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
         const socket = new WebSocket(url, { headers: { cookie: this.cookie }, handshakeTimeout: this.timeoutMs });
         this.socket = socket;
+        const closed = new Promise(resolve => socket.once('close', () => resolve()));
         socket.on('message', (raw, binary) => {
+            if (this.socket !== socket || this.lifetime.signal.aborted)
+                return;
             try {
                 if (binary)
                     throw new Error('Unexpected binary mux frame');
@@ -154,22 +159,40 @@ export class Client {
                 socket.terminate();
             }
         });
-        socket.on('error', error => this.fail(error));
+        socket.on('error', error => { if (this.socket === socket)
+            this.fail(error); });
         socket.on('close', () => {
-            if (this.socket === socket)
-                this.socket = undefined;
+            if (this.socket !== socket)
+                return;
+            this.socket = undefined;
             this.fail(new Error('Connection closed'));
         });
-        await once(socket, 'open');
+        try {
+            await once(socket, 'open', { signal: this.lifetime.signal });
+            this.lifetime.signal.throwIfAborted();
+        }
+        catch (error) {
+            if (socket.readyState !== WebSocket.CLOSED)
+                socket.terminate();
+            await closed;
+            throw error;
+        }
     }
     /** Subscribe on the existing mux; each subscription has a fresh stream identity. */
     subscribe(endpoint, args, listener) {
+        this.lifetime.signal.throwIfAborted();
         const socket = this.socket;
         if (socket?.readyState !== WebSocket.OPEN)
             throw new Error('Mux is not connected');
         const streamId = randomUUID();
         this.listeners.set(streamId, listener);
-        socket.send(JSON.stringify({ type: 'open', streamId, endpoint, payload: { args } }));
+        try {
+            socket.send(JSON.stringify({ type: 'open', streamId, endpoint, payload: { args } }));
+        }
+        catch (error) {
+            this.listeners.delete(streamId);
+            throw error;
+        }
         return { cancel: () => {
                 if (!this.listeners.delete(streamId))
                     return;
@@ -180,57 +203,80 @@ export class Client {
     /** Archived session IDs from the latest authoritative workspace baseline. */
     archivedSessionIds = new Set();
     /** List workspaces by consuming and cancelling the authoritative opening baseline. */
-    async listWorkspaces() {
+    async listWorkspaces(signal) {
+        signal?.throwIfAborted();
         return new Promise((resolve, reject) => {
             let sub;
-            const timer = setTimeout(() => { sub.cancel(); reject(new Error('Workspace baseline timed out')); }, this.timeoutMs);
+            let settled = false;
+            const finish = (error, items) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', cancel);
+                sub?.cancel();
+                if (error !== undefined)
+                    reject(error);
+                else
+                    resolve(items);
+            };
+            const cancel = () => finish(signal.reason);
+            const timer = setTimeout(() => finish(new Error('Workspace baseline timed out')), this.timeoutMs);
+            signal?.addEventListener('abort', cancel, { once: true });
             try {
                 sub = this.subscribe('workspace/follow', {}, {
                     item: value => {
-                        clearTimeout(timer);
-                        sub.cancel();
+                        if (settled)
+                            return;
                         try {
                             const frame = object(value);
                             if (frame.type !== 'baseline')
                                 throw new Error('Workspace stream omitted its baseline');
                             this.archivedSessionIds = new Set(array(object(frame.value).archivedSessionIds).map(string));
-                            resolve(array(object(frame.value).items).map(object));
+                            finish(undefined, array(object(frame.value).items).map(object));
                         }
                         catch (error) {
-                            reject(error);
+                            finish(error);
                         }
                     },
-                    end: error => { clearTimeout(timer); reject(error ?? new Error('Workspace stream ended before baseline')); },
+                    end: error => finish(error ?? new Error('Workspace stream ended before baseline')),
                 });
+                if (settled)
+                    sub.cancel();
             }
             catch (error) {
-                clearTimeout(timer);
-                reject(error);
+                finish(error);
             }
         });
     }
     /** List visible sessions, optionally filtering by the workspace's accounted IDs. */
-    async listSessions(workspaceId) {
-        const sessions = array(object(await this.call('session/list', { _request: {} })).items).map(object);
+    async listSessions(workspaceId, signal) {
+        const sessions = array(object(await this.call('session/list', { _request: {} }, signal)).items).map(object);
         if (!workspaceId)
             return sessions;
-        const workspace = (await this.listWorkspaces()).find(item => item.workspaceId === workspaceId);
+        const workspace = (await this.listWorkspaces(signal)).find(item => item.workspaceId === workspaceId);
         if (!workspace)
             throw new Error(`Workspace not found: ${workspaceId}`);
         const ids = new Set(array(workspace.sessionIds).map(string));
         return sessions.filter(item => ids.has(string(item.sessionId)));
     }
     /** Close all streams, abort in-flight HTTP, and await the physical socket's closure. */
-    async close() {
-        this.lifetime.abort();
+    close() {
+        if (this.closeTask)
+            return this.closeTask;
         const socket = this.socket;
         this.socket = undefined;
+        // Reserve before publishing cancellation: termination callbacks may themselves call close.
+        this.closeTask = Promise.resolve().then(async () => {
+            if (socket && socket.readyState !== WebSocket.CLOSED) {
+                const closed = new Promise(resolve => socket.once('close', () => resolve()));
+                socket.terminate();
+                await closed;
+            }
+        });
+        this.lifetime.abort();
         this.fail(new Error('Client closed'));
-        if (socket && socket.readyState !== WebSocket.CLOSED) {
-            const closed = new Promise(resolve => socket.once('close', () => resolve()));
-            socket.terminate();
-            await closed;
-        }
+        return this.closeTask;
     }
     signal(timeoutMs = this.timeoutMs) {
         return timeoutMs === null ? this.lifetime.signal : AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(timeoutMs)]);