@lemoncloud/chatic-sockets-lib 0.1.0

package/README.md

@@ -0,0 +1,44 @@
+# @lemoncloud/chatic-sockets-lib
+
+`@lemoncloud/chatic-sockets-lib`는 `ClientSocketV2`와 동기화 런타임을 실제 앱에서 재사용할 수 있도록 분리한 npm 배포 패키지다.
+
+## Goals
+
+- 기본 엔트리는 `createClientSocketV2`
+- `lemon-core` 미포함
+- `system.*`, `device.*` socket packet 타입 포함
+- `device.save`, `device.read`, `device.sync`용 중요 타입 포함
+- 클라이언트 생성 시 초기 장치 정보(`id` 포함 가능)를 선택적으로 받을 수 있음
+
+## Main Export
+
+```ts
+import createClientSocketV2, { createDeviceRuntime } from '@lemoncloud/chatic-sockets-lib';
+
+const client = createClientSocketV2({
+  url: 'wss://example.com/dev',
+  device: {
+    id: 'device-web-1',
+    name: 'Device A',
+    platform: 'web'
+  }
+});
+
+const runtime = createDeviceRuntime({ client });
+await runtime.start();
+```
+
+## Notes
+
+- `device.tick`은 서버 관리 값이므로 클라이언트 입력으로는 사용되지 않는다.
+- `device` 옵션에 `tick`이 들어와도 라이브러리에서 제외한다.
+- 패키지 빌드는 `src/client-socket-v2/`와 client-safe 계약 타입만 포함한다.
+
+## Build
+
+루트에서 아래를 실행한다.
+
+```bash
+npm run lib:build
+npm run lib:pack
+```

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

@@ -0,0 +1,4 @@
+export declare const cleanString: <T extends string = string>(value?: unknown, fallback?: string) => T;
+export declare const asString: <T extends string = string>(value?: unknown, fallback?: string) => T;
+export declare const onlyDefined: <T>(value: T) => T;
+export declare const omitKeys: <T extends Record<string, any>, TKey extends keyof T>(value: T, keys: TKey[]) => Omit<T, TKey>;

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.omitKeys = exports.onlyDefined = exports.asString = exports.cleanString = void 0;
+const cleanString = (value, fallback = '') => { var _a; return `${(_a = value !== null && value !== void 0 ? value : fallback) !== null && _a !== void 0 ? _a : ''}`.trim(); };
+exports.cleanString = cleanString;
+const asString = (value, fallback = '') => { var _a; return `${(_a = value !== null && value !== void 0 ? value : fallback) !== null && _a !== void 0 ? _a : ''}`; };
+exports.asString = asString;
+const onlyDefined = (value) => value && typeof value === 'object'
+    ? Object.entries(value).reduce((acc, [key, item]) => {
+        if (item !== undefined)
+            acc[key] = item;
+        return acc;
+    }, {})
+    : null;
+exports.onlyDefined = onlyDefined;
+const omitKeys = (value, keys) => Object.entries(value || {}).reduce((acc, [key, item]) => {
+    if (!keys.includes(key))
+        acc[key] = item;
+    return acc;
+}, {});
+exports.omitKeys = omitKeys;

package/dist/client-socket-v2/connection-rotation-controller.d.ts

@@ -0,0 +1,26 @@
+import type { ClientSocketV2, ReconnectController, SharedTimerScheduler } from './types';
+export interface ConnectionRotationControllerOptions {
+    client: ClientSocketV2;
+    reconnect?: ReconnectController;
+    maxLifetimeMs?: number;
+    refreshBeforeMs?: number;
+    timerScheduler?: SharedTimerScheduler;
+    timerKey?: string;
+}
+export declare class ConnectionRotationController {
+    private readonly options;
+    private readonly maxLifetimeMs;
+    private readonly refreshBeforeMs;
+    private readonly timerScheduler?;
+    private readonly timerKey;
+    private readonly unsubs;
+    private timer?;
+    private active;
+    constructor(options: ConnectionRotationControllerOptions);
+    start: () => void;
+    stop: () => void;
+    destroy: () => void;
+    private scheduleRotation;
+    private rotate;
+    private clearTimer;
+}

package/dist/client-socket-v2/connection-rotation-controller.js

