@synapticon/motion-master-client 2.3.0-beta.0 → 6.0.0-alpha.110

package/dist/mmpd.js

@@ -0,0 +1,322 @@
+// Parser for the `.mmpd` process-data recorder dump (see libs/node/process_data_dump.{h,cc}). The
+// format embeds the process image as a header so a run decodes fully offline — no running Motion
+// Master and no live bus. All multi-byte integers are little-endian.
+//
+// Layout:
+//   Prefix (36 bytes): magic 'MMPD', u16 formatVersion, u16 flags,
+//     u64 startSequence, u64 rowCount, u32 inputBytes, u32 outputBytes, u32 deviceCount.
+//   Device table (deviceCount): u16 slavePosition, u32 vendorId/productCode/revisionNumber/
+//     serialNumber, str name, u32 entryCount, then per entry: u16 index, u8 subindex,
+//     u8 direction (1=output/RxPDO, 0=input/TxPDO), u16 dataType, u16 bitLength, u32 bitOffset,
+//     str name. (str = u16 byte length + UTF-8 bytes.)
+//   Rows (rowCount, fixed stride 16 + inputBytes + outputBytes): u64 sequence, u64 timestampNs,
+//     inputs[inputBytes], outputs[outputBytes].
+const MAGIC = 0x4450_4d4d; // 'MMPD' as a little-endian u32 ('M','M','P','D')
+const SUPPORTED_FORMAT_VERSION = 1;
+const utf8 = new TextDecoder();
+// Cursor over a DataView for sequential little-endian reads while parsing the header.
+class Cursor {
+    dv;
+    u8;
+    offset;
+    constructor(dv, u8, offset = 0) {
+        this.dv = dv;
+        this.u8 = u8;
+        this.offset = offset;
+    }
+    u8val() {
+        return this.dv.getUint8(this.offset++);
+    }
+    u16() {
+        const v = this.dv.getUint16(this.offset, true);
+        this.offset += 2;
+        return v;
+    }
+    u32() {
+        const v = this.dv.getUint32(this.offset, true);
+        this.offset += 4;
+        return v;
+    }
+    u64() {
+        const v = this.dv.getBigUint64(this.offset, true);
+        this.offset += 8;
+        return v;
+    }
+    str() {
+        const len = this.u16();
+        const s = utf8.decode(this.u8.subarray(this.offset, this.offset + len));
+        this.offset += len;
+        return s;
+    }
+}
+/// A parsed `.mmpd` dump. The header is read eagerly; row values are decoded on demand so a
+/// large file (a deep recorder ring) is not fully materialised up front.
+export class MmpdFile {
+    header;
+    u8;
+    dv;
+    rowsStart;
+    constructor(header, u8, dv, 
+    /// Byte offset of the first row within the buffer.
+    rowsStart) {
+        this.header = header;
+        this.u8 = u8;
+        this.dv = dv;
+        this.rowsStart = rowsStart;
+    }
+    get rowCount() {
+        return this.header.rowCount;
+    }
+    /// Per-row byte stride: u64 sequence + u64 timestampNs + inputs + outputs.
+    get rowStride() {
+        return 16 + this.header.inputBytes + this.header.outputBytes;
+    }
+    /// The raw record at row `i` (views into the source buffer; do not retain past the buffer's life).
+    rowAt(i) {
+        const base = this.rowsStart + i * this.rowStride;
+        const inputsAt = base + 16;
+        const outputsAt = inputsAt + this.header.inputBytes;
+        return {
+            sequence: this.dv.getBigUint64(base, true),
+            timestampNs: this.dv.getBigUint64(base + 8, true),
+            inputs: this.u8.subarray(inputsAt, outputsAt),
+            outputs: this.u8.subarray(outputsAt, outputsAt + this.header.outputBytes),
+        };
+    }
+    /// Epoch microseconds for every row (JS-exact in a Number until ~year 2255, matching the live
+    /// monitoring protocol). Sub-microsecond nanoseconds are dropped.
+    timestampsUs() {
+        const out = new Float64Array(this.header.rowCount);
+        for (let i = 0; i < out.length; i++) {
+            out[i] = Number(this.dv.getBigUint64(this.rowsStart + i * this.rowStride + 8, true) / 1000n);
+        }
+        return out;
+    }
+    /// Decodes one entry's value for every row. Numeric types yield numbers (64-bit ints are coerced
+    /// to Number, lossy beyond 2^53); strings, undecodable (dataType 0), and unsupported types yield
+    /// null — so the result is always plottable.
+    decodeSeries(entry) {
+        const out = new Array(this.header.rowCount);
+        const reader = numericReader(entry.dataType);
+        const byteAligned = entry.bitOffset % 8 === 0 && entry.bitLength % 8 === 0;
+        const regionStart = entry.isOutput ? 16 + this.header.inputBytes : 16;
+        if (reader && byteAligned) {
+            // Fast path: read straight from the buffer with no per-row allocation.
+            const valueOffset = regionStart + (entry.bitOffset >> 3);
+            for (let i = 0; i < out.length; i++) {
+                const v = reader(this.dv, this.rowsStart + i * this.rowStride + valueOffset);
+                out[i] = typeof v === 'bigint' ? Number(v) : v;
+            }
+            return out;
+        }
+        // Slow path: sub-byte fields and strings — extract the bits, then decode.
+        for (let i = 0; i < out.length; i++) {
+            const row = this.rowAt(i);
+            const bytes = extractBits(entry.isOutput ? row.outputs : row.inputs, entry.bitOffset, entry.bitLength);
+            const v = decodeMmpdValue(entry.dataType, bytes);
+            out[i] = typeof v === 'number' ? v : typeof v === 'bigint' ? Number(v) : null;
+        }
+        return out;
+    }
+}
+/// Parses a `.mmpd` dump. Throws on a bad magic or an unsupported format version. A file whose row
+/// region is shorter than `rowCount` implies (truncated transfer) is clamped to the rows present.
+export function parseMmpd(data) {
+    const u8 = data instanceof Uint8Array ? data : new Uint8Array(data);
+    const dv = new DataView(u8.buffer, u8.byteOffset, u8.byteLength);
+    if (u8.byteLength < 36 || dv.getUint32(0, true) !== MAGIC) {
+        throw new Error('Not a .mmpd file (bad magic)');
+    }
+    const formatVersion = dv.getUint16(4, true);
+    if (formatVersion !== SUPPORTED_FORMAT_VERSION) {
+        throw new Error(`Unsupported .mmpd format version ${formatVersion} (expected ${SUPPORTED_FORMAT_VERSION})`);
+    }
+    const header = {
+        formatVersion,
+        flags: dv.getUint16(6, true),
+        startSequence: dv.getBigUint64(8, true),
+        rowCount: Number(dv.getBigUint64(16, true)),
+        inputBytes: dv.getUint32(24, true),
+        outputBytes: dv.getUint32(28, true),
+        devices: [],
+    };
+    const deviceCount = dv.getUint32(32, true);
+    const cursor = new Cursor(dv, u8, 36);
+    for (let d = 0; d < deviceCount; d++) {
+        const device = {
+            slavePosition: cursor.u16(),
+            vendorId: cursor.u32(),
+            productCode: cursor.u32(),
+            revisionNumber: cursor.u32(),
+            serialNumber: cursor.u32(),
+            name: cursor.str(),
+            entries: [],
+        };
+        const entryCount = cursor.u32();
+        for (let e = 0; e < entryCount; e++) {
+            device.entries.push({
+                index: cursor.u16(),
+                subindex: cursor.u8val(),
+                isOutput: cursor.u8val() === 1,
+                dataType: cursor.u16(),
+                bitLength: cursor.u16(),
+                bitOffset: cursor.u32(),
+                name: cursor.str(),
+            });
+        }
+        header.devices.push(device);
+    }
+    const rowsStart = cursor.offset;
+    const rowStride = 16 + header.inputBytes + header.outputBytes;
+    const available = Math.floor((u8.byteLength - rowsStart) / rowStride);
+    if (available < header.rowCount) {
+        header.rowCount = Math.max(0, available);
+    }
+    return new MmpdFile(header, u8, dv, rowsStart);
+}
+// A byte-aligned reader for the fixed-width numeric types, or null for variable/sub-byte/string
+// types that need the bit-extraction path.
+function numericReader(dataType) {
+    switch (dataType) {
+        case 1 /* DataType.BOOLEAN */:
+        case 5 /* DataType.UNSIGNED8 */:
+        case 30 /* DataType.BYTE */:
+        case 45 /* DataType.BITARR8 */:
+            return (dv, o) => dv.getUint8(o);
+        case 2 /* DataType.INTEGER8 */:
+            return (dv, o) => dv.getInt8(o);
+        case 3 /* DataType.INTEGER16 */:
+            return (dv, o) => dv.getInt16(o, true);
+        case 6 /* DataType.UNSIGNED16 */:
+        case 31 /* DataType.WORD */:
+        case 46 /* DataType.BITARR16 */:
+            return (dv, o) => dv.getUint16(o, true);
+        case 4 /* DataType.INTEGER32 */:
+            return (dv, o) => dv.getInt32(o, true);
+        case 7 /* DataType.UNSIGNED32 */:
+        case 32 /* DataType.DWORD */:
+        case 47 /* DataType.BITARR32 */:
+            return (dv, o) => dv.getUint32(o, true);
+        case 8 /* DataType.REAL32 */:
+            return (dv, o) => dv.getFloat32(o, true);
+        case 17 /* DataType.REAL64 */:
+            return (dv, o) => dv.getFloat64(o, true);
+        case 21 /* DataType.INTEGER64 */:
+            return (dv, o) => dv.getBigInt64(o, true);
+        case 27 /* DataType.UNSIGNED64 */:
+            return (dv, o) => dv.getBigUint64(o, true);
+        default:
+            return null;
+    }
+}
+/// Fetches the live recorder dump (`GET /api/process-data/dump`) and parses it. `baseUrl` is the
+/// HTTP API origin (e.g. `https://host:61447`). Throws on a non-OK response (the response body's
+/// `error` message when present). Pass `fetch` to inject an implementation (Node, request logging).
+export async function fetchProcessDataDump(baseUrl, options = {}) {
+    const doFetch = options.fetch ?? fetch;
+    const res = await doFetch(`${baseUrl.replace(/\/+$/, '')}/api/process-data/dump`, {
+        headers: { Accept: 'application/octet-stream' },
+        signal: options.signal,
+    });
+    if (!res.ok) {
+        let message = `HTTP ${res.status}`;
+        try {
+            const body = (await res.json());
+            if (body?.error) {
+                message = body.error;
+            }
+        }
+        catch {
+            // Non-JSON error body — keep the status message.
+        }
+        throw new Error(message);
+    }
+    return parseMmpd(await res.arrayBuffer());
+}
+/// Extracts `bitLength` bits starting at `bitOffset` from `src`, returning them LSB-aligned and
+/// little-endian (padded to a byte boundary). Mirrors `extractBits` in libs/node/process_image.cc.
+export function extractBits(src, bitOffset, bitLength) {
+    const out = new Uint8Array((bitLength + 7) >> 3);
+    if (bitOffset % 8 === 0 && bitLength % 8 === 0) {
+        const byteOffset = bitOffset >> 3;
+        for (let i = 0; i < out.length && byteOffset + i < src.length; i++) {
+            out[i] = src[byteOffset + i];
+        }
+        return out;
+    }
+    for (let i = 0; i < bitLength; i++) {
+        const srcBit = bitOffset + i;
+        const srcByte = srcBit >> 3;
+        if (srcByte >= src.length) {
+            break;
+        }
+        const bit = (src[srcByte] >> (srcBit & 7)) & 1;
+        out[i >> 3] |= bit << (i & 7);
+    }
+    return out;
+}
+/// Decodes LSB-aligned little-endian `bytes` (as produced by `extractBits`) for the given ETG.1020
+/// `dataType`. Returns a number for fixed-width numerics, a bigint for 64-bit integers, a string
+/// for VISIBLE/UNICODE strings (trailing NULs/spaces stripped), or null when the type is unknown
+/// (dataType 0) or there are too few bytes. Unmapped codes fall back to an unsigned read of the
+/// available bytes (covers BITn fields).
+export function decodeMmpdValue(dataType, bytes) {
+    const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const n = bytes.byteLength;
+    switch (dataType) {
+        case 1 /* DataType.BOOLEAN */:
+        case 5 /* DataType.UNSIGNED8 */:
+        case 30 /* DataType.BYTE */:
+        case 45 /* DataType.BITARR8 */:
+            return n >= 1 ? dv.getUint8(0) : null;
+        case 2 /* DataType.INTEGER8 */:
+            return n >= 1 ? dv.getInt8(0) : null;
+        case 3 /* DataType.INTEGER16 */:
+            return n >= 2 ? dv.getInt16(0, true) : null;
+        case 6 /* DataType.UNSIGNED16 */:
+        case 31 /* DataType.WORD */:
+        case 46 /* DataType.BITARR16 */:
+            return n >= 2 ? dv.getUint16(0, true) : null;
+        case 4 /* DataType.INTEGER32 */:
+            return n >= 4 ? dv.getInt32(0, true) : null;
+        case 7 /* DataType.UNSIGNED32 */:
+        case 32 /* DataType.DWORD */:
+        case 47 /* DataType.BITARR32 */:
+            return n >= 4 ? dv.getUint32(0, true) : null;
+        case 8 /* DataType.REAL32 */:
+            return n >= 4 ? dv.getFloat32(0, true) : null;
+        case 17 /* DataType.REAL64 */:
+            return n >= 8 ? dv.getFloat64(0, true) : null;
+        case 21 /* DataType.INTEGER64 */:
+            return n >= 8 ? dv.getBigInt64(0, true) : null;
+        case 27 /* DataType.UNSIGNED64 */:
+            return n >= 8 ? dv.getBigUint64(0, true) : null;
+        case 9 /* DataType.VISIBLE_STRING */:
+        case 11 /* DataType.UNICODE_STRING */: {
+            let end = n;
+            while (end > 0 && (bytes[end - 1] === 0x00 || bytes[end - 1] === 0x20)) {
+                end--;
+            }
+            return utf8.decode(bytes.subarray(0, end));
+        }
+        case 0x0000:
+            return null; // OD not enumerated — undecodable
+        default: {
+            // Unknown/sub-byte (e.g. BIT1..BIT16): read the available bytes as a little-endian unsigned.
+            if (n === 0 || n > 4) {
+                return null;
+            }
+            let v = 0;
+            for (let i = 0; i < n; i++) {
+                v |= bytes[i] << (8 * i);
+            }
+            return v >>> 0;
+        }
+    }
+}
+/// Whether `decodeSeries` yields plottable numbers for this ETG.1020 data-type code — a
+/// fixed-width integer/real or a bit field, but not a string, struct, or unenumerated type
+/// (dataType 0). Useful for offering only chartable objects in a UI.
+export function isPlottableDataType(dataType) {
+    return numericReader(dataType) !== null || (dataType >= 0x0030 && dataType <= 0x003f);
+}

