Enrich module APIs with snapshot and batch helpers across categories.

Adds snapshot(), domain batch methods, and clearAll aliases on consensus, core, encoding, experimental, indexes, messaging, network, oracle, pear, routing, storage, supercomputer, and trust modules.

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

consensus-coordination/hyper-p2p-causal-consensus/index.js

@@ -424,6 +424,15 @@ class HyperP2PCausalConsensus extends EventEmitter {
     return { proposals, decided }
   }
 
+  snapshot () {
+    return {
+      proposals: this.proposalIds().length,
+      decided: this.decidedOrders.size,
+      peers: this.peers.size,
+      metrics: this.getMetrics()
+    }
+  }
+
   getMetrics () {
     return { ...this._metrics, peers: this.peers.size, pendingProposals: this.proposals.size - this.decidedOrders.size }
   }

consensus-coordination/hyper-p2p-distributed-lock/index.js

@@ -366,6 +366,14 @@ class HyperP2PDistributedLock extends EventEmitter {
     return { released, locks }
   }
 
+  snapshot () {
+    return {
+      locks: this.locks.size,
+      owned: this.myLocks.size,
+      active: this.listActiveLocks().length
+    }
+  }
+
   /**
    * List all currently active locks (local + remote).
    * Supports optional filter by owner or resource prefix.

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

@@ -139,6 +139,15 @@ class HyperP2PLeaderLease extends EventEmitter {
     return this.resetLease()
   }
 
+  snapshot () {
+    return {
+      leader: this._leader,
+      term: this._term,
+      msRemaining: this.leaseRemainingMs(),
+      followers: this.followerCount()
+    }
+  }
+
   _gossipSync () {
     gossipSend(this, {
       type: 'leader-lease-sync',

consensus-coordination/hyper-p2p-quorum-pool/index.js

@@ -189,6 +189,20 @@ class HyperP2PQuorumPool extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return {
+      members: [...this._members],
+      proposals: this.proposalIds().length,
+      open: this.openProposals().length,
+      quorum: this.quorum
+    }
+  }
+
+  proposeBatch (payloads, opts = {}) {
+    if (!Array.isArray(payloads)) throw new Error('payloads array required')
+    return payloads.map((payload) => this.propose(payload, opts))
+  }
+
   voteBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.vote(e.proposalId, e.voterId, e.accept !== false))

consensus-coordination/hyper-p2p-raft-lite/index.js

@@ -78,6 +78,15 @@ class HyperP2PRaftLite extends EventEmitter {
     return entries.map((entry) => this.appendLog(entry))
   }
 
+  snapshot () {
+    return {
+      term: this.currentTerm(),
+      role: this.role(),
+      logLength: this._log.length,
+      commitIndex: this._commitIndex
+    }
+  }
+
   logEntryAt (index) {
     return this._log[index] || null
   }

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

@@ -259,6 +259,19 @@ class CapabilityManager extends EventEmitter {
     }
   }
 
+  snapshot () {
+    return {
+      issued: this.issued.size,
+      received: this.received.size,
+      revoked: this.revoked.size
+    }
+  }
+
+  issueBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.issue(e.subjectPubKey, e.resource, e.actions, e.ttlMs))
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -348,6 +348,10 @@ class HyperP2PPresence extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { peers: this.peers.size, online: this.onlineCount(), ids: this.peerIds() }
+  }
+
   announceNow () {
     this._broadcastPresence()
     return this.getSelf()

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

@@ -138,6 +138,10 @@ class RPCServer extends EventEmitter {
     return this.unregisterAll()
   }
 
+  snapshot () {
+    return { services: this.listServices(), connections: this.connectionCount() }
+  }
+
   connectionCount () { return this.connections.size }
 
   getStats () {

core-infrastructure/hyper-p2p-vector-clock/index.js

@@ -345,6 +345,10 @@ class HyperP2PVectorClock extends EventEmitter {
 
   peerCount () { return this.clock.size }
 
+  snapshot () {
+    return { clock: this.toJSON(), peers: this.getKnownPeers(), local: this.getLocalCounter() }
+  }
+
   clearAll () {
     const n = this.clock.size
     this.clock.clear()

encoding-wire/hyper-p2p-wire-registry/index.js

@@ -146,6 +146,17 @@ class HyperP2PWireRegistry extends EventEmitter {
     }
   }
 
+  clearAll () {
+    const codecs = this.clearAllCodecs()
+    const protocols = this.unregisterAllProtocols()
+    return { codecs, protocols }
+  }
+
+  registerProtocolBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerProtocol(e.protocolId, e.meta || {}))
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -137,6 +137,10 @@ class HyperP2PContradictionGraph extends EventEmitter {
     return this._claims.length
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-entropy-spiral/index.js

@@ -55,6 +55,10 @@ class HyperP2PEntropySpiral extends EventEmitter {
     return this.reset()
   }
 
+  snapshot () {
+    return this.spiralState()
+  }
+
   sampleBatch (seeds) {
     if (!Array.isArray(seeds)) throw new Error('seeds array required')
     return seeds.map((seed) => this.sampleEntropy(seed))

experimental/hyper-p2p-gravity-well/index.js

@@ -116,6 +116,10 @@ class HyperP2PGravityWell extends EventEmitter {
     return messages.map((msg) => this.attract(msg))
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-memetic-spread/index.js

@@ -96,6 +96,10 @@ class HyperP2PMemeticSpread extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return this.spreadStats()
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -139,6 +139,10 @@ class HyperP2PMirrorRealm extends EventEmitter {
     }
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-mycelium-pool/index.js

@@ -118,6 +118,15 @@ class HyperP2PMyceliumPool extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
+  donateBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.donate(e.peerId, e.credits))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-paradox-clock/index.js

@@ -117,6 +117,15 @@ class HyperP2PParadoxClock extends EventEmitter {
     return [...this._stamps.keys()]
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
+  stampBatch (eventIds, opts = {}) {
+    if (!Array.isArray(eventIds)) throw new Error('eventIds array required')
+    return eventIds.map((id) => this.stamp(id, opts))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-paradox-merge/index.js

@@ -89,6 +89,10 @@ class HyperP2PParadoxMerge extends EventEmitter {
     return { branches, resolved }
   }
 
+  snapshot () {
+    return { open: this.listOpen().length, resolved: this._resolved.size }
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -100,6 +100,10 @@ class HyperP2PPhaseShiftClock extends EventEmitter {
     return this.shift(deltaMs)
   }
 
+  snapshot () {
+    return { phaseMs: this._phaseMs, peers: this.peerPhases() }
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

experimental/hyper-p2p-pheromone-trail/index.js

@@ -114,6 +114,15 @@ class HyperP2PPheromoneTrail extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
+  depositBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.deposit(e.pathId, e.strength, e.dest))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

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

@@ -108,6 +108,10 @@ class HyperP2PSilenceProtocol extends EventEmitter {
     return ids.length
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

experimental/hyper-p2p-tension-field/index.js

@@ -149,6 +149,10 @@ class HyperP2PTensionField extends EventEmitter {
     return cells.map((c) => this.setField(c.x, c.y, c.value))
   }
 
+  snapshot () {
+    return { cells: this.cellCount(), energy: this.fieldEnergy(), peers: this._peerFields.size }
+  }
+
   getStats () {
     return experimentalStats(this._stats, PROTOCOL, {
       cells: this._field.size,

experimental/hyper-p2p-time-capsule/index.js

@@ -144,6 +144,14 @@ class HyperP2PTimeCapsule extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return {
+      sealed: this.listSealed().length,
+      ready: this.listReady().length,
+      total: this._capsules.size
+    }
+  }
+
   sealBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.seal(e.payload, e.opts || {}))

experimental/hyper-p2p-void-channel/index.js

@@ -76,6 +76,10 @@ class HyperP2PVoidChannel extends EventEmitter {
     return { voids: [...this._voids.values()] }
   }
 
+  snapshot () {
+    return this.toSnapshot()
+  }
+
   unsubscribeAll () {
     const n = this._subs.size
     this._subs.clear()

experimental/hyper-p2p-whisper-mesh/index.js

@@ -95,6 +95,10 @@ class HyperP2PWhisperMesh extends EventEmitter {
     return this.clearSeen()
   }
 
+  snapshot () {
+    return { seen: this._seen.size, maxHops: this.maxHops }
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

indexes-search/hyper-p2p-bloom-gossip/index.js

@@ -102,6 +102,15 @@ class HyperP2PBloomGossip extends EventEmitter {
     return this.clear()
   }
 
+  snapshot () {
+    return { keys: this.listKeys(), fillRatio: this.fillRatio(), size: this._size }
+  }
+
+  addBatch (keys) {
+    if (!Array.isArray(keys)) throw new Error('keys array required')
+    return keys.map((k) => this.add(k))
+  }
+
   union (payload) {
     if (!payload || !payload.bits) return 0
     const remote = b4a.from(payload.bits, 'hex')

indexes-search/hyper-p2p-fulltext-lite/index.js

@@ -145,6 +145,19 @@ class HyperP2PFulltextLite extends EventEmitter {
     return [...this._docs.keys()]
   }
 
+  snapshot () {
+    return {
+      documents: this.documentIds().length,
+      terms: this.termCount(),
+      topTerms: this.topTerms(8)
+    }
+  }
+
+  searchBatch (queries, mode = 'and') {
+    if (!Array.isArray(queries)) throw new Error('queries array required')
+    return queries.map((q) => this.search(q, mode))
+  }
+
   clearAll () {
     const n = this._docs.size
     this._docs.clear()

indexes-search/hyper-p2p-graph-index/index.js

@@ -151,6 +151,15 @@ class HyperP2PGraphIndex extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
+  addEdgeBatch (edges) {
+    if (!Array.isArray(edges)) throw new Error('edges array required')
+    return edges.map((e) => this.addEdge(e.from, e.to))
+  }
+
   getStats () {
     return {
       ...this._stats,

indexes-search/hyper-p2p-inverted-index/index.js

@@ -126,6 +126,15 @@ class HyperP2PInvertedIndex extends EventEmitter {
     return docs
   }
 
+  snapshot () {
+    return { terms: this.termCount(), documents: this._docs.size, topTerms: this.topTerms(8) }
+  }
+
+  indexBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.index(e.docId, e.terms))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

indexes-search/hyper-p2p-trie-prefix/index.js

@@ -125,6 +125,10 @@ class HyperP2PTriePrefix extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { words: this.wordCount(), sample: [...this._words].slice(0, 12) }
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -117,6 +117,14 @@ class HyperP2PQosTopic extends EventEmitter {
     return { handlers, pending }
   }
 
+  snapshot () {
+    return {
+      channels: this.listChannels(),
+      queueDepths: this.queueDepths(),
+      handlers: this.handlerCount()
+    }
+  }
+
   _onGossip (data) {
     if (!data || data.type !== 'qos-publish') return
     this._stats.gossipIn++

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

@@ -93,6 +93,15 @@ class HyperP2PRetainedMessages extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { channels: this.listChannels(), total: this.totalRetained() }
+  }
+
+  retainBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.retain(e.channel, e.payload, e.opts || {}))
+  }
+
   getStats () {
     return {
       ...this._stats,

network-discovery/hyper-p2p-topic-announcer/index.js

@@ -66,6 +66,19 @@ class HyperP2PTopicAnnouncer extends EventEmitter {
     return ids.length
   }
 
+  clearAll () {
+    return this.revokeAll()
+  }
+
+  announceBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.announce(e.topicId, e.meta || {}))
+  }
+
+  snapshot () {
+    return { topics: this.list(), count: this.topicCount() }
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

oracles/hyper-p2p-decentralized-oracle/index.js

@@ -467,6 +467,27 @@ class HyperP2PDecentralizedOracle extends EventEmitter {
     return n
   }
 
+  clearAll () {
+    return this.clearAllFeeds()
+  }
+
+  async submitReportBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    const out = []
+    for (const e of entries) {
+      out.push(await this.submitReport(e.feedId, e.data, e.metadata || {}))
+    }
+    return out
+  }
+
+  snapshot () {
+    return {
+      feeds: [...this.feeds.keys()],
+      pendingReports: this.pendingReports.size,
+      metrics: { ...this.metrics }
+    }
+  }
+
   getStats () {
     return {
       ...this._stats,

pear-platform/hyper-bare-bundle-bridge/index.js

@@ -77,6 +77,15 @@ class HyperBareBundleBridge extends EventEmitter {
     return this._bundles.size
   }
 
+  snapshot () {
+    return { bundles: this.listBundles(), count: this.bundleCount() }
+  }
+
+  registerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerBundle(e.id, e.manifest))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

pear-platform/hyper-bare-distributable-hint/index.js

@@ -67,8 +67,9 @@ class HyperBareDistributableHint extends EventEmitter {
     )
   }
 
-  hasHint (appId) {
+  setHintBatch (entries) {
-    return this._hints.has(String(appId))
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.setHint(e.appId, e.layout))
   }
 
   clearAll () {

routing-advanced/hyper-p2p-sticky-session/index.js

@@ -73,6 +73,10 @@ class HyperP2PStickySession extends EventEmitter {
     return this._bindings.size
   }
 
+  snapshot () {
+    return { sessions: this.sessionIds(), count: this.bindingCount() }
+  }
+
   _onGossip (d) {
     if (!d || d.type !== 'sticky-session-sync' || !d.sessionId) return
     this._stats.gossipIn++

routing-paths/hyper-p2p-merge-registry/index.js

@@ -158,6 +158,15 @@ class HyperP2PMergeRegistry extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { keys: this.listKeys(), count: this.entryCount() }
+  }
+
+  registerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.register(e.key, e.value, e.opts || {}))
+  }
+
   tombstoneCount () {
     return [...this._entries.values()].filter((e) => e.tombstone).length
   }

routing-paths/hyper-p2p-pattern-router/index.js

@@ -109,6 +109,10 @@ class HyperP2PPatternRouter extends EventEmitter {
     return this.clearRoutes()
   }
 
+  snapshot () {
+    return { routes: this.routeCount(), patterns: this.listPatterns() }
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

routing-paths/hyper-p2p-relay-tunnel/index.js

@@ -111,6 +111,10 @@ class HyperP2PRelayTunnel extends EventEmitter {
     return { tunnels, routes }
   }
 
+  snapshot () {
+    return { tunnels: this.activeTunnelCount(), routes: this.routeCount() }
+  }
+
   relayBatch (frames) {
     if (!Array.isArray(frames)) throw new Error('frames array required')
     return frames.map((f) => this.relay(f.tunnelId, f.payload))

storage-hyperdrive/hyper-p2p-drive-entry-catalog/index.js

@@ -77,6 +77,10 @@ class HyperP2PDriveEntryCatalog extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { entries: this.listEntries(), count: this._catalog.size }
+  }
+
   mergeCatalog (entries) {
     const n = mergeCatalog(this._catalog, entries)
     if (n) this.emit('merge', { count: n })

storage-hyperdrive/hyper-p2p-drive-mount-bridge/index.js

@@ -83,6 +83,15 @@ class HyperP2PDriveMountBridge extends EventEmitter {
     return n
   }
 
+  mountPathBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.mountPath(e.localPrefix, e.remotePrefix))
+  }
+
+  snapshot () {
+    return { mounts: this.listMounts(), count: this._mounts.size }
+  }
+
   _onGossip (d) {
     if (!d) return
     this._stats.gossipIn++

supercomputer/hyper-p2p-gpu-slot/index.js

@@ -118,6 +118,10 @@ class HyperP2PGpuSlot extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return this.clusterGpuSlots()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

supercomputer/hyper-p2p-thermal-guard/index.js

@@ -113,6 +113,15 @@ class HyperP2PThermalGuard extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { samples: this.listSamples(), health: this.clusterHealth() }
+  }
+
+  reportBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.reportLoad(e.peerId, e.cpuPct, e.ramPct, e.tempC))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

trust-security/hyper-p2p-attestation-chain/index.js

@@ -98,6 +98,14 @@ class HyperP2PAttestationChain extends EventEmitter {
     return payloads.map((p) => this.append(p, opts))
   }
 
+  snapshot () {
+    return this.toJSON()
+  }
+
+  clearAll () {
+    return this.clearChain()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

trust-security/hyper-p2p-blind-pair-handoff/index.js

@@ -110,6 +110,10 @@ class HyperP2PBlindPairHandoff extends EventEmitter {
     return [...this._handoffs.keys()]
   }
 
+  snapshot () {
+    return { sessions: this.sessionIds(), count: this._handoffs.size }
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -104,6 +104,14 @@ class HyperP2PKeyRotation extends EventEmitter {
     return [...this._pending.keys()]
   }
 
+  snapshot () {
+    return {
+      active: [...this._active.keys()],
+      pending: this.pendingKeyIds(),
+      count: this._active.size
+    }
+  }
+
   _maybeActivate (keyId, now = Date.now()) {
     const list = this._pending.get(keyId) || []
     for (const e of list) {

trust-security/hyper-p2p-multisig-threshold/index.js

@@ -134,6 +134,18 @@ class HyperP2PMultisigThreshold extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return {
+      proposals: this.proposalIds().length,
+      pending: this.pendingProposals().length
+    }
+  }
+
+  createProposalBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.createProposal(e.id, e.signers, e.threshold))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

trust-security/hyper-p2p-trust-graph/index.js

@@ -172,6 +172,15 @@ class HyperP2PTrustGraph extends EventEmitter {
     return n
   }
 
+  snapshot () {
+    return { nodes: this.nodeCount(), edges: this.edges().length, decay: this.decay }
+  }
+
+  addEdgeBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.addEdge(e.from, e.to, e.weight))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {