@api.global/typedsocket 4.1.4 → 4.2.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@api.global/typedsocket',
-    version: '4.1.4',
+    version: '4.2.1',
     description: 'A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLCtHQUErRztDQUM3SCxDQUFBIn0=

package/dist_ts/typedsocket.classes.typedsocket.d.ts

@@ -9,6 +9,7 @@ export interface ITypedSocketClientOptions {
     maxRetries?: number;
     initialBackoffMs?: number;
     maxBackoffMs?: number;
+    abortSignal?: AbortSignal;
 }
 /**
  * Wrapper for SmartServe's IWebSocketPeer to provide tag compatibility
@@ -80,7 +81,11 @@ export declare class TypedSocket {
     private serverUrl;
     private retryCount;
     private currentBackoff;
+    private stopped;
+    private abortSignalListener?;
+    private stopListeners;
     private pendingRequests;
+    private clientTags;
     private smartServeRef;
     private smartServeConnectionWrappers;
     private constructor();
@@ -104,6 +109,9 @@ export declare class TypedSocket {
      * Schedules a reconnection attempt with exponential backoff
      */
     private scheduleReconnect;
+    private shouldReconnect;
+    private waitForReconnectDelay;
+    private createAbortError;
     /**
      * Updates connection status and notifies subscribers
      */
