@makeitnow/jumpitnow 0.0.0-stage → 0.1.0-alpha.3

package/dist/esm/internal/gateway.js

@@ -0,0 +1,582 @@
+import { SDKError, asError, fail, integer } from './errors.js';
+import { parse, u16 } from './protocol.js';
+export const VERSION = '0.1.0-alpha.3';
+const INTERFACE = '1';
+const clone = (value) => {
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        throw new SDKError('INVALID_ARGUMENT');
+    }
+};
+const signals = ['vibrate', 'buzzer', 'displayId'];
+export class GatewayEngine {
+    #link;
+    #simulated;
+    #options;
+    #state = 'disconnected';
+    #listeners = new Map();
+    #devices = new Map();
+    #pending = null;
+    #active = null;
+    #activeBackground = false;
+    #queued = false;
+    #connection = null;
+    #disconnecting = null;
+    #closing = false;
+    #blocked = new Set();
+    #owned = new Set();
+    #recent = [];
+    #poll = null;
+    #pollIndex = 0;
+    #reads = new Map();
+    #scanSeen = null;
+    #cancelPause = null;
+    #counter = 0;
+    #prefix = globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    constructor(link, options = {}, simulated = false) {
+        this.#link = link;
+        this.#simulated = simulated;
+        if (!options || typeof options !== 'object' || Array.isArray(options))
+            fail('INVALID_ARGUMENT');
+        if (options.identifySignals && (!Array.isArray(options.identifySignals) || options.identifySignals.some(v => !signals.includes(v))))
+            fail('INVALID_ARGUMENT');
+        this.#options = {
+            requestTimeoutMs: integer(options.requestTimeoutMs ?? 1500, 50, 30000),
+            scanWindowMs: integer(options.scanWindowMs ?? 2000, 50, 30000),
+            pollIntervalMs: integer(options.pollIntervalMs ?? 250, 20, 30000),
+            staleAfterMs: integer(options.staleAfterMs ?? 5000, 50, 300000),
+            identifySignals: [...new Set(options.identifySignals ?? [])]
+        };
+    }
+    #id(prefix) { return `${prefix}-${this.#prefix}-${++this.#counter}`; }
+    #emit(name, value) {
+        for (const listener of this.#listeners.get(name) ?? []) {
+            try {
+                listener(clone(value));
+            }
+            catch { /* A UI callback must not break transport cleanup or other listeners. */ }
+        }
+    }
+    on(name, handler) {
+        if (!['measurement', 'deviceChanged', 'connectionChanged', 'error'].includes(name) || typeof handler !== 'function')
+            fail('INVALID_ARGUMENT');
+        if (!this.#listeners.has(name))
+            this.#listeners.set(name, new Set());
+        const listeners = this.#listeners.get(name);
+        const callback = handler;
+        listeners.add(callback);
+        return () => { listeners.delete(callback); };
+    }
+    #change(state) {
+        const previousState = this.#state;
+        this.#state = state;
+        if (state !== previousState)
+            this.#emit('connectionChanged', { state, previousState });
+    }
+    #deviceState(device, state) {
+        const previousState = device.public.state;
+        device.public.state = state;
+        if (previousState !== state)
+            this.#emit('deviceChanged', { device: device.public, previousState });
+    }
+    #lost() {
+        if (this.#closing || this.#state === 'lost' || this.#state === 'disconnected')
+            return;
+        this.#change('lost');
+        this.#stopPoll();
+        this.#pending?.cancel(new SDKError('CONNECTION_LOST'));
+        this.#cancelPause?.();
+        for (const device of this.#devices.values())
+            this.#deviceState(device, this.#owned.has(device.public.deviceId) ? 'unknown' : 'offline');
+        this.#emit('error', new SDKError('CONNECTION_LOST').toJSON());
+    }
+    #receive(line) {
+        const frame = parse(line);
+        if (!frame)
+            return;
+        if (frame.kind === 'rx' && frame.bytes[0] === 1 && frame.bytes.length === 2)
+            this.#scanSeen?.set(frame.endpoint, frame.number);
+        this.#pending?.receive(frame);
+    }
+    #request(command, match, timeoutMs = this.#options.requestTimeoutMs, key) {
+        if (this.#pending)
+            return Promise.reject(new SDKError('BUSY'));
+        if (key && this.#blocked.has(key))
+            return Promise.reject(new SDKError('INVALID_STATE'));
+        const requestId = this.#id('request');
+        const startedAt = Date.now();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                this.#pending = null;
+                if (key && error && ['TIMEOUT', 'CONNECTION_LOST', 'PROTOCOL_ERROR'].includes(error.code))
+                    this.#blocked.add(key);
+                this.#recent.push({ requestId, durationMs: Date.now() - startedAt, errorCode: error?.code ?? null });
+                if (this.#recent.length > 30)
+                    this.#recent.shift();
+                if (error)
+                    reject(new SDKError(error.code, { requestId }));
+                else
+                    resolve(value);
+            };
+            const timer = setTimeout(() => finish(new SDKError('TIMEOUT')), timeoutMs);
+            this.#pending = {
+                receive: frame => {
+                    try {
+                        if (frame.kind === 'error')
+                            return finish(new SDKError('DEVICE_REJECTED'));
+                        const value = match(frame);
+                        if (value !== undefined)
+                            finish(null, value);
+                    }
+                    catch (error) {
+                        finish(asError(error));
+                    }
+                },
+                cancel: error => finish(error)
+            };
+            // Subscribe first: some ports deliver their response before write() resolves.
+            void this.#link.write(command).catch(() => { finish(new SDKError('CONNECTION_LOST')); this.#lost(); });
+        });
+    }
+    connect() {
+        if (this.#state === 'connected')
+            return Promise.resolve(this.getInfo());
+        if (this.#connection)
+            return this.#connection;
+        if (this.#closing || this.#state === 'lost')
+            return Promise.reject(new SDKError('INVALID_STATE'));
+        this.#change('connecting');
+        this.#connection = (async () => {
+            try {
+                await this.#link.open(line => this.#receive(line), () => this.#lost());
+                let commands = false;
+                let registry = false;
+                let targets = false;
+                await this.#request('help', frame => {
+                    if (frame.kind !== 'help')
+                        return;
+                    commands ||= frame.text.includes('getData|status|fw');
+                    registry ||= frame.text.includes('getList|clearList|scanList|refreshList');
+                    targets ||= frame.text.includes('target=all|0|id|#index|!addr');
+                    if (commands && registry && targets)
+                        return true;
+                });
+                await this.#list();
+                if (this.#state === 'lost')
+                    throw new SDKError('CONNECTION_LOST');
+                // Keep unresolved ownership across a reconnect so it cannot be silently overwritten.
+                for (const device of this.#devices.values()) {
+                    device.mode = null;
+                    this.#deviceState(device, this.#owned.has(device.public.deviceId) ? 'unknown' : 'offline');
+                }
+                this.#change('connected');
+                return this.getInfo();
+            }
+            catch (error) {
+                this.#closing = true;
+                await this.#link.close().catch(() => { });
+                this.#closing = false;
+                this.#change('disconnected');
+                const e = asError(error);
+                throw e.code === 'TIMEOUT' || e.code === 'DEVICE_REJECTED' ? new SDKError('UNSUPPORTED_GATEWAY') : e;
+            }
+            finally {
+                this.#connection = null;
+            }
+        })();
+        return this.#connection;
+    }
+    #run(work, background = false) {
+        if (this.#state !== 'connected')
+            return Promise.reject(new SDKError('NOT_CONNECTED'));
+        if (this.#active && this.#activeBackground && !background && !this.#queued && !this.#closing) {
+            // An invisible automatic read must not make the teacher's stop button fail BUSY.
+            this.#queued = true;
+            this.#stopPoll();
+            return this.#active.catch(() => { }).then(() => { this.#queued = false; return this.#run(work); });
+        }
+        if (this.#active || this.#closing)
+            return Promise.reject(new SDKError('BUSY'));
+        const operation = Promise.resolve().then(() => {
+            if (this.#closing || this.#state !== 'connected')
+                throw new SDKError('CONNECTION_LOST');
+            return work();
+        }).finally(() => { this.#active = null; this.#activeBackground = false; this.#schedulePoll(); });
+        this.#active = operation;
+        this.#activeBackground = background;
+        return operation;
+    }
+    #list() {
+        let begun = false;
+        const records = [];
+        return this.#request('getList', frame => {
+            if (frame.kind === 'list' && frame.phase === 'BEGIN') {
+                begun = true;
+                records.length = 0;
+            }
+            else if (begun && frame.kind === 'device') {
+                if (records.length >= 40)
+                    throw new SDKError('PROTOCOL_ERROR');
+                records.push(frame);
+            }
+            else if (begun && frame.kind === 'list' && frame.phase === 'END')
+                return records;
+        });
+    }
+    #pause(ms) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.#cancelPause = null; resolve(); }, ms);
+            this.#cancelPause = () => { clearTimeout(timer); this.#cancelPause = null; reject(new SDKError('CONNECTION_LOST')); };
+        });
+    }
+    scan(options = {}) {
+        return this.#run(async () => {
+            if (this.#owned.size)
+                fail('BUSY');
+            if (!options || typeof options !== 'object')
+                fail('INVALID_ARGUMENT');
+            const windowMs = integer(options.timeoutMs ?? this.#options.scanWindowMs, 50, 30000);
+            const seen = new Map();
+            this.#scanSeen = seen;
+            try {
+                await this.#request('discover all', frame => {
+                    if (frame.kind === 'tx' && frame.target === 'all' && frame.bytes.length === 1 && frame.bytes[0] === 1) {
+                        if (!frame.ok)
+                            throw new SDKError('DEVICE_REJECTED');
+                        return true;
+                    }
+                });
+                await this.#pause(windowMs);
+                const list = await this.#list();
+                for (const device of this.#devices.values())
+                    this.#deviceState(device, 'offline');
+                for (const row of list) {
+                    if (seen.get(row.endpoint) !== row.number)
+                        continue;
+                    let device = [...this.#devices.values()].find(d => d.endpoint === row.endpoint && d.number === row.number);
+                    if (!device) {
+                        const deviceId = this.#id('rope');
+                        device = { endpoint: row.endpoint, number: row.number, mode: null, session: this.#id('session'), segment: 0, last: null,
+                            public: { deviceId, displayNumber: row.number >= 1 && row.number <= 40 ? row.number : null,
+                                state: 'available', firmwareVersion: row.version === '0.0.0' ? null : row.version,
+                                battery: this.#battery(row.battery), simulated: this.#simulated,
+                                capabilities: { modes: ['free', 'count', 'time'], maxTargetCount: 65535, maxDurationSeconds: 65535,
+                                    identifySignals: [...this.#options.identifySignals], hardwareVerified: false } } };
+                        this.#devices.set(deviceId, device);
+                        this.#emit('deviceChanged', { device: device.public, previousState: null });
+                    }
+                    else {
+                        device.mode = null;
+                        device.session = this.#id('session');
+                        device.segment = 0;
+                        device.last = null;
+                        device.public.firmwareVersion = row.version === '0.0.0' ? null : row.version;
+                        device.public.battery = this.#battery(row.battery);
+                        this.#deviceState(device, 'available');
+                    }
+                }
+                return { devices: this.getDevices(), status: 'complete', windowMs };
+            }
+            finally {
+                this.#scanSeen = null;
+            }
+        });
+    }
+    #device(id) {
+        if (typeof id !== 'string' || !this.#devices.has(id))
+            fail('INVALID_ARGUMENT');
+        return this.#devices.get(id);
+    }
+    #targets(ids, allowOffline = false) {
+        if (!Array.isArray(ids) || ids.length < 1 || ids.length > 40 || new Set(ids).size !== ids.length)
+            fail('INVALID_ARGUMENT');
+        return ids.map(id => {
+            const device = this.#device(id);
+            if (!allowOffline && device.public.state === 'offline')
+                fail('DEVICE_OFFLINE');
+            if (device.public.displayNumber === null || [...this.#devices.values()].filter(d => d.number === device.number && d.public.state !== 'offline').length > 1)
+                fail('AMBIGUOUS_DEVICE');
+            return device;
+        });
+    }
+    #mode(mode) {
+        if (!mode || typeof mode !== 'object')
+            fail('INVALID_ARGUMENT');
+        switch (mode.type) {
+            case 'free': return { mode: { type: 'free' }, command: 'free', code: 16 };
+            case 'count': return { mode: { type: 'count', targetCount: integer(mode.targetCount, 1, 65535) }, command: 'count', code: 17 };
+            case 'time': return { mode: { type: 'time', durationSeconds: integer(mode.durationSeconds, 1, 65535) }, command: 'time', code: 18 };
+            default: return fail('INVALID_ARGUMENT');
+        }
+    }
+    #assertUnblocked(devices, code) {
+        if (devices.some(d => this.#blocked.has(`${d.endpoint}/${code}`)))
+            fail('INVALID_STATE');
+    }
+    async #exchange(device, command, code, parameter, timeoutMs) {
+        const target = `!${device.endpoint}`;
+        const data = await this.#request(`${command} ${target}${parameter === undefined ? '' : ` ${parameter}`}`, frame => {
+            if (frame.kind === 'tx' && frame.endpoint === device.endpoint && frame.bytes[0] === code && !frame.ok)
+                throw new SDKError('DEVICE_REJECTED');
+            if (frame.kind !== 'rx' || frame.endpoint !== device.endpoint || frame.number !== device.number)
+                return;
+            if (frame.bytes[0] === 127 && frame.bytes.length >= 4 && frame.bytes[3] === code)
+                throw new SDKError('DEVICE_REJECTED');
+            if (frame.bytes[0] !== code)
+                return;
+            const expectedLength = code === 21 ? 9 : code === 6 ? 3 : 2;
+            if (frame.bytes.length !== expectedLength)
+                throw new SDKError('PROTOCOL_ERROR');
+            if (code === 6 && frame.bytes[2] > 100)
+                throw new SDKError('PROTOCOL_ERROR');
+            return frame.bytes;
+        }, timeoutMs, `${device.endpoint}/${code}`);
+        return data;
+    }
+    async #command(device, command, code, parameter, cleanup = false) {
+        if (this.#state !== 'connected' || (this.#closing && !cleanup))
+            return { deviceId: device.public.deviceId, status: 'failed', errorCode: 'CONNECTION_LOST' };
+        try {
+            await this.#exchange(device, command, code, parameter);
+            return { deviceId: device.public.deviceId, status: 'acknowledged' };
+        }
+        catch (error) {
+            const e = asError(error);
+            const uncertain = ['TIMEOUT', 'CONNECTION_LOST', 'PROTOCOL_ERROR'].includes(e.code);
+            if (uncertain)
+                this.#deviceState(device, 'unknown');
+            return { deviceId: device.public.deviceId, status: uncertain ? 'unknown' : 'failed', errorCode: e.code };
+        }
+    }
+    #result(results) { return { requestId: this.#id('operation'), ok: results.every(r => r.status === 'acknowledged'), results }; }
+    async configure(options) {
+        // Snapshot caller-owned input before asynchronous execution.
+        const input = clone(options);
+        return this.#run(async () => {
+            const devices = this.#targets(input?.deviceIds);
+            const mode = this.#mode(input?.mode);
+            if (devices.some(d => this.#owned.has(d.public.deviceId)))
+                fail('BUSY');
+            this.#assertUnblocked(devices, mode.code);
+            const parameter = mode.mode.type === 'count' ? mode.mode.targetCount : mode.mode.type === 'time' ? mode.mode.durationSeconds : undefined;
+            const results = [];
+            for (const device of devices) {
+                const result = await this.#command(device, mode.command, mode.code, parameter);
+                device.mode = result.status === 'acknowledged' ? clone(mode.mode) : null;
+                if (result.status === 'acknowledged')
+                    this.#deviceState(device, 'available');
+                results.push(result);
+            }
+            return this.#result(results);
+        });
+    }
+    async start(options) {
+        const ids = clone(options?.deviceIds);
+        return this.#run(async () => {
+            const devices = this.#targets(ids);
+            if (devices.some(d => this.#owned.has(d.public.deviceId)))
+                fail('BUSY');
+            if (devices.some(d => !d.mode || d.public.state !== 'available'))
+                fail('INVALID_STATE');
+            this.#assertUnblocked(devices, 19);
+            // A rollback must remain possible before admitting a new start.
+            this.#assertUnblocked(devices, 20);
+            const results = [];
+            for (const device of devices) {
+                const result = await this.#command(device, 'start', 19);
+                results.push(result);
+                if (result.status !== 'failed') {
+                    this.#owned.add(device.public.deviceId);
+                    device.session = this.#id('session');
+                    device.segment = 0;
+                    device.last = null;
+                    this.#deviceState(device, result.status === 'acknowledged' ? 'running' : 'unknown');
+                }
+            }
+            if (results.some(r => r.status !== 'acknowledged')) {
+                for (const result of results) {
+                    if (result.status === 'failed')
+                        continue;
+                    const recovery = await this.#stopOne(this.#device(result.deviceId), false);
+                    result.recovery = { action: 'stop', status: recovery.status };
+                }
+            }
+            return this.#result(results);
+        });
+    }
+    async #stopOne(device, finalRead) {
+        const result = await this.#command(device, 'stop', 20, undefined, true);
+        if (result.status === 'acknowledged') {
+            this.#owned.delete(device.public.deviceId);
+            this.#deviceState(device, 'available');
+        }
+        else if (this.#owned.has(device.public.deviceId))
+            this.#deviceState(device, 'unknown');
+        if (finalRead) {
+            let measurement = null;
+            if (result.status === 'acknowledged') {
+                try {
+                    measurement = await this.#measure(device);
+                }
+                catch { /* Stop ACK remains distinct from final data. */ }
+            }
+            result.finalMeasurement = { available: measurement !== null, measurement };
+        }
+        return result;
+    }
+    async stop(options) {
+        const ids = clone(options?.deviceIds);
+        return this.#run(async () => {
+            const devices = this.#targets(ids, true);
+            this.#assertUnblocked(devices, 20);
+            const results = [];
+            for (const device of devices)
+                results.push(await this.#stopOne(device, true));
+            return this.#result(results);
+        });
+    }
+    async #measure(device, timeoutMs) {
+        const data = await this.#exchange(device, 'getData', 21, undefined, timeoutMs);
+        const count = u16(data, 3);
+        const elapsedMs = u16(data, 5) * 100;
+        if (device.last && (count < device.last.count || elapsedMs < device.last.elapsedMs))
+            device.segment++;
+        const measurement = { deviceId: device.public.deviceId, displayNumber: device.public.displayNumber,
+            sessionId: device.session, segmentId: `${device.session}/${device.segment}`, count, elapsedMs,
+            pauseCount: u16(data, 7), receivedAt: Date.now(), source: 'live', stale: false, simulated: this.#simulated };
+        device.last = measurement;
+        this.#emit('measurement', measurement);
+        return clone(measurement);
+    }
+    async readMeasurement(options) {
+        return this.#readMeasurement(options);
+    }
+    async #readMeasurement(options, background = false) {
+        const input = clone(options);
+        const pending = this.#reads.get(input?.deviceId);
+        if (pending)
+            return pending.then(clone);
+        const result = this.#run(async () => {
+            const device = this.#targets([input?.deviceId])[0];
+            const timeout = integer(input.timeoutMs ?? this.#options.requestTimeoutMs, 50, 30000);
+            try {
+                return await this.#measure(device, timeout);
+            }
+            catch (error) {
+                const e = asError(error);
+                if (e.code === 'TIMEOUT')
+                    this.#deviceState(device, 'unknown');
+                throw new SDKError(e.code, { deviceId: device.public.deviceId, requestId: e.requestId });
+            }
+        }, background);
+        this.#reads.set(input?.deviceId, result);
+        void result.finally(() => { this.#reads.delete(input?.deviceId); }).catch(() => { });
+        return result.then(clone);
+    }
+    getLastMeasurement(options) {
+        const device = this.#device(options?.deviceId);
+        const last = device.last;
+        return last ? { ...last, source: 'cache', stale: this.#state !== 'connected' || device.public.state === 'offline' || device.public.state === 'unknown' || Date.now() - last.receivedAt > this.#options.staleAfterMs } : null;
+    }
+    #battery(value) { return Number.isInteger(value) && value >= 0 && value <= 100 ? { kind: 'percent', value } : { kind: 'unknown' }; }
+    async readBattery(options) {
+        const input = clone(options);
+        return this.#run(async () => {
+            const device = this.#targets([input?.deviceId])[0];
+            const timeout = integer(input.timeoutMs ?? this.#options.requestTimeoutMs, 50, 30000);
+            const data = await this.#exchange(device, 'getBattery', 6, undefined, timeout);
+            const battery = this.#battery(data[2]);
+            if (battery.kind === 'unknown')
+                fail('PROTOCOL_ERROR');
+            device.public.battery = battery;
+            return clone(battery);
+        });
+    }
+    async identify(options) {
+        const input = clone(options);
+        return this.#run(async () => {
+            const device = this.#targets([input?.deviceId])[0];
+            if (!this.#options.identifySignals.includes(input.signal))
+                fail('UNSUPPORTED_FEATURE');
+            if (this.#owned.has(device.public.deviceId))
+                fail('BUSY');
+            const operation = { vibrate: ['vibrate', 49], buzzer: ['buzzer', 48], displayId: ['showId', 51] };
+            const [command, code] = operation[input.signal];
+            this.#assertUnblocked([device], code);
+            return this.#result([await this.#command(device, command, code)]);
+        });
+    }
+    #stopPoll() { if (this.#poll)
+        clearTimeout(this.#poll); this.#poll = null; }
+    #schedulePoll() {
+        this.#stopPoll();
+        if (this.#closing || this.#queued || this.#state !== 'connected' || !this.#owned.size)
+            return;
+        this.#poll = setTimeout(() => {
+            this.#poll = null;
+            if (this.#active) {
+                this.#schedulePoll();
+                return;
+            }
+            const devices = [...this.#owned].map(id => this.#device(id)).filter(d => !this.#blocked.has(`${d.endpoint}/21`));
+            if (!devices.length)
+                return;
+            const device = devices[this.#pollIndex++ % devices.length];
+            void this.#readMeasurement({ deviceId: device.public.deviceId }, true).catch(error => this.#emit('error', asError(error).toJSON()));
+        }, this.#options.pollIntervalMs);
+    }
+    disconnect() {
+        if (this.#disconnecting)
+            return this.#disconnecting;
+        if (this.#connection)
+            return Promise.reject(new SDKError('BUSY'));
+        if (this.#state === 'disconnected')
+            return Promise.resolve({ closed: true, stopResults: null });
+        this.#closing = true;
+        this.#stopPoll();
+        this.#pending?.cancel(new SDKError('CONNECTION_LOST'));
+        this.#cancelPause?.();
+        this.#disconnecting = (async () => {
+            try {
+                await this.#active?.catch(() => { });
+                const results = [];
+                for (const id of [...this.#owned])
+                    results.push(await this.#stopOne(this.#device(id), false));
+                this.#change('disconnecting');
+                let closed = true;
+                try {
+                    await this.#link.close();
+                }
+                catch {
+                    closed = false;
+                    this.#emit('error', new SDKError('PORT_UNAVAILABLE').toJSON());
+                }
+                for (const device of this.#devices.values())
+                    this.#deviceState(device, this.#owned.has(device.public.deviceId) ? 'unknown' : 'offline');
+                this.#change(closed ? 'disconnected' : 'lost');
+                return { closed, stopResults: results.length ? this.#result(results) : null };
+            }
+            finally {
+                this.#closing = false;
+                this.#disconnecting = null;
+            }
+        })();
+        return this.#disconnecting;
+    }
+    getDevices() { return [...this.#devices.values()].map(d => clone(d.public)); }
+    getInfo() {
+        return { connection: this.#state, sdkVersion: VERSION, interfaceVersion: INTERFACE, firmwareVersion: null,
+            simulated: this.#simulated, features: ['scan', 'configure', 'start', 'stop', 'measurement', 'battery', ...this.#options.identifySignals] };
+    }
+    getDiagnostics() {
+        return { sdkVersion: VERSION, interfaceVersion: INTERFACE, connection: this.#state, simulated: this.#simulated,
+            deviceCount: this.#devices.size, blockedOperationCount: this.#blocked.size, recentRequests: clone(this.#recent) };
+    }
+}

package/dist/esm/internal/link.d.ts

@@ -0,0 +1,13 @@
+import type { Support } from '../types.js';
+export interface Link {
+    open(line: (line: string) => void, lost: () => void): Promise<void>;
+    write(command: string): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function getSupport(): Support;
+export declare class BrowserLink implements Link {
+    #private;
+    open(line: (line: string) => void, lost: () => void): Promise<void>;
+    write(command: string): Promise<void>;
+    close(): Promise<void>;
+}