Add batch helpers and domain utilities across modules missing Batch APIs.

Third enrichment pass: *Batch methods for agents, economy, consensus, core, messaging, network, observability, pear-platform, scheduling, storage, supercomputer, and time-ordering modules.

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

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

@@ -450,6 +450,20 @@ class HyperP2PAgentMemory extends EventEmitter {
     return { memories: this.memories.size, tags: this.tagIndex.size }
   }
 
+  async storeMemoryBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    const out = []
+    for (const e of entries) {
+      out.push(await this.storeMemory(e.content, e.options || {}))
+    }
+    return out
+  }
+
+  async forgetBatch (ids) {
+    if (!Array.isArray(ids)) throw new Error('ids array required')
+    return ids.map((id) => this.forget(id))
+  }
+
   getStats () {
     return {
       ...this._metrics,

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

@@ -137,6 +137,16 @@ class HyperP2PAuctionGossip extends EventEmitter {
     return { auctions: this._auctions.size, open: this.listOpen().length }
   }
 
+  openAuctionBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.openAuction(e.auctionId, e.meta || {}))
+  }
+
+  placeBidBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.placeBid(e.auctionId, e.amount, e.meta || {}))
+  }
+
   _gossip (payload) {
     if (!this._peerMsgs) return
     gossipSend(this, payload)

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

@@ -117,6 +117,11 @@ class HyperP2PMarketplaceListing extends EventEmitter {
     return { listings: this._listings.size, active: this.listActive().length }
   }
 
+  createListingBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.createListing(e.listingId, e.listing))
+  }
+
   removeAllActive () {
     const ids = this.listActive().map((l) => l.id)
     for (const id of ids) this.removeListing(id)

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

@@ -433,6 +433,15 @@ class HyperP2PCausalConsensus extends EventEmitter {
     }
   }
 
+  async proposeBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    const out = []
+    for (const e of entries) {
+      out.push(await this.propose(e.data, e.causalDeps || {}))
+    }
+    return out
+  }
+
   getMetrics () {
     return { ...this._metrics, peers: this.peers.size, pendingProposals: this.proposals.size - this.decidedOrders.size }
   }

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

@@ -374,6 +374,15 @@ class HyperP2PDistributedLock extends EventEmitter {
     }
   }
 
