@lemoncloud/chatic-sockets-lib 0.1.0

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

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeepAliveLoop = void 0;
+class KeepAliveLoop {
+    constructor(options) {
+        var _a, _b, _c;
+        this.options = options;
+        this.unsubs = [];
+        this.running = false;
+        this.start = () => {
+            this.running = true;
+            if (this.options.client.state === 'connected')
+                this.scheduleNow();
+        };
+        this.stop = () => {
+            this.running = false;
+            this.clearTimer();
+        };
+        this.destroy = () => {
+            this.stop();
+            this.unsubs.splice(0).forEach(unsub => unsub());
+        };
+        this.scheduleNow = () => {
+            this.clearTimer();
+            if (this.timerScheduler) {
+                this.timerScheduler.schedule(this.timerKey, 0, () => this.tick());
+                return;
+            }
+            this.timer = setTimeout(() => void this.tick(), 0);
+        };
+        this.scheduleNext = () => {
+            this.clearTimer();
+            if (!this.running || this.options.client.state !== 'connected')
+                return;
+            if (this.timerScheduler) {
+                this.timerScheduler.schedule(this.timerKey, this.intervalMs, () => this.tick());
+                return;
+            }
+            this.timer = setTimeout(() => void this.tick(), this.intervalMs);
+        };
+        this.clearTimer = () => {
+            var _a;
+            (_a = this.timerScheduler) === null || _a === void 0 ? void 0 : _a.cancel(this.timerKey);
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = undefined;
+        };
+        this.tick = () => __awaiter(this, void 0, void 0, function* () {
+            var _d, _e, _f;
+            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;
+            this.inFlight = Promise.resolve()
+                .then(() => __awaiter(this, void 0, void 0, function* () {
+                if (this.mode === 'send') {
+                    this.options.client.send('system.ping', payload);
+                    return;
+                }
+                yield this.options.client.request('system.ping', payload, {
+                    timeoutMs: this.options.timeoutMs,
+                });
+            }))
+                .catch(() => undefined)
+                .then(() => {
+                this.inFlight = undefined;
+                this.scheduleNext();
+            });
+            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.timerScheduler = options.timerScheduler;
+        this.timerKey = (_c = options.timerKey) !== null && _c !== void 0 ? _c : 'keepalive';
+        this.unsubs.push(options.client.onState(event => {
+            if (event.next === 'connected' && this.running)
+                this.scheduleNow();
+            if (event.next === 'closing' || event.next === 'closed')
+                this.clearTimer();
+        }));
+    }
+}
+exports.KeepAliveLoop = KeepAliveLoop;

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

@@ -0,0 +1,9 @@
+import type { SocketMessage } from '../lib/types';
+export declare type MessageListener<T = any> = (message: SocketMessage<T>) => void;
+export declare class MessageRouter {
+    private readonly anyListeners;
+    private readonly typeListeners;
+    onAny: (listener: MessageListener) => (() => void);
+    onType: <T = any>(type: string, listener: MessageListener<T>) => (() => void);
+    route: (message: SocketMessage<any>) => number;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageRouter = void 0;
+class MessageRouter {
+    constructor() {
+        this.anyListeners = new Set();
+        this.typeListeners = new Map();
+        this.onAny = (listener) => {
+            this.anyListeners.add(listener);
+            return () => this.anyListeners.delete(listener);
+        };
+        this.onType = (type, listener) => {
+            var _a;
+            const key = `${type !== null && type !== void 0 ? type : ''}`.trim();
+            if (!key)
+                throw new Error(`@type (string) is required - MessageRouter.onType()`);
+            const bucket = (_a = this.typeListeners.get(key)) !== null && _a !== void 0 ? _a : new Set();
+            bucket.add(listener);
+            this.typeListeners.set(key, bucket);
+            return () => {
+                bucket.delete(listener);
+                if (!bucket.size)
+                    this.typeListeners.delete(key);
+            };
+        };
+        this.route = (message) => {
+            var _a;
+            const key = `${(_a = message === null || message === void 0 ? void 0 : message.type) !== null && _a !== void 0 ? _a : ''}`.trim();
+            let count = 0;
+            this.anyListeners.forEach(listener => {
+                listener(message);
+                count += 1;
+            });
+            if (!key)
+                return count;
+            const bucket = this.typeListeners.get(key);
+            bucket === null || bucket === void 0 ? void 0 : bucket.forEach(listener => {
+                listener(message);
+                count += 1;
+            });
+            return count;
+        };
+    }
+}
+exports.MessageRouter = MessageRouter;

package/dist/client-socket-v2/pending-request-store.d.ts

@@ -0,0 +1,23 @@
+import type { SocketMessage } from '../lib/types';
+import type { SharedTimerScheduler } from './types';
+export interface PendingRequestStoreOptions {
+    timerScheduler?: SharedTimerScheduler;
+    timerPrefix?: string;
+}
+export declare class PendingRequestStore {
+    private readonly items;
+    private readonly timerScheduler?;
+    private readonly timerPrefix;
+    constructor(options?: PendingRequestStoreOptions);
+    size: () => number;
+    has: (mid: string) => boolean;
+    create<T = any>(mid: string, options?: {
+        timeoutMs?: number;
+        onTimeout?: (mid: string) => Error;
+    }): Promise<T>;
+    resolve: <T = any>(mid: string, value: T) => boolean;
+    reject: (mid: string, error: unknown) => boolean;
+    clear: (reason?: unknown) => number;
+    settle: (message: SocketMessage<any>) => boolean;
+    private toTimerKey;
+}

package/dist/client-socket-v2/pending-request-store.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PendingRequestStore = void 0;
+class PendingRequestStore {
+    constructor(options = {}) {
+        var _a;
+        this.items = new Map();
+        this.size = () => this.items.size;
+        this.has = (mid) => this.items.has(mid);
+        this.resolve = (mid, value) => {
+            var _a;
+            const item = this.items.get(mid);
+            if (!item)
+                return false;
+            this.items.delete(mid);
+            (_a = this.timerScheduler) === null || _a === void 0 ? void 0 : _a.cancel(this.toTimerKey(mid));
+            item.timer && clearTimeout(item.timer);
+            item.resolve(value);
+            return true;
+        };
+        this.reject = (mid, error) => {
+            var _a;
+            const item = this.items.get(mid);
+            if (!item)
+                return false;
+            this.items.delete(mid);
+            (_a = this.timerScheduler) === null || _a === void 0 ? void 0 : _a.cancel(this.toTimerKey(mid));
+            item.timer && clearTimeout(item.timer);
+            item.reject(error);
+            return true;
+        };
+        this.clear = (reason) => {
+            const mids = [...this.items.keys()];
+            mids.forEach(mid => this.reject(mid, reason !== null && reason !== void 0 ? reason : new Error(`499 CLIENT CLOSED REQUEST - pending[${mid}]`)));
+            return mids.length;
+        };
+        this.settle = (message) => {
+            var _a, _b, _c;
+            const mid = `${(_a = message === null || message === void 0 ? void 0 : message.mid) !== null && _a !== void 0 ? _a : ''}`;
+            if (!mid)
+                return false;
+            if ((_b = message === null || message === void 0 ? void 0 : message.type) === null || _b === void 0 ? void 0 : _b.endsWith(':ok'))
+                return this.resolve(mid, message.data);
+            if ((_c = message === null || message === void 0 ? void 0 : message.type) === null || _c === void 0 ? void 0 : _c.endsWith(':error'))
+                return this.reject(mid, new Error(`${(message === null || message === void 0 ? void 0 : message.error) || 'socket request failed'} - ${message === null || message === void 0 ? void 0 : message.type}`));
+            return false;
+        };
+        this.toTimerKey = (mid) => `${this.timerPrefix}${mid}`;
+        this.timerScheduler = options.timerScheduler;
+        this.timerPrefix = (_a = options.timerPrefix) !== null && _a !== void 0 ? _a : 'pending:';
+    }
+    create(mid, options) {
+        if (!mid)
+            throw new Error(`@mid (string) is required - PendingRequestStore.create()`);
+        if (this.items.has(mid))
+            throw new Error(`409 CONFLICT - pending request[${mid}] already exists`);
+        return new Promise((resolve, reject) => {
+            const item = {
+                resolve,
+                reject,
+                timer: (options === null || options === void 0 ? void 0 : options.timeoutMs) && options.timeoutMs > 0 && !this.timerScheduler
+                    ? setTimeout(() => {
+                        var _a, _b;
+                        this.items.delete(mid);
+                        const error = (_b = (_a = options === null || options === void 0 ? void 0 : options.onTimeout) === null || _a === void 0 ? void 0 : _a.call(options, mid)) !== null && _b !== void 0 ? _b : new Error(`408 REQUEST TIMEOUT - pending[${mid}]`);
+                        reject(error);
+                    }, options.timeoutMs)
+                    : undefined,
+            };
+            this.items.set(mid, item);
+            if ((options === null || options === void 0 ? void 0 : options.timeoutMs) && options.timeoutMs > 0 && this.timerScheduler) {
+                this.timerScheduler.schedule(this.toTimerKey(mid), options.timeoutMs, () => {
+                    var _a, _b;
+                    const current = this.items.get(mid);
+                    if (!current)
+                        return;
+                    this.items.delete(mid);
+                    const error = (_b = (_a = options === null || options === void 0 ? void 0 : options.onTimeout) === null || _a === void 0 ? void 0 : _a.call(options, mid)) !== null && _b !== void 0 ? _b : new Error(`408 REQUEST TIMEOUT - pending[${mid}]`);
+                    reject(error);
+                });
+            }
+        });
+    }
+}
+exports.PendingRequestStore = PendingRequestStore;

package/dist/client-socket-v2/plans/device-sync-plan.d.ts

@@ -0,0 +1,30 @@
+import type { DeviceGetResponseData } from '../../lib/device/types';
+import type { SocketMessage } from '../../lib/types';
+import type { DomainSyncContext, DomainSyncPlan, SyncTargetDescriptor } from '../types';
+export interface DeviceSyncTarget extends SyncTargetDescriptor {
+    type: 'device';
+}
+export interface DeviceSyncSnapshot {
+    id?: string;
+    tick?: number;
+    lastAppliedTick?: number;
+    view?: DeviceGetResponseData;
+}
+export interface DeviceSyncPlanOptions {
+    intervalMs?: number;
+    sendSyncHint?: boolean;
+    resetSnapshotOnConnected?: boolean;
+    onUpdate?: (target: DeviceSyncTarget, view: DeviceGetResponseData, previous?: DeviceSyncSnapshot) => void;
+}
+export declare class DeviceSyncPlan implements DomainSyncPlan<DeviceSyncTarget> {
+    private readonly options;
+    readonly domain = "device";
+    constructor(options?: DeviceSyncPlanOptions);
+    supports: (target: SyncTargetDescriptor) => target is DeviceSyncTarget;
+    getKey: (target: DeviceSyncTarget) => string;
+    getIntervalMs: (target: DeviceSyncTarget) => number;
+    onConnected: (target: DeviceSyncTarget, ctx: DomainSyncContext) => void;
+    run: (target: DeviceSyncTarget, ctx: DomainSyncContext) => Promise<void>;
+    onTrigger: (target: DeviceSyncTarget, message: SocketMessage<any>, ctx: DomainSyncContext) => Promise<void>;
+    updateLocalState: (target: DeviceSyncTarget, snapshot: unknown, ctx: DomainSyncContext) => void;
+}

package/dist/client-socket-v2/plans/device-sync-plan.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceSyncPlan = void 0;
+class DeviceSyncPlan {
+    constructor(options = {}) {
+        this.options = options;
+        this.domain = 'device';
+        this.supports = (target) => (target === null || target === void 0 ? void 0 : target.type) === 'device';
+        this.getKey = (target) => { var _a; return `device:${(_a = target === null || target === void 0 ? void 0 : target.id) !== null && _a !== void 0 ? _a : 'current'}`; };
+        this.getIntervalMs = (target) => { var _a, _b; return (_b = (_a = target.intervalMs) !== null && _a !== void 0 ? _a : this.options.intervalMs) !== null && _b !== void 0 ? _b : 2000; };
+        this.onConnected = (target, ctx) => {
+            if (this.options.resetSnapshotOnConnected === false)
+                return;
+            ctx.writeSnapshot(target, undefined);
+        };
+        this.run = (target, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            const prev = ctx.readSnapshot(target);
+            if (this.options.sendSyncHint !== false) {
+                const syncData = Object.assign(Object.assign({}, (target.id ? { id: target.id } : {})), (typeof (prev === null || prev === void 0 ? void 0 : prev.tick) === 'number' ? { tick: prev.tick } : {}));
+                ctx.client.send('device.sync', Object.keys(syncData).length ? syncData : null);
+            }
+            const input = target.id ? { id: target.id } : null;
+            const view = yield ctx.client.request('device.read', input);
+            const nextTick = typeof (view === null || view === void 0 ? void 0 : view.tick) === 'number' ? view.tick : undefined;
+            const prevTick = typeof (prev === null || prev === void 0 ? void 0 : prev.tick) === 'number' ? prev.tick : undefined;
+            const lastAppliedTick = typeof (prev === null || prev === void 0 ? void 0 : prev.lastAppliedTick) === 'number' ? prev.lastAppliedTick : undefined;
+            if (lastAppliedTick !== undefined && nextTick !== undefined && nextTick < lastAppliedTick)
+                return;
+            if (prevTick === nextTick && (prev === null || prev === void 0 ? void 0 : prev.view))
+                return;
+            const next = {
+                id: `${(_b = (_a = view === null || view === void 0 ? void 0 : view.id) !== null && _a !== void 0 ? _a : target.id) !== null && _b !== void 0 ? _b : ''}` || undefined,
+                tick: nextTick,
+                lastAppliedTick: nextTick,
+                view,
+            };
+            ctx.writeSnapshot(target, next);
+            (_d = (_c = this.options).onUpdate) === null || _d === void 0 ? void 0 : _d.call(_c, target, view, prev);
+        });
+        this.onTrigger = (target, message, ctx) => __awaiter(this, void 0, void 0, function* () {
+            const data = ((message === null || message === void 0 ? void 0 : message.data) || {});
+            if (target.id && (data === null || data === void 0 ? void 0 : data.id) && target.id !== data.id)
+                return;
+            yield this.run(target, ctx);
+        });
+        this.updateLocalState = (target, snapshot, ctx) => {
+            var _a, _b, _c;
+            const prev = ctx.readSnapshot(target);
+            const patch = (snapshot || {});
+            ctx.writeSnapshot(target, Object.assign(Object.assign(Object.assign({}, prev), patch), { view: (_a = patch.view) !== null && _a !== void 0 ? _a : prev === null || prev === void 0 ? void 0 : prev.view, tick: (_b = patch.tick) !== null && _b !== void 0 ? _b : prev === null || prev === void 0 ? void 0 : prev.tick, lastAppliedTick: (_c = patch.lastAppliedTick) !== null && _c !== void 0 ? _c : prev === null || prev === void 0 ? void 0 : prev.lastAppliedTick }));
+        };
+    }
+}
+exports.DeviceSyncPlan = DeviceSyncPlan;

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

@@ -0,0 +1,32 @@
+import type { ClientSocketV2, ReconnectController, SharedTimerScheduler } from './types';
+export interface AutoReconnectControllerOptions {
+    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 timerScheduler?;
+    private readonly timerKey;
+    private readonly unsubs;
+    private timer?;
+    private active;
+    private manualStop;
+    private restarting;
+    private attempt;
+    private connecting?;
+    constructor(options: AutoReconnectControllerOptions);
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    restart: () => Promise<void>;
+    destroy: () => void;
+    private scheduleReconnect;
+    private tryConnect;
+    private clearTimer;
+}

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

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoReconnectController = void 0;
+class AutoReconnectController {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        this.options = options;
+        this.unsubs = [];
+        this.active = false;
+        this.manualStop = false;
+        this.restarting = false;
+        this.attempt = 0;
+        this.start = () => __awaiter(this, void 0, void 0, function* () {
+            this.active = true;
+            this.manualStop = false;
+            this.clearTimer();
+            if (this.options.client.state !== 'connected') {
+                yield this.tryConnect();
+            }
+        });
+        this.stop = () => __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.restart = () => __awaiter(this, void 0, void 0, function* () {
+            if (!this.active) {
+                yield this.start();
+                return;
+            }
+            this.clearTimer();
+            this.attempt = 0;
+            this.restarting = true;
+            try {
+                if (this.options.client.state === 'connected' || this.options.client.state === 'connecting') {
+                    yield this.options.client.disconnect(1012, 'service-restart');
+                }
+                yield this.tryConnect();
+            }
+            finally {
+                this.restarting = false;
+            }
+        });
+        this.destroy = () => {
+            this.clearTimer();
+            this.unsubs.splice(0).forEach(unsub => unsub());
+        };
+        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.timerScheduler) {
+                this.timerScheduler.schedule(this.timerKey, delayMs, () => {
+                    void this.tryConnect();
+                });
+                this.attempt += 1;
+                return;
+            }
+            this.timer = setTimeout(() => {
+                this.timer = undefined;
+                void this.tryConnect();
+            }, delayMs);
+            this.attempt += 1;
+        };
+        this.tryConnect = () => __awaiter(this, void 0, void 0, function* () {
+            if (!this.active || this.manualStop)
+                return;
+            if (this.connecting)
+                return this.connecting;
+            this.connecting = this.options.client
+                .connect()
+                .catch(() => {
+                this.scheduleReconnect();
+            })
+                .then(() => {
+                this.connecting = undefined;
+            });
+            return this.connecting;
+        });
+        this.clearTimer = () => {
+            var _a;
+            (_a = this.timerScheduler) === null || _a === void 0 ? void 0 : _a.cancel(this.timerKey);
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = undefined;
+        };
+        this.minDelayMs = (_a = options.minDelayMs) !== null && _a !== void 0 ? _a : 500;
+        this.maxDelayMs = (_b = options.maxDelayMs) !== null && _b !== void 0 ? _b : 10000;
+        this.factor = (_c = options.factor) !== null && _c !== void 0 ? _c : 2;
+        this.timerScheduler = options.timerScheduler;
+        this.timerKey = (_d = options.timerKey) !== null && _d !== void 0 ? _d : 'reconnect';
+        this.unsubs.push(options.client.onState(event => {
+            if (!this.active)
+                return;
+            if (event.next === 'connected') {
+                this.attempt = 0;
+                this.clearTimer();
+                this.connecting = undefined;
+            }
+            if (event.next === 'closed' && !this.manualStop && !this.restarting) {
+                this.scheduleReconnect();
+            }
+        }));
+    }
+}
+exports.AutoReconnectController = AutoReconnectController;

