@cero-base/core 1.10.0 → 1.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cero-base/core",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "cero p2p primitives — identity, storage, network, database, blobs, rpc, pairing.",
   "type": "module",
   "sideEffects": false,

package/src/network/transports/ble.js

@@ -4,7 +4,7 @@ import { hash, randomBytes } from 'hypercore-crypto'
 import safetyCatch from 'safety-catch'
 
 import { GattStream } from './gatt.js'
-import { L2CAPStream, readSidPreamble } from './l2cap.js'
+import { L2CAPStream, readIdPreamble } from './l2cap.js'
 
 // One data characteristic (write + notify) carries the framed control traffic
 // both ways — and, on the gatt pipe, the data too.
@@ -48,17 +48,19 @@ const DRAIN_MS = 300
 const EMPTY = b4a.alloc(0)
 
 /**
- * Build a wire frame [type][sessionId][payload].
+ * Build a wire frame [type][sessionId][payload]. The session id is a hex
+ * string end to end — the one canonical form (it is also the sessions map
+ * key); the codec is the only place it touches bytes.
  *
  * @param {number} type
- * @param {Uint8Array} sid  8-byte session id.
+ * @param {string} id  Session id (hex).
  * @param {Uint8Array} [payload]
  * @returns {Buffer}
  */
-function frame(type, sid, payload = EMPTY) {
+function frame(type, id, payload = EMPTY) {
   const out = b4a.allocUnsafe(HEADER + payload.byteLength)
   out[0] = type
-  b4a.copy(sid, out, 1)
+  b4a.write(out, id, 1, SID_LEN, 'hex')
   if (payload.byteLength) b4a.copy(payload, out, HEADER)
   return out
 }
@@ -67,15 +69,13 @@ function frame(type, sid, payload = EMPTY) {
  * Parse a wire frame. Short/empty buffers → null (caller drops).
  *
  * @param {Uint8Array} buf
- * @returns {{ type: number, sid: Uint8Array, sidHex: string, payload: Uint8Array } | null}
+ * @returns {{ type: number, id: string, payload: Uint8Array } | null}
  */
 function parseFrame(buf) {
   if (!buf || buf.byteLength < HEADER) return null
-  const sid = buf.subarray(1, HEADER)
   return {
     type: buf[0],
-    sid,
-    sidHex: b4a.toString(sid, 'hex'),
+    id: b4a.toString(buf.subarray(1, HEADER), 'hex'),
     payload: buf.subarray(HEADER)
   }
 }
@@ -177,7 +177,7 @@ export class BLETransport extends ReadyResource {
     this._dataChar = null
     /** the published l2cap listener's psm, advertised to centrals over hello */
     this._psm = null
-    /** sessionId hex → { stream, sid } for server-side (peripheral) sessions */
+    /** id → { id, stream, conn, name, pipeTimer } for server-side (peripheral) sessions */
     this._sessions = new Map()
     /** serialized server notify queue: { frame, resolve, reject } */
     this._notifyQueue = []
@@ -186,9 +186,13 @@ export class BLETransport extends ReadyResource {
     this._serviceAdded = false
     /** peripheral id → per-peer dial state { timer, linked, coolUntil, failures, peerKey, peripheral } */
     this._devices = new Map()
+    /** rate-limited discoveries held for the next dial window */
+    this._candidates = new Map()
+    this._dialTimer = null
     /** last central.connect timestamp — global inter-dial rate limit */
     this._lastDial = 0
     this._scanTimer = null
+    this._cyclePending = false
     this._suspended = false
     /** live injected links keyed by remote node id hex */
     this.peers = new Map()
@@ -300,9 +304,17 @@ export class BLETransport extends ReadyResource {
 
   // Fresh listener, fresh psm — the next hello advertises it. A dead session
   // leaves its channel state on the shared radio link, and the OS refuses a
-  // second open to a psm it remembers there.
+  // second open to a psm it remembers there. Never yank the psm out from under
+  // a session still opening its channel — hold the rotation until the last
+  // pending session resolves (bind or reap).
   _cycleListener() {
     if (this.pipe !== 'l2cap' || this._suspended || this.closing || this.closed) return
+    for (const s of this._sessions.values()) {
+      if (s.stream) continue
+      this._cyclePending = true
+      return
+    }
+    this._cyclePending = false
     this._unpublishListener()
     this._publishListener()
   }
@@ -328,66 +340,60 @@ export class BLETransport extends ReadyResource {
   _onServerFrame(data) {
     const f = parseFrame(data)
     if (!f) return
+    // an OPEN for a live session is a dup; every other type needs one
+    const s = this._sessions.get(f.id)
     if (f.type === TYPE_OPEN) {
-      if (this._sessions.has(f.sidHex)) return
+      if (s) return
       if (this._sessions.size >= this.maxInbound) {
         // established links win: refuse newcomers with a CLOSE so the dialer's
         // stream ends cleanly and backs off — the mesh converges transitively.
-        this._enqueueNotify(frame(TYPE_CLOSE, f.sid)).catch(safetyCatch)
+        this._notifyClose(f.id)
         return
       }
-      const sid = b4a.from(f.sid) // copy: f.sid views the transient request buffer
-      const session = { stream: null, sid, conn: null, name: null, pipeTimer: null }
-      this._sessions.set(f.sidHex, session)
+      const session = { id: f.id, stream: null, conn: null, name: null, pipeTimer: null }
+      this._sessions.set(f.id, session)
       if (this.pipe === 'l2cap' && this._psm !== null) {
         // the session has no stream until the central opens our channel and
-        // its sid preamble matches — reap it if that never happens
+        // its id preamble matches — reap it if that never happens
         session.pipeTimer = setTimeout(() => {
           session.pipeTimer = null
-          if (this._sessions.get(f.sidHex) !== session || session.stream) return
-          this._reapSession(f.sidHex, session)
-          this._enqueueNotify(frame(TYPE_CLOSE, sid)).catch(safetyCatch)
+          if (this._sessions.get(f.id) !== session || session.stream) return
+          this._reapSession(f.id, session)
+          this._notifyClose(f.id)
         }, PIPE_PENDING_TIMEOUT)
         if (session.pipeTimer.unref) session.pipeTimer.unref()
       } else {
-        this._openServerGatt(f.sidHex, session)
+        this._openServerGatt(session)
       }
-      this._enqueueNotify(frame(TYPE_HELLO, sid, this._helloPayload())).catch(safetyCatch)
+      this._enqueueNotify(frame(TYPE_HELLO, f.id, this._helloPayload())).catch(safetyCatch)
     } else if (f.type === TYPE_DATA) {
-      const s = this._sessions.get(f.sidHex)
       if (!s) return
       if (!s.stream) {
         // gatt data on a session awaiting its l2cap channel is a pipe
         // mismatch — close instead of silently degrading
-        this._reapSession(f.sidHex, s)
-        this._enqueueNotify(frame(TYPE_CLOSE, f.sid)).catch(safetyCatch)
+        this._closeServerSession(f.id)
         return
       }
       s.stream.receive(b4a.from(f.payload))
     } else if (f.type === TYPE_HELLO) {
-      const s = this._sessions.get(f.sidHex)
       if (s) this._applyPeerName(s, f.payload)
     } else if (f.type === TYPE_CLOSE) {
-      const s = this._sessions.get(f.sidHex)
-      if (s) {
-        this._reapSession(f.sidHex, s)
-        if (s.stream) s.stream.remoteEnd()
-      }
+      if (!s) return
+      this._reapSession(f.id, s)
+      if (s.stream) s.stream.remoteEnd()
     }
   }
 
-  _openServerGatt(sidHex, session) {
-    const sid = session.sid
-    session.stream = new GattStream({
-      send: (payload) => this._enqueueNotify(frame(TYPE_DATA, sid, payload)),
-      onclose: () => this._closeServerSession(sidHex, sid)
+  _openServerGatt(session) {
+    const stream = new GattStream({
+      send: (payload) => this._enqueueNotify(frame(TYPE_DATA, session.id, payload))
     })
-    session.conn = this._onChannel(session.stream, false, null)
+    this._bindServerStream(session, stream)
   }
 
   // Incoming l2cap channel: the central writes its 8-byte session id first,
   // matching the channel to the session negotiated over the characteristic.
-  _onServerChannel(channel) {
+  async _onServerChannel(channel) {
     if (this.closing || this.closed || this._suspended) {
       try {
         channel.destroy()
@@ -396,45 +402,49 @@ export class BLETransport extends ReadyResource {
       }
       return
     }
-    readSidPreamble(
-      channel,
-      SID_LEN,
-      (sid, leftover) => {
-        const sidHex = sid !== null ? b4a.toString(sid, 'hex') : null
-        const session = sidHex !== null ? this._sessions.get(sidHex) : undefined
-        if (!session || session.stream) {
-          try {
-            channel.destroy()
-          } catch (err) {
-            safetyCatch(err)
-          }
-          return
-        }
-        if (session.pipeTimer) clearTimeout(session.pipeTimer)
-        session.pipeTimer = null
-        session.stream = new L2CAPStream(channel, {
-          onclose: () => this._closeServerSession(sidHex, session.sid)
-        })
-        session.conn = this._onChannel(session.stream, false, null)
-        if (session.name && session.conn) session.conn._peerName = session.name
-        if (leftover.byteLength) session.stream.receive(leftover)
-      },
-      this._l2capTimeout
-    )
+    const { id, rest } = await readIdPreamble(channel, SID_LEN, this._l2capTimeout)
+    const session = id !== null ? this._sessions.get(id) : undefined
+    if (!session || session.stream) {
+      try {
+        channel.destroy()
+      } catch (err) {
+        safetyCatch(err)
+      }
+      return
+    }
+    const stream = new L2CAPStream(channel)
+    this._bindServerStream(session, stream)
+    if (rest.byteLength) stream.receive(rest)
+  }
+
+  // A pipe stream binds here — session wiring and close-time cleanup are
+  // transport concerns shared by both pipes.
+  _bindServerStream(session, stream) {
+    if (session.pipeTimer) clearTimeout(session.pipeTimer)
+    session.pipeTimer = null
+    session.stream = stream
+    stream.on('close', () => this._closeServerSession(session.id))
+    session.conn = this._onChannel(stream, false, null)
+    if (session.name && session.conn) session.conn._peerName = session.name
+    if (this._cyclePending) this._cycleListener()
   }
 
-  _reapSession(sidHex, session) {
+  _reapSession(id, session) {
     if (session.pipeTimer) clearTimeout(session.pipeTimer)
     session.pipeTimer = null
-    this._sessions.delete(sidHex)
+    this._sessions.delete(id)
     this._cycleListener()
   }
 
-  _closeServerSession(sidHex, sid) {
-    const session = this._sessions.get(sidHex)
+  _closeServerSession(id) {
+    const session = this._sessions.get(id)
     if (!session) return
-    this._reapSession(sidHex, session)
-    this._enqueueNotify(frame(TYPE_CLOSE, sid)).catch(safetyCatch)
+    this._reapSession(id, session)
+    this._notifyClose(id)
+  }
+
+  _notifyClose(id) {
+    this._enqueueNotify(frame(TYPE_CLOSE, id)).catch(safetyCatch)
   }
 
   // ─── peer display name (hello frame) ──────────────────────────────────────
@@ -557,8 +567,10 @@ export class BLETransport extends ReadyResource {
     this._scanning = false
     // the power cycle wiped the GATT db — the listener is gone with it
     this._psm = null
+    this._cyclePending = false
     for (const d of this._devices.values()) if (d.timer) clearTimeout(d.timer)
     this._devices.clear()
+    this._clearCandidates()
     for (const conn of this.peers.values()) {
       try {
         conn.destroy()
@@ -596,7 +608,20 @@ export class BLETransport extends ReadyResource {
       if (d.timer) return // already connecting to this one
     }
     if (this.linkCount >= this.maxOutbound) return // gossip covers the rest
-    if (Date.now() - this._lastDial < DIAL_MIN_INTERVAL) return
+    const wait = DIAL_MIN_INTERVAL - (Date.now() - this._lastDial)
+    if (wait > 0) {
+      // hold rate-limited discoveries (the radio may not re-report them until
+      // the next scan cycle) and dial the strongest signal when the window opens
+      this._candidates.set(peripheral.id, peripheral)
+      if (!this._dialTimer) {
+        this._dialTimer = setTimeout(() => {
+          this._dialTimer = null
+          this._flushCandidates()
+        }, wait)
+        if (this._dialTimer.unref) this._dialTimer.unref()
+      }
+      return
+    }
     // dial every discovery and open a session; a redundant link is dropped by
     // _track's dedup
     this._lastDial = Date.now()
@@ -610,6 +635,20 @@ export class BLETransport extends ReadyResource {
     }
   }
 
+  // strongest signal first — the nearest peer makes the best link. The first
+  // dial re-rate-limits the rest, so each window dials the strongest remaining.
+  _flushCandidates() {
+    const held = [...this._candidates.values()].sort((a, b) => (b.rssi ?? -100) - (a.rssi ?? -100))
+    this._candidates.clear()
+    for (const peripheral of held) this._onDiscover(peripheral)
+  }
+
+  _clearCandidates() {
+    if (this._dialTimer) clearTimeout(this._dialTimer)
+    this._dialTimer = null
+    this._candidates.clear()
+  }
+
   _onConnect(peripheral) {
     this._device(peripheral.id).peripheral = peripheral
     peripheral.on('error', (err) => {
@@ -645,14 +684,13 @@ export class BLETransport extends ReadyResource {
   // ─── central side ─────────────────────────────────────────────────────────
 
   _startCentralSession(peripheral, char) {
-    const sid = randomBytes(SID_LEN)
-    const sidHex = b4a.toString(sid, 'hex')
-    peripheral._session = { sidHex, sid, upgrading: false }
+    const id = b4a.toString(randomBytes(SID_LEN), 'hex')
+    peripheral._session = { id, upgrading: false }
     peripheral._char = char // suspend's goodbye writes reuse it
     peripheral.on('notify', (_char, data) => this._onCentralNotify(peripheral, data))
     // open frame first: it registers the session on the server before any data
-    this._centralSend(peripheral, char, frame(TYPE_OPEN, sid)).catch(safetyCatch)
-    this._centralSend(peripheral, char, frame(TYPE_HELLO, sid, this._helloPayload())).catch(
+    this._centralSend(peripheral, char, frame(TYPE_OPEN, id)).catch(safetyCatch)
+    this._centralSend(peripheral, char, frame(TYPE_HELLO, id, this._helloPayload())).catch(
       safetyCatch
     )
     if (this.pipe === 'l2cap') {
@@ -666,9 +704,15 @@ export class BLETransport extends ReadyResource {
   _openCentralGatt(peripheral, sess) {
     const stream = new GattStream({
       send: (payload) =>
-        this._centralSend(peripheral, peripheral._char, frame(TYPE_DATA, sess.sid, payload)),
-      onclose: () => this._closeCentralSession(peripheral, sess)
+        this._centralSend(peripheral, peripheral._char, frame(TYPE_DATA, sess.id, payload))
     })
+    this._bindCentralStream(peripheral, sess, stream)
+  }
+
+  // A pipe stream binds here — dial state, peripheral refs and close-time
+  // cleanup are transport concerns shared by both pipes.
+  _bindCentralStream(peripheral, sess, stream) {
+    stream.on('close', () => this._closeCentralSession(peripheral, sess))
     peripheral._stream = stream
     this._clearDial(peripheral.id)
     peripheral._conn = this._onChannel(stream, true, peripheral.id)
@@ -676,7 +720,7 @@ export class BLETransport extends ReadyResource {
   }
 
   _closeCentralSession(peripheral, sess) {
-    this._centralSend(peripheral, peripheral._char, frame(TYPE_CLOSE, sess.sid)).catch(safetyCatch)
+    this._centralSend(peripheral, peripheral._char, frame(TYPE_CLOSE, sess.id)).catch(safetyCatch)
     // platforms reuse peripheral objects across reconnects — stale refs here
     // would make the next session look live and get dropped
     peripheral._stream = null
@@ -712,17 +756,9 @@ export class BLETransport extends ReadyResource {
         this._abortDial(peripheral, 'l2cap-failed')
         return
       }
-      // sid preamble first: the server matches the channel to the session
-      channel.write(sess.sid)
-      const stream = new L2CAPStream(channel, {
-        onclose: () => this._closeCentralSession(peripheral, sess)
-      })
-      peripheral._stream = stream
-      this._clearDial(peripheral.id)
-      peripheral._conn = this._onChannel(stream, true, peripheral.id)
-      if (peripheral._peerName && peripheral._conn) {
-        peripheral._conn._peerName = peripheral._peerName
-      }
+      // id preamble first: the server matches the channel to the session
+      channel.write(b4a.from(sess.id, 'hex'))
+      this._bindCentralStream(peripheral, sess, new L2CAPStream(channel))
     } finally {
       sess.upgrading = false
     }
@@ -764,7 +800,7 @@ export class BLETransport extends ReadyResource {
     if (!sess) return
     const f = parseFrame(data)
     if (!f) return
-    if (f.sidHex !== sess.sidHex) return // not our session
+    if (f.id !== sess.id) return // not our session
     if (f.type === TYPE_DATA) {
       if (peripheral._stream) peripheral._stream.receive(b4a.from(f.payload))
     } else if (f.type === TYPE_HELLO) {
@@ -938,14 +974,14 @@ export class BLETransport extends ReadyResource {
   // flush. Resolves regardless: suspend must never hang on a wedged radio.
   async _sayGoodbye() {
     const sent = []
-    for (const { sid } of this._sessions.values()) {
-      sent.push(this._enqueueNotify(frame(TYPE_CLOSE, sid)).catch(safetyCatch))
+    for (const id of this._sessions.keys()) {
+      sent.push(this._enqueueNotify(frame(TYPE_CLOSE, id)).catch(safetyCatch))
     }
     for (const d of this._devices.values()) {
       const peripheral = d.peripheral
       const sess = peripheral && peripheral._session
       if (!sess || !peripheral._char) continue
-      const f = frame(TYPE_CLOSE, sess.sid)
+      const f = frame(TYPE_CLOSE, sess.id)
       sent.push(this._centralSend(peripheral, peripheral._char, f).catch(safetyCatch))
     }
     if (!sent.length) return
@@ -962,7 +998,9 @@ export class BLETransport extends ReadyResource {
     this._suspended = true
     if (this._scanTimer) clearTimeout(this._scanTimer)
     this._scanTimer = null
+    this._cyclePending = false // suspend tears the sessions down; resume republishes fresh
     for (const d of this._devices.values()) if (d.timer) clearTimeout(d.timer)
+    this._clearCandidates()
     // say goodbye BEFORE teardown so the remote reacts in <1s instead of waiting
     // out the 15s keepalive: close frames, a short drain, then an ACL disconnect
     // (an instant OS-level signal on both roles).
@@ -1037,6 +1075,7 @@ export class BLETransport extends ReadyResource {
     // stop advertising/scanning and let the runtime reclaim.
     for (const d of this._devices.values()) if (d.timer) clearTimeout(d.timer)
     this._devices.clear()
+    this._clearCandidates()
     try {
       this.central?.stopScan()
     } catch (err) {

package/src/network/transports/gatt.js

@@ -15,12 +15,10 @@ export class GattStream extends Duplex {
   /**
    * @param {object} opts
    * @param {(buffer: Uint8Array) => Promise<void>} opts.send  Transmit one payload piece (transport frames it).
-   * @param {() => void} [opts.onclose]  Called once on teardown (send a close frame, disconnect).
    */
-  constructor({ send, onclose } = {}) {
+  constructor({ send } = {}) {
     super()
     this._send = send
-    this._onclose = onclose || null
   }
 
   async _write(chunk, cb) {
@@ -41,17 +39,4 @@ export class GattStream extends Duplex {
   remoteEnd() {
     this.push(null)
   }
-
-  _destroy(cb) {
-    const onclose = this._onclose
-    this._onclose = null
-    if (onclose) {
-      try {
-        onclose()
-      } catch {
-        // teardown is best-effort
-      }
-    }
-    cb(null)
-  }
 }

package/src/network/transports/l2cap.js

@@ -12,13 +12,10 @@ import b4a from 'b4a'
 export class L2CAPStream extends Duplex {
   /**
    * @param {any} channel  bare-bluetooth L2CAPChannel (a duplex).
-   * @param {object} [opts]
-   * @param {() => void} [opts.onclose]  Called once on teardown (send a close frame, disconnect).
    */
-  constructor(channel, { onclose } = {}) {
+  constructor(channel) {
     super()
     this.channel = channel
-    this._onclose = onclose || null
 
     channel.on('data', (data) => {
       // propagate read backpressure: hold the channel while our buffer is full
@@ -48,15 +45,6 @@ export class L2CAPStream extends Duplex {
   }
 
   _destroy(cb) {
-    const onclose = this._onclose
-    this._onclose = null
-    if (onclose) {
-      try {
-        onclose()
-      } catch {
-        // teardown is best-effort
-      }
-    }
     try {
       this.channel.destroy()
     } catch {
@@ -68,33 +56,35 @@ export class L2CAPStream extends Duplex {
 
 /**
  * Accumulate the session-id preamble a central writes first on a fresh
- * channel, then hand (sid, leftover) to the callback exactly once. Owns the
- * channel's data events until then so no bytes race past the switchover.
- * Timeout → callback with (null, null).
+ * channel. Resolves { id, rest } — id as a hex string and rest being any bytes
+ * delivered past it (the channel is a byte stream; the first payload bytes may
+ * arrive glued to the id). Owns the channel's data events until then so no
+ * bytes race past the switchover. Timeout resolves { id: null, rest: null }.
  *
  * @param {any} channel
- * @param {number} sidLen
- * @param {(sid: Uint8Array | null, leftover: Uint8Array | null) => void} onSid
+ * @param {number} idLen
  * @param {number} timeout
+ * @returns {Promise<{ id: string | null, rest: Uint8Array | null }>}
  */
-export function readSidPreamble(channel, sidLen, onSid, timeout) {
-  let buf = b4a.alloc(0)
-  let done = false
+export function readIdPreamble(channel, idLen, timeout) {
+  return new Promise((resolve) => {
+    let buf = b4a.alloc(0)
 
-  const finish = (sid, leftover) => {
-    if (done) return
-    done = true
-    clearTimeout(timer)
-    channel.removeListener('data', onData)
-    onSid(sid, leftover)
-  }
+    const finish = (id, rest) => {
+      clearTimeout(timer)
+      channel.removeListener('data', onData)
+      resolve({ id, rest })
+    }
 
-  const onData = (data) => {
-    buf = b4a.concat([buf, b4a.from(data)])
-    if (buf.byteLength >= sidLen) finish(buf.subarray(0, sidLen), buf.subarray(sidLen))
-  }
+    const onData = (data) => {
+      buf = b4a.concat([buf, b4a.from(data)])
+      if (buf.byteLength >= idLen) {
+        finish(b4a.toString(buf.subarray(0, idLen), 'hex'), buf.subarray(idLen))
+      }
+    }
 
-  const timer = setTimeout(() => finish(null, null), timeout)
-  if (timer.unref) timer.unref()
-  channel.on('data', onData)
+    const timer = setTimeout(() => finish(null, null), timeout)
+    if (timer.unref) timer.unref()
+    channel.on('data', onData)
+  })
 }

package/types/network/transports/ble.d.ts

@@ -74,7 +74,7 @@ export class BLETransport extends ReadyResource {
     _dataChar: any;
     /** the published l2cap listener's psm, advertised to centrals over hello */
     _psm: any;
-    /** sessionId hex → { stream, sid } for server-side (peripheral) sessions */
+    /** id → { id, stream, conn, name, pipeTimer } for server-side (peripheral) sessions */
     _sessions: Map<any, any>;
     /** serialized server notify queue: { frame, resolve, reject } */
     _notifyQueue: any[];
@@ -83,9 +83,13 @@ export class BLETransport extends ReadyResource {
     _serviceAdded: boolean;
     /** peripheral id → per-peer dial state { timer, linked, coolUntil, failures, peerKey, peripheral } */
     _devices: Map<any, any>;
+    /** rate-limited discoveries held for the next dial window */
+    _candidates: Map<any, any>;
+    _dialTimer: any;
     /** last central.connect timestamp — global inter-dial rate limit */
     _lastDial: number;
     _scanTimer: any;
+    _cyclePending: boolean;
     _suspended: boolean;
     /** live injected links keyed by remote node id hex */
     peers: Map<any, any>;
@@ -108,10 +112,12 @@ export class BLETransport extends ReadyResource {
     _maybeAdvertise(): void;
     _onWriteRequests(requests: any): void;
     _onServerFrame(data: any): void;
-    _openServerGatt(sidHex: any, session: any): void;
-    _onServerChannel(channel: any): void;
-    _reapSession(sidHex: any, session: any): void;
-    _closeServerSession(sidHex: any, sid: any): void;
+    _openServerGatt(session: any): void;
+    _onServerChannel(channel: any): Promise<void>;
+    _bindServerStream(session: any, stream: any): void;
+    _reapSession(id: any, session: any): void;
+    _closeServerSession(id: any): void;
+    _notifyClose(id: any): void;
     _helloPayload(): any;
     /**
      * @param {Uint8Array} payload
@@ -137,9 +143,12 @@ export class BLETransport extends ReadyResource {
     _onRadioDown(): void;
     _onState(raw: any): void;
     _onDiscover(peripheral: any): void;
+    _flushCandidates(): void;
+    _clearCandidates(): void;
     _onConnect(peripheral: any): void;
     _startCentralSession(peripheral: any, char: any): void;
     _openCentralGatt(peripheral: any, sess: any): void;
+    _bindCentralStream(peripheral: any, sess: any, stream: any): void;
     _closeCentralSession(peripheral: any, sess: any): void;
     _openCentralL2CAP(peripheral: any, sess: any, psm: any): Promise<void>;
     _openChannel(peripheral: any, psm: any): Promise<any>;

package/types/network/transports/gatt.d.ts

@@ -9,17 +9,13 @@ export class GattStream extends Duplex<import("streamx").DuplexEvents> {
     /**
      * @param {object} opts
      * @param {(buffer: Uint8Array) => Promise<void>} opts.send  Transmit one payload piece (transport frames it).
-     * @param {() => void} [opts.onclose]  Called once on teardown (send a close frame, disconnect).
      */
-    constructor({ send, onclose }?: {
+    constructor({ send }?: {
         send: (buffer: Uint8Array) => Promise<void>;
-        onclose?: () => void;
     });
     _send: (buffer: Uint8Array) => Promise<void>;
-    _onclose: () => void;
     _write(chunk: any, cb: any): Promise<void>;
     receive(buffer: any): void;
     remoteEnd(): void;
-    _destroy(cb: any): void;
 }
 import { Duplex } from 'streamx';

package/types/network/transports/l2cap.d.ts

@@ -1,15 +1,19 @@
 /**
  * Accumulate the session-id preamble a central writes first on a fresh
- * channel, then hand (sid, leftover) to the callback exactly once. Owns the
- * channel's data events until then so no bytes race past the switchover.
- * Timeout → callback with (null, null).
+ * channel. Resolves { id, rest } — id as a hex string and rest being any bytes
+ * delivered past it (the channel is a byte stream; the first payload bytes may
+ * arrive glued to the id). Owns the channel's data events until then so no
+ * bytes race past the switchover. Timeout resolves { id: null, rest: null }.
  *
  * @param {any} channel
- * @param {number} sidLen
- * @param {(sid: Uint8Array | null, leftover: Uint8Array | null) => void} onSid
+ * @param {number} idLen
  * @param {number} timeout
+ * @returns {Promise<{ id: string | null, rest: Uint8Array | null }>}
  */
-export function readSidPreamble(channel: any, sidLen: number, onSid: (sid: Uint8Array | null, leftover: Uint8Array | null) => void, timeout: number): void;
+export function readIdPreamble(channel: any, idLen: number, timeout: number): Promise<{
+    id: string | null;
+    rest: Uint8Array | null;
+}>;
 /**
  * Byte pipe over an L2CAP channel — the GattStream-shaped wrapper so
  * BLETransport can treat both pipes identically. The channel is already a
@@ -21,14 +25,9 @@ export function readSidPreamble(channel: any, sidLen: number, onSid: (sid: Uint8
 export class L2CAPStream extends Duplex<import("streamx").DuplexEvents> {
     /**
      * @param {any} channel  bare-bluetooth L2CAPChannel (a duplex).
-     * @param {object} [opts]
-     * @param {() => void} [opts.onclose]  Called once on teardown (send a close frame, disconnect).
      */
-    constructor(channel: any, { onclose }?: {
-        onclose?: () => void;
-    });
+    constructor(channel: any);
     channel: any;
-    _onclose: () => void;
     _read(cb: any): void;
     _write(chunk: any, cb: any): void;
     receive(buffer: any): void;