Add listKeys() and keyCount() helpers across modules (ninth pass).

Standardize key enumeration after size() on map- and registry-style modules, aliasing existing list* methods or primary store keys so callers can inspect occupancy without parsing snapshots.

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

agents-workflows/hyper-p2p-agent-memory/index.js

@@ -470,6 +470,14 @@ class HyperP2PAgentMemory extends EventEmitter {
     return this.memoryCount()
   }
 
+  listKeys () {
+    return this.memoryIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async storeMemoryBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     const out = []

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

@@ -475,6 +475,14 @@ class HyperP2PTaskOrchestrator extends EventEmitter {
     return this.tasks.size
   }
 
+  listKeys () {
+    return this.listTaskIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     const counts = this.taskCounts()
     return {

agents-workflows/hyper-p2p-workflow-graph/index.js

@@ -205,6 +205,14 @@ class HyperP2PWorkflowGraph extends EventEmitter {
     return this.nodeCount()
   }
 
+  listKeys () {
+    return this.nodeIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   nodeIds () {
     return [...this._nodes.keys()]
   }

applications-collab/hyper-p2p-collab-room/index.js

@@ -184,6 +184,14 @@ class HyperP2PCollabRoom extends EventEmitter {
     return this.roomCount()
   }
 
+  listKeys () {
+    return this.listRooms()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _onGossip (data) {
     if (!data || !data.type) return
     this._stats.gossipIn++

applications-collab/hyper-p2p-cursor-presence/index.js

@@ -130,6 +130,14 @@ class HyperP2PCursorPresence extends EventEmitter {
     return this.cursorCount()
   }
 
+  listKeys () {
+    return this.listDocIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _onGossip (data) {
     if (!data) return
     this._stats.gossipIn++

applications-collab/hyper-p2p-document-line-lock/index.js

@@ -124,6 +124,14 @@ class HyperP2PDocumentLineLock extends EventEmitter {
     return this.lockCount()
   }
 
+  listKeys () {
+    return [...this._locks.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   acquireBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.acquire(e.docId, e.line))

applications-collab/hyper-p2p-whiteboard-op/index.js

@@ -122,6 +122,14 @@ class HyperP2PWhiteboardOp extends EventEmitter {
     return this.opCount()
   }
 
+  listKeys () {
+    return this.listRooms()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   applyBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.apply(e.roomId, e.op))

applications-economy/hyper-p2p-auction-gossip/index.js

@@ -157,6 +157,14 @@ class HyperP2PAuctionGossip extends EventEmitter {
     return this.snapshot().auctions
   }
 
+  listKeys () {
+    return this.listAuctionIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   openAuctionBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.openAuction(e.auctionId, e.meta || {}))

applications-economy/hyper-p2p-credit-ledger/index.js

@@ -126,6 +126,14 @@ class HyperP2PCreditLedger extends EventEmitter {
     return this.accountCount()
   }
 
+  listKeys () {
+    return this.listAccounts()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _apply (accountId, delta, kind, reason) {
     assertNonEmpty(accountId, 'accountId')
     const acct = this._accounts.get(accountId)

applications-economy/hyper-p2p-marketplace-listing/index.js

@@ -137,6 +137,14 @@ class HyperP2PMarketplaceListing extends EventEmitter {
     return this.snapshot().listings
   }
 
+  listKeys () {
+    return this.listListingIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   createListingBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.createListing(e.listingId, e.listing))

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

@@ -453,6 +453,14 @@ class HyperP2PCausalConsensus extends EventEmitter {
     return this.proposals.size + this.decidedOrders.size
   }
 
+  listKeys () {
+    return [...new Set([...this.proposals.keys(), ...this.decidedOrders.keys()])]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async proposeBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     const out = []

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

@@ -394,6 +394,14 @@ class HyperP2PDistributedLock extends EventEmitter {
     return this.lockCount()
   }
 
+  listKeys () {
+    return [...this.locks.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async acquireBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     const out = []

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

@@ -168,6 +168,16 @@ class HyperP2PLeaderLease extends EventEmitter {
     return this.followerCount() + (this._leader ? 1 : 0)
   }
 
+  listKeys () {
+    const keys = this.followers()
+    if (this._leader) keys.push(this._leader)
+    return keys
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossipSync () {
     gossipSend(this, {
       type: 'leader-lease-sync',

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

@@ -218,6 +218,14 @@ class HyperP2PQuorumPool extends EventEmitter {
     return this.proposalCount()
   }
 
+  listKeys () {
+    return [...this._proposals.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   proposeBatch (payloads, opts = {}) {
     if (!Array.isArray(payloads)) throw new Error('payloads array required')
     return payloads.map((payload) => this.propose(payload, opts))

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

@@ -289,6 +289,14 @@ class CapabilityManager extends EventEmitter {
     return s.issued + s.received + s.revoked
   }
 
+  listKeys () {
+    return [...this.issued.keys(), ...this.received.keys()]
+  }
+
+  keyCount () {
+    return this.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))

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

@@ -372,6 +372,14 @@ class HyperP2PPresence extends EventEmitter {
     return Math.max(0, this.peers.size - 1)
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   announceNow () {
     this._broadcastPresence()
     return this.getSelf()

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

@@ -168,6 +168,14 @@ class RPCServer extends EventEmitter {
     return this.connectionCount() + this.pendingCount()
   }
 
+  listKeys () {
+    return this.listServices()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   connectionCount () { return this.connections.size }
 
   getStats () {

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

@@ -105,6 +105,14 @@ class HyperP2PSessionBridge extends EventEmitter {
     return this.pairCount()
   }
 
+  listKeys () {
+    return this.listPairs()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async createPairBatch (count = 1) {
     const n = Math.max(1, count | 0)
     const out = []

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

@@ -365,6 +365,14 @@ class HyperP2PVectorClock extends EventEmitter {
     return this.peerCount()
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   clearAll () {
     const n = this.clock.size
     this.clock.clear()

encoding-wire/hyper-p2p-schema-validator/index.js

@@ -130,6 +130,14 @@ class HyperP2PSchemaValidator extends EventEmitter {
     return this.listSchemas().length
   }
 
+  listKeys () {
+    return this.listSchemas()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerSchemaBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.register(e.name, e.schema))

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

@@ -166,6 +166,14 @@ class HyperP2PWireRegistry extends EventEmitter {
     return this._codecs.size + this._protocols.size
   }
 
+  listKeys () {
+    return [...this.listCodecs(), ...this.listProtocols()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   clearAll () {
     const codecs = this.clearAllCodecs()
     const protocols = this.unregisterAllProtocols()

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

@@ -120,6 +120,14 @@ class HyperP2PMemeticSpread extends EventEmitter {
     return this.snapshot().totalMemes
   }
 
+  listKeys () {
+    return this.listMemeIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -115,6 +115,14 @@ class HyperP2PParadoxMerge extends EventEmitter {
     return s.open + s.resolved
   }
 
+  listKeys () {
+    return [...this.listOpen(), ...this._resolved.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   branchBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.branch(e.id, e.value))

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

@@ -124,6 +124,14 @@ class HyperP2PPhaseShiftClock extends EventEmitter {
     return Object.keys(this.snapshot().peers).length
   }
 
+  listKeys () {
+    return Object.keys(this.snapshot().peers)
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   shiftBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.shift(e.phaseMs))

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

@@ -134,6 +134,14 @@ class HyperP2PPheromoneTrail extends EventEmitter {
     return this.trailCount()
   }
 
+  listKeys () {
+    return this.listPathIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   depositBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.deposit(e.pathId, e.strength, e.dest))

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

@@ -128,6 +128,14 @@ class HyperP2PSilenceProtocol extends EventEmitter {
     return this.listAbsent().length
   }
 
+  listKeys () {
+    return this.listAbsent()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

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

@@ -172,6 +172,14 @@ class HyperP2PTimeCapsule extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return this.listIds()
+  }
+
+  keyCount () {
+    return this.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

@@ -100,6 +100,14 @@ class HyperP2PVoidChannel extends EventEmitter {
     return this.snapshot().voids.length
   }
 
+  listKeys () {
+    return this.listChannels()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   unsubscribeAll () {
     const n = this._subs.size
     this._subs.clear()

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

@@ -122,6 +122,10 @@ class HyperP2PBloomGossip extends EventEmitter {
     return this.snapshot().size === 0
   }
 
+  keyCount () {
+    return this.size()
+  }
+
   addBatch (keys) {
     if (!Array.isArray(keys)) throw new Error('keys array required')
     return keys.map((k) => this.add(k))

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

@@ -173,6 +173,14 @@ class HyperP2PFulltextLite extends EventEmitter {
     return this.snapshot().documents
   }
 
+  listKeys () {
+    return this.listDocuments()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   searchBatch (queries, mode = 'and') {
     if (!Array.isArray(queries)) throw new Error('queries array required')
     return queries.map((q) => this.search(q, mode))

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

@@ -171,6 +171,14 @@ class HyperP2PGraphIndex extends EventEmitter {
     return this.snapshot().edges.length
   }
 
+  listKeys () {
+    return this.nodes()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   addEdgeBatch (edges) {
     if (!Array.isArray(edges)) throw new Error('edges array required')
     return edges.map((e) => this.addEdge(e.from, e.to))

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

@@ -150,6 +150,14 @@ class HyperP2PInvertedIndex extends EventEmitter {
     return this.snapshot().documents
   }
 
+  listKeys () {
+    return [...this._docs.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   indexBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.index(e.docId, e.terms))

indexes-search/hyper-p2p-semantic-vector-index/index.js

@@ -666,6 +666,15 @@ class HyperP2PSemanticVectorIndex extends EventEmitter {
     const s = await this.snapshot()
     return s.vectorIds
   }
+
+  async listKeys () {
+    return this.vectorIds()
+  }
+
+  async keyCount () {
+    const s = await this.snapshot()
+    return s.vectorIds
+  }
 }
 
 module.exports = HyperP2PSemanticVectorIndex

indexes-search/hyper-p2p-similarity-lsh/index.js

@@ -192,6 +192,14 @@ class HyperP2PSimilarityLsh extends EventEmitter {
     return s.vectors + s.buckets
   }
 
+  listKeys () {
+    return this.listIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -149,6 +149,14 @@ class HyperP2PTriePrefix extends EventEmitter {
     return this.snapshot().words
   }
 
+  listKeys () {
+    return this.list()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

indexes-search/hyper-spatial-index/index.js

@@ -297,6 +297,15 @@ class SpatialIndex extends EventEmitter {
     return s.points
   }
 
+  async listKeys () {
+    return [...this.localPoints.keys()]
+  }
+
+  async keyCount () {
+    const s = await this.snapshot()
+    return s.points
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -56,6 +56,14 @@ class HyperP2PBucketRateLimit extends EventEmitter {
     return Object.keys(this.snapshot().buckets).length
   }
 
+  listKeys () {
+    return Object.keys(this.snapshot().buckets)
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _bucketSnapshot () {
     const out = {}
     for (const [peerId, b] of this._buckets) {

measurement-rate-control/hyper-p2p-histogram-gossip/index.js

@@ -108,6 +108,14 @@ class HyperP2PHistogramGossip extends EventEmitter {
     return this._metrics.size
   }
 
+  listKeys () {
+    return [...this._metrics.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   toJSON () {
     return this.moduleSnapshot()
   }

measurement-rate-control/hyper-p2p-sla-budget/index.js

@@ -127,6 +127,14 @@ class HyperP2PSlaBudget extends EventEmitter {
     return this.serviceCount()
   }
 
+  listKeys () {
+    return this.services()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   toJSON () {
     return this.moduleSnapshot()
   }

media-streaming/hyper-p2p-bandwidth-aggregator/index.js

@@ -151,6 +151,14 @@ class HyperP2PBandwidthAggregator extends EventEmitter {
     return this.sourceCount()
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   sourceCount () {
     return this._sources.size
   }

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

@@ -129,6 +129,10 @@ class HyperP2PContentProtection extends EventEmitter {
     return this.keyCount()
   }
 
+  listKeys () {
+    return [...this._keys.keys()]
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { activeKeyId: this._activeKeyId, keys: this._keys.size })
   }

media-streaming/hyper-p2p-contribution-ledger/index.js

@@ -118,6 +118,14 @@ class HyperP2PContributionLedger extends EventEmitter {
     return this.snapshot().contributors
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (payload) {
     if (this._peerMsgs) {
       gossipSend(this, payload)

media-streaming/hyper-p2p-enterprise-orchestrator/index.js

@@ -138,6 +138,14 @@ class HyperP2PEnterpriseOrchestrator extends EventEmitter {
     return this.snapshot().count
   }
 
+  listKeys () {
+    return this.listRegions()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { regions: this._regions.size })
   }

media-streaming/hyper-p2p-fec-video/index.js

@@ -127,6 +127,14 @@ class HyperP2PFecVideo extends EventEmitter {
     return this.snapshot().groups
   }
 
+  listKeys () {
+    return this.listGroupIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { groups: this._groups.size })
   }

media-streaming/hyper-p2p-helper-swarm-coordinator/index.js

@@ -137,6 +137,14 @@ class HyperP2PHelperSwarmCoordinator extends EventEmitter {
     return this.snapshot().helpers
   }
 
+  listKeys () {
+    return this.listViewers()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerHelperBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.registerHelper(e.peerId, e.capacityBps))

media-streaming/hyper-p2p-latency-optimizer/index.js

@@ -115,6 +115,14 @@ class HyperP2PLatencyOptimizer extends EventEmitter {
     return this.snapshot().paths
   }
 
+  listKeys () {
+    return this.listPathIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   measureBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries must be an array')
     return entries.map((e) => this.measurePath(e.pathId, e.hops || []))

media-streaming/hyper-p2p-live-edge-manager/index.js

@@ -116,6 +116,14 @@ class HyperP2PLiveEdgeManager extends EventEmitter {
     return this.snapshot().count
   }
 
+  listKeys () {
+    return this.listEdges()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   setLiveEdgeBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.setLiveEdge(e.streamId, e.seq, e.wallAt))

media-streaming/hyper-p2p-media-chunker/index.js

@@ -153,6 +153,14 @@ class HyperP2PMediaChunker extends EventEmitter {
     return this.snapshot().stored
   }
 
+  listKeys () {
+    return [...this._chunks.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { stored: this._chunks.size })
   }

media-streaming/hyper-p2p-media-tree-orchestrator/index.js

@@ -188,6 +188,14 @@ class HyperP2PMediaTreeOrchestrator extends EventEmitter {
     return this.snapshot().nodes
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (payload) {
     if (!this._peerMsgs) return
     gossipSend(this, payload)

media-streaming/hyper-p2p-origin-hybrid-bridge/index.js

@@ -124,6 +124,14 @@ class HyperP2POriginHybridBridge extends EventEmitter {
     return this.snapshot().streams
   }
 
+  listKeys () {
+    return this.listStreamIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerOriginBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.registerOrigin(e.streamId, e.url, e.weight))

media-streaming/hyper-p2p-peer-selector-streaming/index.js

@@ -146,6 +146,14 @@ class HyperP2PPeerSelectorStreaming extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerPeerBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.registerPeer(e.peerId, e.stats || {}))

media-streaming/hyper-p2p-quality-ladder/index.js

@@ -126,6 +126,14 @@ class HyperP2PQualityLadder extends EventEmitter {
     return this.snapshot().ladders
   }
 
+  listKeys () {
+    return this.listStreamIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { ladders: this._ladders.size })
   }

media-streaming/hyper-p2p-stream-access-control/index.js

@@ -132,6 +132,14 @@ class HyperP2PStreamAccessControl extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return [...this._tokens.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   grantCapabilityBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.grantCapability(e.streamId, e.subject, e.ttlMs))

media-streaming/hyper-p2p-stream-manifest/index.js

@@ -129,6 +129,14 @@ class HyperP2PStreamManifest extends EventEmitter {
     return this.snapshot().count
   }
 
+  listKeys () {
+    return this.listStreamIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   buildManifestBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.buildManifest(e.streamId, e.meta || {}))

media-streaming/hyper-p2p-stream-telemetry/index.js

@@ -148,6 +148,14 @@ class HyperP2PStreamTelemetry extends EventEmitter {
     return this.sessionCount()
   }
 
+  listKeys () {
+    return this.listSessionIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return mediaStats(this._stats, PROTOCOL, { sessions: this._sessions.size })
   }

messaging-gossip/hyper-p2p-dedup-filter/index.js

@@ -171,6 +171,14 @@ class HyperP2PDedupFilter extends EventEmitter {
     return this.snapshot().size === 0
   }
 
+  listKeys () {
+    return [...this._seen]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   restoreSnapshot (snap) {
     if (!snap || !Array.isArray(snap.ids)) throw new Error('invalid snapshot')
     this._seen = new Set(snap.ids)

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

@@ -404,6 +404,14 @@ class HyperP2PDistributedEventBus extends EventEmitter {
     return s.topics + s.subscribers + this.seenEvents.size
   }
 
+  listKeys () {
+    return this.listTopics()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   hasSeen (eventId) {
     return this.seenEvents.has(String(eventId))
   }

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

@@ -170,6 +170,14 @@ class HyperP2PGossipMesh extends EventEmitter {
     return this.seenCount()
   }
 
+  listKeys () {
+    return [...this._seen]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   hasSeen (id) {
     return this._seen.has(String(id))
   }

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

@@ -149,6 +149,14 @@ class HyperP2PQosTopic extends EventEmitter {
     return s.channels.length + s.handlers + depth
   }
 
+  listKeys () {
+    return this.listChannels()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _onGossip (data) {
     if (!data || data.type !== 'qos-publish') return
     this._stats.gossipIn++

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

@@ -117,6 +117,14 @@ class HyperP2PRetainedMessages extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return this.listChannels()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   retainBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.retain(e.channel, e.payload, e.opts || {}))

messaging-pubsub/hyper-p2p-subscription-lease/index.js

@@ -165,6 +165,14 @@ class HyperP2PSubscriptionLease extends EventEmitter {
     return this.snapshot().leases
   }
 
+  listKeys () {
+    return this.listChannels()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   acquireBatch (channels) {
     if (!Array.isArray(channels)) throw new Error('channels array required')
     return channels.map((ch) => this.acquire(ch))

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

@@ -138,6 +138,14 @@ class HyperP2PTopicChannel extends EventEmitter {
     return s.channels + s.retained
   }
 
+  listKeys () {
+    return this.listChannels()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _deliverLocal (channel, payload, meta) {
     const handler = this._subs.get(channel)
     if (handler) {

messaging-streams/hyper-p2p-stream-multiplex/index.js

@@ -147,6 +147,14 @@ class HyperP2PStreamMultiplex extends EventEmitter {
     return this.snapshot().open
   }
 
+  listKeys () {
+    return this.listOpenStreamIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   openStreamBatch (ids) {
     if (!Array.isArray(ids)) throw new Error('ids array required')
     return ids.map((id) => this.openStream(id))

messaging-streams/hyper-p2p-stream-resume-token/index.js

@@ -140,6 +140,14 @@ class HyperP2PStreamResumeToken extends EventEmitter {
     return this.snapshot().tokens
   }
 
+  listKeys () {
+    return [...this._tokens.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   writeBatch (chunks) {
     if (!Array.isArray(chunks)) throw new Error('chunks array required')
     return chunks.map((c) => this.write(c))

messaging-streams/hyper-p2p-stream-tee/index.js

@@ -115,6 +115,14 @@ class HyperP2PStreamTee extends EventEmitter {
     return this.snapshot().branches
   }
 
+  listKeys () {
+    return this.listBranches()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   addBranchBatch (names) {
     if (!Array.isArray(names)) throw new Error('names array required')
     return names.map((name) => this.addBranch(name))

network-discovery/hyper-p2p-capability-discovery/index.js

@@ -91,6 +91,14 @@ class HyperP2PCapabilityDiscovery extends EventEmitter {
     return this.snapshot().capabilities
   }
 
+  listKeys () {
+    return this.listCapabilities()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerCapabilityBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.registerCapability(e.name, e.meta || {}))

network-discovery/hyper-p2p-discovery-health/index.js

@@ -107,6 +107,14 @@ class HyperP2PDiscoveryHealth extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return [...this._peers.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   reportPeerBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.reportPeer(e.peerId, e.status || {}))

network-discovery/hyper-p2p-peer-bootstrap-store/index.js

@@ -97,6 +97,14 @@ class HyperP2PPeerBootstrapStore extends EventEmitter {
     return this.snapshot().bootstraps
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

network-discovery/hyper-p2p-seeder-registry/index.js

@@ -110,6 +110,14 @@ class HyperP2PSeederRegistry extends EventEmitter {
     return this.snapshot().topics
   }
 
+  listKeys () {
+    return this.topicIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -99,6 +99,14 @@ class HyperP2PTopicAnnouncer extends EventEmitter {
     return this.snapshot().count
   }
 
+  listKeys () {
+    return this.listTopicIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

network-stack/hyper-p2p-anycast-selector/index.js

@@ -120,6 +120,14 @@ class HyperP2PAnycastSelector extends EventEmitter {
     return s.tags + s.latencyPeers
   }
 
+  listKeys () {
+    return this.listTags()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return { ...this._stats, tags: this._tags.size, latencyPeers: this._latency.size, protocol: PROTOCOL }
   }

network-stack/hyper-p2p-bandwidth-broker/index.js

@@ -108,6 +108,14 @@ class HyperP2PBandwidthBroker extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   grantBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.grant(e.peerId, e.bytes))

network-stack/hyper-p2p-circuit-loom/index.js

@@ -135,6 +135,14 @@ class HyperP2PCircuitLoom extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return this.listCircuitIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   hopCount (circuitId) {
     const c = this._circuits.get(circuitId)
     return c ? c.hops.length : 0

network-stack/hyper-p2p-congestion-signal/index.js

@@ -104,6 +104,14 @@ class HyperP2PCongestionSignal extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.listPeerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   reportSampleBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.reportSample(e.peerId, e.rttMs, e.loss))

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

@@ -109,6 +109,14 @@ class HyperP2PConnectionPool extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return this.listPeerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   acquireBatch (peerIds) {
     if (!Array.isArray(peerIds)) throw new Error('peerIds array required')
     return peerIds.map((peerId) => this.acquire(peerId))

network-stack/hyper-p2p-link-probe/index.js

@@ -112,6 +112,14 @@ class HyperP2PLinkProbe extends EventEmitter {
     return this.snapshot().entries
   }
 
+  listKeys () {
+    return this.listPeerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   probeBatch (peerIds) {
     if (!Array.isArray(peerIds)) throw new Error('peerIds array required')
     return peerIds.map((id) => this.probe(id))

network-stack/hyper-p2p-multipath-fanout/index.js

@@ -121,6 +121,14 @@ class HyperP2PMultipathFanout extends EventEmitter {
     return this.pendingCount()
   }
 
+  listKeys () {
+    return this.listPendingIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   fanoutBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.fanout(e.payload, e.pathCount))

network-stack/hyper-p2p-overlay-topology/index.js

@@ -108,6 +108,14 @@ class HyperP2POverlayTopology extends EventEmitter {
     return this.snapshot().degree
   }
 
+  listKeys () {
+    return this.neighborIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return { ...this._stats, degree: this._neighbors.size, protocol: PROTOCOL }
   }

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

@@ -113,6 +113,14 @@ class HyperP2PProtocolHandshake extends EventEmitter {
     return s.pending + s.agreed
   }
 
+  listKeys () {
+    return [...this._offers.keys(), ...this._agreed.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   offerBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.offer(e.features || {}))

network-transport/hyper-p2p-blind-relay-bridge/index.js

@@ -136,6 +136,14 @@ class HyperP2PBlindRelayBridge extends EventEmitter {
     return this.snapshot().relays
   }
 
+  listKeys () {
+    return [...this._relays.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerRelayBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.registerRelay(e.peerId, e.endpoint))

network-transport/hyper-p2p-dht-bootstrap-hint/index.js

@@ -131,6 +131,14 @@ class HyperP2PDhtBootstrapHint extends EventEmitter {
     return this.snapshot().hints
   }
 
+  listKeys () {
+    return [...this._hints.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   addHintBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.addHint(e.nodeId, e.address))

network-transport/hyper-p2p-noise-session-wrap/index.js

@@ -125,6 +125,14 @@ class HyperP2PNoiseSessionWrap extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return [...this._sessions.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   createSessionBatch (optsList) {
     if (!Array.isArray(optsList)) throw new Error('optsList array required')
     return optsList.map((opts) => this.createSession(opts))

network-transport/hyper-p2p-wakeup-channel/index.js

@@ -144,6 +144,14 @@ class HyperP2PWakeupChannel extends EventEmitter {
     return this.snapshot().pending
   }
 
+  listKeys () {
+    return this.pendingPeerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

observability/hyper-p2p-health-probe/index.js

@@ -112,6 +112,14 @@ class HyperP2PHealthProbe extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

observability/hyper-p2p-stats-exporter/index.js

@@ -77,6 +77,14 @@ class HyperP2PStatsExporter extends EventEmitter {
     return this._sources.size + this._history.length
   }
 
+  listKeys () {
+    return this.listSources()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   exportSnapshot (filter = null) {
     return this.moduleSnapshot(filter)
   }

observability/hyper-p2p-trace-span/index.js

@@ -126,6 +126,14 @@ class HyperP2PTraceSpan extends EventEmitter {
     return this.snapshot().total
   }
 
+  listKeys () {
+    return this.listSpanIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   startSpanBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.startSpan(e.name, e.parentId ?? null))

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

@@ -510,6 +510,14 @@ class HyperP2PDecentralizedOracle extends EventEmitter {
     return s.feeds.length + s.pendingReports
   }
 
+  listKeys () {
+    return this.listFeeds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -176,6 +176,14 @@ class HyperP2PCircuitBreaker extends EventEmitter {
     return this.snapshot().registered
   }
 
+  listKeys () {
+    return this.listCircuitIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return {
       ...this._stats,

routing-advanced/hyper-p2p-geo-hint-router/index.js

@@ -117,6 +117,14 @@ class HyperP2PGeoHintRouter extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getStats () {
     return { ...this._stats, registered: this._peers.size, protocol: PROTOCOL }
   }

routing-advanced/hyper-p2p-load-spread/index.js

@@ -115,6 +115,14 @@ class HyperP2PLoadSpread extends EventEmitter {
     return this.snapshot().peers
   }
 
+  listKeys () {
+    return this.peerIds()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   registerPeerBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     for (const e of entries) this.registerPeer(e.peerId, e.load)

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

@@ -115,6 +115,14 @@ class HyperP2PRetryPolicy extends EventEmitter {
     return this.snapshot().routes
   }
 
+  listKeys () {
+    return this.listRoutes()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   resetStats () {
     this._stats = { routes: this._routes.size, retries: 0, denied: 0 }
     return this._stats

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

@@ -97,6 +97,14 @@ class HyperP2PStickySession extends EventEmitter {
     return this.snapshot().count
   }
 
+  listKeys () {
+    return this.listSessions()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   _onGossip (d) {
     if (!d || d.type !== 'sticky-session-sync' || !d.sessionId) return
     this._stats.gossipIn++

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

@@ -472,6 +472,14 @@ class HyperP2PIntentRouter extends EventEmitter {
     return s.local + s.peerIntents
   }
 
+  listKeys () {
+    return [...this.localIntents.keys(), ...this.peerIntents.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   getPeerIntents (peerHex = null) {
     if (peerHex) {
       const p = this.peerIntents.get(peerHex)

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

@@ -178,6 +178,10 @@ class HyperP2PMergeRegistry extends EventEmitter {
     return this.snapshot().count
   }
 
+  keyCount () {
+    return 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 || {}))

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

@@ -133,6 +133,14 @@ class HyperP2PPatternRouter extends EventEmitter {
     return this.snapshot().routes
   }
 
+  listKeys () {
+    return this.listPatterns()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

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

@@ -135,6 +135,14 @@ class HyperP2PRelayTunnel extends EventEmitter {
     return this.snapshot().tunnels
   }
 
+  listKeys () {
+    return this.listRoutes()
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   relayBatch (frames) {
     if (!Array.isArray(frames)) throw new Error('frames array required')
     return frames.map((f) => this.relay(f.tunnelId, f.payload))

scheduling-queues/hyper-p2p-activity-queue/index.js

@@ -238,6 +238,17 @@ class HyperP2PActivityQueue extends EventEmitter {
     return s.pending + s.claimed + s.deadLetter
   }
 
+  listKeys () {
+    const ids = this._queue.map((e) => e.id)
+    for (const id of this._claimed.keys()) ids.push(id)
+    for (const e of this._deadLetter) ids.push(e.id)
+    return ids
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   clearAll () {
     const pending = this._queue.length
     const claimed = this._claimed.size

scheduling-queues/hyper-p2p-cron-gossip/index.js

@@ -132,6 +132,14 @@ class HyperP2PCronGossip extends EventEmitter {
     return this.snapshot().jobs
   }
 
+  listKeys () {
+    return [...this._jobs.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   scheduleBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     return entries.map((e) => this.schedule(e.expr, e.jobId))

scheduling-queues/hyper-p2p-deadline-queue/index.js

@@ -123,6 +123,14 @@ class HyperP2PDeadlineQueue extends EventEmitter {
     return this.snapshot().pending
   }
 
+  listKeys () {
+    return [...this._byId.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   enqueueBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries array required')
     for (const e of entries) this.enqueue(e.id, e.task, e.deadline)

scheduling-queues/hyper-p2p-peer-scheduler/index.js

@@ -102,6 +102,14 @@ class HyperP2PPeerScheduler extends EventEmitter {
     return this.snapshot().jobs
   }
 
+  listKeys () {
+    return [...this._jobs.keys()]
+  }
+
+  keyCount () {
+    return this.size()
+  }
+
   scheduleBatch (entries) {
     if (!Array.isArray(entries)) throw new Error('entries must be an array')
     return entries.map((e) => this.schedule(e.expr, e.id, { shard: e.shard }))