@totemsdk/edge-modbus 0.2.0 → 0.2.2

package/dist/cjs/index.d.ts

@@ -0,0 +1,7 @@
+export type { ModbusTransportPort, ModbusMessage } from './transport.js';
+export { createModbusGateway } from './gateway.js';
+export type { ModbusGatewayConfig, ModbusGateway } from './gateway.js';
+export { createModbusSensorBridge } from './sensor-bridge.js';
+export type { ModbusSensorBinding, ModbusSensorBridgeConfig, ModbusSensorBridge } from './sensor-bridge.js';
+export { NativeModbusTransport } from './native-transport.js';
+export type { NativeModbusConfig } from './native-transport.js';

package/dist/cjs/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeModbusTransport = exports.createModbusSensorBridge = exports.createModbusGateway = void 0;
+var gateway_js_1 = require("./gateway.js");
+Object.defineProperty(exports, "createModbusGateway", { enumerable: true, get: function () { return gateway_js_1.createModbusGateway; } });
+var sensor_bridge_js_1 = require("./sensor-bridge.js");
+Object.defineProperty(exports, "createModbusSensorBridge", { enumerable: true, get: function () { return sensor_bridge_js_1.createModbusSensorBridge; } });
+var native_transport_js_1 = require("./native-transport.js");
+Object.defineProperty(exports, "NativeModbusTransport", { enumerable: true, get: function () { return native_transport_js_1.NativeModbusTransport; } });