package/dist/client-socket-v2/shared-timer-scheduler.d.ts

@@ -0,0 +1,17 @@
+import type { SharedTimerScheduler } from './types';
+export interface SharedTimerSchedulerOptions {
+    now?: () => number;
+}
+export declare class InMemorySharedTimerScheduler implements SharedTimerScheduler {
+    private readonly tasks;
+    private readonly now;
+    private timer?;
+    constructor(options?: SharedTimerSchedulerOptions);
+    schedule: (key: string, delayMs: number, task: () => void | Promise<void>) => void;
+    cancel: (key: string) => void;
+    cancelAll: (prefix?: string) => void;
+    size: () => number;
+    private rearm;
+    private getNextTask;
+    private flush;
+}

package/dist/client-socket-v2/shared-timer-scheduler.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemorySharedTimerScheduler = void 0;
+class InMemorySharedTimerScheduler {
+    constructor(options = {}) {
+        var _a;
+        this.tasks = new Map();
+        this.schedule = (key, delayMs, task) => {
+            const safeDelayMs = Math.max(0, delayMs || 0);
+            this.tasks.set(key, {
+                key,
+                dueAt: this.now() + safeDelayMs,
+                task,
+            });
+            this.rearm();
+        };
+        this.cancel = (key) => {
+            this.tasks.delete(key);
+            this.rearm();
+        };
+        this.cancelAll = (prefix) => {
+            if (!prefix) {
+                this.tasks.clear();
+                this.rearm();
+                return;
+            }
+            [...this.tasks.keys()].forEach(key => {
+                if (key.startsWith(prefix))
+                    this.tasks.delete(key);
+            });
+            this.rearm();
+        };
+        this.size = () => this.tasks.size;
+        this.rearm = () => {
+            if (this.timer)
+                clearTimeout(this.timer);
+            this.timer = undefined;
+            const next = this.getNextTask();
+            if (!next)
+                return;
+            const delayMs = Math.max(0, next.dueAt - this.now());
+            this.timer = setTimeout(() => void this.flush(), delayMs);
+        };
+        this.getNextTask = () => {
+            let next;
+            this.tasks.forEach(task => {
+                if (!next || task.dueAt < next.dueAt)
+                    next = task;
+            });
+            return next;
+        };
+        this.flush = () => __awaiter(this, void 0, void 0, function* () {
+            this.timer = undefined;
+            const now = this.now();
+            const due = [...this.tasks.values()].filter(task => task.dueAt <= now);
+            due.forEach(task => this.tasks.delete(task.key));
+            this.rearm();
+            yield Promise.all(due.map(task => Promise.resolve(task.task()).catch(() => undefined)));
+        });
+        this.now = (_a = options.now) !== null && _a !== void 0 ? _a : (() => Date.now());
+    }
+}
+exports.InMemorySharedTimerScheduler = InMemorySharedTimerScheduler;

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

