npm - @oesp/transport-ble-gatt - Versions diffs - 2.0.0 → 5.0.0 - Mend

@oesp/transport-ble-gatt 2.0.0 → 5.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/dist/OESPBleGattTransport.d.ts +28 -0
package/dist/OESPBleGattTransport.js +171 -0
package/dist/frames.d.ts +43 -0
package/dist/frames.js +4 -0
package/dist/index.d.ts +4 -96
package/dist/index.js +4 -211
package/dist/link/BleGattLink.d.ts +9 -0
package/dist/link/BleGattLink.js +1 -0
package/dist/link/mock.d.ts +13 -0
package/dist/link/mock.js +32 -0
package/package.json +11 -3

package/dist/OESPBleGattTransport.d.ts ADDED Viewed

@@ -0,0 +1,28 @@
+import { BleGattLink } from "./link/BleGattLink";
+export interface TransportOpts {
+    maxChunkBytes?: number;
+    timeoutMs?: number;
+    retries?: number;
+    sha256: (data: Uint8Array) => Uint8Array | Promise<Uint8Array>;
+}
+export declare class OESPBleGattTransport {
+    private maxChunkBytes;
+    private timeoutMs;
+    private retries;
+    private sha256;
+    constructor(opts: TransportOpts);
+    /**
+     * Envoie un token OESP via BLE GATT (Central -> Peripheral)
+     */
+    sendToken(token: string, link: BleGattLink, sid?: string): Promise<void>;
+    /**
+     * Boucle de réception pour le Peripheral (GATT Server)
+     */
+    receiveLoop(link: BleGattLink, onToken: (token: string) => void): void;
+    private fragment;
+    private reassemble;
+    private sendFrameWithAck;
+    private waitForAck;
+    private sendAck;
+    private sendNack;
+}

package/dist/OESPBleGattTransport.js ADDED Viewed

@@ -0,0 +1,171 @@
+import { base64Encode, base64Decode } from "@oesp/core";
+export class OESPBleGattTransport {
+    constructor(opts) {
+        this.maxChunkBytes = opts.maxChunkBytes || 1024;
+        this.timeoutMs = opts.timeoutMs || 3000;
+        this.retries = opts.retries || 3;
+        this.sha256 = opts.sha256;
+    }
+    /**
+     * Envoie un token OESP via BLE GATT (Central -> Peripheral)
+     */
+    async sendToken(token, link, sid = Math.random().toString(36).substring(7)) {
+        const tokenBytes = new TextEncoder().encode(token);
+        const shaBytes = await this.sha256(tokenBytes);
+        const sha256 = base64Encode(shaBytes);
+        const totalLen = tokenBytes.length;
+        const chunks = this.fragment(tokenBytes, this.maxChunkBytes);
+        const parts = chunks.length;
+        // 1. Send START
+        const startFrame = {
+            t: "START",
+            sid,
+            mid: Math.random().toString(36).substring(7),
+            totalLen,
+            parts,
+            sha256
+        };
+        await this.sendFrameWithAck(link, startFrame, -1);
+        // 2. Send CHUNKS (Stop-and-Wait)
+        for (let i = 0; i < chunks.length; i++) {
+            const chunkFrame = {
+                t: "CHUNK",
+                sid,
+                seq: i,
+                data: base64Encode(chunks[i])
+            };
+            await this.sendFrameWithAck(link, chunkFrame, i);
+        }
+        // 3. Send END
+        await this.sendFrameWithAck(link, { t: "END", sid }, -1);
+    }
+    /**
+     * Boucle de réception pour le Peripheral (GATT Server)
+     */
+    receiveLoop(link, onToken) {
+        let currentSession = null;
+        link.onTxNotify(async (data) => {
+            try {
+                const frame = JSON.parse(new TextDecoder().decode(data));
+                switch (frame.t) {
+                    case "START":
+                        currentSession = {
+                            sid: frame.sid,
+                            expectedSha: frame.sha256,
+                            expectedParts: frame.parts,
+                            chunks: new Array(frame.parts),
+                            receivedParts: new Set()
+                        };
+                        await this.sendAck(link, frame.sid, -1);
+                        break;
+                    case "CHUNK":
+                        if (currentSession && currentSession.sid === frame.sid) {
+                            const chunkData = base64Decode(frame.data);
+                            currentSession.chunks[frame.seq] = chunkData;
+                            currentSession.receivedParts.add(frame.seq);
+                            await this.sendAck(link, frame.sid, frame.seq);
+                        }
+                        break;
+                    case "END":
+                        if (currentSession && currentSession.sid === frame.sid) {
+                            if (currentSession.receivedParts.size === currentSession.expectedParts) {
+                                const fullTokenBytes = this.reassemble(currentSession.chunks);
+                                const actualShaBytes = await this.sha256(fullTokenBytes);
+                                const actualSha = base64Encode(actualShaBytes);
+                                if (actualSha === currentSession.expectedSha) {
+                                    const token = new TextDecoder().decode(fullTokenBytes);
+                                    await this.sendAck(link, frame.sid, -1);
+                                    onToken(token);
+                                }
+                                else {
+                                    await this.sendNack(link, frame.sid, -1, "BAD_HASH");
+                                }
+                            }
+                            else {
+                                await this.sendNack(link, frame.sid, -1, "BAD_SEQ");
+                            }
+                            currentSession = null;
+                        }
+                        break;
+                }
+            }
+            catch (e) {
+                console.error("Failed to parse frame", e);
+            }
+        });
+    }
+    fragment(data, maxChunk) {
+        const chunks = [];
+        for (let i = 0; i < data.length; i += maxChunk) {
+            chunks.push(data.slice(i, i + maxChunk));
+        }
+        return chunks;
+    }
+    reassemble(chunks) {
+        const totalLen = chunks.reduce((acc, c) => acc + c.length, 0);
+        const result = new Uint8Array(totalLen);
+        let offset = 0;
+        for (const chunk of chunks) {
+            if (chunk) {
+                result.set(chunk, offset);
+                offset += chunk.length;
+            }
+        }
+        return result;
+    }
+    async sendFrameWithAck(link, frame, expectedAck) {
+        let attempts = 0;
+        const frameBytes = new TextEncoder().encode(JSON.stringify(frame));
+        while (attempts < this.retries) {
+            await link.writeRx(frameBytes);
+            try {
+                await this.waitForAck(link, frame.sid, expectedAck);
+                return;
+            }
+            catch (e) {
+                attempts++;
+                if (attempts >= this.retries)
+                    throw new Error(`Failed to send frame ${frame.t} after ${this.retries} attempts`);
+            }
+        }
+    }
+    waitForAck(link, sid, expectedAck) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                cleanup();
+                reject(new Error("Timeout waiting for ACK"));
+            }, this.timeoutMs);
+            const handler = (data) => {
+                try {
+                    const frame = JSON.parse(new TextDecoder().decode(data));
+                    if (frame.sid === sid) {
+                        if (frame.t === "ACK" && frame.ack === expectedAck) {
+                            cleanup();
+                            resolve();
+                        }
+                        else if (frame.t === "NACK" && frame.at === expectedAck) {
+                            cleanup();
+                            reject(new Error(`Received NACK: ${frame.reason}`));
+                        }
+                    }
+                }
+                catch (e) { }
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                if (link.offTxNotify) {
+                    link.offTxNotify(handler);
+                }
+            };
+            link.onTxNotify(handler);
+        });
+    }
+    async sendAck(link, sid, ack) {
+        const ackFrame = { t: "ACK", sid, ack };
+        await link.writeRx(new TextEncoder().encode(JSON.stringify(ackFrame)));
+    }
+    async sendNack(link, sid, at, reason) {
+        const nackFrame = { t: "NACK", sid, at, reason };
+        await link.writeRx(new TextEncoder().encode(JSON.stringify(nackFrame)));
+    }
+}

package/dist/frames.d.ts ADDED Viewed

