@cero-base/core 1.12.0 → 1.13.0

package/src/network/transports/gatt.js

@@ -1,42 +0,0 @@
-import { Duplex } from 'streamx'
-
-// A single GATT write/notify caps at ATT_MTU − 3 ≈ 182 bytes; 150 stays under
-// that without negotiating an MTU.
-const PAYLOAD = 150
-
-/**
- * A dumb byte-carrying duplex for the GATT transport. Framing and session logic
- * live in BLETransport; this only fragments outbound writes to fit a GATT
- * write and pushes inbound payload bytes.
- *
- * @extends Duplex
- */
-export class GattStream extends Duplex {
-  /**
-   * @param {object} opts
-   * @param {(buffer: Uint8Array) => Promise<void>} opts.send  Transmit one payload piece (transport frames it).
-   */
-  constructor({ send } = {}) {
-    super()
-    this._send = send
-  }
-
-  async _write(chunk, cb) {
-    try {
-      for (let offset = 0; offset < chunk.byteLength; offset += PAYLOAD) {
-        await this._send(chunk.subarray(offset, offset + PAYLOAD))
-      }
-      cb(null)
-    } catch (err) {
-      cb(err)
-    }
-  }
-
-  receive(buffer) {
-    this.push(buffer)
-  }
-
-  remoteEnd() {
-    this.push(null)
-  }
-}

package/src/network/transports/l2cap.js

@@ -1,90 +0,0 @@
-import { Duplex } from 'streamx'
-import b4a from 'b4a'
-
-/**
- * Byte pipe over an L2CAP channel — the GattStream-shaped wrapper so
- * BLETransport can treat both pipes identically. The channel is already a
- * reliable ordered duplex with credit-based flow control, so no framing or
- * fragmentation is needed.
- *
- * @extends Duplex
- */
-export class L2CAPStream extends Duplex {
-  /**
-   * @param {any} channel  bare-bluetooth L2CAPChannel (a duplex).
-   */
-  constructor(channel) {
-    super()
-    this.channel = channel
-
-    channel.on('data', (data) => {
-      // propagate read backpressure: hold the channel while our buffer is full
-      if (!this.push(b4a.from(data))) channel.pause()
-    })
-    channel.on('end', () => this.push(null))
-    channel.on('error', () => this.destroy())
-    channel.on('close', () => this.destroy())
-  }
-
-  _read(cb) {
-    this.channel.resume()
-    cb(null)
-  }
-
-  _write(chunk, cb) {
-    if (this.channel.write(chunk)) cb(null)
-    else this.channel.once('drain', () => cb(null))
-  }
-
-  receive(buffer) {
-    this.push(buffer)
-  }
-
-  remoteEnd() {
-    this.push(null)
-  }
-
-  _destroy(cb) {
-    try {
-      this.channel.destroy()
-    } catch {
-      // channel may already be gone
-    }
-    cb(null)
-  }
-}
-
-/**
- * Accumulate the session-id preamble a central writes first on a fresh
- * 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} idLen
- * @param {number} timeout
- * @returns {Promise<{ id: string | null, rest: Uint8Array | null }>}
- */
-export function readIdPreamble(channel, idLen, timeout) {
-  return new Promise((resolve) => {
-    let buf = b4a.alloc(0)
-
-    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 >= 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)
-  })
-}

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

@@ -1,180 +0,0 @@
-/**
- * Derive a stable 128-bit BLE service UUID from a topic. Only devices that
- * compute the same UUID (same channel / same invite) ever discover each other.
- *
- * @param {Uint8Array} topic
- * @param {string} [tag]  Namespace so channel and invite meshes never collide.
- * @returns {string}
- */
-export function toServiceUUID(topic: Uint8Array, tag?: string): string;
-/**
- * Dual-role BLE transport: advertises + scans one service UUID, opens a GATT
- * byte-stream to each discovered peer, and feeds it into `network.inject`. From
- * there replication and pairing are transport-agnostic (see Network.inject).
- *
- * The server adds one data characteristic (write + notify) and advertises. The
- * central connects, discovers the characteristic, subscribes, then framed bytes
- * flow both ways — central→server as GATT writes, server→central as
- * notifications — each tagged with an 8-byte session id. `backend` is
- * bare-bluetooth in production and a mock in tests.
- *
- * @extends ReadyResource
- */
-export class BLETransport extends ReadyResource {
-    /**
-     * @param {object} opts
-     * @param {any} opts.backend            bare-bluetooth-shaped module (Central, Server, Service, Characteristic).
-     * @param {import('../index.js').Network} opts.network
-     * @param {Uint8Array} opts.uuid        The 32-byte topic the service UUID derives from.
-     * @param {Uint8Array} opts.nodeId      Stable local id (identity/device key) for the initiate tie-break.
-     * @param {string} [opts.tag]           UUID namespace (channel mesh vs invite mesh).
-     * @param {number} [opts.maxOutbound]   Max concurrent outbound dials/links; gossip covers the rest.
-     * @param {number} [opts.maxInbound]    Max concurrent inbound sessions; newcomers past this are refused.
-     * @param {{ scanMode?: any }} [opts.scanOptions]  Platform scan options (e.g. Android low-power).
-     * @param {boolean} [opts.keepLinks]    On close, stop the radio but leave established links alive (invite rendezvous: the link outlives the QR and carries the initial replication).
-     * @param {string} [opts.name]          Local app-user display name, sent to peers over a hello frame.
-     * @param {'l2cap' | 'gatt'} [opts.pipe]  Data pipe: 'l2cap' (default — a real channel per session, several times faster) or 'gatt' (framed characteristic stream). Both peers must match.
-     * @param {{ timeout?: number }} [opts.l2cap]  Deadline for an l2cap channel open.
-     */
-    constructor({ backend, network, uuid, nodeId, tag, maxOutbound, maxInbound, scanOptions, keepLinks, name, pipe, l2cap }: {
-        backend: any;
-        network: import("../index.js").Network;
-        uuid: Uint8Array;
-        nodeId: Uint8Array;
-        tag?: string;
-        maxOutbound?: number;
-        maxInbound?: number;
-        scanOptions?: {
-            scanMode?: any;
-        };
-        keepLinks?: boolean;
-        name?: string;
-        pipe?: "l2cap" | "gatt";
-        l2cap?: {
-            timeout?: number;
-        };
-    });
-    backend: any;
-    network: import("../index.js").Network;
-    name: string;
-    nodeId: Uint8Array<ArrayBufferLike>;
-    nodeHex: any;
-    serviceUUID: string;
-    maxOutbound: number;
-    maxInbound: number;
-    scanOptions: {
-        scanMode?: any;
-    };
-    keepLinks: boolean;
-    pipe: "l2cap" | "gatt";
-    _l2capTimeout: number;
-    state: string;
-    central: any;
-    server: any;
-    _dataChar: any;
-    /** the published l2cap listener's psm, advertised to centrals over hello */
-    _psm: any;
-    /** id → { id, stream, conn, name, pipeTimer } for server-side (peripheral) sessions */
-    _sessions: Map<any, any>;
-    /** serialized server notify queue: { frame, resolve, reject } */
-    _notifyQueue: any[];
-    _scanning: boolean;
-    _advertising: boolean;
-    _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>;
-    /**
-     * Whether we should be the one to open the connection to `peerNodeId`. The
-     * lexicographically smaller id initiates; the larger waits — so a pair
-     * connects once, not twice. Equal (our own reflection) → false.
-     *
-     * @param {Uint8Array} peerNodeId
-     * @returns {boolean}
-     */
-    shouldInitiate(peerNodeId: Uint8Array): boolean;
-    get linkCount(): number;
-    _device(id: any): any;
-    _prune(id: any): void;
-    _startServer(Service: any, Characteristic: any): void;
-    _publishListener(): void;
-    _unpublishListener(): void;
-    _cycleListener(): void;
-    _maybeAdvertise(): void;
-    _onWriteRequests(requests: any): void;
-    _onServerFrame(data: 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
-     * @returns {{ name: string, psm: number | null } | null}
-     */
-    _parseHello(payload: Uint8Array): {
-        name: string;
-        psm: number | null;
-    } | null;
-    _applyPeerName(session: any, payload: any): void;
-    _enqueueNotify(f: any): Promise<any>;
-    _drainNotify(): void;
-    _startScan(): void;
-    _armScanRestart(): void;
-    _stopScan(): void;
-    /**
-     * A radio power cycle invalidates the GATT service, advertising, scans,
-     * subscriptions and every open link, but the bookkeeping flags survive —
-     * without a reset the device never re-registers or re-advertises and goes
-     * dark until the app-level toggle is cycled. Reset so the poweredOn
-     * handlers bootstrap everything from scratch.
-     */
-    _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>;
-    _onCentralNotify(peripheral: any, data: any): void;
-    _centralSend(peripheral: any, char: any, f: any): any;
-    _writeOnce(peripheral: any, char: any, f: any): Promise<any>;
-    _abortDial(peripheral: any, _reason: any): void;
-    _clearDial(id: any): void;
-    _isDialing(): boolean;
-    _onCentralError(err: any): void;
-    _onChannel(stream: any, isInitiator: any, peripheralId: any): any;
-    _track(conn: any, peripheralId: any, isInitiator: any): void;
-    _untrack(conn: any): void;
-    _sayGoodbye(): Promise<void>;
-    /**
-     * Pause radio activity but KEEP the Server/Central instances and the
-     * registered GATT service alive — the toggle-friendly counterpart to _close.
-     * CoreBluetooth managers can't be destroy()ed (native double-free), so one
-     * transport is reused across toggles rather than recreated. Idempotent.
-     */
-    suspend(): Promise<void>;
-    /**
-     * Restart advertising + scanning on the SAME Server/Central. `_serviceAdded`
-     * is still true (the service was never removed) so advertising resumes
-     * immediately. Safe to call repeatedly; no-op once closing/closed.
-     */
-    resume(): void;
-}
-import ReadyResource from 'ready-resource';

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

@@ -1,21 +0,0 @@
-/**
- * A dumb byte-carrying duplex for the GATT transport. Framing and session logic
- * live in BLETransport; this only fragments outbound writes to fit a GATT
- * write and pushes inbound payload bytes.
- *
- * @extends Duplex
- */
-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).
-     */
-    constructor({ send }?: {
-        send: (buffer: Uint8Array) => Promise<void>;
-    });
-    _send: (buffer: Uint8Array) => Promise<void>;
-    _write(chunk: any, cb: any): Promise<void>;
-    receive(buffer: any): void;
-    remoteEnd(): void;
-}
-import { Duplex } from 'streamx';

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

@@ -1,37 +0,0 @@
-/**
- * Accumulate the session-id preamble a central writes first on a fresh
- * 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} idLen
- * @param {number} timeout
- * @returns {Promise<{ id: string | null, rest: Uint8Array | null }>}
- */
-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
- * reliable ordered duplex with credit-based flow control, so no framing or
- * fragmentation is needed.
- *
- * @extends Duplex
- */
-export class L2CAPStream extends Duplex<import("streamx").DuplexEvents> {
-    /**
-     * @param {any} channel  bare-bluetooth L2CAPChannel (a duplex).
-     */
-    constructor(channel: any);
-    channel: any;
-    _read(cb: any): void;
-    _write(chunk: any, cb: any): void;
-    receive(buffer: any): void;
-    remoteEnd(): void;
-    _destroy(cb: any): void;
-}
-import { Duplex } from 'streamx';