@cero-base/core 1.3.0 → 1.5.0

package/src/network/transports/dht.js

@@ -0,0 +1,110 @@
+import Hyperswarm from 'hyperswarm'
+import b4a from 'b4a'
+import { hash } from 'hypercore-crypto'
+import safetyCatch from 'safety-catch'
+
+/**
+ * @typedef {object} DHTTransportOpts
+ * @property {import('../../identity/index.js').Identity} [identity]  Long-lived keypair used as the swarm identity.
+ * @property {Array<{ host: string, port: number }>} [bootstrap]      Custom DHT bootstrap nodes.
+ * @property {(remotePublicKey: Uint8Array, payload: any) => boolean} [firewall]  Incoming-connection filter.
+ * @property {Uint8Array[]} [relayThrough]                            Relay public keys to tunnel through.
+ * @property {string} [channel]                                       Optional network-isolation label; only same-channel peers meet.
+ */
+
+/**
+ * The internet transport: a Hyperswarm that finds peers over the DHT. Owns the
+ * swarm's whole lifecycle — construction (identity keyPair, bootstrap, firewall,
+ * relay), the channel-topic join/leave wrapping, flush, suspend/resume, and
+ * teardown. {@link Network} subscribes to `this.swarm`'s connection/peer events
+ * and drives topic joins; the swarm-specific wiring lives here.
+ */
+export class DHTTransport {
+  /** @param {DHTTransportOpts} [opts] */
+  constructor({ identity, bootstrap, firewall, relayThrough, channel } = {}) {
+    const opts = {}
+    if (identity) opts.keyPair = { publicKey: identity.publicKey, secretKey: identity.secretKey }
+    if (bootstrap) opts.bootstrap = bootstrap
+    if (firewall) opts.firewall = firewall
+    if (relayThrough) opts.relayThrough = relayThrough
+
+    this.swarm = new Hyperswarm(opts)
+
+    if (channel) {
+      const join = this.swarm.join.bind(this.swarm)
+      const leave = this.swarm.leave.bind(this.swarm)
+      this.swarm.join = (topic, opts) => join(channelTopic(topic, channel), opts)
+      this.swarm.leave = (topic) => leave(channelTopic(topic, channel))
+    }
+  }
+
+  /** @returns {boolean} */
+  get suspended() {
+    return this.swarm?.suspended === true
+  }
+
+  /**
+   * Wait for pending DHT announces and lookups to settle, bounded by timeout.
+   *
+   * @param {{ timeout?: number }} [opts]
+   * @returns {Promise<void>}
+   */
+  async flush({ timeout = 500 } = {}) {
+    if (!this.swarm) return
+    await Promise.race([this.swarm.flush(), new Promise((r) => setTimeout(r, timeout))])
+  }
+
+  /**
+   * Pause the swarm — keeps state, drops sockets. Idempotent.
+   *
+   * @returns {Promise<void>}
+   */
+  async suspend() {
+    if (!this.swarm || this.swarm.suspended) return
+    try {
+      await this.swarm.suspend()
+    } catch (err) {
+      safetyCatch(err)
+    }
+  }
+
+  /**
+   * Resume a suspended swarm. Idempotent.
+   *
+   * @returns {Promise<void>}
+   */
+  async resume() {
+    if (!this.swarm || !this.swarm.suspended) return
+    try {
+      await this.swarm.resume()
+    } catch (err) {
+      safetyCatch(err)
+    }
+  }
+
+  /**
+   * Flush pending discovery, then tear down the swarm. Idempotent.
+   *
+   * @returns {Promise<void>}
+   */
+  async destroy() {
+    if (!this.swarm) return
+    try {
+      await this.flush()
+    } catch (err) {
+      safetyCatch(err)
+    }
+    try {
+      await this.swarm.destroy()
+    } catch (err) {
+      safetyCatch(err)
+    }
+    this.swarm = null
+  }
+}
+
+// A channel re-namespaces every swarm topic so only same-channel peers meet.
+// No channel → identity (unchanged, back-compat).
+export function channelTopic(topic, channel) {
+  return channel ? hash([topic, b4a.from(channel)]) : topic
+}

package/src/network/{gatt-stream.js → transports/gatt.js}

@@ -1,15 +1,13 @@
 import { Duplex } from 'streamx'
 
-// iOS caps a single GATT write (and a notify payload) at ATT_MTU − 3 ≈ 182
-// bytes. 150 stays safely under that without negotiating an MTU. Raise later
-// via the peripheral's maximumWriteValueLength + write-without-response.
+// 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 BluetoothTransport; this only fragments outbound writes to fit a GATT
- * write and pushes inbound payload bytes. NoiseSecretStream wraps it as a raw
- * duplex, exactly like the old L2CAP channel.
+ * live in BLETransport; this only fragments outbound writes to fit a GATT
+ * write and pushes inbound payload bytes.
  *
  * @extends Duplex
  */

package/src/rpc/index.js

@@ -12,6 +12,7 @@ const EMPTY = b4a.alloc(0)
 // Default envelope encodings for the @cero namespace, used when the supplied
 // spec does not provide its own rows/query/create types in its schema.
 const DEFAULT_ROWS = getEncoding('@cero/rows')
+const DEFAULT_CHANGES = getEncoding('@cero/changes')
 const DEFAULT_QUERY = getEncoding('@cero/query')
 const DEFAULT_CREATE = getEncoding('@cero/create')
 
@@ -26,6 +27,8 @@ const DEFAULT_CREATE = getEncoding('@cero/create')
  * @property {(type: string, row: any) => Uint8Array} encodeRow
  * @property {(type: string, buf: Uint8Array) => any} decodeRow
  * @property {(type: string, rows: any[]) => Uint8Array} encodeRows
+ * @property {(type: string, changes: Array<{ prev: any, next: any }>) => Uint8Array} encodeChanges
+ * @property {(type: string, buf: Uint8Array) => Array<{ prev: any, next: any }>} decodeChanges
  * @property {(type: string, buf: Uint8Array) => any[]} decodeRows
  * @property {(q: any) => Uint8Array} encodeQuery
  * @property {(buf: Uint8Array) => any} decodeQuery
