@lemoncloud/chatic-sockets-lib 0.1.0 → 0.2.1

package/dist/client-socket-v2/keep-alive-loop.js

@@ -10,12 +10,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeepAliveLoop = void 0;
+const DEFAULT_PING_TIMEOUT_MS = 10000;
+const DEFAULT_MAX_MISSED_PONGS = 2;
 class KeepAliveLoop {
     constructor(options) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         this.options = options;
         this.unsubs = [];
         this.running = false;
+        this.missedPongs = 0;
         this.start = () => {
             this.running = true;
             if (this.options.client.state === 'connected')
@@ -55,12 +58,12 @@ class KeepAliveLoop {
             this.timer = undefined;
         };
         this.tick = () => __awaiter(this, void 0, void 0, function* () {
-            var _d, _e, _f;
+            var _f, _g, _h;
             if (!this.running || this.options.client.state !== 'connected')
                 return;
             if (this.inFlight)
                 return;
-            const payload = (_f = (_e = (_d = this.options).buildPayload) === null || _e === void 0 ? void 0 : _e.call(_d)) !== null && _f !== void 0 ? _f : null;
+            const payload = (_h = (_g = (_f = this.options).buildPayload) === null || _g === void 0 ? void 0 : _g.call(_f)) !== null && _h !== void 0 ? _h : null;
             this.inFlight = Promise.resolve()
                 .then(() => __awaiter(this, void 0, void 0, function* () {
                 if (this.mode === 'send') {
@@ -68,10 +71,24 @@ class KeepAliveLoop {
                     return;
                 }
                 yield this.options.client.request('system.ping', payload, {
-                    timeoutMs: this.options.timeoutMs,
+                    timeoutMs: this.pingTimeoutMs,
                 });
+                this.missedPongs = 0;
+            }))
+                .catch(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.mode !== 'request')
+                    return;
+                this.missedPongs += 1;
+                if (this.missedPongs < this.maxMissedPongs)
+                    return;
+                this.missedPongs = 0;
+                if (this.options.onPongTimeout) {
+                    yield Promise.resolve(this.options.onPongTimeout()).catch(() => undefined);
+                }
+                else {
+                    yield this.options.client.disconnect(1001, 'pong-timeout').catch(() => undefined);
+                }
             }))
-                .catch(() => undefined)
                 .then(() => {
                 this.inFlight = undefined;
                 this.scheduleNext();
@@ -79,14 +96,20 @@ class KeepAliveLoop {
             yield this.inFlight;
         });
         this.intervalMs = (_a = options.intervalMs) !== null && _a !== void 0 ? _a : 30000;
-        this.mode = (_b = options.mode) !== null && _b !== void 0 ? _b : 'request';
+        this.pingTimeoutMs = (_b = options.timeoutMs) !== null && _b !== void 0 ? _b : DEFAULT_PING_TIMEOUT_MS;
+        this.maxMissedPongs = Math.max(1, (_c = options.maxMissedPongs) !== null && _c !== void 0 ? _c : DEFAULT_MAX_MISSED_PONGS);
+        this.mode = (_d = options.mode) !== null && _d !== void 0 ? _d : 'request';
         this.timerScheduler = options.timerScheduler;
-        this.timerKey = (_c = options.timerKey) !== null && _c !== void 0 ? _c : 'keepalive';
+        this.timerKey = (_e = options.timerKey) !== null && _e !== void 0 ? _e : 'keepalive';
         this.unsubs.push(options.client.onState(event => {
-            if (event.next === 'connected' && this.running)
+            if (event.next === 'connected' && this.running) {
+                this.missedPongs = 0;
                 this.scheduleNow();
-            if (event.next === 'closing' || event.next === 'closed')
+            }
+            if (event.next === 'closing' || event.next === 'closed') {
+                this.missedPongs = 0;
                 this.clearTimer();
+            }
         }));
     }
 }

package/dist/client-socket-v2/message-router.d.ts

@@ -5,5 +5,6 @@ export declare class MessageRouter {
     private readonly typeListeners;
     onAny: (listener: MessageListener) => (() => void);
     onType: <T = any>(type: string, listener: MessageListener<T>) => (() => void);
+    clear: () => void;
     route: (message: SocketMessage<any>) => number;
 }

package/dist/client-socket-v2/message-router.js

@@ -23,6 +23,10 @@ class MessageRouter {
                     this.typeListeners.delete(key);
             };
         };