@@ -0,0 +1,79 @@
+"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.ConnectionRotationController = void 0;
+class ConnectionRotationController {
+    constructor(options) {
+        var _a, _b, _c;
+        this.options = options;
+        this.unsubs = [];
+        this.active = false;
+        this.start = () => {
+            this.active = true;
+            if (this.options.client.state === 'connected')
+                this.scheduleRotation();
+        };
+        this.stop = () => {
+            this.active = false;
+            this.clearTimer();
+        };
+        this.destroy = () => {
+            this.stop();
+            this.unsubs.splice(0).forEach(unsub => unsub());
+        };
+        this.scheduleRotation = () => {
+            this.clearTimer();
+            if (!this.active)
+                return;
+            const delayMs = Math.max(0, this.maxLifetimeMs - this.refreshBeforeMs);
+            if (this.timerScheduler) {
+                this.timerScheduler.schedule(this.timerKey, delayMs, () => this.rotate());
+                return;
+            }
+            this.timer = setTimeout(() => void this.rotate(), delayMs);
+        };
+        this.rotate = () => __awaiter(this, void 0, void 0, function* () {
+            if (!this.active)
+                return;
+            try {
+                if (this.options.reconnect) {
+                    yield this.options.reconnect.restart();
+                    return;
+                }
+                yield this.options.client.disconnect(1012, 'service-restart');
+                yield this.options.client.connect();
+            }
+            catch (_e) {
+                return;
+            }
+        });
+        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.maxLifetimeMs = (_a = options.maxLifetimeMs) !== null && _a !== void 0 ? _a : 1000 * 60 * 110;
+        this.refreshBeforeMs = (_b = options.refreshBeforeMs) !== null && _b !== void 0 ? _b : 1000 * 60 * 10;
+        this.timerScheduler = options.timerScheduler;
+        this.timerKey = (_c = options.timerKey) !== null && _c !== void 0 ? _c : 'rotation';
+        this.unsubs.push(options.client.onState(event => {
+            if (!this.active)
+                return;
+            if (event.next === 'connected')
+                this.scheduleRotation();
+            if (event.next === 'closing' || event.next === 'closed')
+                this.clearTimer();
+        }));
+    }
+}
+exports.ConnectionRotationController = ConnectionRotationController;

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

@@ -0,0 +1,2 @@
+import type { ClientSocketOptions, ClientSocketV2 } from './types';
+export declare const createClientSocketV2: (options: ClientSocketOptions) => ClientSocketV2;

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