@@ -51,6 +54,7 @@ export function bindCodec(spec) {
 
   const ns = spec.meta?.ns
   const ROWS = ns ? `@${ns}/rows` : null
+  const CHANGES = ns ? `@${ns}/changes` : null
   const QUERY = ns ? `@${ns}/query` : null
   const CREATE = ns ? `@${ns}/create` : null
 
@@ -73,6 +77,25 @@ export function bindCodec(spec) {
       const data = env?.data || []
       return data.map((b) => schema.decode(type, b))
     },
+    encodeChanges(type, changes) {
+      const prev = changes.map((x) => (x.prev ? schema.encode(type, x.prev) : EMPTY))
+      const next = changes.map((x) => (x.next ? schema.encode(type, x.next) : EMPTY))
+      return encodeEnvelope(schema, CHANGES, DEFAULT_CHANGES, { prev, next })
+    },
+    decodeChanges(type, buf) {
+      if (!buf || buf.length === 0) return []
+      const env = decodeEnvelope(schema, CHANGES, DEFAULT_CHANGES, buf)
+      const prev = env?.prev || []
+      const next = env?.next || []
+      const out = []
+      for (let i = 0; i < Math.max(prev.length, next.length); i++) {
+        out.push({
+          prev: prev[i]?.length ? schema.decode(type, prev[i]) : null,
+          next: next[i]?.length ? schema.decode(type, next[i]) : null
+        })
+      }
+      return out
+    },
     encodeQuery(q) {
       if (q == null) return encodeEnvelope(schema, QUERY, DEFAULT_QUERY, {})
       const { gt, gte, lt, lte, limit, reverse, ...rest } = q

package/types/database/changes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Pull-driven delta stream over a collection: batches of `{ prev, next }`
+ * pairs diffed between per-stream snapshot cursors. Update ticks only mark
+ * the stream dirty — the diff runs when the reader demands, so backpressure
+ * folds bursts into one bigger batch and nothing is ever dropped. The first
+ * batch, and any batch after the view is swapped or fast-forwarded to a new
+ * core, carries the full matching state as inserts with `reset: true`.
+ *
+ * @param {import('./index.js').Database} db
+ * @param {string} name    Ref name (scopes the update ticks).
+ * @param {string} col     Collection path (`@ns/name`).
+ * @param {(row: any) => boolean} matches
+ * @returns {import('streamx').Readable}
+ */
+export function makeChanges(db: import("./index.js").Database, name: string, col: string, matches: (row: any) => boolean): import("streamx").Readable;

package/types/database/envelope.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Prefix an encoded op with the app's contract version.
+ *
+ * @param {number} version
+ * @param {Uint8Array} body
+ * @returns {Uint8Array}
+ */
+export function wrap(version: number, body: Uint8Array): Uint8Array;
+/**
+ * Split an op into contract version and payload. Ops written before the
+ * envelope existed carry no sentinel and read as version 0.
+ *
+ * @param {Uint8Array} buf
+ * @returns {{ version: number, body: Uint8Array }}
+ */
+export function unwrap(buf: Uint8Array): {
+    version: number;
+    body: Uint8Array;
+};

package/types/database/index.d.ts

@@ -54,6 +54,8 @@ export class Database extends ReadyResource {
         kind?: string;
         verb?: string;
     }>;
+    version: any;
+    behind: any;
     routes: Record<string, Function>;
     namespace: string;
     encryptionKey: Uint8Array<ArrayBufferLike>;
@@ -216,6 +218,24 @@ export class Database extends ReadyResource {
      * @returns {Promise<void>}
      */
     write(ops: Array<[string, any]>): Promise<void>;
+    /**
+     * Record that the log contains ops from a newer app version than this
+     * peer understands. Fires `'behind'` once per version so apps can prompt
+     * an upgrade; the marker survives restarts via local core userData.
+     *
+     * @param {number} version
+     */
+    _onFuture(version: number): void;
+    /**
+     * Validate ops against the committed view before appending: each op runs in
+     * a throwaway transaction with host effects stubbed, so a throwing handler
+     * rejects the write and nothing enters the permanent log. Permission gates
+     * that `return` are not rejections — apply stays the authority at
+     * linearization time.
+     *
+     * @param {Uint8Array[]} encoded
+     */
+    _dryRun(encoded: Uint8Array[]): Promise<void>;
     /**
      * Read a row. With no `query`: list all (collection) or fetch the one
      * record (single). With a string id: fetch that specific row.
@@ -247,6 +267,18 @@ export class Database extends ReadyResource {
      * @returns {import('streamx').Readable}
      */
     watch(name: string, query?: Query): import("streamx").Readable;
+    /**
+     * Delta subscription: batches of `{ prev, next }` row pairs instead of
+     * full snapshots. The first batch (and any batch after a view swap) carries
+     * the current matching rows as inserts with `reset: true` — replaying every
+     * batch into a Map keyed by row id always reconstructs current state.
+     * `limit`/`reverse` are not applied; deltas are unwindowed by design.
+     *
+     * @param {string} name
+     * @param {Query} [query]
+     * @returns {import('streamx').Readable}
+     */
+    changes(name: string, query?: Query): import("streamx").Readable;
     /**
      * First-run bootstrap: create the device writer, save it, and swap into it.
      *

package/types/lib/spec/index.d.ts

@@ -2,12 +2,8 @@ export function resolveStruct(name: any, v?: number): {
     preencode(state: any, m: any): void;
     encode(state: any, m: any): void;
     decode(state: any): {
-        coreKey: any;
-        blockOffset: any;
-        blockLength: any;
-        byteOffset: any;
-        byteLength: any;
-        type: any;
+        prev: any;
+        next: any;
     } | {
         status: any;
         reason: any;
@@ -21,18 +17,21 @@ export function resolveStruct(name: any, v?: number): {
         name: any;
         role: any;
         noAccept: boolean;
-    };
-};
-export function getStruct(name: any, v?: number): {
-    preencode(state: any, m: any): void;
-    encode(state: any, m: any): void;
-    decode(state: any): {
+    } | {
         coreKey: any;
         blockOffset: any;
         blockLength: any;
         byteOffset: any;
         byteLength: any;
         type: any;
+    };
+};
+export function getStruct(name: any, v?: number): {
+    preencode(state: any, m: any): void;
+    encode(state: any, m: any): void;
+    decode(state: any): {
+        prev: any;
+        next: any;
     } | {
         status: any;
         reason: any;
@@ -46,6 +45,13 @@ export function getStruct(name: any, v?: number): {
         name: any;
         role: any;
         noAccept: boolean;
+    } | {
+        coreKey: any;
+        blockOffset: any;
+        blockLength: any;
+        byteOffset: any;
+        byteLength: any;
+        type: any;
     };
 };
 export function getEnum(name: any): void;
@@ -85,6 +91,13 @@ export function getEncoding(name: any): {
         byteLength: any;
         type: any;
     };
+} | {
+    preencode(state: any, m: any): void;
+    encode(state: any, m: any): void;
+    decode(state: any): {
+        prev: any;
+        next: any;
+    };
 };
 export function encode(name: any, value: any, v?: number): any;
 export function decode(name: any, buffer: any, v?: number): any;

package/types/network/index.d.ts

@@ -1,4 +1,4 @@
-export function channelTopic(topic: any, channel: any): any;
+export { channelTopic };
 /**
  * @typedef {object} NetworkOpts
  * @property {import('../identity/index.js').Identity} [identity]  Long-lived keypair used as the swarm identity.
@@ -6,6 +6,8 @@ export function channelTopic(topic: any, channel: any): any;
  * @property {(remotePublicKey: Uint8Array, payload: any) => boolean} [firewall]  Incoming-connection filter.
  * @property {Uint8Array[]} [relayThrough]                          Relay public keys to tunnel through.
  * @property {string} [channel]                                     Optional network-isolation label; only same-channel peers meet.
+ * @property {any} [store]                                          Corestore; required for mirrors (blind peers replicate its cores).
+ * @property {Array<string | Uint8Array>} [mirrors]                Blind-peer public keys; each attached room/blob core is mirrored through them for offline sync.
  *
  * @typedef {{ replicate: (stream: any) => any }} Replicable
  */
@@ -15,7 +17,7 @@ export function channelTopic(topic: any, channel: any): any;
  */
 export class Network extends ReadyResource {
     /** @param {NetworkOpts} [opts] */
-    constructor({ identity, bootstrap, firewall, relayThrough, channel }?: NetworkOpts);
+    constructor({ identity, bootstrap, firewall, relayThrough, channel, store, mirrors }?: NetworkOpts);
     identity: import("../index.js").Identity;
     bootstrap: {
         host: string;
@@ -24,12 +26,17 @@ export class Network extends ReadyResource {
     firewall: (remotePublicKey: Uint8Array, payload: any) => boolean;
     relayThrough: Uint8Array<ArrayBufferLike>[];
     channel: string;
-    swarm: any;
+    store: any;
+    mirrors: any[];
+    _dht: DHTTransport;
     wakeup: any;
     _replicateables: Set<any>;
     _discoveries: Set<any>;
     _injected: Set<any>;
     _blind: any;
+    _blindPeering: any;
+    /** @returns {any} The underlying hyperswarm, or null before ready / after close. */
+    get swarm(): any;
     /**
      * Feed an externally-established connection — a Bluetooth L2CAP channel, a
      * serial link, an in-process pair, any duplex — into the network. A raw
@@ -75,7 +82,7 @@ export class Network extends ReadyResource {
      * @param {{ timeout?: number }} [opts]
      * @returns {Promise<void>}
      */
-    flush({ timeout }?: {
+    flush(opts?: {
         timeout?: number;
     }): Promise<void>;
     /**
@@ -149,9 +156,19 @@ export type NetworkOpts = {
      * Optional network-isolation label; only same-channel peers meet.
      */
     channel?: string;
+    /**
+     * Corestore; required for mirrors (blind peers replicate its cores).
+     */
+    store?: any;
+    /**
+     * Blind-peer public keys; each attached room/blob core is mirrored through them for offline sync.
+     */
+    mirrors?: Array<string | Uint8Array>;
 };
 export type Replicable = {
     replicate: (stream: any) => any;
 };
+import { channelTopic } from './transports/dht.js';
 import ReadyResource from 'ready-resource';
+import { DHTTransport } from './transports/dht.js';
 import { Discovery } from './discovery.js';

package/types/network/{bluetooth.d.ts → transports/ble.d.ts}

@@ -12,37 +12,36 @@ export function toServiceUUID(topic: Uint8Array, tag?: string): string;
  * byte-stream to each discovered peer, and feeds it into `network.inject`. From
  * there replication and pairing are transport-agnostic (see Network.inject).
  *
- * Choreography: 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 (bitchat
- * model). `backend` is bare-bluetooth in production and a mock in tests.
- *
- * ponytail: capability-handshake DoS link-scoring is deferred — it needs a
- * replication-progress signal (design §4b). v1 caps links + times out dials.
+ * 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 BluetoothTransport 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 {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.cap]           Max concurrent links; gossip covers the rest.
+     * @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.
      */
-    constructor({ backend, network, uuid, nodeId, tag, cap, scanOptions, keepLinks, name }: {
+    constructor({ backend, network, uuid, nodeId, tag, maxOutbound, maxInbound, scanOptions, keepLinks, name }: {
         backend: any;
-        network: import("./index.js").Network;
+        network: import("../index.js").Network;
         uuid: Uint8Array;
         nodeId: Uint8Array;
         tag?: string;
-        cap?: number;
+        maxOutbound?: number;
+        maxInbound?: number;
         scanOptions?: {
             scanMode?: any;
         };
@@ -50,12 +49,13 @@ export class BluetoothTransport extends ReadyResource {
         name?: string;
     });
     backend: any;
-    network: import("./index.js").Network;
+    network: import("../index.js").Network;
     name: string;
     nodeId: Uint8Array<ArrayBufferLike>;
     nodeHex: any;
     serviceUUID: string;
-    cap: number;
+    maxOutbound: number;
+    maxInbound: number;
     scanOptions: {
         scanMode?: any;
     };
@@ -71,19 +71,8 @@ export class BluetoothTransport extends ReadyResource {
     _scanning: boolean;
     _advertising: boolean;
     _serviceAdded: boolean;
-    /** peripheral id being dialed → its connect-timeout timer */
-    _dialing: Map<any, any>;
-    /** peripheral ids that carry a live channel — never re-dialed (a second
-     * dial's failure would disconnect the peripheral and kill the good link) */
-    _linked: Set<any>;
-    /** peripheral id → retry-after timestamp; failed dials back off */
-    _coolUntil: Map<any, any>;
-    /** peripheral id → consecutive failure count; drives exponential backoff */
-    _failures: Map<any, any>;
-    /** peripheral id → remote peer key, learned at handshake — dial guard */
-    _peerByPeripheral: Map<any, any>;
-    /** live central-side peripheral wrappers — for goodbye + physical hang-up on suspend */
-    _connectedPeripherals: Set<any>;
+    /** peripheral id → per-peer dial state { timer, linked, coolUntil, failures, peerKey, peripheral } */
+    _devices: Map<any, any>;
     /** last central.connect timestamp — global inter-dial rate limit */
     _lastDial: number;
     _scanTimer: any;
@@ -100,21 +89,15 @@ export class BluetoothTransport extends ReadyResource {
      */
     shouldInitiate(peerNodeId: Uint8Array): boolean;
     get linkCount(): number;
+    _device(id: any): any;
+    _prune(id: any): void;
     _startServer(Service: any, Characteristic: any): void;
     _maybeAdvertise(): void;
     _onWriteRequests(requests: any): void;
     _onServerFrame(data: any): void;
     _closeServerSession(sidHex: any, sid: any): void;
-    /** Our hello payload: the local app-user name the peer labels this link with. */
     _helloPayload(): any;
-    /**
-     * Parse a hello payload. Malformed → null (the caller ignores it).
-     *
-     * @param {Uint8Array} payload
-     * @returns {string | null}
-     */
-    _parseHello(payload: Uint8Array): string | null;
-    /** Stash a peer's name onto a server session + its conn, then refresh mirrors. */
+    _parseHello(payload: any): string;
     _applyPeerName(session: any, payload: any): void;
     _enqueueNotify(f: any): Promise<any>;
     _drainNotify(): void;
@@ -130,26 +113,17 @@ export class BluetoothTransport extends ReadyResource {
     _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(l2cap: any, isInitiator: any, peripheralId: any): any;
+    _onChannel(stream: any, isInitiator: any, peripheralId: any): any;
     _track(conn: any, peripheralId: any, isInitiator: any): void;
     _untrack(conn: any): void;
-    /**
-     * Best-effort TYPE_CLOSE to every live session — server sessions over the
-     * notify path, central sessions over the write path — reusing the same helpers
-     * a normal stream close uses. Waits up to DRAIN_MS for the frames to flush,
-     * then resolves regardless: suspend must never hang on a wedged radio.
-     *
-     * @returns {Promise<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.
-     * iOS CoreBluetooth managers can't be destroy()ed (native double-free), so a
-     * fresh transport per toggle leaks a manager whose stale peripheral-manager
-     * keeps a duplicate GATT service registered; remote centrals then subscribe to
-     * the dead service and hear silence. Reuse one instance instead. Idempotent.
+     * CoreBluetooth managers can't be destroy()ed (native double-free), so one
+     * transport is reused across toggles rather than recreated. Idempotent.
      */
     suspend(): Promise<void>;
     /**

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

@@ -0,0 +1,75 @@
+export function channelTopic(topic: any, channel: any): any;
+/**
+ * @typedef {object} DHTTransportOpts
+ * @property {import('../../identity/index.js').Identity} [identity]  Long-lived keypair used as the swarm identity.
+ * @property {Array<{ host: string, port: number }>} [bootstrap]      Custom DHT bootstrap nodes.
+ * @property {(remotePublicKey: Uint8Array, payload: any) => boolean} [firewall]  Incoming-connection filter.
+ * @property {Uint8Array[]} [relayThrough]                            Relay public keys to tunnel through.
+ * @property {string} [channel]                                       Optional network-isolation label; only same-channel peers meet.
+ */
+/**
+ * The internet transport: a Hyperswarm that finds peers over the DHT. Owns the
+ * swarm's whole lifecycle — construction (identity keyPair, bootstrap, firewall,
+ * relay), the channel-topic join/leave wrapping, flush, suspend/resume, and
+ * teardown. {@link Network} subscribes to `this.swarm`'s connection/peer events
+ * and drives topic joins; the swarm-specific wiring lives here.
+ */
+export class DHTTransport {
+    /** @param {DHTTransportOpts} [opts] */
+    constructor({ identity, bootstrap, firewall, relayThrough, channel }?: DHTTransportOpts);
+    swarm: any;
+    /** @returns {boolean} */
+    get suspended(): boolean;
+    /**
+     * Wait for pending DHT announces and lookups to settle, bounded by timeout.
+     *
+     * @param {{ timeout?: number }} [opts]
+     * @returns {Promise<void>}
+     */
+    flush({ timeout }?: {
+        timeout?: number;
+    }): Promise<void>;
+    /**
+     * Pause the swarm — keeps state, drops sockets. Idempotent.
+     *
+     * @returns {Promise<void>}
+     */
+    suspend(): Promise<void>;
+    /**
+     * Resume a suspended swarm. Idempotent.
+     *
+     * @returns {Promise<void>}
+     */
+    resume(): Promise<void>;
+    /**
+     * Flush pending discovery, then tear down the swarm. Idempotent.
+     *
+     * @returns {Promise<void>}
+     */
+    destroy(): Promise<void>;
+}
+export type DHTTransportOpts = {
+    /**
+     * Long-lived keypair used as the swarm identity.
+     */
+    identity?: import("../../identity/index.js").Identity;
+    /**
+     * Custom DHT bootstrap nodes.
+     */
+    bootstrap?: Array<{
+        host: string;
+        port: number;
+    }>;
+    /**
+     * Incoming-connection filter.
+     */
+    firewall?: (remotePublicKey: Uint8Array, payload: any) => boolean;
+    /**
+     * Relay public keys to tunnel through.
+     */
+    relayThrough?: Uint8Array[];
+    /**
+     * Optional network-isolation label; only same-channel peers meet.
+     */
+    channel?: string;
+};

package/types/network/{gatt-stream.d.ts → transports/gatt.d.ts}

@@ -1,8 +1,7 @@
 /**
  * A dumb byte-carrying duplex for the GATT transport. Framing and session logic
- * live in BluetoothTransport; this only fragments outbound writes to fit a GATT
- * write and pushes inbound payload bytes. NoiseSecretStream wraps it as a raw
- * duplex, exactly like the old L2CAP channel.
+ * live in BLETransport; this only fragments outbound writes to fit a GATT
+ * write and pushes inbound payload bytes.
  *
  * @extends Duplex
  */

package/types/rpc/index.d.ts

@@ -9,6 +9,8 @@
  * @property {(type: string, row: any) => Uint8Array} encodeRow
  * @property {(type: string, buf: Uint8Array) => any} decodeRow
  * @property {(type: string, rows: any[]) => Uint8Array} encodeRows
+ * @property {(type: string, changes: Array<{ prev: any, next: any }>) => Uint8Array} encodeChanges
+ * @property {(type: string, buf: Uint8Array) => Array<{ prev: any, next: any }>} decodeChanges
  * @property {(type: string, buf: Uint8Array) => any[]} decodeRows
  * @property {(q: any) => Uint8Array} encodeQuery
  * @property {(buf: Uint8Array) => any} decodeQuery
@@ -57,6 +59,14 @@ export type Codec = {
     encodeRow: (type: string, row: any) => Uint8Array;
     decodeRow: (type: string, buf: Uint8Array) => any;
     encodeRows: (type: string, rows: any[]) => Uint8Array;
+    encodeChanges: (type: string, changes: Array<{
+        prev: any;
+        next: any;
+    }>) => Uint8Array;
+    decodeChanges: (type: string, buf: Uint8Array) => Array<{
+        prev: any;
+        next: any;
+    }>;
     decodeRows: (type: string, buf: Uint8Array) => any[];
     encodeQuery: (q: any) => Uint8Array;
     decodeQuery: (buf: Uint8Array) => any;