package/dist/sdo.d.ts

@@ -0,0 +1,17 @@
+export declare const SDO_TYPES: readonly ["uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "float32", "float64", "string", "raw"];
+export type SdoType = (typeof SDO_TYPES)[number];
+export declare const SDO_TYPE_HINT: Record<SdoType, string>;
+export declare function parseIntegerFlexible(s: string): bigint | null;
+export declare function isIntegerSdoType(type: SdoType): boolean;
+export declare function encodeSdoValue(type: SdoType, raw: string): {
+    bytes: number[];
+} | {
+    error: string;
+};
+export declare function sdoTypeForDataTypeName(dataTypeName: string): SdoType;
+export interface SdoInterpretation {
+    label: string;
+    value: string;
+}
+export declare function interpretSdoBytes(bytes: number[]): SdoInterpretation[];
+export declare function decodeSdoBytes(dataTypeName: string, bytes: number[]): number | string | number[];

package/dist/sdo.js

@@ -0,0 +1,219 @@
+// Encoding and decoding helpers for CoE SDO values: turning the raw little-endian
+// byte arrays exchanged over the wire into human-readable values and back.
+import { parseHexBytes } from './hex.js';
+// CoE data types the SDO download card can encode a value into. `raw` is an
+// escape hatch for entering bytes directly.
+export const SDO_TYPES = [
+    'uint8', 'int8', 'uint16', 'int16', 'uint32', 'int32',
+    'uint64', 'int64', 'float32', 'float64', 'string', 'raw',
+];
+// Placeholder text shown in the value input for each type.
+export const SDO_TYPE_HINT = {
+    uint8: 'e.g. 200 or 0xC8',
+    int8: 'e.g. -42',
+    uint16: 'e.g. 1000 or 0x03E8',
+    int16: 'e.g. -1000',
+    uint32: 'e.g. 100000',
+    int32: 'e.g. -100000',
+    uint64: 'e.g. 4294967296',
+    int64: 'e.g. -4294967296',
+    float32: 'e.g. 3.14',
+    float64: 'e.g. 3.141592653589793',
+    string: 'e.g. SOMANET',
+    raw: 'hex bytes, e.g. 01 02 0A FF',
+};
+const INT_ENC = {
+    uint8: { size: 1, signed: false }, int8: { size: 1, signed: true },
+    uint16: { size: 2, signed: false }, int16: { size: 2, signed: true },
+    uint32: { size: 4, signed: false }, int32: { size: 4, signed: true },
+    uint64: { size: 8, signed: false }, int64: { size: 8, signed: true },
+};
+// Accepts decimal (with optional leading '-') or 0x-prefixed hex; returns null on anything else.
+// Signed hex is signed-magnitude ("-0x1"), not two's-complement — so a value round-trips through
+// the range check in encodeSdoValue regardless of the base it was entered in.
+export function parseIntegerFlexible(s) {
+    if (/^-?[0-9]+$/.test(s))
+        return BigInt(s);
+    if (/^0[xX][0-9a-fA-F]+$/.test(s))
+        return BigInt(s);
+    if (/^-0[xX][0-9a-fA-F]+$/.test(s))
+        return -BigInt(s.slice(1));
+    return null;
+}
+// True for the fixed-width integer types — the ones a value can meaningfully be shown and edited
+// in hexadecimal (floats and strings have no base; `raw` is already entered as hex bytes).
+export function isIntegerSdoType(type) {
+    return type in INT_ENC;
+}
+// Encodes a human-entered value into the little-endian byte sequence for an SDO download.
+export function encodeSdoValue(type, raw) {
+    const s = raw.trim();
+    const meta = INT_ENC[type];
+    if (meta) {
+        const n = parseIntegerFlexible(s);
+        if (n === null)
+            return { error: 'Not a valid integer' };
+        const bits = BigInt(meta.size * 8);
+        const min = meta.signed ? -(1n << (bits - 1n)) : 0n;
+        const max = meta.signed ? (1n << (bits - 1n)) - 1n : (1n << bits) - 1n;
+        if (n < min || n > max)
+            return { error: `Out of range for ${type} [${min}, ${max}]` };
+        const view = new DataView(new ArrayBuffer(meta.size));
+        if (meta.size === 1)
+            meta.signed ? view.setInt8(0, Number(n)) : view.setUint8(0, Number(n));
+        else if (meta.size === 2)
+            meta.signed ? view.setInt16(0, Number(n), true) : view.setUint16(0, Number(n), true);
+        else if (meta.size === 4)
+            meta.signed ? view.setInt32(0, Number(n), true) : view.setUint32(0, Number(n), true);
+        else
+            meta.signed ? view.setBigInt64(0, n, true) : view.setBigUint64(0, n, true);
+        return { bytes: [...new Uint8Array(view.buffer)] };
+    }
+    if (type === 'float32' || type === 'float64') {
+        if (s === '')
+            return { error: 'Value is empty' };
+        const f = Number(s);
+        if (Number.isNaN(f))
+            return { error: 'Not a valid number' };
+        const size = type === 'float32' ? 4 : 8;
+        const view = new DataView(new ArrayBuffer(size));
+        if (type === 'float32')
+            view.setFloat32(0, f, true);
+        else
+            view.setFloat64(0, f, true);
+        return { bytes: [...new Uint8Array(view.buffer)] };
+    }
+    if (type === 'string') {
+        return { bytes: [...new TextEncoder().encode(raw)] };
+    }
+    // raw: whitespace- or comma-separated hex bytes
+    const bytes = parseHexBytes(s);
+    if (bytes === null)
+        return { error: 'Not a valid even-length hex byte string' };
+    return { bytes };
+}
+// Maps a CoE object's data-type name (as reported by SDO Info) to the SdoType the
+// encoder understands, so a value typed inline against an object can be encoded
+// without the user picking a type. Falls back to `raw` for unknown/complex types.
+export function sdoTypeForDataTypeName(dataTypeName) {
+    switch (dataTypeName) {
+        case 'BOOLEAN':
+        case 'UNSIGNED8':
+        case 'BYTE':
+            return 'uint8';
+        case 'INTEGER8':
+            return 'int8';
+        case 'UNSIGNED16':
+        case 'WORD':
+            return 'uint16';
+        case 'INTEGER16':
+            return 'int16';
+        case 'UNSIGNED32':
+        case 'DWORD':
+            return 'uint32';
+        case 'INTEGER32':
+            return 'int32';
+        case 'UNSIGNED64':
+            return 'uint64';
+        case 'INTEGER64':
+            return 'int64';
+        case 'REAL32':
+            return 'float32';
+        case 'REAL64':
+            return 'float64';
+        case 'VISIBLE_STRING':
+        case 'UNICODE_STRING':
+            return 'string';
+        default:
+            return 'raw';
+    }
+}
+// Best-effort interpretation of raw SDO bytes as every fixed-width type that fits,
+// plus a printable-string reading. Used to show what an uploaded value could mean.
+export function interpretSdoBytes(bytes) {
+    const view = new DataView(new Uint8Array(bytes).buffer);
+    const out = [];
+    if (bytes.length === 1) {
+        out.push({ label: 'int8', value: String(view.getInt8(0)) });
+        out.push({ label: 'uint8', value: String(view.getUint8(0)) });
+    }
+    else if (bytes.length === 2) {
+        out.push({ label: 'int16 LE', value: String(view.getInt16(0, true)) });
+        out.push({ label: 'uint16 LE', value: String(view.getUint16(0, true)) });
+    }
+    else if (bytes.length === 4) {
+        out.push({ label: 'int32 LE', value: String(view.getInt32(0, true)) });
+        out.push({ label: 'uint32 LE', value: String(view.getUint32(0, true)) });
+        out.push({ label: 'float32 LE', value: String(view.getFloat32(0, true)) });
+    }
+    else if (bytes.length === 8) {
+        out.push({ label: 'int64 LE', value: view.getBigInt64(0, true).toString() });
+        out.push({ label: 'uint64 LE', value: view.getBigUint64(0, true).toString() });
+        out.push({ label: 'float64 LE', value: String(view.getFloat64(0, true)) });
+    }
+    if (bytes.length > 0 && bytes.every(b => (b >= 0x20 && b <= 0x7e) || b === 0)) {
+        // VISIBLE_STRING is space-padded to a fixed width and may carry a terminating
+        // NUL — neither is significant, so strip trailing 0x20/0x00 before display.
+        let len = bytes.length;
+        while (len > 0 && (bytes[len - 1] === 0x00 || bytes[len - 1] === 0x20))
+            len--;
+        const str = new TextDecoder().decode(new Uint8Array(bytes.slice(0, len).filter(b => b !== 0)));
+        out.push({ label: 'string', value: `"${str}"` });
+    }
+    return out;
+}
+// Decodes raw SDO bytes into a typed value, given the object's CoE data-type name.
+// Falls back to the raw byte array for unknown types or short reads.
+export function decodeSdoBytes(dataTypeName, bytes) {
+    const view = new DataView(new Uint8Array(bytes).buffer);
+    switch (dataTypeName) {
+        case 'BOOLEAN':
+        case 'UNSIGNED8':
+        case 'BYTE':
+            if (bytes.length >= 1)
+                return view.getUint8(0);
+            break;
+        case 'INTEGER8':
+            if (bytes.length >= 1)
+                return view.getInt8(0);
+            break;
+        case 'INTEGER16':
+            if (bytes.length >= 2)
+                return view.getInt16(0, true);
+            break;
+        case 'INTEGER32':
+            if (bytes.length >= 4)
+                return view.getInt32(0, true);
+            break;
+        case 'UNSIGNED16':
+        case 'WORD':
+            if (bytes.length >= 2)
+                return view.getUint16(0, true);
+            break;
+        case 'UNSIGNED32':
+        case 'DWORD':
+            if (bytes.length >= 4)
+                return view.getUint32(0, true);
+            break;
+        case 'REAL32':
+            if (bytes.length >= 4)
+                return view.getFloat32(0, true);
+            break;
+        case 'REAL64':
+            if (bytes.length >= 8)
+                return view.getFloat64(0, true);
+            break;
+        case 'INTEGER64':
+            if (bytes.length >= 8)
+                return Number(view.getBigInt64(0, true));
+            break;
+        case 'UNSIGNED64':
+            if (bytes.length >= 8)
+                return Number(view.getBigUint64(0, true));
+            break;
+        case 'VISIBLE_STRING':
+        case 'UNICODE_STRING':
+            return new TextDecoder().decode(new Uint8Array(bytes.filter(b => b !== 0)));
+    }
+    return bytes;
+}

package/dist/web-socket-connection.d.ts

@@ -0,0 +1,70 @@
+export type ReadyState = 'connecting' | 'open' | 'closed';
+export type MonitoringRow = (number | null)[];
+export type MonitoringBatch = MonitoringRow[];
+export interface MonitoringMessage {
+    type: 'monitoring';
+    topic: string;
+    data: MonitoringBatch;
+}
+export interface NotificationMessage {
+    type: 'notification';
+    data: unknown;
+}
+export interface ProgressMessage {
+    type: 'progress';
+    data: unknown;
+}
+export type ServerMessage = MonitoringMessage | NotificationMessage | ProgressMessage;
+type MonitoringListener = (rows: MonitoringBatch) => void;
+type NotificationListener = (data: unknown) => void;
+type ProgressListener = (data: unknown) => void;
+type StateListener = (state: ReadyState) => void;
+export declare const NOTIFICATION_TOPIC = "notifications";
+export interface WebSocketLike {
+    readyState: number;
+    send(data: string): void;
+    close(): void;
+    onopen: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onmessage: ((event: {
+        data: unknown;
+    }) => void) | null;
+}
+export type WebSocketConstructor = new (url: string, protocolsOrOptions?: unknown) => WebSocketLike;
+export interface WebSocketConnectionOptions {
+    url: string;
+    WebSocket?: WebSocketConstructor;
+    protocolsOrOptions?: unknown;
+    reconnectDelayMs?: number;
+    maxReconnectDelayMs?: number;
+}
+export declare class WebSocketConnection {
+    private readonly url;
+    private readonly WebSocketImpl?;
+    private readonly protocolsOrOptions?;
+    private readonly reconnectDelayMs;
+    private readonly maxReconnectDelayMs;
+    private socket;
+    private state;
+    private closedByUser;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private readonly topicListeners;
+    private readonly notificationListeners;
+    private readonly progressListeners;
+    private readonly stateListeners;
+    constructor(options: WebSocketConnectionOptions);
+    get readyState(): ReadyState;
+    connect(): void;
+    close(): void;
+    subscribe(topic: string, listener: MonitoringListener): () => void;
+    onNotification(listener: NotificationListener): () => void;
+    onProgress(listener: ProgressListener): () => void;
+    onStateChange(listener: StateListener): () => void;
+    private setState;
+    private send;
+    private handleDisconnect;
+    private route;
+}
+export {};