@@ -0,0 +1,164 @@
+"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.createClientSocketV2 = void 0;
+const common_1 = require("./common");
+const message_router_1 = require("./message-router");
+const pending_request_store_1 = require("./pending-request-store");
+const shared_timer_scheduler_1 = require("./shared-timer-scheduler");
+const socket_transport_1 = require("./socket-transport");
+const buildMid = () => `m-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+const parseMessage = (raw) => {
+    const text = `${raw !== null && raw !== void 0 ? raw : ''}`.trim();
+    if (!text)
+        throw new Error(`@raw message is empty`);
+    if (!text.startsWith('{') || !text.endsWith('}'))
+        throw new Error(`invalid socket JSON message`);
+    const message = JSON.parse(text);
+    if (typeof (message === null || message === void 0 ? void 0 : message.type) !== 'string' || !message.type.trim()) {
+        throw new Error(`@message.type (string) is required`);
+    }
+    return (0, common_1.onlyDefined)(Object.assign(Object.assign({}, message), { type: (0, common_1.cleanString)(message.type) }));
+};
+class ClientSocketV2Impl {
+    constructor(options) {
+        var _a;
+        this.options = options;
+        this.router = new message_router_1.MessageRouter();
+        this.stateListeners = new Set();
+        this.errorListeners = new Set();
+        this.messageListeners = new Set();
+        this._state = 'idle';
+        this.connect = () => __awaiter(this, void 0, void 0, function* () {
+            if (this._state === 'connected' || this._state === 'connecting')
+                return;
+            this.setState('connecting');
+            try {
+                yield this.transport.connect();
+            }
+            catch (error) {
+                this.emitError({ error, phase: 'connect' });
+                this.setState('closed');
+                throw error;
+            }
+        });
+        this.disconnect = (code, reason) => __awaiter(this, void 0, void 0, function* () {
+            if (this._state === 'closed' || this._state === 'idle')
+                return;
+            this.setState('closing');
+            try {
+                yield this.transport.disconnect(code, reason);
+            }
+            catch (error) {
+                this.emitError({ error, phase: 'disconnect' });
+                throw error;
+            }
+        });
+        this.send = (arg1, arg2) => {
+            var _a;
+            const message = typeof arg1 === 'string'
+                ? (0, common_1.onlyDefined)({
+                    type: this.normalizeType(arg1),
+                    data: (_a = arg2) !== null && _a !== void 0 ? _a : null,
+                })
+                : (0, common_1.onlyDefined)(Object.assign(Object.assign({}, arg1), { type: this.normalizeType(arg1.type) }));
+            this.transport.send(JSON.stringify(message));
+        };
+        this.request = (type, data, options) => __awaiter(this, void 0, void 0, function* () {
+            var _b, _c, _d, _e, _f;
+            const mid = (_d = (_c = (_b = this.options).createMid) === null || _c === void 0 ? void 0 : _c.call(_b)) !== null && _d !== void 0 ? _d : buildMid();
+            const canonicalType = this.normalizeType(type);
+            const promise = this.pending.create(mid, {
+                timeoutMs: (_e = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _e !== void 0 ? _e : this.options.requestTimeoutMs,
+                onTimeout: requestMid => new Error(`408 REQUEST TIMEOUT - ${canonicalType}[${requestMid}]`),
+            });
+            try {
+                this.transport.send(JSON.stringify((0, common_1.onlyDefined)({
+                    type: canonicalType,
+                    data: (_f = data) !== null && _f !== void 0 ? _f : null,
+                    mid,
+                })));
+            }
+            catch (error) {
+                this.pending.reject(mid, error);
+                this.emitError({ error, phase: 'request' });
+                throw error;
+            }
+            return promise;
+        });
+        this.onState = (listener) => {
+            this.stateListeners.add(listener);
+            return () => this.stateListeners.delete(listener);
+        };
+        this.onError = (listener) => {
+            this.errorListeners.add(listener);
+            return () => this.errorListeners.delete(listener);
+        };
+        this.onMessage = (listener) => {
+            this.messageListeners.add(listener);
+            return () => this.messageListeners.delete(listener);
+        };
+        this.onType = (type, listener) => this.router.onType(type, listener);
+        this.normalizeType = (type) => {
+            var _a;
+            const source = (0, common_1.cleanString)(type);
+            if (!source)
+                throw new Error(`@type (string) is required - ClientSocketV2`);
+            return ((_a = this.aliases[source]) !== null && _a !== void 0 ? _a : source);
+        };
+        this.handleRawMessage = (raw) => {
+            try {
+                const message = parseMessage(raw);
+                const handled = this.pending.settle(message);
+                const event = { message, raw };
+                this.messageListeners.forEach(listener => listener(event));
+                if (!handled)
+                    this.router.route(message);
+            }
+            catch (error) {
+                this.emitError({ error, phase: 'message', raw });
+            }
+        };
+        this.setState = (next) => {
+            const prev = this._state;
+            this._state = next;
+            if (prev === next)
+                return;
+            const event = { prev, next };
+            this.stateListeners.forEach(listener => listener(event));
+        };
+        this.emitError = (event) => {
+            this.errorListeners.forEach(listener => listener(event));
+        };
+        this.deviceDefaults = options.device ? (0, common_1.omitKeys)(options.device, ['tick']) : undefined;
+        this.timerScheduler = (_a = options.timerScheduler) !== null && _a !== void 0 ? _a : new shared_timer_scheduler_1.InMemorySharedTimerScheduler(options.now ? { now: options.now } : {});
+        this.pending = new pending_request_store_1.PendingRequestStore({
+            timerScheduler: this.timerScheduler,
+            timerPrefix: 'pending:',
+        });
+        this.aliases = Object.assign({ ping: 'system.ping' }, (options.aliases || {}));
+        this.transport = new socket_transport_1.WebSocketTransport(options.url, options.protocols, options.socketFactory);
+        this.transport.on('open', () => this.setState('connected'));
+        this.transport.on('close', () => {
+            this.pending.clear(new Error(`499 CLIENT CLOSED REQUEST - socket closed`));
+            this.setState('closed');
+        });
+        this.transport.on('error', event => {
+            this.emitError({ error: event === null || event === void 0 ? void 0 : event.error, phase: 'transport' });
+        });
+        this.transport.on('message', event => this.handleRawMessage(event.data));
+    }
+    get state() {
+        return this._state;
+    }
+}
+const createClientSocketV2 = (options) => new ClientSocketV2Impl(options);
+exports.createClientSocketV2 = createClientSocketV2;

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

@@ -0,0 +1,19 @@
+import { type DeviceGateway } from './gateways/device-gateway';
+import { DeviceSyncPlan, type DeviceSyncPlanOptions } from './plans/device-sync-plan';
+import { type ClientSocketRuntimeOptions } from './socket-runtime';
+import type { ClientSocketRuntime, ClientSocketV2 } from './types';
+export interface DeviceSocketRuntime extends ClientSocketRuntime {
+    readonly client: ClientSocketV2;
+    readonly device: DeviceGateway;
+    readonly devicePlan: DeviceSyncPlan;
+    saveCurrentDevice(): Promise<void>;
+    startCurrentDeviceSync(intervalMs?: number): void;
+    startDeviceSync(id: string, intervalMs?: number): void;
+}
+export interface CreateDeviceRuntimeOptions extends Omit<ClientSocketRuntimeOptions, 'client' | 'syncPlans' | 'scheduler' | 'keepAlive' | 'reconnect' | 'rotation'> {
+    client: ClientSocketV2;
+    devicePlan?: DeviceSyncPlan;
+    devicePlanOptions?: DeviceSyncPlanOptions;
+    extraSyncPlans?: ClientSocketRuntimeOptions['syncPlans'];
+}
+export declare const createDeviceRuntime: (options: CreateDeviceRuntimeOptions) => DeviceSocketRuntime;

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

@@ -0,0 +1,53 @@
+"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.createDeviceRuntime = void 0;
+const device_gateway_1 = require("./gateways/device-gateway");
+const device_sync_plan_1 = require("./plans/device-sync-plan");
+const socket_runtime_1 = require("./socket-runtime");
+const createDeviceRuntime = (options) => {
+    var _a, _b;
+    const devicePlan = (_a = options.devicePlan) !== null && _a !== void 0 ? _a : new device_sync_plan_1.DeviceSyncPlan(options.devicePlanOptions);
+    const runtime = new socket_runtime_1.SocketRuntime(Object.assign(Object.assign({}, options), { client: options.client, syncPlans: [devicePlan, ...((_b = options.extraSyncPlans) !== null && _b !== void 0 ? _b : [])] }));
+    const device = (0, device_gateway_1.createDeviceGateway)(options.client);
+    let active = false;
+    const saveCurrentDevice = () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!active || !options.client.deviceDefaults)
+            return;
+        yield device.save(options.client.deviceDefaults);
+    });
+    options.client.onState(event => {
+        if (event.next === 'connected')
+            void saveCurrentDevice();
+    });
+    return {
+        client: options.client,
+        device,
+        devicePlan,
+        start: () => __awaiter(void 0, void 0, void 0, function* () {
+            active = true;
+            yield runtime.start();
+        }),
+        stop: () => __awaiter(void 0, void 0, void 0, function* () {
+            active = false;
+            yield runtime.stop();
+        }),
+        startSync: runtime.startSync,
+        stopSync: runtime.stopSync,
+        stopAllSync: runtime.stopAllSync,
+        listSyncTargets: runtime.listSyncTargets,
+        updateLocalSnapshot: runtime.updateLocalSnapshot,
+        saveCurrentDevice,
+        startCurrentDeviceSync: (intervalMs) => runtime.startSync({ type: 'device', intervalMs }),
+        startDeviceSync: (id, intervalMs) => runtime.startSync({ type: 'device', id, intervalMs }),
+    };
+};
+exports.createDeviceRuntime = createDeviceRuntime;

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

@@ -0,0 +1 @@
+export type { DomainSyncContext, DomainSyncPlan, SyncTargetDescriptor, SyncTargetType } from './types';

package/dist/client-socket-v2/domain-sync-plan.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/client-socket-v2/gateways/create-domain-gateway.d.ts

@@ -0,0 +1,6 @@
+import type { ClientSocketV2 } from '../types';
+export interface DomainGateway {
+    send(action: string, data?: unknown): void;
+    request<TResult = unknown>(action: string, data?: unknown): Promise<TResult>;
+}
+export declare const createDomainGateway: (domain: string, client: ClientSocketV2) => DomainGateway;

package/dist/client-socket-v2/gateways/create-domain-gateway.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDomainGateway = void 0;
+const createDomainGateway = (domain, client) => {
+    const prefix = `${domain !== null && domain !== void 0 ? domain : ''}`.trim();
+    if (!prefix)
+        throw new Error(`@domain (string) is required - createDomainGateway()`);
+    const resolveType = (action) => {
+        const suffix = `${action !== null && action !== void 0 ? action : ''}`.trim();
+        if (!suffix)
+            throw new Error(`@action (string) is required - createDomainGateway(${prefix})`);
+        return `${prefix}.${suffix}`;
+    };
+    return {
+        send: (action, data) => client.send(resolveType(action), data),
+        request: (action, data) => client.request(resolveType(action), data),
+    };
+};
+exports.createDomainGateway = createDomainGateway;

package/dist/client-socket-v2/gateways/device-gateway.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceGetInput, DeviceGetResponseData, DeviceSaveInput, DeviceSaveResponseData, DeviceSyncInput } from '../../lib/device/types';
+import type { ClientSocketV2 } from '../types';
+export interface DeviceGateway {
+    save(data: DeviceSaveInput): Promise<DeviceSaveResponseData>;
+    read(data?: DeviceGetInput | null): Promise<DeviceGetResponseData>;
+    sync(data?: DeviceSyncInput | null): void;
+}
+export declare const createDeviceGateway: (client: ClientSocketV2) => DeviceGateway;

package/dist/client-socket-v2/gateways/device-gateway.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeviceGateway = void 0;
+const create_domain_gateway_1 = require("./create-domain-gateway");
+const createDeviceGateway = (client) => {
+    const gateway = (0, create_domain_gateway_1.createDomainGateway)('device', client);
+    return {
+        save: data => gateway.request('save', data),
+        read: data => gateway.request('read', data !== null && data !== void 0 ? data : null),
+        sync: data => gateway.send('sync', data !== null && data !== void 0 ? data : null),
+    };
+};
+exports.createDeviceGateway = createDeviceGateway;

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

@@ -0,0 +1,23 @@
+import '../lib/sockets/packets';
+import '../lib/device/types';
+export * from './types';
+export * from './common';
+export { createClientSocketV2 as default } from './create-client-socket-v2';
+export * from './domain-sync-plan';
+export * from './pending-request-store';
+export * from './message-router';
+export * from './shared-timer-scheduler';
+export * from './socket-transport';
+export * from './create-client-socket-v2';
+export * from './keep-alive-loop';
+export * from './reconnect-controller';
+export * from './connection-rotation-controller';
+export * from './sync-scheduler';
+export * from './socket-runtime';
+export * from './create-device-runtime';
+export * from './plans/device-sync-plan';
+export * from './gateways/create-domain-gateway';
+export * from './gateways/device-gateway';
+export * from '../lib/types';
+export * from '../lib/device/types';
+export * from '../lib/device/contracts';

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

@@ -0,0 +1,41 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+require("../lib/sockets/packets");
+require("../lib/device/types");
+__exportStar(require("./types"), exports);
+__exportStar(require("./common"), exports);
+var create_client_socket_v2_1 = require("./create-client-socket-v2");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return create_client_socket_v2_1.createClientSocketV2; } });
+__exportStar(require("./domain-sync-plan"), exports);
+__exportStar(require("./pending-request-store"), exports);
+__exportStar(require("./message-router"), exports);
+__exportStar(require("./shared-timer-scheduler"), exports);
+__exportStar(require("./socket-transport"), exports);
+__exportStar(require("./create-client-socket-v2"), exports);
+__exportStar(require("./keep-alive-loop"), exports);
+__exportStar(require("./reconnect-controller"), exports);
+__exportStar(require("./connection-rotation-controller"), exports);
+__exportStar(require("./sync-scheduler"), exports);
+__exportStar(require("./socket-runtime"), exports);
+__exportStar(require("./create-device-runtime"), exports);
+__exportStar(require("./plans/device-sync-plan"), exports);
+__exportStar(require("./gateways/create-domain-gateway"), exports);
+__exportStar(require("./gateways/device-gateway"), exports);
+__exportStar(require("../lib/types"), exports);
+__exportStar(require("../lib/device/types"), exports);
+__exportStar(require("../lib/device/contracts"), exports);

package/dist/client-socket-v2/keep-alive-loop.d.ts

@@ -0,0 +1,29 @@
+import type { KeepAliveLoopControl, ClientSocketV2, SharedTimerScheduler } from './types';
+export interface KeepAliveLoopOptions {
+    client: ClientSocketV2;
+    intervalMs?: number;
+    timeoutMs?: number;
+    buildPayload?: () => unknown;
+    mode?: 'send' | 'request';
+    timerScheduler?: SharedTimerScheduler;
+    timerKey?: string;
+}
+export declare class KeepAliveLoop implements KeepAliveLoopControl {
+    private readonly options;
+    private readonly intervalMs;
+    private readonly mode;
+    private readonly timerScheduler?;
+    private readonly timerKey;
+    private readonly unsubs;
+    private timer?;
+    private running;
+    private inFlight?;
+    constructor(options: KeepAliveLoopOptions);
+    start: () => void;
+    stop: () => void;
+    destroy: () => void;
+    private scheduleNow;
+    private scheduleNext;
+    private clearTimer;
+    private tick;
+}