@@ -0,0 +1,32 @@
+import { AutoReconnectController } from './reconnect-controller';
+import { ConnectionRotationController } from './connection-rotation-controller';
+import { KeepAliveLoop } from './keep-alive-loop';
+import type { ClientSocketRuntime, ClientSocketV2, DomainSyncPlan, KeepAliveLoopControl, ReconnectController, SharedTimerScheduler, SyncScheduler, SyncTargetDescriptor } from './types';
+export interface ClientSocketRuntimeOptions {
+    client: ClientSocketV2;
+    scheduler?: SyncScheduler;
+    keepAlive?: KeepAliveLoopControl;
+    reconnect?: ReconnectController;
+    rotation?: ConnectionRotationController;
+    timerScheduler?: SharedTimerScheduler;
+    syncPlans?: DomainSyncPlan<any>[];
+    keepAliveOptions?: Omit<ConstructorParameters<typeof KeepAliveLoop>[0], 'client' | 'timerScheduler'>;
+    reconnectOptions?: Omit<ConstructorParameters<typeof AutoReconnectController>[0], 'client'>;
+    rotationOptions?: Omit<ConstructorParameters<typeof ConnectionRotationController>[0], 'client' | 'reconnect'>;
+}
+export declare class SocketRuntime implements ClientSocketRuntime {
+    private readonly options;
+    readonly scheduler: SyncScheduler;
+    readonly keepAlive: KeepAliveLoopControl;
+    readonly reconnect: ReconnectController;
+    readonly rotation: ConnectionRotationController;
+    readonly timerScheduler: SharedTimerScheduler;
+    constructor(options: ClientSocketRuntimeOptions);
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+    startSync: (target: SyncTargetDescriptor) => void;
+    stopSync: (target: SyncTargetDescriptor) => void;
+    stopAllSync: () => void;
+    listSyncTargets: () => SyncTargetDescriptor[];
+    updateLocalSnapshot: (target: SyncTargetDescriptor, snapshot: unknown) => void;
+}