@@ -132,6 +140,11 @@ export declare class TypedSocket {
      * @client-only
      */
     setTag<T extends plugins.typedrequestInterfaces.ITag>(name: T['name'], payload: T['payload']): Promise<void>;
+    /**
+     * Re-applies all client tags after a reconnect, since server-side tags are
+     * bound to the previous connection.
+     */
+    private reapplyClientTags;
     /**
      * Removes a tag from this client connection.
      * @client-only

package/dist_ts/typedsocket.classes.typedsocket.js

@@ -49,7 +49,22 @@ export class TypedSocket {
         typedSocket.clientOptions = opts;
         typedSocket.serverUrl = serverUrlArg;
         typedSocket.currentBackoff = opts.initialBackoffMs;
-        await typedSocket.connect();
+        if (opts.abortSignal?.aborted) {
+            throw typedSocket.createAbortError();
+        }
+        if (opts.abortSignal) {
+            typedSocket.abortSignalListener = () => {
+                void typedSocket.stop();
+            };
+            opts.abortSignal.addEventListener('abort', typedSocket.abortSignalListener, { once: true });
+        }
+        try {
+            await typedSocket.connect();
+        }
+        catch (error) {
+            await typedSocket.stop();
+            throw error;
+        }
         return typedSocket;
     }
     /**
@@ -129,7 +144,12 @@ export class TypedSocket {
         this.serverUrl = '';
         this.retryCount = 0;
         this.currentBackoff = 1000;
+        this.stopped = false;
+        this.stopListeners = new Set();
         this.pendingRequests = new Map();
+        // Tags set via setTag(), kept client-side so reconnects can restore them on
+        // the fresh server-side connection (server tags die with the old socket).
+        this.clientTags = new Map();
         // Server-specific properties (SmartServe mode)
         this.smartServeRef = null;
         this.smartServeConnectionWrappers = new Map();
@@ -143,33 +163,70 @@ export class TypedSocket {
      * Connects the client to the server using native WebSocket
      */
     async connect() {
+        if (this.stopped || this.clientOptions?.abortSignal?.aborted) {
+            throw this.createAbortError();
+        }
         const done = plugins.smartpromise.defer();
+        let connectionSettled = false;
+        let connectionTimeout;
+        let abortConnection;
+        const settleConnection = (errorArg) => {
+            if (connectionSettled) {
+                return;
+            }
+            connectionSettled = true;
+            if (connectionTimeout) {
+                clearTimeout(connectionTimeout);
+            }
+            if (abortConnection) {
+                this.stopListeners.delete(abortConnection);
+                this.clientOptions?.abortSignal?.removeEventListener('abort', abortConnection);
+            }
+            if (errorArg) {
+                done.reject(errorArg);
+            }
+            else {
+                done.resolve();
+            }
+        };
         this.updateStatus('connecting');
         // Convert HTTP URL to WebSocket URL
         const wsUrl = this.toWebSocketUrl(this.serverUrl);
         console.log(`TypedSocket connecting to ${wsUrl}...`);
         this.websocket = new WebSocket(wsUrl);
-        const connectionTimeout = setTimeout(() => {
+        abortConnection = () => {
+            this.websocket?.close();
+            settleConnection(this.createAbortError());
+        };
+        this.stopListeners.add(abortConnection);
+        this.clientOptions?.abortSignal?.addEventListener('abort', abortConnection, { once: true });
+        connectionTimeout = setTimeout(() => {
             if (this.connectionStatus !== 'connected') {
                 console.warn('TypedSocket connection timeout');
                 this.websocket?.close();
-                done.reject(new Error('Connection timeout'));
+                settleConnection(new Error('Connection timeout'));
             }
         }, 10000);
         this.websocket.onopen = () => {
-            clearTimeout(connectionTimeout);
             console.log('TypedSocket connected!');
             this.updateStatus('connected');
             this.retryCount = 0;
             this.currentBackoff = this.clientOptions?.initialBackoffMs ?? 1000;
-            done.resolve();
+            settleConnection();
+            void this.reapplyClientTags();
         };
         this.websocket.onmessage = async (event) => {
             await this.handleMessage(event.data);
         };
         this.websocket.onclose = () => {
-            clearTimeout(connectionTimeout);
-            this.handleDisconnect();
+            if (this.connectionStatus === 'connected') {
+                this.handleDisconnect();
+            }
+            else {
+                settleConnection(this.stopped || this.clientOptions?.abortSignal?.aborted
+                    ? this.createAbortError()
+                    : new Error('TypedSocket connection closed before it opened'));
+            }
         };
         this.websocket.onerror = (error) => {
             console.error('TypedSocket WebSocket error:', error);
@@ -178,9 +235,14 @@ export class TypedSocket {
             await done.promise;
         }
         catch (err) {
-            clearTimeout(connectionTimeout);
-            if (this.clientOptions?.autoReconnect) {
+            if (connectionTimeout) {
+                clearTimeout(connectionTimeout);
+            }
+            if (this.shouldReconnect()) {
                 await this.scheduleReconnect();
+                if (this.connectionStatus !== 'connected') {
+                    throw this.stopped || this.clientOptions?.abortSignal?.aborted ? this.createAbortError() : err;
+                }
             }
             else {
                 throw err;
@@ -232,7 +294,7 @@ export class TypedSocket {
             pending.reject(new Error('TypedSocket disconnected'));
         }
         this.pendingRequests.clear();
-        if (this.clientOptions?.autoReconnect && this.retryCount < this.clientOptions.maxRetries) {
+        if (this.shouldReconnect()) {
             this.scheduleReconnect();
         }
     }
@@ -240,17 +302,20 @@ export class TypedSocket {
      * Schedules a reconnection attempt with exponential backoff
      */
     async scheduleReconnect() {
-        if (!this.clientOptions)
+        if (!this.shouldReconnect())
             return;
+        const clientOptions = this.clientOptions;
         this.updateStatus('reconnecting');
         this.retryCount++;
         // Exponential backoff with jitter
         const jitter = this.currentBackoff * 0.2 * (Math.random() * 2 - 1);
-        const delay = Math.min(this.currentBackoff + jitter, this.clientOptions.maxBackoffMs);
-        console.log(`TypedSocket reconnecting in ${Math.round(delay)}ms (attempt ${this.retryCount}/${this.clientOptions.maxRetries})`);
-        await plugins.smartdelay.delayFor(delay);
+        const delay = Math.min(this.currentBackoff + jitter, clientOptions.maxBackoffMs);
+        console.log(`TypedSocket reconnecting in ${Math.round(delay)}ms (attempt ${this.retryCount}/${clientOptions.maxRetries})`);
+        await this.waitForReconnectDelay(delay);
+        if (!this.shouldReconnect())
+            return;
         // Increase backoff for next time
-        this.currentBackoff = Math.min(this.currentBackoff * 2, this.clientOptions.maxBackoffMs);
+        this.currentBackoff = Math.min(this.currentBackoff * 2, clientOptions.maxBackoffMs);
         try {
             await this.connect();
         }
@@ -258,6 +323,43 @@ export class TypedSocket {
             console.error('TypedSocket reconnection failed:', err);
         }
     }
+    shouldReconnect() {
+        return Boolean(this.clientOptions?.autoReconnect &&
+            !this.stopped &&
+            !this.clientOptions.abortSignal?.aborted &&
+            this.retryCount < this.clientOptions.maxRetries);
+    }
+    async waitForReconnectDelay(delayMsArg) {
+        await new Promise((resolve) => {
+            let timeout;
+            let finished = false;
+            const finish = () => {
+                if (finished)
+                    return;
+                finished = true;
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                this.stopListeners.delete(finish);
+                this.clientOptions?.abortSignal?.removeEventListener('abort', finish);
+                resolve();
+            };
+            if (this.clientOptions?.abortSignal?.aborted) {
+                finish();
+                return;
+            }
+            if (this.stopped) {
+                finish();
+                return;
+            }
+            timeout = setTimeout(finish, delayMsArg);
+            this.stopListeners.add(finish);
+            this.clientOptions?.abortSignal?.addEventListener('abort', finish, { once: true });
+        });
+    }
+    createAbortError() {
+        return new Error('TypedSocket client startup aborted');
+    }
     /**
      * Updates connection status and notifies subscribers
      */
@@ -307,8 +409,9 @@ export class TypedSocket {
      */
     createTypedRequest(methodName, targetConnection) {
         const postMethod = async (requestDataArg) => {
+            const typedRequestData = requestDataArg;
             if (this.side === 'client') {
-                return this.sendRequest(requestDataArg);
+                return this.sendRequest(typedRequestData);
             }
             // Server-side: send to target connection
             if (!this.smartServeRef) {
@@ -328,10 +431,14 @@ export class TypedSocket {
                     throw new Error('Multiple connections available - specify targetConnection');
                 }
             }
+            typedRequestData.correlation ||= {
+                id: plugins.smartstring.create.createCryptoRandomString(),
+                phase: 'request',
+            };
             // Register interest for response
-            const interest = await this.typedrouter.fireEventInterestMap.addInterest(requestDataArg.correlation.id, requestDataArg);
+            const interest = await this.typedrouter.fireEventInterestMap.addInterest(typedRequestData.correlation.id, typedRequestData);
             // Send request
-            target.peer.send(plugins.smartjson.stringify(requestDataArg));
+            target.peer.send(plugins.smartjson.stringify(typedRequestData));
             // Wait for response
             return await interest.interestFullfilled;
         };
@@ -348,13 +455,25 @@ export class TypedSocket {
      */
     async stop() {
         if (this.side === 'client') {
+            this.stopped = true;
+            for (const stopListener of Array.from(this.stopListeners)) {
+                stopListener();
+            }
+            this.stopListeners.clear();
             if (this.clientOptions) {
                 this.clientOptions.autoReconnect = false;
+                if (this.clientOptions.abortSignal && this.abortSignalListener) {
+                    this.clientOptions.abortSignal.removeEventListener('abort', this.abortSignalListener);
+                }
             }
+            this.abortSignalListener = undefined;
             if (this.websocket) {
                 this.websocket.close();
                 this.websocket = null;
             }
+            for (const pendingRequest of this.pendingRequests.values()) {
+                pendingRequest.reject(new Error('TypedSocket stopped'));
+            }
             this.pendingRequests.clear();
         }
         else {
@@ -379,6 +498,25 @@ export class TypedSocket {
         if (!response.success) {
             throw new Error('Failed to set tag on server');
         }
+        this.clientTags.set(name, payload);
+    }
+    /**
+     * Re-applies all client tags after a reconnect, since server-side tags are
+     * bound to the previous connection.
+     */
+    async reapplyClientTags() {
+        for (const [name, payload] of this.clientTags) {
+            try {
+                const request = this.createTypedRequest('__typedsocket_setTag');
+                const response = await request.fire({ name, payload });
+                if (!response.success) {
+                    console.warn(`TypedSocket failed to restore tag ${name} after reconnect`);
+                }
+            }
+            catch (error) {
+                console.warn(`TypedSocket failed to restore tag ${name} after reconnect: ${error.message}`);
+            }
+        }
     }
     /**
      * Removes a tag from this client connection.
@@ -393,6 +531,7 @@ export class TypedSocket {
         if (!response.success) {
             throw new Error('Failed to remove tag on server');
         }
+        this.clientTags.delete(name);
     }
     // ============================================================================
     // SERVER-ONLY METHODS
@@ -465,4 +604,4 @@ export class TypedSocket {
         return allResults[0];
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typedsocket.classes.typedsocket.js","sourceRoot":"","sources":["../ts/typedsocket.classes.typedsocket.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typedsocket.classes.typedsocket.js","sourceRoot":"","sources":["../ts/typedsocket.classes.typedsocket.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@api.global/typedsocket",
-  "version": "4.1.4",
+  "version": "4.2.1",
   "private": false,
   "description": "A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.",
   "main": "dist_ts/index.js",
@@ -8,15 +8,19 @@
   "type": "module",
   "author": "Lossless GmbH",
   "license": "MIT",
+  "scripts": {
+    "test": "(tstest test/ --verbose)",
+    "build": "(tsbuild --web --allowimplicitany --skiplibcheck)",
+    "buildDocs": "tsdoc"
+  },
   "devDependencies": {
-    "@git.zone/tsbuild": "^3.1.2",
-    "@git.zone/tsbundle": "^2.6.3",
-    "@git.zone/tsrun": "^2.0.0",
-    "@git.zone/tstest": "^3.1.3",
+    "@git.zone/tsbuild": "^4.4.2",
+    "@git.zone/tsbundle": "^2.10.4",
+    "@git.zone/tsrun": "^2.0.4",
+    "@git.zone/tstest": "^3.6.6",
     "@push.rocks/smartenv": "^6.0.0",
     "@push.rocks/smartserve": "^1.1.2",
-    "@push.rocks/tapbundle": "^6.0.3",
-    "@types/node": "^24.10.1"
+    "@types/node": "25.9.1"
   },
   "dependencies": {
     "@api.global/typedrequest": "^3.1.11",
@@ -54,9 +58,5 @@
     "TypeScript",
     "Networking"
   ],
-  "scripts": {
-    "test": "(tstest test/ --verbose)",
-    "build": "(tsbuild --web --allowimplicitany --skiplibcheck)",
-    "buildDocs": "tsdoc"
-  }
-}
+  "packageManager": "pnpm@10.18.1+sha512.77a884a165cbba2d8d1c19e3b4880eee6d2fcabd0d879121e282196b80042351d5eb3ca0935fa599da1dc51265cc68816ad2bddd2a2de5ea9fdf92adbec7cd34"
+}

package/readme.md

@@ -58,11 +58,12 @@ interface IGreetingRequest extends typedrequestInterfaces.implementsTR<
 
 ### Server Setup
 
-Create a WebSocket server that handles typed requests:
+TypedSocket binds to a SmartServe WebSocket server. Create the SmartServe instance with a typed router, then expose it through `TypedSocket.fromSmartServe()`:
 
 ```typescript
 import { TypedSocket } from '@api.global/typedsocket';
 import * as typedrequest from '@api.global/typedrequest';
+import { SmartServe } from '@push.rocks/smartserve';
 
 // Create the router and add handlers
 const typedRouter = new typedrequest.TypedRouter();
@@ -75,8 +76,15 @@ typedRouter.addTypedHandler<IGreetingRequest>(
   })
 );
 
-// Start the TypedSocket server (defaults to port 3000)
-const server = await TypedSocket.createServer(typedRouter);
+const smartServe = new SmartServe({
+  port: 3000,
+  websocket: {
+    typedRouter,
+  },
+});
+await smartServe.start();
+
+const server = TypedSocket.fromSmartServe(smartServe, typedRouter);
 ```
 
 #### Integration with SmartServe
@@ -142,6 +150,33 @@ const client = await TypedSocket.createClient(
 );
 ```
 
+#### Abortable Startup
+
+Pass an `AbortSignal` when startup or reconnect attempts must be cancellable. Aborting stops the in-flight WebSocket and prevents queued reconnect attempts from continuing.
+
+```typescript
+const abortController = new AbortController();
+
+const clientPromise = TypedSocket.createClient(
+  clientRouter,
+  'http://localhost:3000',
+  {
+    abortSignal: abortController.signal,
+    initialBackoffMs: 1000,
+    maxRetries: 10,
+  }
+);
+
+// Later, if the connection attempt should no longer continue:
+abortController.abort();
+
+try {
+  const client = await clientPromise;
+} catch (error) {
+  // Startup was aborted before a stable connection was established.
+}
+```
+
 #### Using Window Location (Browser)
 
 In browser environments, you can automatically use the current page's origin:
@@ -196,7 +231,7 @@ interface IUserTag extends typedrequestInterfaces.ITag {
   payload: 'admin' | 'user' | 'guest';
 }
 
-client.addTag<IUserTag>('userRole', 'admin');
+await client.setTag<IUserTag>('userRole', 'admin');
 ```
 
 ```typescript
@@ -221,11 +256,11 @@ const firstAdmin = await server.findTargetConnectionByTag<IUserTag>('userRole',
 Subscribe to connection status events:
 
 ```typescript
-client.eventSubject.subscribe((status) => {
+client.statusSubject.subscribe((status) => {
   console.log('Connection status:', status);
 });
 
-server.eventSubject.subscribe((status) => {
+server.statusSubject.subscribe((status) => {
   console.log('Server connection event:', status);
 });
 ```
@@ -238,8 +273,8 @@ Properly close connections when done:
 // Client
 await client.stop();
 
-// Server
-await server.stop();
+// SmartServe owns the server-side WebSocket lifecycle
+await smartServe.stop();
 ```
 
 ## API Reference
@@ -250,8 +285,7 @@ await server.stop();
 
 | Method | Description |
 |--------|-------------|
-| `createServer(router)` | Creates a WebSocket server (defaults to port 3000). |
-| `createClient(router, serverUrl, alias?)` | Creates a WebSocket client that connects to the specified server URL. |
+| `createClient(router, serverUrl, options?)` | Creates a WebSocket client that connects to the specified server URL. Options include `autoReconnect`, `maxRetries`, `initialBackoffMs`, `maxBackoffMs`, and `abortSignal`. |
 | `fromSmartServe(smartServe, router)` | Creates a TypedSocket bound to an existing SmartServe instance. |
 | `useWindowLocationOriginUrl()` | Returns the current window location origin (browser only). |
 
@@ -261,14 +295,15 @@ await server.stop();
 |----------|-------------|
 | `side` | Whether this instance is a `'server'` or `'client'`. |
 | `typedrouter` | The TypedRouter instance handling requests. |
-| `eventSubject` | RxJS Subject for connection status events. |
+| `statusSubject` | RxJS Subject for connection status events. |
 
 #### Instance Methods
 
 | Method | Description |
 |--------|-------------|
 | `createTypedRequest(method, targetConnection?)` | Creates a typed request for the specified method. |
-| `addTag(name, payload)` | Adds a tag to the client connection (client-side only). |
+| `setTag(name, payload)` | Sets a tag on the client connection (client-side only). |
+| `removeTag(name)` | Removes a tag from the client connection (client-side only). |
 | `findAllTargetConnections(filterFn)` | Finds all connections matching the filter (server-side only). |
 | `findTargetConnection(filterFn)` | Finds the first connection matching the filter (server-side only). |
 | `findAllTargetConnectionsByTag(key, payload?)` | Finds all connections with the specified tag. |
@@ -277,7 +312,7 @@ await server.stop();
 
 ## License and Legal Information
 
-This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](./license) file.
 
 **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@api.global/typedsocket',
-  version: '4.1.4',
+  version: '4.2.1',
   description: 'A library for creating typed WebSocket connections, supporting bi-directional communication with type safety.'
 }

package/ts/typedsocket.classes.typedsocket.ts

@@ -28,6 +28,7 @@ export interface ITypedSocketClientOptions {
   maxRetries?: number;
   initialBackoffMs?: number;
   maxBackoffMs?: number;
+  abortSignal?: AbortSignal;
 }
 
 /**
@@ -82,7 +83,7 @@ export class TypedSocket {
     serverUrlArg: string,
     options: ITypedSocketClientOptions = {}
   ): Promise<TypedSocket> {
-    const defaultOptions: Required<ITypedSocketClientOptions> = {
+    const defaultOptions: Omit<Required<ITypedSocketClientOptions>, 'abortSignal'> = {
       autoReconnect: true,
       maxRetries: 100,
       initialBackoffMs: 1000,
@@ -95,7 +96,22 @@ export class TypedSocket {
     typedSocket.serverUrl = serverUrlArg;
     typedSocket.currentBackoff = opts.initialBackoffMs;
 
-    await typedSocket.connect();
+    if (opts.abortSignal?.aborted) {
+      throw typedSocket.createAbortError();
+    }
+    if (opts.abortSignal) {
+      typedSocket.abortSignalListener = () => {
+        void typedSocket.stop();
+      };
+      opts.abortSignal.addEventListener('abort', typedSocket.abortSignalListener, { once: true });
+    }
+
+    try {
+      await typedSocket.connect();
+    } catch (error) {
+      await typedSocket.stop();
+      throw error;
+    }
 
     return typedSocket;
   }
@@ -195,14 +211,20 @@ export class TypedSocket {
 
   // Client-specific properties
   private websocket: WebSocket | null = null;
-  private clientOptions: Required<ITypedSocketClientOptions> | null = null;
+  private clientOptions: (Omit<Required<ITypedSocketClientOptions>, 'abortSignal'> & Pick<ITypedSocketClientOptions, 'abortSignal'>) | null = null;
   private serverUrl: string = '';
   private retryCount = 0;
   private currentBackoff = 1000;
+  private stopped = false;
+  private abortSignalListener?: () => void;
+  private stopListeners = new Set<() => void>();
   private pendingRequests = new Map<string, {
     resolve: (response: any) => void;
     reject: (error: Error) => void;
   }>();
+  // Tags set via setTag(), kept client-side so reconnects can restore them on
+  // the fresh server-side connection (server tags die with the old socket).
+  private clientTags = new Map<string, unknown>();
 
   // Server-specific properties (SmartServe mode)
   private smartServeRef: plugins.SmartServe | null = null;
@@ -228,7 +250,33 @@ export class TypedSocket {
    * Connects the client to the server using native WebSocket
    */
   private async connect(): Promise<void> {
+    if (this.stopped || this.clientOptions?.abortSignal?.aborted) {
+      throw this.createAbortError();
+    }
+
     const done = plugins.smartpromise.defer<void>();
+    let connectionSettled = false;
+    let connectionTimeout: ReturnType<typeof setTimeout> | undefined;
+    let abortConnection: (() => void) | undefined;
+
+    const settleConnection = (errorArg?: Error) => {
+      if (connectionSettled) {
+        return;
+      }
+      connectionSettled = true;
+      if (connectionTimeout) {
+        clearTimeout(connectionTimeout);
+      }
+      if (abortConnection) {
+        this.stopListeners.delete(abortConnection);
+        this.clientOptions?.abortSignal?.removeEventListener('abort', abortConnection);
+      }
+      if (errorArg) {
+        done.reject(errorArg);
+      } else {
+        done.resolve();
+      }
+    };
 
     this.updateStatus('connecting');
 
@@ -238,21 +286,28 @@ export class TypedSocket {
 
     this.websocket = new WebSocket(wsUrl);
 
-    const connectionTimeout = setTimeout(() => {
+    abortConnection = () => {
+      this.websocket?.close();
+      settleConnection(this.createAbortError());
+    };
+    this.stopListeners.add(abortConnection);
+    this.clientOptions?.abortSignal?.addEventListener('abort', abortConnection, { once: true });
+
+    connectionTimeout = setTimeout(() => {
       if (this.connectionStatus !== 'connected') {
         console.warn('TypedSocket connection timeout');
         this.websocket?.close();
-        done.reject(new Error('Connection timeout'));
+        settleConnection(new Error('Connection timeout'));
       }
     }, 10000);
 
     this.websocket.onopen = () => {
-      clearTimeout(connectionTimeout);
       console.log('TypedSocket connected!');
       this.updateStatus('connected');
       this.retryCount = 0;
       this.currentBackoff = this.clientOptions?.initialBackoffMs ?? 1000;
-      done.resolve();
+      settleConnection();
+      void this.reapplyClientTags();
     };
 
     this.websocket.onmessage = async (event) => {
@@ -260,8 +315,13 @@ export class TypedSocket {
     };
 
     this.websocket.onclose = () => {
-      clearTimeout(connectionTimeout);
-      this.handleDisconnect();
+      if (this.connectionStatus === 'connected') {
+        this.handleDisconnect();
+      } else {
+        settleConnection(this.stopped || this.clientOptions?.abortSignal?.aborted
+          ? this.createAbortError()
+          : new Error('TypedSocket connection closed before it opened'));
+      }
     };
 
     this.websocket.onerror = (error) => {
@@ -271,9 +331,14 @@ export class TypedSocket {
     try {
       await done.promise;
     } catch (err) {
-      clearTimeout(connectionTimeout);
-      if (this.clientOptions?.autoReconnect) {
+      if (connectionTimeout) {
+        clearTimeout(connectionTimeout);
+      }
+      if (this.shouldReconnect()) {
         await this.scheduleReconnect();
+        if (this.connectionStatus !== 'connected') {
+          throw this.stopped || this.clientOptions?.abortSignal?.aborted ? this.createAbortError() : err;
+        }
       } else {
         throw err;
       }
@@ -331,7 +396,7 @@ export class TypedSocket {
     }
     this.pendingRequests.clear();
 
-    if (this.clientOptions?.autoReconnect && this.retryCount < this.clientOptions.maxRetries) {
+    if (this.shouldReconnect()) {
       this.scheduleReconnect();
     }
   }
@@ -340,21 +405,24 @@ export class TypedSocket {
    * Schedules a reconnection attempt with exponential backoff
    */
   private async scheduleReconnect(): Promise<void> {
-    if (!this.clientOptions) return;
+    if (!this.shouldReconnect()) return;
+    const clientOptions = this.clientOptions!;
 
     this.updateStatus('reconnecting');
     this.retryCount++;
 
     // Exponential backoff with jitter
     const jitter = this.currentBackoff * 0.2 * (Math.random() * 2 - 1);
-    const delay = Math.min(this.currentBackoff + jitter, this.clientOptions.maxBackoffMs);
+    const delay = Math.min(this.currentBackoff + jitter, clientOptions.maxBackoffMs);
 
-    console.log(`TypedSocket reconnecting in ${Math.round(delay)}ms (attempt ${this.retryCount}/${this.clientOptions.maxRetries})`);
+    console.log(`TypedSocket reconnecting in ${Math.round(delay)}ms (attempt ${this.retryCount}/${clientOptions.maxRetries})`);
 
-    await plugins.smartdelay.delayFor(delay);
+    await this.waitForReconnectDelay(delay);
+
+    if (!this.shouldReconnect()) return;
 
     // Increase backoff for next time
-    this.currentBackoff = Math.min(this.currentBackoff * 2, this.clientOptions.maxBackoffMs);
+    this.currentBackoff = Math.min(this.currentBackoff * 2, clientOptions.maxBackoffMs);
 
     try {
       await this.connect();
@@ -363,6 +431,47 @@ export class TypedSocket {
     }
   }
 
+  private shouldReconnect(): boolean {
+    return Boolean(
+      this.clientOptions?.autoReconnect &&
+      !this.stopped &&
+      !this.clientOptions.abortSignal?.aborted &&
+      this.retryCount < this.clientOptions.maxRetries,
+    );
+  }
+
+  private async waitForReconnectDelay(delayMsArg: number): Promise<void> {
+    await new Promise<void>((resolve) => {
+      let timeout: ReturnType<typeof setTimeout> | undefined;
+      let finished = false;
+      const finish = () => {
+        if (finished) return;
+        finished = true;
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        this.stopListeners.delete(finish);
+        this.clientOptions?.abortSignal?.removeEventListener('abort', finish);
+        resolve();
+      };
+      if (this.clientOptions?.abortSignal?.aborted) {
+        finish();
+        return;
+      }
+      if (this.stopped) {
+        finish();
+        return;
+      }
+      timeout = setTimeout(finish, delayMsArg);
+      this.stopListeners.add(finish);
+      this.clientOptions?.abortSignal?.addEventListener('abort', finish, { once: true });
+    });
+  }
+
+  private createAbortError(): Error {
+    return new Error('TypedSocket client startup aborted');
+  }
+
   /**
    * Updates connection status and notifies subscribers
    */
@@ -423,9 +532,12 @@ export class TypedSocket {
     methodName: T['method'],
     targetConnection?: ISmartServeConnectionWrapper
   ): plugins.typedrequest.TypedRequest<T> {
-    const postMethod = async (requestDataArg: T): Promise<T> => {
+    const postMethod = async (
+      requestDataArg: plugins.typedrequestInterfaces.ITypedRequest,
+    ): Promise<plugins.typedrequestInterfaces.ITypedRequest> => {
+      const typedRequestData = requestDataArg as T;
       if (this.side === 'client') {
-        return this.sendRequest(requestDataArg);
+        return this.sendRequest(typedRequestData);
       }
 
       // Server-side: send to target connection
@@ -446,14 +558,19 @@ export class TypedSocket {
         }
       }
 
+      typedRequestData.correlation ||= {
+        id: plugins.smartstring.create.createCryptoRandomString(),
+        phase: 'request',
+      };
+
       // Register interest for response
       const interest = await this.typedrouter.fireEventInterestMap.addInterest(
-        requestDataArg.correlation.id,
-        requestDataArg
+        typedRequestData.correlation.id,
+        typedRequestData,
       );
 
       // Send request
-      target.peer.send(plugins.smartjson.stringify(requestDataArg));
+      target.peer.send(plugins.smartjson.stringify(typedRequestData));
 
       // Wait for response
       return await interest.interestFullfilled as T;
@@ -477,13 +594,25 @@ export class TypedSocket {
    */
   public async stop(): Promise<void> {
     if (this.side === 'client') {
+      this.stopped = true;
+      for (const stopListener of Array.from(this.stopListeners)) {
+        stopListener();
+      }
+      this.stopListeners.clear();
       if (this.clientOptions) {
         this.clientOptions.autoReconnect = false;
+        if (this.clientOptions.abortSignal && this.abortSignalListener) {
+          this.clientOptions.abortSignal.removeEventListener('abort', this.abortSignalListener);
+        }
       }
+      this.abortSignalListener = undefined;
       if (this.websocket) {
         this.websocket.close();
         this.websocket = null;
       }
+      for (const pendingRequest of this.pendingRequests.values()) {
+        pendingRequest.reject(new Error('TypedSocket stopped'));
+      }
       this.pendingRequests.clear();
     } else {
       // Server mode - just clear wrappers (SmartServe manages its own lifecycle)
@@ -514,6 +643,25 @@ export class TypedSocket {
     if (!response.success) {
       throw new Error('Failed to set tag on server');
     }
+    this.clientTags.set(name, payload);
+  }
+
+  /**
+   * Re-applies all client tags after a reconnect, since server-side tags are
+   * bound to the previous connection.
+   */
+  private async reapplyClientTags(): Promise<void> {
+    for (const [name, payload] of this.clientTags) {
+      try {
+        const request = this.createTypedRequest<IReq_SetClientTag>('__typedsocket_setTag');
+        const response = await request.fire({ name, payload });
+        if (!response.success) {
+          console.warn(`TypedSocket failed to restore tag ${name} after reconnect`);
+        }
+      } catch (error) {
+        console.warn(`TypedSocket failed to restore tag ${name} after reconnect: ${(error as Error).message}`);
+      }
+    }
   }
 
   /**
@@ -531,6 +679,7 @@ export class TypedSocket {
     if (!response.success) {
       throw new Error('Failed to remove tag on server');
     }
+    this.clientTags.delete(name);
   }
 
   // ============================================================================