+  async acquireBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    const out = []
+    for (const e of entries) {
+      out.push(await this.acquire(e.resourceId, e.opts || {}))
+    }
+    return out
+  }
+
   /**
    * List all currently active locks (local + remote).
    * Supports optional filter by owner or resource prefix.

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

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

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

@@ -32,6 +32,12 @@ class RPCServer extends EventEmitter {
     this.services.set(name, { handler, schema })
   }
 
+  registerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.register(e.name, e.handler, e.schema || null)
+    return entries.length
+  }
+
   unregister (name) {
     return this.services.delete(name)
   }

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

@@ -85,6 +85,13 @@ class HyperP2PSessionBridge extends EventEmitter {
     return { pairs: this.listPairs().length }
   }
 
+  async createPairBatch (count = 1) {
+    const n = Math.max(1, count | 0)
+    const out = []
+    for (let i = 0; i < n; i++) out.push(await this.createPair())
+    return out
+  }
+
   async removePair (token) {
     const entry = this._tokens.get(token)
     if (!entry) return false

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

@@ -93,6 +93,11 @@ class HyperP2PParadoxMerge extends EventEmitter {
     return { open: this.listOpen().length, resolved: this._resolved.size }
   }
 
+  branchBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.branch(e.id, e.value))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -104,6 +104,11 @@ class HyperP2PPhaseShiftClock extends EventEmitter {
     return { phaseMs: this._phaseMs, peers: this.peerPhases() }
   }
 
+  shiftBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.shift(e.phaseMs))
+  }
+
   _gossip (data) {
     if (!this._peerMsgs) return
     gossipSend(this, data)

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

@@ -117,6 +117,11 @@ class HyperP2PHelperSwarmCoordinator extends EventEmitter {
     return { helpers: this._helpers.size, assignments: this.assignmentCount() }
   }
 
+  registerHelperBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerHelper(e.peerId, e.capacityBps))
+  }
+
   _gossip (payload) {
     if (this._peerMsgs) gossipSend(this, payload)
   }

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

@@ -145,6 +145,11 @@ class HyperP2PSubscriptionLease extends EventEmitter {
     return { leases: this._leases.size, channels: this.listChannels() }
   }
 
+  acquireBatch (channels) {
+    if (!Array.isArray(channels)) throw new Error('channels array required')
+    return channels.map((ch) => this.acquire(ch))
+  }
+
   getStats () {
     return { ...this._stats, active: this._leases.size, protocol: PROTOCOL }
   }

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

@@ -127,6 +127,11 @@ class HyperP2PStreamMultiplex extends EventEmitter {
     return { open: this._streams.size, frames: this._stats.frames, bytes: this._stats.bytes }
   }
 
+  openStreamBatch (ids) {
+    if (!Array.isArray(ids)) throw new Error('ids array required')
+    return ids.map((id) => this.openStream(id))
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -95,6 +95,11 @@ class HyperP2PStreamTee extends EventEmitter {
     return { branches: this._branches.size }
   }
 
+  addBranchBatch (names) {
+    if (!Array.isArray(names)) throw new Error('names array required')
+    return names.map((name) => this.addBranch(name))
+  }
+
   getStats () {
     return { ...this._stats, branchCount: this._branches.size, protocol: PROTOCOL }
   }

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

@@ -89,6 +89,11 @@ class HyperP2PConnectionPool extends EventEmitter {
     return this.getPoolStats()
   }
 
+  acquireBatch (peerIds) {
+    if (!Array.isArray(peerIds)) throw new Error('peerIds array required')
+    return peerIds.map((peerId) => this.acquire(peerId))
+  }
+
   _sweepIdle () {
     const now = Date.now()
     for (const [id, lane] of this._lanes) {

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

@@ -91,6 +91,11 @@ class HyperP2PProtocolHandshake extends EventEmitter {
     return { pending: this._offers.size, agreed: this._agreed.size }
   }
 
+  offerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.offer(e.features || {}))
+  }
+
   getStats () {
     return { ...this._stats, pending: this._offers.size, agreed: this._agreed.size, protocol: PROTOCOL }
   }

network-transport/hyper-p2p-secret-stream-pair/index.js

@@ -92,6 +92,13 @@ class HyperP2PSecretStreamPair {
     return { active: this.hasActivePair(), publicKey: this.publicKeyHex() }
   }
 
+  createBatch (count = 1) {
+    const n = Math.max(1, count | 0)
+    const out = []
+    for (let i = 0; i < n; i++) out.push(this.create())
+    return out
+  }
+
   publicKeyHex () {
     return require('b4a').toString(this.keyPair.publicKey, 'hex')
   }

observability/hyper-p2p-metrics-aggregator/index.js

@@ -68,6 +68,12 @@ class HyperP2PMetricsAggregator extends EventEmitter {
     return { series: this._metrics.size, names: this.metricNames() }
   }
 
+  recordBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.record(e.name, e.value, e.labels || {})
+    return entries.length
+  }
+
   metricNames () {
     const names = new Set()
     for (const s of this._metrics.values()) names.add(s.name)

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

@@ -106,6 +106,11 @@ class HyperP2PTraceSpan extends EventEmitter {
     return { active: this.activeSpans().length, total: this.spanCount() }
   }
 
+  startSpanBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.startSpan(e.name, e.parentId ?? null))
+  }
+
   activeCount () {
     return this.activeSpans().length
   }

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

@@ -110,6 +110,12 @@ class HyperBareArgvBridge extends EventEmitter {
     return { flags: this._flags.size, rest: this._rest.length, targets: this.launchTargets().length }
   }
 
+  appendArgvBatch (chunks) {
+    if (!Array.isArray(chunks)) throw new Error('chunks array required')
+    for (const extra of chunks) this.appendArgv(extra)
+    return chunks.length
+  }
+
   getStats () {
     return platformStats(this._stats, PROTOCOL, {
       flags: this._flags.size,

pear-platform/hyper-bare-headless-ui/index.js

@@ -112,6 +112,11 @@ class HyperBareHeadlessUi extends EventEmitter {
     }
   }
 
+  sendToUiBatch (messages) {
+    if (!Array.isArray(messages)) throw new Error('messages array required')
+    return messages.map((m) => this.sendToUi(m.channel, m.payload))
+  }
+
   getStats () {
     return platformStats(this._stats, PROTOCOL, this.snapshot())
   }

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

@@ -106,6 +106,12 @@ class HyperBareImportMap extends EventEmitter {
     return { entries: Object.keys(this._imports).length }
   }
 
+  setBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.set(e.specifier, e.target)
+    return entries.length
+  }
+
   getStats () {
     return platformStats(this._stats, PROTOCOL, { entries: Object.keys(this._imports).length })
   }

pear-platform/hyper-bare-target-matrix/index.js

@@ -106,6 +106,11 @@ class HyperBareTargetMatrix extends EventEmitter {
     return { host: this.host, targets: this.targetCount() }
   }
 
+  addTargetBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.addTarget(e.os, e.arch, e.extra || {}))
+  }
+
   targetCount () {
     return this._targets.length
   }

pear-platform/hyper-pear-applink-config/index.js

@@ -74,6 +74,12 @@ class HyperPearApplinkConfig extends EventEmitter {
     return this._config ? JSON.parse(JSON.stringify(this._config)) : null
   }
 
+  setFlagBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.setFlag(e.name, e.value)
+    return entries.length
+  }
+
   applinkHref () {
     return this._config ? this._config.applink : null
   }

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

@@ -90,6 +90,12 @@ class HyperPearDevProfile extends EventEmitter {
     }
   }
 
+  setFlagBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.setFlag(e.name, e.value)
+    return entries.length
+  }
+
   isProduction () {
     return !this.dev
   }

pear-platform/hyper-pear-electron-bridge/index.js

@@ -44,6 +44,12 @@ class HyperPearElectronBridge extends EventEmitter {
     return { handlers: this.handlerCount(), renderer: this.renderer }
   }
 
+  registerIpcBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.registerIpc(e.name, e.handler)
+    return entries.length
+  }
+
   handlerCount () {
     return this._channels.size
   }

pear-platform/hyper-pear-ota-state/index.js

@@ -47,6 +47,12 @@ class HyperPearOtaState extends EventEmitter {
 
   snapshot () { return { ...this._state } }
 
+  transitionBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.transition(e.phase, e.patch || {})
+    return entries.length
+  }
+
   history (limit = 32) {
     return this._log.slice(-limit)
   }

pear-platform/hyper-pear-preflight-sync/index.js

@@ -147,6 +147,11 @@ class HyperPearPreflightSync extends EventEmitter {
     return { jobs: this._jobs.size, pending: this.listPending().length }
   }
 
+  startBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.start(e.target, e.meta || {}))
+  }
+
   getStats () {
     return platformStats(this._stats, PROTOCOL, {
       jobs: this._jobs.size,

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

@@ -87,6 +87,11 @@ class HyperPearRuntimeEmbed extends EventEmitter {
     }
   }
 
+  planRunBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.planRun(e.entrypoint, e.args || [], e.opts || {}))
+  }
+
   async close () {
     if (!this._opened) return
     this._opened = false

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

@@ -98,6 +98,11 @@ class HyperPearRuntimeSession extends EventEmitter {
     return { total: this._sessions.size, active: this.activeSessions().length }
   }
 
+  startSessionBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.startSession(e.meta || {}))
+  }
+
   getStats () {
     return {
       ...this._stats,

pear-platform/hyper-pear-storage-layout/index.js

@@ -78,6 +78,11 @@ class HyperPearStorageLayout extends EventEmitter {
     return Object.fromEntries(this._apps)
   }
 
+  registerAppBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerApp(e.appKey, e.layout || {}))
+  }
+
   setDefaultApp (appKey) {
     this.defaultApp = assertId(appKey, 'appKey')
     return this.defaultApp

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

@@ -95,6 +95,12 @@ class HyperP2PLoadSpread extends EventEmitter {
     return { peers: this._peers.size, totalLoad: this.totalLoad() }
   }
 
+  registerPeerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.registerPeer(e.peerId, e.load)
+    return entries.length
+  }
+
   getStats () {
     return {
       ...this._stats,

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

@@ -112,6 +112,11 @@ class HyperP2PCronGossip extends EventEmitter {
     return { jobs: this._jobs.size, paused: this.pausedCount() }
   }
 
+  scheduleBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.schedule(e.expr, e.jobId))
+  }
+
   pausedCount () {
     return [...this._jobs.values()].filter((j) => j.paused).length
   }

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

@@ -103,6 +103,12 @@ class HyperP2PDeadlineQueue extends EventEmitter {
     return { pending: this._queue.length }
   }
 
+  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)
+    return entries.length
+  }
+
   cancelAll () {
     const ids = [...this._byId.keys()]
     for (const id of ids) this.cancel(id)

scheduling-queues/hyper-p2p-topic-lease/index.js

@@ -91,6 +91,11 @@ class HyperP2PTopicLease extends EventEmitter {
     return { leases: this.leaseCount(), shards: [...this._leases.keys()] }
   }
 
+  acquireBatch (topicShards) {
+    if (!Array.isArray(topicShards)) throw new Error('topicShards array required')
+    return topicShards.map((topicShard) => this.acquire(topicShard))
+  }
+
   leaseCount () {
     const now = Date.now()
     return [...this._leases.values()].filter((l) => l.expiresAt > now).length

state-crdts/hyper-p2p-crdt-lww-register/index.js

@@ -86,6 +86,18 @@ class HyperP2PCrdtLwwRegister extends EventEmitter {
     return out
   }
 
+  setBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    for (const e of entries) this.set(e.key, e.value, e.ts)
+    return entries.length
+  }
+
+  deleteBatch (keys) {
+    if (!Array.isArray(keys)) throw new Error('keys array required')
+    for (const key of keys) this.delete(key)
+    return keys.length
+  }
+
   compare (key, ts) {
     const e = this._values.get(key)
     if (!e) return ts

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

@@ -81,6 +81,11 @@ class HyperP2PAutobaseWriterLease extends EventEmitter {
     return { leases: this.listActiveLeases(), localWriterId: this.localWriterId }
   }
 
+  acquireLeaseBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.acquireLease(e.writerId, e.ttlMs))
+  }
+
   listActiveLeases () {
     const now = Date.now()
     const out = []

storage-hypercore/hyper-p2p-core-bitfield-scheduler/index.js

@@ -115,6 +115,10 @@ class HyperP2PCoreBitfieldScheduler extends EventEmitter {
     return { pending: this._queue.length, served: this._served.size }
   }
 
+  scheduleRangeBatch (ranges) {
+    return this.scheduleMany(ranges)
+  }
+
   getStats () {
     return coreStats(this._stats, PROTOCOL, {
       pending: this._queue.length,

storage-hypercore/hyper-p2p-core-fork-picker/index.js

@@ -106,6 +106,11 @@ class HyperP2PCoreForkPicker extends EventEmitter {
     return { forks: this._forks.size, chosen: this._chosen }
   }
 
+  registerForkBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.registerFork(e.head, e.length, e.meta || {}))
+  }
+
   getStats () {
     return coreStats(this._stats, PROTOCOL, {
       forkCount: this._forks.size,

storage-hypercore/hyper-p2p-core-priority-fetch/index.js

@@ -118,6 +118,10 @@ class HyperP2PCorePriorityFetch extends EventEmitter {
     return { pending: this._heap.length, inflight: this._inflight.size }
   }
 
+  enqueueBlockBatch (indices, priority = 0) {
+    return this.enqueueMany(indices, priority)
+  }
+
   getStats () {
     return coreStats(this._stats, PROTOCOL, {
       pending: this._heap.length,

storage-hyperdrive/hyper-p2p-drive-version-snapshot/index.js

@@ -111,6 +111,11 @@ class HyperP2PDriveVersionSnapshot extends EventEmitter {
     return this.stateSnapshot()
   }
 
+  snapshotVersionBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.snapshotVersion(e.label, e.meta || {}))
+  }
+
   getStats () {
     return driveStats(this._stats, PROTOCOL, { snapshots: this._snapshots.size })
   }

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

@@ -107,6 +107,11 @@ class HyperP2PClusterAffinity extends EventEmitter {
     return { tags: this._tags.size, peers: this.listTagged().length }
   }
 
+  tagPeerBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    return entries.map((e) => this.tagPeer(e.peerId, e.tags || [], e.latencyMs ?? null))
+  }
+
   async ready () {
     if (this.swarm || !this.topic) return this
     await initModuleSwarm(this, {

time-ordering/hyper-p2p-temporal-index/index.js

@@ -409,6 +409,15 @@ class HyperP2PTemporalIndex extends EventEmitter {
     return { events: this.events.size, buckets: this.timeIndex.size }
   }
 
+  async insertEventBatch (entries) {
+    if (!Array.isArray(entries)) throw new Error('entries array required')
+    const out = []
+    for (const e of entries) {
+      out.push(await this.insertEvent(e.data, e.options || {}))
+    }
+    return out
+  }
+
   getStats () {
     return {
       events: this.events.size,