@@ -0,0 +1,43 @@
+export declare const OESP_BLE_SERVICE_UUID = "e95f1234-5678-4321-8765-abcdef012345";
+export declare const OESP_BLE_CHAR_RX_UUID = "e95f1235-5678-4321-8765-abcdef012345";
+export declare const OESP_BLE_CHAR_TX_UUID = "e95f1236-5678-4321-8765-abcdef012345";
+export declare const OESP_BLE_CHAR_META_UUID = "e95f1237-5678-4321-8765-abcdef012345";
+export type FrameType = "HELLO" | "START" | "CHUNK" | "END" | "ACK" | "NACK";
+export interface BaseFrame {
+    t: FrameType;
+    sid: string;
+}
+export interface HelloFrame extends BaseFrame {
+    t: "HELLO";
+    ver: number;
+    did: string;
+    caps: {
+        maxChunk: number;
+        mtuHint?: number;
+    };
+}
+export interface StartFrame extends BaseFrame {
+    t: "START";
+    mid: string;
+    totalLen: number;
+    parts: number;
+    sha256: string;
+}
+export interface ChunkFrame extends BaseFrame {
+    t: "CHUNK";
+    seq: number;
+    data: string;
+}
+export interface EndFrame extends BaseFrame {
+    t: "END";
+}
+export interface AckFrame extends BaseFrame {
+    t: "ACK";
+    ack: number;
+}
+export interface NackFrame extends BaseFrame {
+    t: "NACK";
+    at: number;
+    reason: "BAD_HASH" | "TIMEOUT" | "BAD_SEQ" | "UNKNOWN";
+}
+export type OESPBleFrame = HelloFrame | StartFrame | ChunkFrame | EndFrame | AckFrame | NackFrame;

package/dist/frames.js ADDED Viewed

@@ -0,0 +1,4 @@
+export const OESP_BLE_SERVICE_UUID = "e95f1234-5678-4321-8765-abcdef012345";
+export const OESP_BLE_CHAR_RX_UUID = "e95f1235-5678-4321-8765-abcdef012345"; // Central -> Peripheral (Write)
+export const OESP_BLE_CHAR_TX_UUID = "e95f1236-5678-4321-8765-abcdef012345"; // Peripheral -> Central (Notify)
+export const OESP_BLE_CHAR_META_UUID = "e95f1237-5678-4321-8765-abcdef012345"; // Meta (Read)

package/dist/index.d.ts CHANGED Viewed

@@ -1,96 +1,4 @@
-declare const OESP_BLE_SERVICE_UUID = "e95f1234-5678-4321-8765-abcdef012345";
-declare const OESP_BLE_CHAR_RX_UUID = "e95f1235-5678-4321-8765-abcdef012345";
-declare const OESP_BLE_CHAR_TX_UUID = "e95f1236-5678-4321-8765-abcdef012345";
-declare const OESP_BLE_CHAR_META_UUID = "e95f1237-5678-4321-8765-abcdef012345";
-type FrameType = "HELLO" | "START" | "CHUNK" | "END" | "ACK" | "NACK";
-interface BaseFrame {
-    t: FrameType;
-    sid: string;
-}
-interface HelloFrame extends BaseFrame {
-    t: "HELLO";
-    ver: number;
-    did: string;
-    caps: {
-        maxChunk: number;
-        mtuHint?: number;
-    };
-}
-interface StartFrame extends BaseFrame {
-    t: "START";
-    mid: string;
-    totalLen: number;
-    parts: number;
-    sha256: string;
-}
-interface ChunkFrame extends BaseFrame {
-    t: "CHUNK";
-    seq: number;
-    data: string;
-}
-interface EndFrame extends BaseFrame {
-    t: "END";
-}
-interface AckFrame extends BaseFrame {
-    t: "ACK";
-    ack: number;
-}
-interface NackFrame extends BaseFrame {
-    t: "NACK";
-    at: number;
-    reason: "BAD_HASH" | "TIMEOUT" | "BAD_SEQ" | "UNKNOWN";
-}
-type OESPBleFrame = HelloFrame | StartFrame | ChunkFrame | EndFrame | AckFrame | NackFrame;
-interface BleGattLink {
-    connect(deviceId: string): Promise<void>;
-    disconnect(): Promise<void>;
-    writeRx(frameBytes: Uint8Array): Promise<void>;
-    onTxNotify(cb: (frameBytes: Uint8Array) => void): void;
-    offTxNotify?(cb: (frameBytes: Uint8Array) => void): void;
-    startNotify(): Promise<void>;
-    getMtuHint?(): Promise<number | undefined>;
-}
-interface TransportOpts {
-    maxChunkBytes?: number;
-    timeoutMs?: number;
-    retries?: number;
-    sha256: (data: Uint8Array) => Uint8Array | Promise<Uint8Array>;
-}
-declare class OESPBleGattTransport {
-    private maxChunkBytes;
-    private timeoutMs;
-    private retries;
-    private sha256;
-    constructor(opts: TransportOpts);
-    /**
-     * Envoie un token OESP via BLE GATT (Central -> Peripheral)
-     */
-    sendToken(token: string, link: BleGattLink, sid?: string): Promise<void>;
-    /**
-     * Boucle de réception pour le Peripheral (GATT Server)
-     */
-    receiveLoop(link: BleGattLink, onToken: (token: string) => void): void;
-    private fragment;
-    private reassemble;
-    private sendFrameWithAck;
-    private waitForAck;
-    private sendAck;
-    private sendNack;
-}
-declare class MockBleGattLink implements BleGattLink {
-    private notifyCb?;
-    lastWrittenRx?: Uint8Array;
-    connect(deviceId: string): Promise<void>;
-    disconnect(): Promise<void>;
-    writeRx(frameBytes: Uint8Array): Promise<void>;
-    onTxNotify(cb: (frameBytes: Uint8Array) => void): void;
-    offTxNotify(cb: (frameBytes: Uint8Array) => void): void;
-    startNotify(): Promise<void>;
-    getMtuHint(): Promise<number>;
-    simulateTxNotify(data: Uint8Array): void;
-}
-export { type AckFrame, type BaseFrame, type BleGattLink, type ChunkFrame, type EndFrame, type FrameType, type HelloFrame, MockBleGattLink, type NackFrame, type OESPBleFrame, OESPBleGattTransport, OESP_BLE_CHAR_META_UUID, OESP_BLE_CHAR_RX_UUID, OESP_BLE_CHAR_TX_UUID, OESP_BLE_SERVICE_UUID, type StartFrame, type TransportOpts };
+export * from "./frames";
+export * from "./OESPBleGattTransport";
+export * from "./link/BleGattLink";
+export * from "./link/mock";

package/dist/index.js CHANGED Viewed

@@ -1,211 +1,4 @@
-// src/frames.ts
-var OESP_BLE_SERVICE_UUID = "e95f1234-5678-4321-8765-abcdef012345";
-var OESP_BLE_CHAR_RX_UUID = "e95f1235-5678-4321-8765-abcdef012345";
-var OESP_BLE_CHAR_TX_UUID = "e95f1236-5678-4321-8765-abcdef012345";
-var OESP_BLE_CHAR_META_UUID = "e95f1237-5678-4321-8765-abcdef012345";
-// src/OESPBleGattTransport.ts
-import { base64Encode, base64Decode } from "@oesp/core";
-var OESPBleGattTransport = class {
-  constructor(opts) {
-    this.maxChunkBytes = opts.maxChunkBytes || 1024;
-    this.timeoutMs = opts.timeoutMs || 3e3;
-    this.retries = opts.retries || 3;
-    this.sha256 = opts.sha256;
-  }
-  /**
-   * Envoie un token OESP via BLE GATT (Central -> Peripheral)
-   */
-  async sendToken(token, link, sid = Math.random().toString(36).substring(7)) {
-    const tokenBytes = new TextEncoder().encode(token);
-    const shaBytes = await this.sha256(tokenBytes);
-    const sha256 = base64Encode(shaBytes);
-    const totalLen = tokenBytes.length;
-    const chunks = this.fragment(tokenBytes, this.maxChunkBytes);
-    const parts = chunks.length;
-    const startFrame = {
-      t: "START",
-      sid,
-      mid: Math.random().toString(36).substring(7),
-      totalLen,
-      parts,
-      sha256
-    };
-    await this.sendFrameWithAck(link, startFrame, -1);
-    for (let i = 0; i < chunks.length; i++) {
-      const chunkFrame = {
-        t: "CHUNK",
-        sid,
-        seq: i,
-        data: base64Encode(chunks[i])
-      };
-      await this.sendFrameWithAck(link, chunkFrame, i);
-    }
-    await this.sendFrameWithAck(link, { t: "END", sid }, -1);
-  }
-  /**
-   * Boucle de réception pour le Peripheral (GATT Server)
-   */
-  receiveLoop(link, onToken) {
-    let currentSession = null;
-    link.onTxNotify(async (data) => {
-      try {
-        const frame = JSON.parse(new TextDecoder().decode(data));
-        switch (frame.t) {
-          case "START":
-            currentSession = {
-              sid: frame.sid,
-              expectedSha: frame.sha256,
-              expectedParts: frame.parts,
-              chunks: new Array(frame.parts),
-              receivedParts: /* @__PURE__ */ new Set()
-            };
-            await this.sendAck(link, frame.sid, -1);
-            break;
-          case "CHUNK":
-            if (currentSession && currentSession.sid === frame.sid) {
-              const chunkData = base64Decode(frame.data);
-              currentSession.chunks[frame.seq] = chunkData;
-              currentSession.receivedParts.add(frame.seq);
-              await this.sendAck(link, frame.sid, frame.seq);
-            }
-            break;
-          case "END":
-            if (currentSession && currentSession.sid === frame.sid) {
-              if (currentSession.receivedParts.size === currentSession.expectedParts) {
-                const fullTokenBytes = this.reassemble(currentSession.chunks);
-                const actualShaBytes = await this.sha256(fullTokenBytes);
-                const actualSha = base64Encode(actualShaBytes);
-                if (actualSha === currentSession.expectedSha) {
-                  const token = new TextDecoder().decode(fullTokenBytes);
-                  await this.sendAck(link, frame.sid, -1);
-                  onToken(token);
-                } else {
-                  await this.sendNack(link, frame.sid, -1, "BAD_HASH");
-                }
-              } else {
-                await this.sendNack(link, frame.sid, -1, "BAD_SEQ");
-              }
-              currentSession = null;
-            }
-            break;
-        }
-      } catch (e) {
-        console.error("Failed to parse frame", e);
-      }
-    });
-  }
-  fragment(data, maxChunk) {
-    const chunks = [];
-    for (let i = 0; i < data.length; i += maxChunk) {
-      chunks.push(data.slice(i, i + maxChunk));
-    }
-    return chunks;
-  }
-  reassemble(chunks) {
-    const totalLen = chunks.reduce((acc, c) => acc + c.length, 0);
-    const result = new Uint8Array(totalLen);
-    let offset = 0;
-    for (const chunk of chunks) {
-      if (chunk) {
-        result.set(chunk, offset);
-        offset += chunk.length;
-      }
-    }
-    return result;
-  }
-  async sendFrameWithAck(link, frame, expectedAck) {
-    let attempts = 0;
-    const frameBytes = new TextEncoder().encode(JSON.stringify(frame));
-    while (attempts < this.retries) {
-      await link.writeRx(frameBytes);
-      try {
-        await this.waitForAck(link, frame.sid, expectedAck);
-        return;
-      } catch (e) {
-        attempts++;
-        if (attempts >= this.retries) throw new Error(`Failed to send frame ${frame.t} after ${this.retries} attempts`);
-      }
-    }
-  }
-  waitForAck(link, sid, expectedAck) {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        cleanup();
-        reject(new Error("Timeout waiting for ACK"));
-      }, this.timeoutMs);
-      const handler = (data) => {
-        try {
-          const frame = JSON.parse(new TextDecoder().decode(data));
-          if (frame.sid === sid) {
-            if (frame.t === "ACK" && frame.ack === expectedAck) {
-              cleanup();
-              resolve();
-            } else if (frame.t === "NACK" && frame.at === expectedAck) {
-              cleanup();
-              reject(new Error(`Received NACK: ${frame.reason}`));
-            }
-          }
-        } catch (e) {
-        }
-      };
-      const cleanup = () => {
-        clearTimeout(timeout);
-        if (link.offTxNotify) {
-          link.offTxNotify(handler);
-        }
-      };
-      link.onTxNotify(handler);
-    });
-  }
-  async sendAck(link, sid, ack) {
-    const ackFrame = { t: "ACK", sid, ack };
-    await link.writeRx(new TextEncoder().encode(JSON.stringify(ackFrame)));
-  }
-  async sendNack(link, sid, at, reason) {
-    const nackFrame = { t: "NACK", sid, at, reason };
-    await link.writeRx(new TextEncoder().encode(JSON.stringify(nackFrame)));
-  }
-};
-// src/link/mock.ts
-var MockBleGattLink = class {
-  async connect(deviceId) {
-    console.log(`Mock: Connected to ${deviceId}`);
-  }
-  async disconnect() {
-    console.log("Mock: Disconnected");
-  }
-  async writeRx(frameBytes) {
-    this.lastWrittenRx = frameBytes;
-    console.log("Mock: Wrote RX", new TextDecoder().decode(frameBytes));
-  }
-  onTxNotify(cb) {
-    this.notifyCb = cb;
-  }
-  offTxNotify(cb) {
-    if (this.notifyCb === cb) {
-      this.notifyCb = void 0;
-    }
-  }
-  async startNotify() {
-    console.log("Mock: Started Notify");
-  }
-  async getMtuHint() {
-    return 185;
-  }
-  // Helper for tests
-  simulateTxNotify(data) {
-    if (this.notifyCb) {
-      this.notifyCb(data);
-    }
-  }
-};
-export {
-  MockBleGattLink,
-  OESPBleGattTransport,
-  OESP_BLE_CHAR_META_UUID,
-  OESP_BLE_CHAR_RX_UUID,
-  OESP_BLE_CHAR_TX_UUID,
-  OESP_BLE_SERVICE_UUID
-};
+export * from "./frames";
+export * from "./OESPBleGattTransport";
+export * from "./link/BleGattLink";
+export * from "./link/mock";