+        this.clear = () => {
+            this.anyListeners.clear();
+            this.typeListeners.clear();
+        };
         this.route = (message) => {
             var _a;
             const key = `${(_a = message === null || message === void 0 ? void 0 : message.type) !== null && _a !== void 0 ? _a : ''}`.trim();

package/dist/client-socket-v2/reconnect-controller.d.ts

@@ -1,32 +1,48 @@
-import type { ClientSocketV2, ReconnectController, SharedTimerScheduler } from './types';
-export interface AutoReconnectControllerOptions {
+import type { AutoReconnectOptionsPartial, ClientSocketV2, ReconnectController, SharedTimerScheduler } from './types';
+export interface AutoReconnectGiveUpEvent {
+    attempts: number;
+}
+export interface AutoReconnectConnectFailedEvent {
+    attempt: number;
+    error: unknown;
+}
+export interface AutoReconnectControllerOptions extends AutoReconnectOptionsPartial {
     client: ClientSocketV2;
-    minDelayMs?: number;
-    maxDelayMs?: number;
-    factor?: number;
     timerScheduler?: SharedTimerScheduler;
-    timerKey?: string;
 }
 export declare class AutoReconnectController implements ReconnectController {
     private readonly options;
     private readonly minDelayMs;
     private readonly maxDelayMs;
     private readonly factor;
+    private readonly jitterRatio;
+    private readonly jitterMode;
+    private readonly maxAttempts;
+    private readonly minStableMs;
     private readonly timerScheduler?;
     private readonly timerKey;
+    private readonly now;
     private readonly unsubs;
+    private readonly giveUpListeners;
+    private readonly connectFailedListeners;
     private timer?;
     private active;
     private manualStop;
     private restarting;
     private attempt;
     private connecting?;
+    private stableSince?;
     constructor(options: AutoReconnectControllerOptions);
     start: () => Promise<void>;
-    stop: () => Promise<void>;
+    stop: (code?: number, reason?: string) => Promise<void>;
     restart: () => Promise<void>;
+    onGiveUp: (listener: (event: AutoReconnectGiveUpEvent) => void) => (() => void);
+    onConnectFailed: (listener: (event: AutoReconnectConnectFailedEvent) => void) => (() => void);
     destroy: () => void;
+    private applyStableReset;
+    private giveUp;
     private scheduleReconnect;
     private tryConnect;
     private clearTimer;
+    private computeBackoffDelay;
 }

package/dist/client-socket-v2/reconnect-controller.js

@@ -10,11 +10,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoReconnectController = void 0;
+const DEFAULT_MIN_STABLE_MS = 5000;
 class AutoReconnectController {
     constructor(options) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         this.options = options;
         this.unsubs = [];
+        this.giveUpListeners = new Set();
+        this.connectFailedListeners = new Set();
         this.active = false;
         this.manualStop = false;
         this.restarting = false;
@@ -23,17 +26,20 @@ class AutoReconnectController {
             this.active = true;
             this.manualStop = false;
             this.clearTimer();
+            this.attempt = 0;
+            this.stableSince = this.options.client.state === 'connected' ? this.now() : undefined;
             if (this.options.client.state !== 'connected') {
                 yield this.tryConnect();
             }
         });
-        this.stop = () => __awaiter(this, void 0, void 0, function* () {
+        this.stop = (code, reason) => __awaiter(this, void 0, void 0, function* () {
             this.active = false;
             this.manualStop = true;
             this.restarting = false;
             this.clearTimer();
             this.attempt = 0;
-            yield this.options.client.disconnect();
+            this.stableSince = undefined;
+            yield this.options.client.disconnect(code, reason);
         });
         this.restart = () => __awaiter(this, void 0, void 0, function* () {
             if (!this.active) {
@@ -42,6 +48,7 @@ class AutoReconnectController {
             }
             this.clearTimer();
             this.attempt = 0;
+            this.stableSince = undefined;
             this.restarting = true;
             try {
                 if (this.options.client.state === 'connected' || this.options.client.state === 'connecting') {
@@ -53,16 +60,48 @@ class AutoReconnectController {
                 this.restarting = false;
             }
         });
+        this.onGiveUp = (listener) => {
+            this.giveUpListeners.add(listener);
+            return () => {
+                this.giveUpListeners.delete(listener);
+            };
+        };
+        this.onConnectFailed = (listener) => {
+            this.connectFailedListeners.add(listener);
+            return () => {
+                this.connectFailedListeners.delete(listener);
+            };
+        };
         this.destroy = () => {
             this.clearTimer();
+            this.giveUpListeners.clear();
+            this.connectFailedListeners.clear();
             this.unsubs.splice(0).forEach(unsub => unsub());
         };
+        this.applyStableReset = () => {
+            if (this.stableSince === undefined)
+                return;
+            const stableMs = this.now() - this.stableSince;
+            this.stableSince = undefined;
+            if (stableMs >= this.minStableMs)
+                this.attempt = 0;
+        };
+        this.giveUp = () => {
+            const attempts = this.attempt;
+            this.active = false;
+            this.clearTimer();
+            this.giveUpListeners.forEach(listener => listener({ attempts }));
+        };
         this.scheduleReconnect = () => {
             if (!this.active || this.manualStop)
                 return;
             if (this.timer || this.connecting)
                 return;
-            const delayMs = Math.min(this.minDelayMs * Math.pow(this.factor, this.attempt), this.maxDelayMs);
+            if (this.maxAttempts > 0 && this.attempt >= this.maxAttempts) {
+                this.giveUp();
+                return;
+            }
+            const delayMs = this.computeBackoffDelay(this.attempt);
             if (this.timerScheduler) {
                 this.timerScheduler.schedule(this.timerKey, delayMs, () => {
                     void this.tryConnect();
@@ -81,13 +120,21 @@ class AutoReconnectController {
                 return;
             if (this.connecting)
                 return this.connecting;
+            const attempt = this.attempt;
+            let failed = false;
+            let failedError;
             this.connecting = this.options.client
                 .connect()
-                .catch(() => {
-                this.scheduleReconnect();
+                .catch(error => {
+                failed = true;
+                failedError = error;
             })
                 .then(() => {
                 this.connecting = undefined;
+                if (failed) {
+                    this.connectFailedListeners.forEach(listener => listener({ attempt, error: failedError }));
+                    this.scheduleReconnect();
+                }
             });
             return this.connecting;
         });
@@ -98,20 +145,36 @@ class AutoReconnectController {
                 clearTimeout(this.timer);
             this.timer = undefined;
         };
+        this.computeBackoffDelay = (attempt) => {
+            const expDelay = Math.min(this.minDelayMs * Math.pow(this.factor, attempt), this.maxDelayMs);
+            if (this.jitterMode === 'full') {
+                /** AWS full jitter: random in [0, expDelay). minDelay floor 적용. */
+                const delay = Math.random() * expDelay;
+                return Math.max(this.minDelayMs, Math.min(this.maxDelayMs, delay));
+            }
+            const jitter = this.jitterRatio > 0 ? expDelay * (Math.random() * 2 - 1) * this.jitterRatio : 0;
+            return Math.max(this.minDelayMs, Math.min(this.maxDelayMs, expDelay + jitter));
+        };
         this.minDelayMs = (_a = options.minDelayMs) !== null && _a !== void 0 ? _a : 500;
-        this.maxDelayMs = (_b = options.maxDelayMs) !== null && _b !== void 0 ? _b : 10000;
+        this.maxDelayMs = (_b = options.maxDelayMs) !== null && _b !== void 0 ? _b : 30000;
         this.factor = (_c = options.factor) !== null && _c !== void 0 ? _c : 2;
+        this.jitterRatio = Math.max(0, Math.min(1, (_d = options.jitterRatio) !== null && _d !== void 0 ? _d : 0.3));
+        this.jitterMode = (_e = options.jitterMode) !== null && _e !== void 0 ? _e : 'equal';
+        this.maxAttempts = Math.max(0, (_f = options.maxAttempts) !== null && _f !== void 0 ? _f : 0);
+        this.minStableMs = Math.max(0, (_g = options.minStableMs) !== null && _g !== void 0 ? _g : DEFAULT_MIN_STABLE_MS);
         this.timerScheduler = options.timerScheduler;
-        this.timerKey = (_d = options.timerKey) !== null && _d !== void 0 ? _d : 'reconnect';
+        this.timerKey = (_h = options.timerKey) !== null && _h !== void 0 ? _h : 'reconnect';
+        this.now = (_j = options.now) !== null && _j !== void 0 ? _j : (() => Date.now());
         this.unsubs.push(options.client.onState(event => {
             if (!this.active)
                 return;
             if (event.next === 'connected') {
-                this.attempt = 0;
+                this.stableSince = this.now();
                 this.clearTimer();
                 this.connecting = undefined;
             }
             if (event.next === 'closed' && !this.manualStop && !this.restarting) {
+                this.applyStableReset();
                 this.scheduleReconnect();
             }
         }));

package/dist/client-socket-v2/socket-runtime.js

@@ -17,7 +17,7 @@ const shared_timer_scheduler_1 = require("./shared-timer-scheduler");
 const sync_scheduler_1 = require("./sync-scheduler");
 class SocketRuntime {
     constructor(options) {
-        var _a, _b, _c, _d, _e, _f, _g;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         this.options = options;
         this.start = () => __awaiter(this, void 0, void 0, function* () {
             this.keepAlive.start();
@@ -42,11 +42,21 @@ class SocketRuntime {
                 timerScheduler: this.timerScheduler,
             });
         this.keepAlive =
-            (_e = options.keepAlive) !== null && _e !== void 0 ? _e : new keep_alive_loop_1.KeepAliveLoop(Object.assign({ client: options.client, timerScheduler: this.timerScheduler }, (options.keepAliveOptions || {})));
+            (_e = options.keepAlive) !== null && _e !== void 0 ? _e : (options.keepAliveOptions
+                ? new keep_alive_loop_1.KeepAliveLoop(Object.assign({ client: options.client, timerScheduler: this.timerScheduler }, options.keepAliveOptions))
+                : (_f = options.client.keepAlive) !== null && _f !== void 0 ? _f : new keep_alive_loop_1.KeepAliveLoop({
+                    client: options.client,
+                    timerScheduler: this.timerScheduler,
+                }));
         this.reconnect =
-            (_f = options.reconnect) !== null && _f !== void 0 ? _f : new reconnect_controller_1.AutoReconnectController(Object.assign({ client: options.client, timerScheduler: this.timerScheduler }, (options.reconnectOptions || {})));
+            (_g = options.reconnect) !== null && _g !== void 0 ? _g : (options.reconnectOptions
+                ? new reconnect_controller_1.AutoReconnectController(Object.assign({ client: options.client, timerScheduler: this.timerScheduler }, options.reconnectOptions))
+                : (_h = options.client.reconnect) !== null && _h !== void 0 ? _h : new reconnect_controller_1.AutoReconnectController({
+                    client: options.client,
+                    timerScheduler: this.timerScheduler,
+                }));
         this.rotation =
-            (_g = options.rotation) !== null && _g !== void 0 ? _g : new connection_rotation_controller_1.ConnectionRotationController(Object.assign({ client: options.client, reconnect: this.reconnect, timerScheduler: this.timerScheduler }, (options.rotationOptions || {})));
+            (_j = options.rotation) !== null && _j !== void 0 ? _j : new connection_rotation_controller_1.ConnectionRotationController(Object.assign({ client: options.client, reconnect: this.reconnect, timerScheduler: this.timerScheduler }, (options.rotationOptions || {})));
     }
 }
 exports.SocketRuntime = SocketRuntime;

package/dist/client-socket-v2/socket-transport.d.ts

@@ -1,18 +1,35 @@
 import type { ClientSocketState, SocketFactoryContext, SocketLike, SocketTransport, SocketTransportEventMap } from './types';
+export interface WebSocketTransportOptions {
+    /** connect() open 이벤트 대기 timeout. 만료 시 socket close + Promise reject. 0이면 무한 대기. 기본 10000 */
+    connectTimeoutMs?: number;
+}
+/**
+ * `SocketTransport` adapter over lemon-model's owned WebSocket network.
+ *
+ * Raw network concerns (socket creation, OPEN send guard, actual close, raw event mapping) are owned by
+ * `OwnedWebSocketNetwork`. This adapter only translates that single-shot network into chatic's reconnectable,
+ * code-carrying, 4-event / 5-state lifecycle. The connect timeout stays here because it belongs to the
+ * reconnect/backoff policy, not the raw transport.
+ */
 export declare class WebSocketTransport implements SocketTransport {
     readonly url: string;
     readonly protocols?: string | string[];
-    private readonly socketFactory;
+    private readonly socketFactory?;
     private _state;
-    private socket?;
-    private unbinders;
+    private network?;
+    private networkUnsubs;
     private readonly listeners;
-    constructor(url: string, protocols?: string | string[], socketFactory?: (context: SocketFactoryContext) => SocketLike);
+    private readonly connectTimeoutMs;
+    private connecting?;
+    private cancelConnecting?;
+    constructor(url: string, protocols?: string | string[], socketFactory?: (context: SocketFactoryContext) => SocketLike, options?: WebSocketTransportOptions);
     get state(): ClientSocketState;
     on: <TType extends keyof SocketTransportEventMap>(type: TType, listener: (event: SocketTransportEventMap[TType]) => void) => (() => void);
     connect: () => Promise<void>;
     disconnect: (code?: number, reason?: string) => Promise<void>;
     send: (raw: string) => void;
     private emit;
-    private cleanupSocket;
+    /** bridge chatic's `SocketLike` factory to the owned network's `WebSocketClosable` factory */
+    private buildSocketFactory;
+    private cleanupNetwork;
 }

package/dist/client-socket-v2/socket-transport.js

@@ -10,28 +10,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebSocketTransport = void 0;
-const common_1 = require("./common");
-const OPEN_STATE = 1;
-const bindSocketListener = (socket, type, listener) => {
-    if (socket.addEventListener) {
-        socket.addEventListener(type, listener);
-        return () => { var _a; return (_a = socket.removeEventListener) === null || _a === void 0 ? void 0 : _a.call(socket, type, listener); };
-    }
-    const key = `on${type}`;
-    const prev = socket[key];
-    socket[key] = listener;
-    return () => {
-        if (socket[key] === listener)
-            socket[key] = prev !== null && prev !== void 0 ? prev : null;
-    };
-};
+const lemon_model_1 = require("lemon-model");
+const DEFAULT_CONNECT_TIMEOUT_MS = 10000;
+/**
+ * `SocketTransport` adapter over lemon-model's owned WebSocket network.
+ *
+ * Raw network concerns (socket creation, OPEN send guard, actual close, raw event mapping) are owned by
+ * `OwnedWebSocketNetwork`. This adapter only translates that single-shot network into chatic's reconnectable,
+ * code-carrying, 4-event / 5-state lifecycle. The connect timeout stays here because it belongs to the
+ * reconnect/backoff policy, not the raw transport.
+ */
 class WebSocketTransport {
-    constructor(url, protocols, socketFactory = context => new globalThis.WebSocket(context.url, context.protocols)) {
+    constructor(url, protocols, socketFactory, options) {
+        var _a;
         this.url = url;
         this.protocols = protocols;
         this.socketFactory = socketFactory;
         this._state = 'idle';
-        this.unbinders = [];
+        this.networkUnsubs = [];
         this.listeners = new Map();
         this.on = (type, listener) => {
             var _a;
@@ -47,75 +43,103 @@ class WebSocketTransport {
         this.connect = () => __awaiter(this, void 0, void 0, function* () {
             if (this._state === 'connected')
                 return;
-            if (this._state === 'connecting')
-                return;
-            this.cleanupSocket();
+            if (this.connecting)
+                return this.connecting;
+            this.cleanupNetwork();
             this._state = 'connecting';
-            const socket = this.socketFactory({ url: this.url, protocols: this.protocols });
-            this.socket = socket;
-            yield new Promise((resolve, reject) => {
-                let connectSettled = false;
+            const network = (0, lemon_model_1.createOwnedWebSocketNetwork)({
+                url: this.url,
+                protocols: this.protocols,
+                socketFactory: this.buildSocketFactory(),
+                connectTimeoutMs: 0, // connect timeout is owned here (reconnect policy), not by the network
+            });
+            this.network = network;
+            this.connecting = new Promise((resolve, reject) => {
+                var _a;
+                let settled = false;
+                let timeoutTimer;
                 const settleConnect = (handler) => {
-                    if (connectSettled)
+                    if (settled)
                         return;
-                    connectSettled = true;
+                    settled = true;
+                    if (timeoutTimer)
+                        clearTimeout(timeoutTimer);
+                    this.connecting = undefined;
+                    this.cancelConnecting = undefined;
                     handler();
                 };
-                this.unbinders = [
-                    bindSocketListener(socket, 'open', () => {
-                        this._state = 'connected';
-                        this.emit('open', undefined);
-                        settleConnect(() => resolve());
-                    }),
-                    bindSocketListener(socket, 'close', event => {
-                        this._state = 'closed';
-                        this.emit('close', {
-                            code: event === null || event === void 0 ? void 0 : event.code,
-                            reason: event === null || event === void 0 ? void 0 : event.reason,
-                            wasClean: event === null || event === void 0 ? void 0 : event.wasClean,
-                        });
-                        settleConnect(() => resolve());
-                    }),
-                    bindSocketListener(socket, 'error', event => {
+                this.cancelConnecting = error => settleConnect(() => reject(error));
+                if (this.connectTimeoutMs > 0) {
+                    timeoutTimer = setTimeout(() => {
+                        const error = new Error(`408 CONNECT TIMEOUT - WebSocketTransport.connect() after ${this.connectTimeoutMs}ms`);
+                        settleConnect(() => reject(error));
+                        network.close(1000, 'connect-timeout');
+                    }, this.connectTimeoutMs);
+                }
+                const unsubOpen = (_a = network.onOpen) === null || _a === void 0 ? void 0 : _a.call(network, () => {
+                    this._state = 'connected';
+                    this.emit('open', undefined);
+                    settleConnect(() => resolve());
+                });
+                this.networkUnsubs = [
+                    network.onMessage(raw => this.emit('message', { data: raw })),
+                    network.onError((event, context) => {
                         var _a;
-                        const error = (_a = event === null || event === void 0 ? void 0 : event.error) !== null && _a !== void 0 ? _a : new Error(`socket transport error`);
+                        if (context.scope === 'ownedWebSocket.close') {
+                            const close = event;
+                            this._state = 'closed';
+                            this.emit('close', { code: close === null || close === void 0 ? void 0 : close.code, reason: close === null || close === void 0 ? void 0 : close.reason, wasClean: close === null || close === void 0 ? void 0 : close.wasClean });
+                            settleConnect(() => resolve()); // close-before-open resolves connect (reconnect drives off state)
+                            return;
+                        }
+                        const error = (_a = event === null || event === void 0 ? void 0 : event.error) !== null && _a !== void 0 ? _a : (event instanceof Error ? event : new Error(`socket transport error`));
                         this.emit('error', { error });
                         if (this._state !== 'connected')
                             this._state = 'closed';
                         settleConnect(() => reject(error));
                     }),
-                    bindSocketListener(socket, 'message', event => {
-                        this.emit('message', { data: (0, common_1.asString)(event === null || event === void 0 ? void 0 : event.data, '') });
-                    }),
                 ];
+                if (unsubOpen)
+                    this.networkUnsubs.push(unsubOpen);
             });
+            return this.connecting;
         });
         this.disconnect = (code, reason) => __awaiter(this, void 0, void 0, function* () {
-            if (!this.socket) {
+            var _b;
+            if (!this.network) {
                 this._state = 'closed';
                 return;
             }
             this._state = 'closing';
-            const socket = this.socket;
-            socket.close(code, reason);
-            this.cleanupSocket();
+            const network = this.network;
+            network.close(code, reason);
+            (_b = this.cancelConnecting) === null || _b === void 0 ? void 0 : _b.call(this, new Error(`499 CLIENT CLOSED REQUEST - disconnect during connecting`));
+            this.cleanupNetwork();
             this._state = 'closed';
             this.emit('close', { code, reason, wasClean: true });
         });
         this.send = (raw) => {
-            if (!this.socket || this.socket.readyState !== undefined && this.socket.readyState !== OPEN_STATE) {
+            if (!this.network || this.network.readyState !== 'open') {
                 throw new Error(`503 SOCKET NOT CONNECTED - WebSocketTransport.send()`);
             }
-            this.socket.send(raw);
+            this.network.send(raw);
         };
         this.emit = (type, event) => {
             var _a;
             (_a = this.listeners.get(type)) === null || _a === void 0 ? void 0 : _a.forEach(listener => listener(event));
         };
-        this.cleanupSocket = () => {
-            this.unbinders.splice(0).forEach(unbind => unbind());
-            this.socket = undefined;
+        /** bridge chatic's `SocketLike` factory to the owned network's `WebSocketClosable` factory */
+        this.buildSocketFactory = () => {
+            const factory = this.socketFactory;
+            if (!factory)
+                return undefined;
+            return context => factory({ url: context.url, protocols: context.protocols });
+        };
+        this.cleanupNetwork = () => {
+            this.networkUnsubs.splice(0).forEach(unsub => unsub());
+            this.network = undefined;
         };
+        this.connectTimeoutMs = (_a = options === null || options === void 0 ? void 0 : options.connectTimeoutMs) !== null && _a !== void 0 ? _a : DEFAULT_CONNECT_TIMEOUT_MS;
     }
     get state() {
         return this._state;