Expand 35 modules across encoding, consensus, experimental, messaging, pear, storage, and supercomputer APIs.

Co-authored-by: Cursor <[email protected]>

agents-workflows/hyper-p2p-task-orchestrator/index.js

@@ -382,6 +382,16 @@ class HyperP2PTaskOrchestrator extends EventEmitter {
     return n
   }
 
+  async clearAll () {
+    const cancelled = await this.cancelAllPending()
+    const tasks = this.tasks.size
+    this.tasks.clear()
+    this.results.clear()
+    this.dependencies.clear()
+    this.reverseDeps.clear()
+    return { cancelled, tasks }
+  }
+
   async queryTasks (filter = {}) {
     await this.ready()
     let results = Array.from(this.tasks.values())

consensus-coordination/hyper-p2p-leader-lease/index.js

@@ -135,6 +135,10 @@ class HyperP2PLeaderLease extends EventEmitter {
     return true
   }
 
+  clearAll () {
+    return this.resetLease()
+  }
+
   _gossipSync () {
     gossipSend(this, {
       type: 'leader-lease-sync',

core-infrastructure/hyper-p2p-presence/index.js

@@ -336,6 +336,18 @@ class HyperP2PPresence extends EventEmitter {
     return [...this.peers.keys()]
   }
 
+  clearAll () {
+    const selfKey = b4a.toString(this.keyPair.publicKey, 'hex')
+    let n = 0
+    for (const id of this.peerIds()) {
+      if (id !== selfKey) {
+        this.peers.delete(id)
+        n++
+      }
+    }
+    return n
+  }
+
   announceNow () {
     this._broadcastPresence()
     return this.getSelf()

core-infrastructure/hyper-p2p-session-bridge/index.js

@@ -77,6 +77,10 @@ class HyperP2PSessionBridge extends EventEmitter {
     return n
   }
 
+  async clearAll () {
+    return this.removeAllPairs()
+  }
+
   async removePair (token) {
     const entry = this._tokens.get(token)
     if (!entry) return false

encoding-wire/hyper-p2p-compact-codec-bridge/index.js

@@ -77,6 +77,10 @@ class HyperP2PCompactCodecBridge extends EventEmitter {
     return this._stats
   }
 
+  clearAll () {
+    return this.resetStats()
+  }
+
   getStats () {
     return {
       ...this._stats,

encoding-wire/hyper-p2p-message-envelope/index.js

@@ -109,6 +109,10 @@ class HyperP2PMessageEnvelope extends EventEmitter {
     return this._stats
   }
 
+  clearAll () {
+    return this.resetStats()
+  }
+
   getStats () {
     return { ...this._stats, protocol: PROTOCOL }
   }

experimental/hyper-p2p-contradiction-graph/index.js

@@ -120,6 +120,15 @@ class HyperP2PContradictionGraph extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clear()
+  }
+
+  claimBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.claim(e.subject, e.predicate, e.value))
+  }
+
   claimIds () {
     return this._claims.map((c) => c.id)
   }

experimental/hyper-p2p-mirror-realm/index.js

@@ -118,6 +118,15 @@ class HyperP2PMirrorRealm extends EventEmitter {
     return { realmA: this.clearRealm('A'), realmB: this.clearRealm('B') }
   }
 
+  clearAll () {
+    return this.clearBoth()
+  }
+
+  writeBatch (realm, entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.write(realm, e.key, e.value))
+  }
+
   hasDiff (key) {
     return this.diffKeys().includes(String(key))
   }

experimental/hyper-p2p-phase-shift-clock/index.js

@@ -87,6 +87,11 @@ class HyperP2PPhaseShiftClock extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    this.resetPhase()
+    return this.clearPeerPhases()
+  }
+
   getPeerPhase (peer) {
     return this._peerPhases.get(peer) ?? null
   }

experimental/hyper-p2p-silence-protocol/index.js

@@ -85,6 +85,15 @@ class HyperP2PSilenceProtocol extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clear()
+  }
+
+  assertAbsentBatch (ids) {
+    if (!Array.isArray(ids)) throw new Error('ids array required')
+    return ids.map((id) => this.assertAbsent(id))
+  }
+
   revokeAbsent (id) {
     return this._absent.delete(String(id))
   }

measurement-rate-control/hyper-p2p-bucket-rate-limit/index.js

@@ -110,6 +110,10 @@ class HyperP2PBucketRateLimit extends EventEmitter {
     return this._buckets.delete(key)
   }
 
+  clearAll () {
+    return this.reset()
+  }
+
   lowestTokens () {
     let worst = null
     for (const [peerId, b] of this._buckets) {

media-streaming/hyper-p2p-adaptive-streaming-engine/index.js

@@ -81,6 +81,10 @@ class HyperP2PAdaptiveStreamingEngine extends EventEmitter {
     return this._recommendation
   }
 
+  clearAll () {
+    return this.reset()
+  }
+
   bufferMs () {
     return this._bufferMs
   }

media-streaming/hyper-p2p-content-protection/index.js

@@ -101,6 +101,10 @@ class HyperP2PContentProtection extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearKeys()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { activeKeyId: this._activeKeyId, keys: this._keys.size })
   }

messaging-gossip/hyper-p2p-distributed-event-bus/index.js

@@ -362,6 +362,13 @@ class HyperP2PDistributedEventBus extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    const seen = this.clearSeenEvents()
+    const subs = this.unsubscribeAll()
+    this.eventLog.clear()
+    return { seen, subs }
+  }
+
   async publishBatch (events) {
     if (!Array.isArray(events)) throw new Error('events array required')
     const out = []

messaging-gossip/hyper-p2p-gossip-mesh/index.js

@@ -138,9 +138,14 @@ class HyperP2PGossipMesh extends EventEmitter {
     const n = this._seen.size
     this._seen.clear()
     this._seenAt.clear()
+    this._recent = []
     return n
   }
 
+  clearAll () {
+    return this.clearSeen()
+  }
+
   hasSeen (id) {
     return this._seen.has(String(id))
   }

messaging-pubsub/hyper-p2p-retained-messages/index.js

@@ -53,6 +53,10 @@ class HyperP2PRetainedMessages extends EventEmitter {
     return ok
   }
 
+  clearAll () {
+    return this.clear()
+  }
+
   channelCount () {
     return this._store.size
   }

messaging-pubsub/hyper-p2p-topic-channel/index.js

@@ -102,6 +102,12 @@ class HyperP2PTopicChannel extends EventEmitter {
     return channels.length
   }
 
+  clearAll () {
+    const subs = this.unsubscribeAll()
+    const retained = this.clearRetained()
+    return { subs, retained }
+  }
+
   retainedChannels () {
     return [...this._retained.keys()]
   }

network-stack/hyper-p2p-connection-pool/index.js

@@ -81,6 +81,10 @@ class HyperP2PConnectionPool extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.closeAll()
+  }
+
   _sweepIdle () {
     const now = Date.now()
     for (const [id, lane] of this._lanes) {

network-stack/hyper-p2p-protocol-handshake/index.js

@@ -83,6 +83,10 @@ class HyperP2PProtocolHandshake extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return { offers: this.clearOffers(), agreed: this.clearAgreed() }
+  }
+
   getStats () {
     return { ...this._stats, pending: this._offers.size, agreed: this._agreed.size, protocol: PROTOCOL }
   }

pear-platform/hyper-bare-entry-runner/index.js

@@ -122,6 +122,15 @@ class HyperBareEntryRunner extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearRuns()
+  }
+
+  planRunBatch (specs) {
+    if (!Array.isArray(specs)) throw new Error('specs array required')
+    return specs.map((s) => this.planRun(s.target, s.args || [], s.flags || {}))
+  }
+
   cancelAllRuns () {
     let n = 0
     for (const id of this.runIds()) {

pear-platform/hyper-bare-import-map/index.js

@@ -87,8 +87,9 @@ class HyperBareImportMap extends EventEmitter {
     return n
   }
 
-  has (specifier) {
+  setBatch (entries) {
-    return Object.prototype.hasOwnProperty.call(this._imports, String(specifier))
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.set(e.specifier, e.target))
   }
 
   entryCount () {

pear-platform/hyper-pear-dev-profile/index.js

@@ -65,6 +65,11 @@ class HyperPearDevProfile extends EventEmitter {
     return this.snapshot()
   }
 
+  clearAll () {
+    this.disableDev()
+    return this.resetFlags()
+  }
+
   mergeArgv (argvBridge) {
     if (!argvBridge || typeof argvBridge.hasFlag !== 'function') {
       throw new Error('argv bridge required')

pear-platform/hyper-pear-link-resolver/index.js

@@ -62,6 +62,10 @@ class HyperPearLinkResolver extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearCache()
+  }
+
   normalize (parts) {
     const href = this.serialize(parts)
     return this.parse(href)

pear-platform/hyper-pear-runtime-embed/index.js

@@ -74,6 +74,10 @@ class HyperPearRuntimeEmbed extends EventEmitter {
     return true
   }
 
+  clearAll () {
+    return this.reset()
+  }
+
   snapshot () {
     return {
       dir: this.dir,

routing-advanced/hyper-p2p-circuit-breaker/index.js

@@ -115,6 +115,17 @@ class HyperP2PCircuitBreaker extends EventEmitter {
     return ids.length
   }
 
+  clearAll () {
+    const n = this._circuits.size
+    this._circuits.clear()
+    return n
+  }
+
+  registerBatch (ids) {
+    if (!Array.isArray(ids)) throw new Error('ids array required')
+    return ids.map((id) => this.register(id))
+  }
+
   closedCount () {
     let n = 0
     for (const c of this._circuits.values()) {

routing-advanced/hyper-p2p-retry-policy/index.js

@@ -73,6 +73,15 @@ class HyperP2PRetryPolicy extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearRoutes()
+  }
+
+  registerRouteBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerRoute(e.id, e.opts || {}))
+  }
+
   getRoute (id) {
     const r = this._routes.get(String(id))
     return r ? { ...r } : null

storage-autobase/hyper-p2p-autobase-indexer-bus/index.js

@@ -98,6 +98,12 @@ class HyperP2PAutobaseIndexerBus extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    const events = this.clearEvents()
+    const subs = this.unsubscribeAll()
+    return { events, subs }
+  }
+
   subscriberCount () {
     return this._subs.size
   }

storage-autobase/hyper-p2p-autobase-light-writer/index.js

@@ -95,6 +95,14 @@ class HyperP2PAutobaseLightWriter extends EventEmitter {
     return this.flushOps()
   }
 
+  clearPending () {
+    return this.rollbackOps()
+  }
+
+  clearAll () {
+    return this.clearPending()
+  }
+
   getStats () {
     return autobaseStats(this._stats, PROTOCOL, {
       pending: this._ops.length,

storage-hyperbee/hyper-p2p-bee-range-watch/index.js

@@ -52,6 +52,10 @@ class HyperP2PBeeRangeWatch extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.unwatchAll()
+  }
+
   emitChange (key, value, op = 'put') {
     if (key == null) throw new Error('key required')
     let n = 0

storage-hyperdrive/hyper-p2p-drive-watch-notify/index.js

@@ -64,6 +64,15 @@ class HyperP2PDriveWatchNotify extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.unwatchAll()
+  }
+
+  watchPathBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.watchPath(e.path, e.cb))
+  }
+
   hasWatch (id) {
     return this._watches.has(id)
   }

supercomputer/hyper-p2p-bandwidth-share/index.js

@@ -122,6 +122,15 @@ class HyperP2PBandwidthShare extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearOffers()
+  }
+
+  offerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.offer(e.peerId, e.upMbps, e.downMbps))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

supercomputer/hyper-p2p-cluster-fabric/index.js

@@ -303,6 +303,20 @@ class HyperP2PClusterFabric extends EventEmitter {
     return ok
   }
 
+  clearAll () {
+    const nodes = this._nodes.size
+    const reservations = this._reservations.size
+    for (const id of [...this._nodes.keys()]) this.removeNode(id)
+    this._reservations.clear()
+    this._used = { cpuMs: 0, ramMb: 0, gpuSlots: 0, diskGb: 0 }
+    return { nodes, reservations }
+  }
+
+  publishNodeBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.publishNode(e.resources || {}, e.peerId))
+  }
+
   /**
    * Check if the combined cluster can satisfy a workload without reserving.
    */

supercomputer/hyper-p2p-net-gateway/index.js

@@ -110,6 +110,18 @@ class HyperP2PNetGateway extends EventEmitter {
     return Math.max(0, gw.maxBytes - (this._usage.get(id) || 0))
   }
 
+  clearAll () {
+    const gateways = this._gateways.size
+    this._gateways.clear()
+    this._usage.clear()
+    return gateways
+  }
+
+  registerGatewayBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerGateway(e.peerId, e.caps || {}))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

trust-security/hyper-p2p-key-rotation/index.js

@@ -81,6 +81,15 @@ class HyperP2PKeyRotation extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.revokeAll()
+  }
+
+  scheduleRotationBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.scheduleRotation(e.keyId, e.newMaterial, e.activateAt))
+  }
+
   nextActivation (keyId) {
     const list = this._pending.get(String(keyId)) || []
     if (!list.length) return null

trust-security/hyper-p2p-session-rotation/index.js

@@ -83,6 +83,15 @@ class HyperP2PSessionRotation extends EventEmitter {
     return ids.length
   }
 
+  clearAll () {
+    return this.revokeAll()
+  }
+
+  rotateSessionBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.rotateSession(e.sessionId, e.newToken))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)