package/dist/link/BleGattLink.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export interface BleGattLink {
+    connect(deviceId: string): Promise<void>;
+    disconnect(): Promise<void>;
+    writeRx(frameBytes: Uint8Array): Promise<void>;
+    onTxNotify(cb: (frameBytes: Uint8Array) => void): void;
+    offTxNotify?(cb: (frameBytes: Uint8Array) => void): void;
+    startNotify(): Promise<void>;
+    getMtuHint?(): Promise<number | undefined>;
+}

package/dist/link/BleGattLink.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/link/mock.d.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { BleGattLink } from "./BleGattLink";
+export declare class MockBleGattLink implements BleGattLink {
+    private notifyCb?;
+    lastWrittenRx?: Uint8Array;
+    connect(deviceId: string): Promise<void>;
+    disconnect(): Promise<void>;
+    writeRx(frameBytes: Uint8Array): Promise<void>;
+    onTxNotify(cb: (frameBytes: Uint8Array) => void): void;
+    offTxNotify(cb: (frameBytes: Uint8Array) => void): void;
+    startNotify(): Promise<void>;
+    getMtuHint(): Promise<number>;
+    simulateTxNotify(data: Uint8Array): void;
+}

package/dist/link/mock.js ADDED Viewed

@@ -0,0 +1,32 @@
+export class MockBleGattLink {
+    async connect(deviceId) {
+        console.log(`Mock: Connected to ${deviceId}`);
+    }
+    async disconnect() {
+        console.log("Mock: Disconnected");
+    }
+    async writeRx(frameBytes) {
+        this.lastWrittenRx = frameBytes;
+        console.log("Mock: Wrote RX", new TextDecoder().decode(frameBytes));
+    }
+    onTxNotify(cb) {
+        this.notifyCb = cb;
+    }
+    offTxNotify(cb) {
+        if (this.notifyCb === cb) {
+            this.notifyCb = undefined;
+        }
+    }
+    async startNotify() {
+        console.log("Mock: Started Notify");
+    }
+    async getMtuHint() {
+        return 185;
+    }
+    // Helper for tests
+    simulateTxNotify(data) {
+        if (this.notifyCb) {
+            this.notifyCb(data);
+        }
+    }
+}

package/package.json CHANGED Viewed

@@ -1,12 +1,20 @@
 {
   "name": "@oesp/transport-ble-gatt",
-  "version": "2.0.0",
+  "version": "5.0.0",
   "private": false,
   "description": "OESP BLE GATT Transport (P2P offline)",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "sideEffects": false,
   "files": [
     "dist"
   ],
@@ -14,7 +22,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@oesp/core": "2.0.0"
+    "@oesp/core": "5.0.0"
   },
   "devDependencies": {
     "tsup": "^8.0.1",
@@ -22,7 +30,7 @@
     "vitest": "^1.6.0"
   },
   "scripts": {
-    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
     "lint": "tsc -p tsconfig.json --noEmit"
   }