@oesp/transport-ble-gatt 1.0.0

package/README.md

@@ -0,0 +1,90 @@
+# @oesp/transport-ble-gatt
+
+Transport OESP via BLE GATT (Central <-> Peripheral) avec support asynchrone et fragmentation.
+
+## Installation
+
+```bash
+npm install @oesp/transport-ble-gatt
+```
+
+## Fonctionnalités
+
+- **Communication P2P Offline** : Échange de données sans internet.
+- **Fragmentation Automatique** : Gestion transparente du MTU BLE.
+- **Protocole Stop-and-Wait** : Fiabilité accrue via acquittements (ACK).
+- **Opérations Asynchrones** : Utilisation de `Promise` pour toutes les opérations I/O.
+- **Crypto Agnostique** : Injection de la fonction de hachage SHA-256 pour compatibilité multi-plateforme (Node.js, React Native, Browser).
+
+## Utilisation (Central)
+
+Le mode Central est généralement utilisé par l'application mobile qui scanne et se connecte au périphérique.
+
+```ts
+import { OESPBleGattTransport } from '@oesp/transport-ble-gatt';
+import { MyBleLink } from './MyBleLink'; // Votre implémentation de BleGattLink
+import { sha256 } from 'js-sha256'; // Ou autre provider
+
+// 1. Initialiser le transport avec le provider SHA-256
+const transport = new OESPBleGattTransport({
+  sha256: async (data) => new Uint8Array(sha256.arrayBuffer(data))
+});
+
+const link = new MyBleLink();
+
+try {
+  // 2. Connexion (géré par votre implémentation Link)
+  await link.connect('DEVICE_UUID');
+
+  // 3. Envoi d'un token OESP de manière asynchrone
+  // La méthode gère la fragmentation et les ACK automatiquement
+  await transport.sendToken(oespTokenBytes, link);
+  console.log("Token envoyé avec succès !");
+
+} catch (err) {
+  console.error("Erreur de transport:", err);
+}
+```
+
+## Utilisation (Peripheral)
+
+Le mode Peripheral est utilisé par l'appareil IoT ou le receveur.
+
+```ts
+const transport = new OESPBleGattTransport({
+  sha256: async (data) => new Uint8Array(sha256.arrayBuffer(data))
+});
+const link = new MyBleLink(); // Implémentation côté périphérique
+
+// Boucle de réception asynchrone
+transport.receiveLoop(link, async (token) => {
+  console.log("Token OESP complet reçu:", token);
+  // Traitement du token...
+});
+```
+
+## Interface `BleGattLink`
+
+Vous devez fournir une implémentation de l'interface `BleGattLink` adaptée à votre environnement (ex: `react-native-ble-plx` ou `noble`).
+
+```ts
+interface BleGattLink {
+  // MTU négocié (doit être > 23 pour de meilleures performances)
+  mtu: number;
+  
+  // Écrit des données sur la caractéristique RX du pair
+  write(data: Uint8Array): Promise<void>;
+  
+  // Lit des données depuis la caractéristique TX du pair
+  read(): Promise<Uint8Array>;
+  
+  // Ferme la connexion
+  close(): Promise<void>;
+}
+```
+
+## Notes Techniques
+
+- **MTU & Fragmentation** : Le transport découpe les messages OESP (souvent > MTU) en trames. Assurez-vous que `link.mtu` reflète le MTU réel négocié.
+- **Timeout** : Un timeout est appliqué si un ACK n'est pas reçu à temps.
+- **Android** : Nécessite les permissions `BLUETOOTH_SCAN` et `BLUETOOTH_CONNECT`.

package/dist/index.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MockBleGattLink: () => MockBleGattLink,
+  OESPBleGattTransport: () => OESPBleGattTransport,
+  OESP_BLE_CHAR_META_UUID: () => OESP_BLE_CHAR_META_UUID,
+  OESP_BLE_CHAR_RX_UUID: () => OESP_BLE_CHAR_RX_UUID,
+  OESP_BLE_CHAR_TX_UUID: () => OESP_BLE_CHAR_TX_UUID,
+  OESP_BLE_SERVICE_UUID: () => OESP_BLE_SERVICE_UUID
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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
+var import_core = require("@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 = (0, import_core.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: (0, import_core.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 = (0, import_core.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 = (0, import_core.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);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MockBleGattLink,
+  OESPBleGattTransport,
+  OESP_BLE_CHAR_META_UUID,
+  OESP_BLE_CHAR_RX_UUID,
+  OESP_BLE_CHAR_TX_UUID,
+  OESP_BLE_SERVICE_UUID
+});

package/dist/index.d.cts

@@ -0,0 +1,96 @@
+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 };

package/dist/index.d.ts

@@ -0,0 +1,96 @@
+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 };

package/dist/index.js

@@ -0,0 +1,211 @@
+// 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
+};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@oesp/transport-ble-gatt",
+  "version": "1.0.0",
+  "private": false,
+  "description": "OESP BLE GATT Transport (P2P offline)",
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs",
+    "test": "vitest run",
+    "lint": "tsc -p tsconfig.json --noEmit"
+  },
+  "dependencies": {
+    "@oesp/core": "workspace:*"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.1",
+    "typescript": "^5.6.3",
+    "vitest": "^1.6.0"
+  }
+}