package/dist/cjs/native-transport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * NativeModbusTransport — connects to the edge-modbus Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15002)
+ * and accepts newline-delimited JSON requests. This class implements
+ * ModbusTransportPort by forwarding all calls to the Go process.
+ *
+ * Usage:
+ *   const transport = new NativeModbusTransport({ host: '127.0.0.1', port: 15002 });
+ *   await transport.connect();
+ *   const response = await transport.sendFrame(requestFrame);
+ *   transport.disconnect();
+ */
+import type { ModbusTransportPort } from './transport.js';
+export interface NativeModbusConfig {
+    host?: string;
+    port?: number;
+    /** Connection timeout in ms. Default 5000. */
+    connectTimeoutMs?: number;
+    /** Per-request timeout in ms. Default 10000. */
+    requestTimeoutMs?: number;
+}
+export declare class NativeModbusTransport implements ModbusTransportPort {
+    private socket;
+    private buffer;
+    private pending;
+    private frameHandlers;
+    private errorHandlers;
+    private readonly config;
+    constructor(config?: NativeModbusConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    sendFrame(frame: Uint8Array): Promise<Uint8Array>;
+    onFrame(handler: (frame: Uint8Array) => void): () => void;
+    onError(handler: (err: Error) => void): () => void;
+}

package/dist/cjs/native-transport.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * NativeModbusTransport — connects to the edge-modbus Go binary over TCP.
+ *
+ * The Go binary listens on a local TCP socket (default 127.0.0.1:15002)
+ * and accepts newline-delimited JSON requests. This class implements
+ * ModbusTransportPort by forwarding all calls to the Go process.
+ *
+ * Usage:
+ *   const transport = new NativeModbusTransport({ host: '127.0.0.1', port: 15002 });
+ *   await transport.connect();
+ *   const response = await transport.sendFrame(requestFrame);
+ *   transport.disconnect();
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeModbusTransport = void 0;
+let requestCounter = 0;
+class NativeModbusTransport {
+    constructor(config = {}) {
+        this.socket = null;
+        this.buffer = '';
+        this.pending = new Map();
+        this.frameHandlers = [];
+        this.errorHandlers = [];
+        this.config = {
+            host: config.host ?? '127.0.0.1',
+            port: config.port ?? 15002,
+            connectTimeoutMs: config.connectTimeoutMs ?? 5000,
+            requestTimeoutMs: config.requestTimeoutMs ?? 10000,
+        };
+    }
+    async connect() {
+        const net = await Promise.resolve().then(() => __importStar(require('net')));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.socket?.destroy();
+                reject(new Error(`NativeModbusTransport: connect timeout (${this.config.connectTimeoutMs}ms)`));
+            }, this.config.connectTimeoutMs);
+            this.socket = net.createConnection({ host: this.config.host, port: this.config.port }, () => {
+                clearTimeout(timer);
+                resolve();
+            });
+            this.socket.on('data', (chunk) => {
+                this.buffer += chunk.toString('utf-8');
+                const lines = this.buffer.split('\n');
+                this.buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const msg = JSON.parse(line);
+                        if (msg.id && this.pending.has(msg.id)) {
+                            const { resolve: res, reject: rej } = this.pending.get(msg.id);
+                            this.pending.delete(msg.id);
+                            if (msg.ok && msg.frame) {
+                                res(hexToBytes(msg.frame));
+                            }
+                            else {
+                                rej(new Error(msg.error ?? 'unknown error'));
+                            }
+                        }
+                    }
+                    catch {
+                        // ignore parse errors on partial lines
+                    }
+                }
+            });
+            this.socket.on('error', (err) => {
+                for (const handler of this.errorHandlers) {
+                    try {
+                        handler(err);
+                    }
+                    catch { }
+                }
+            });
+            this.socket.on('close', () => {
+                for (const [, pending] of this.pending) {
+                    pending.reject(new Error('NativeModbusTransport: connection closed'));
+                }
+                this.pending.clear();
+            });
+        });
+    }
+    async disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+    }
+    async sendFrame(frame) {
+        if (!this.socket) {
+            throw new Error('NativeModbusTransport: not connected');
+        }
+        const id = `modbus-${++requestCounter}`;
+        const request = { id, frame: bytesToHex(frame) };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`NativeModbusTransport: request ${id} timed out (${this.config.requestTimeoutMs}ms)`));
+            }, this.config.requestTimeoutMs);
+            this.pending.set(id, {
+                resolve: (data) => { clearTimeout(timer); resolve(data); },
+                reject: (err) => { clearTimeout(timer); reject(err); },
+            });
+            this.socket.write(JSON.stringify(request) + '\n');
+        });
+    }
+    onFrame(handler) {
+        this.frameHandlers.push(handler);
+        return () => {
+            this.frameHandlers = this.frameHandlers.filter(h => h !== handler);
+        };
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+        return () => {
+            this.errorHandlers = this.errorHandlers.filter(h => h !== handler);
+        };
+    }
+}
+exports.NativeModbusTransport = NativeModbusTransport;
+function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+function hexToBytes(hex) {
+    if (hex.length % 2 !== 0)
+        throw new Error('Invalid hex string');
+    const arr = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < arr.length; i++) {
+        arr[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return arr;
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/sensor-bridge.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Modbus Sensor Bridge — maps Modbus register reads to Edge proof inputs.
+ *
+ * Shares gateway validation so malformed responses never become sensor proofs.
+ */
+import type { EdgeRuntime } from '@totemsdk/edge';
+import type { ModbusTransportPort } from './transport.js';
+import type { ModbusGateway } from './gateway.js';
+export interface ModbusSensorBinding {
+    sensorId: string;
+    unitId: number;
+    functionCode: number;
+    address: number;
+    count: number;
+    intervalMs: number;
+    dataType: 'coil' | 'register' | 'input';
+    unit?: string;
+}
+export interface ModbusSensorBridgeConfig {
+    runtime: EdgeRuntime;
+    transport: ModbusTransportPort;
+    gateway?: ModbusGateway;
+    bindings: ModbusSensorBinding[];
+}
+export interface ModbusSensorBridge {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    poll(): Promise<void>;
+}
+export declare function createModbusSensorBridge(config: ModbusSensorBridgeConfig): ModbusSensorBridge;

package/dist/cjs/sensor-bridge.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Modbus Sensor Bridge — maps Modbus register reads to Edge proof inputs.
+ *
+ * Shares gateway validation so malformed responses never become sensor proofs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createModbusSensorBridge = createModbusSensorBridge;
+const gateway_js_1 = require("./gateway.js");
+function createModbusSensorBridge(config) {
+    const timers = [];
+    let running = false;
+    const gateway = config.gateway ?? (0, gateway_js_1.createModbusGateway)({ runtime: config.runtime, transport: config.transport });
+    async function pollBinding(binding) {
+        try {
+            const args = [binding.unitId, binding.address, binding.count];
+            const result = binding.functionCode === 1 ? await gateway.readCoils(...args)
+                : binding.functionCode === 2 ? await gateway.readDiscreteInputs(...args)
+                    : binding.functionCode === 3 ? await gateway.readHoldingRegisters(...args)
+                        : binding.functionCode === 4 ? await gateway.readInputRegisters(...args) : undefined;
+            if (!result?.ok || !result.data)
+                return;
+            const values = result.data.values;
+            if (config.runtime.ports.proof) {
+                await config.runtime.ports.proof.createProof({
+                    subject: `sensor:${binding.sensorId}`,
+                    claims: [{
+                            sensorId: binding.sensorId,
+                            unitId: binding.unitId,
+                            address: binding.address,
+                            values,
+                            unit: binding.unit,
+                            timestamp: Date.now(),
+                        }],
+                });
+            }
+        }
+        catch {
+            // Poll failures are non-fatal — next cycle retries
+        }
+    }
+    return {
+        async start() {
+            if (running)
+                return;
+            for (const binding of config.bindings) {
+                await pollBinding(binding);
+                timers.push(setInterval(() => pollBinding(binding), binding.intervalMs));
+            }
+            running = true;
+        },
+        async stop() {
+            for (const t of timers)
+                clearInterval(t);
+            timers.length = 0;
+            running = false;
+        },
+        async poll() {
+            for (const binding of config.bindings) {
+                await pollBinding(binding);
+            }
+        },
+    };
+}

package/dist/cjs/transport.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Modbus transport port — injected by the caller.
+ *
+ * Supports Modbus TCP (port 502) and Modbus RTU (serial).
+ * The caller provides the actual socket/serial implementation.
+ */
+export interface ModbusTransportPort {
+    /** Open the connection. */
+    connect(): Promise<void>;
+    /** Close the connection. */
+    disconnect(): Promise<void>;
+    /**
+     * Exchange [unitId, functionCode, ...PDU data], with no CRC or MBAP header.
+     * Reads return [unitId, functionCode, byteCount, ...data]; successful writes
+     * return [unitId, functionCode, addressHi, addressLo, valueOrCountHi, valueOrCountLo].
+     * The binding must validate wire CRC/MBAP transaction identity and must not
+     * retry writes automatically when the physical outcome is uncertain.
+     */
+    sendFrame(frame: Uint8Array): Promise<Uint8Array>;
+    /** Register a handler for unsolicited/inbound frames. */
+    onFrame(handler: (frame: Uint8Array) => void): () => void;
+    /** Register a handler for connection errors. */
+    onError(handler: (err: Error) => void): () => void;
+}
+export interface ModbusMessage {
+    /** Unit/slave ID (1-247). */
+    unitId: number;
+    /** Modbus function code (1-6, 15, 16). */
+    functionCode: number;
+    /** Starting address (0-based). */
+    address: number;
+    /** Register/coil count or value. */
+    value: number | number[];
+    /** Raw frame bytes. */
+    raw: Uint8Array;
+    /** Timestamp of receipt. */
+    receivedAt: number;
+}

package/dist/cjs/transport.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Modbus transport port — injected by the caller.
+ *
+ * Supports Modbus TCP (port 502) and Modbus RTU (serial).
+ * The caller provides the actual socket/serial implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/gateway.d.ts

@@ -1,9 +1,8 @@
 /**
  * Modbus Edge Gateway — wires a ModbusTransportPort into an EdgeRuntime.
  *
- * Supports Modbus RTU frame format (no MBAP header) to match the Go native binary.
- * The Go binary parses frame[0] as unitId and frame[1] as functionCode, which
- * is correct for RTU but would misparse TCP frames.
+ * Uses a unit-prefixed PDU (no CRC or MBAP header) at the transport boundary.
+ * The binding owns TCP transaction framing or RTU CRC validation.
  */
 import type { EdgeRuntime, EdgeOperationResult } from '@totemsdk/edge';
 import type { ModbusTransportPort } from './transport.js';

package/dist/gateway.js

@@ -1,14 +1,10 @@
-"use strict";
 /**
  * Modbus Edge Gateway — wires a ModbusTransportPort into an EdgeRuntime.
  *
- * Supports Modbus RTU frame format (no MBAP header) to match the Go native binary.
- * The Go binary parses frame[0] as unitId and frame[1] as functionCode, which
- * is correct for RTU but would misparse TCP frames.
+ * Uses a unit-prefixed PDU (no CRC or MBAP header) at the transport boundary.
+ * The binding owns TCP transaction framing or RTU CRC validation.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModbusGateway = createModbusGateway;
-function createModbusGateway(config) {
+export function createModbusGateway(config) {
     let status = 'stopped';
     let unsubFrame;
     let unsubError;
@@ -45,6 +41,8 @@ function createModbusGateway(config) {
             return readRegisters(config.transport, unitId, 4, address, count);
         },
         async writeSingleCoil(unitId, address, value) {
+            if (typeof value !== 'boolean')
+                return { ok: false, error: 'Coil value must be boolean', errorCode: 'MODBUS_INVALID_REQUEST' };
             return writeSingle(config.transport, unitId, 5, address, value ? 0xFF00 : 0x0000);
         },
         async writeSingleRegister(unitId, address, value) {
@@ -58,29 +56,48 @@ function createModbusGateway(config) {
         },
     };
 }
-// ── RTU frame builders (no MBAP header — matches Go binary) ──────────────
+// ── Unit-prefixed PDU builders (no CRC or MBAP header) ───────────────────
+class ModbusRequestError extends Error {
+}
+class ModbusExceptionError extends Error {
+}
+function validateRange(unitId, address, count, maximum) {
+    if (!Number.isInteger(unitId) || unitId < 1 || unitId > 247 ||
+        !Number.isInteger(address) || address < 0 || address > 0xffff ||
+        !Number.isInteger(count) || count < 1 || count > maximum || address + count > 0x10000) {
+        throw new ModbusRequestError('Invalid Modbus unit, address or quantity');
+    }
+}
+function validateRegister(value) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
+        throw new ModbusRequestError('Register value must be an unsigned 16-bit integer');
+    }
+}
 function buildReadFrame(unitId, fc, address, count) {
-    const buf = new Uint8Array(8);
+    validateRange(unitId, address, count, fc <= 2 ? 2000 : 125);
+    const buf = new Uint8Array(6);
     buf[0] = unitId;
     buf[1] = fc;
     new DataView(buf.buffer).setUint16(2, address, false);
     new DataView(buf.buffer).setUint16(4, count, false);
-    // CRC placeholder (bytes 6-7) — Go library handles CRC internally
-    buf[6] = 0;
-    buf[7] = 0;
     return buf;
 }
 function buildWriteSingleFrame(unitId, fc, address, value) {
-    const buf = new Uint8Array(8);
+    validateRange(unitId, address, 1, 1);
+    validateRegister(value);
+    const buf = new Uint8Array(6);
     buf[0] = unitId;
     buf[1] = fc;
     new DataView(buf.buffer).setUint16(2, address, false);
     new DataView(buf.buffer).setUint16(4, value, false);
-    buf[6] = 0;
-    buf[7] = 0;
     return buf;
 }
 function buildWriteMultipleCoilsFrame(unitId, address, values) {
+    validateRange(unitId, address, values.length, 1968);
+    for (const value of values) {
+        if (typeof value !== 'boolean')
+            throw new ModbusRequestError('Coil values must be boolean');
+    }
     const byteCount = Math.ceil(values.length / 8);
     const buf = new Uint8Array(7 + byteCount);
     buf[0] = unitId;
@@ -96,6 +113,9 @@ function buildWriteMultipleCoilsFrame(unitId, address, values) {
     return buf;
 }
 function buildWriteMultipleRegistersFrame(unitId, address, values) {
+    validateRange(unitId, address, values.length, 123);
+    for (const value of values)
+        validateRegister(value);
     const byteCount = values.length * 2;
     const buf = new Uint8Array(7 + byteCount);
     buf[0] = unitId;
@@ -109,26 +129,45 @@ function buildWriteMultipleRegistersFrame(unitId, address, values) {
     return buf;
 }
 // ── Response parsers (RTU format — no MBAP header) ────────────────────────
-function checkException(response) {
-    if (response.length < 2)
-        return;
+function checkResponse(response, unitId, expectedFunction) {
+    if (response.length < 2 || response[0] !== unitId)
+        throw new Error('Modbus response unit/length mismatch');
     const fc = response[1];
-    if (fc & 0x80) {
-        const exceptionCode = response.length >= 3 ? response[2] : 0;
-        throw new Error(`Modbus exception: function=${fc & 0x7F} code=${exceptionCode}`);
+    if (fc === (expectedFunction | 0x80)) {
+        if (response.length !== 3 || response[2] === 0)
+            throw new Error('Malformed Modbus exception response');
+        throw new ModbusExceptionError(`Modbus exception: function=${expectedFunction} code=${response[2]}`);
     }
+    if (fc !== expectedFunction)
+        throw new Error('Modbus response function mismatch');
+}
+function checkReadLength(response, byteCount) {
+    if (response.length !== 3 + byteCount || response[2] !== byteCount) {
+        throw new Error('Modbus response byte count/length mismatch');
+    }
+}
+function checkWriteResponse(response, request) {
+    checkResponse(response, request[0], request[1]);
+    if (response.length !== 6 || response.some((byte, index) => byte !== request[index])) {
+        throw new Error('Modbus write acknowledgement mismatch');
+    }
+}
+function writeFailure(error) {
+    return { ok: false, error: String(error), errorCode: error instanceof ModbusRequestError
+            ? 'MODBUS_INVALID_REQUEST' : error instanceof ModbusExceptionError
+            ? 'MODBUS_EXCEPTION' : 'MODBUS_WRITE_OUTCOME_UNKNOWN' };
 }
 function parseBitResponse(response, count) {
-    checkException(response);
+    checkReadLength(response, Math.ceil(count / 8));
     const values = [];
     for (let i = 0; i < count; i++) {
-        const byte = response[3 + Math.floor(i / 8)] ?? 0;
+        const byte = response[3 + Math.floor(i / 8)];
         values.push(((byte >> (i % 8)) & 1) === 1);
     }
     return values;
 }
 function parseRegisterResponse(response, count) {
-    checkException(response);
+    checkReadLength(response, count * 2);
     const values = [];
     for (let i = 0; i < count; i++) {
         values.push(new DataView(response.buffer, response.byteOffset + 3 + i * 2, 2).getUint16(0, false));
@@ -140,6 +179,7 @@ async function readBits(transport, unitId, fc, address, count) {
     try {
         const request = buildReadFrame(unitId, fc, address, count);
         const response = await transport.sendFrame(request);
+        checkResponse(response, unitId, fc);
         return { ok: true, data: { values: parseBitResponse(response, count) } };
     }
     catch (e) {
@@ -150,6 +190,7 @@ async function readRegisters(transport, unitId, fc, address, count) {
     try {
         const request = buildReadFrame(unitId, fc, address, count);
         const response = await transport.sendFrame(request);
+        checkResponse(response, unitId, fc);
         return { ok: true, data: { values: parseRegisterResponse(response, count) } };
     }
     catch (e) {
@@ -160,32 +201,32 @@ async function writeSingle(transport, unitId, fc, address, value) {
     try {
         const request = buildWriteSingleFrame(unitId, fc, address, value);
         const response = await transport.sendFrame(request);
-        checkException(response);
+        checkWriteResponse(response, request);
         return { ok: true };
     }
     catch (e) {
-        return { ok: false, error: String(e) };
+        return writeFailure(e);
     }
 }
 async function writeMultipleCoilsImpl(transport, unitId, address, values) {
     try {
         const request = buildWriteMultipleCoilsFrame(unitId, address, values);
         const response = await transport.sendFrame(request);
-        checkException(response);
+        checkWriteResponse(response, request);
         return { ok: true };
     }
     catch (e) {
-        return { ok: false, error: String(e) };
+        return writeFailure(e);
     }
 }
 async function writeMultipleRegistersImpl(transport, unitId, address, values) {
     try {
         const request = buildWriteMultipleRegistersFrame(unitId, address, values);
         const response = await transport.sendFrame(request);
-        checkException(response);
+        checkWriteResponse(response, request);
         return { ok: true };
     }
     catch (e) {
-        return { ok: false, error: String(e) };
+        return writeFailure(e);
     }
 }

package/dist/index.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NativeModbusTransport = exports.createModbusSensorBridge = exports.createModbusGateway = void 0;
-var gateway_js_1 = require("./gateway.js");
-Object.defineProperty(exports, "createModbusGateway", { enumerable: true, get: function () { return gateway_js_1.createModbusGateway; } });
-var sensor_bridge_js_1 = require("./sensor-bridge.js");
-Object.defineProperty(exports, "createModbusSensorBridge", { enumerable: true, get: function () { return sensor_bridge_js_1.createModbusSensorBridge; } });
-var native_transport_js_1 = require("./native-transport.js");
-Object.defineProperty(exports, "NativeModbusTransport", { enumerable: true, get: function () { return native_transport_js_1.NativeModbusTransport; } });
+export { createModbusGateway } from './gateway.js';
+export { createModbusSensorBridge } from './sensor-bridge.js';
+export { NativeModbusTransport } from './native-transport.js';

package/dist/native-transport.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * NativeModbusTransport — connects to the edge-modbus Go binary over TCP.
  *
@@ -12,10 +11,8 @@
  *   const response = await transport.sendFrame(requestFrame);
  *   transport.disconnect();
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NativeModbusTransport = void 0;
 let requestCounter = 0;
-class NativeModbusTransport {
+export class NativeModbusTransport {
     constructor(config = {}) {
         this.socket = null;
         this.buffer = '';
@@ -118,7 +115,6 @@ class NativeModbusTransport {
         };
     }
 }
-exports.NativeModbusTransport = NativeModbusTransport;
 function bytesToHex(bytes) {
     return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
 }

package/dist/sensor-bridge.d.ts

@@ -1,7 +1,7 @@
 /**
  * Modbus Sensor Bridge — maps Modbus register reads to Edge proof inputs.
  *
- * Uses RTU frame format (no MBAP header) to match the Go native binary.
+ * Shares gateway validation so malformed responses never become sensor proofs.
  */
 import type { EdgeRuntime } from '@totemsdk/edge';
 import type { ModbusTransportPort } from './transport.js';