@optimystic/db-p2p 1.0.0-beta.2 → 1.0.0

package/src/cluster/spread-on-churn.ts

@@ -1,15 +1,14 @@
 import type { Startable, Libp2p } from '@libp2p/interface'
 import type { IPeerNetwork } from '@optimystic/db-core'
+import { routingKeyForBlock } from '@optimystic/db-core'
 import { hashKey } from 'p2p-fret'
 import type { FretService } from 'p2p-fret'
-import { peerIdFromString } from '@libp2p/peer-id'
 import type { PartitionDetector } from './partition-detector.js'
 import type { ProofRetainingRepo } from '../storage/block-archive.js'
-import { BlockTransferClient, sourceBlockCertification } from './block-transfer-service.js'
+import { pushBlockToPeers } from './block-transfer-service.js'
 import { createLogger } from '../logger.js'
 
 const log = createLogger('spread-on-churn')
-const textEncoder = new TextEncoder()
 
 // ── Types ────────────────────────────────────────────────────────────
 
@@ -208,7 +207,7 @@ export class SpreadOnChurnMonitor implements Startable {
 		const spreadResults: SpreadEvent['spread'] = []
 
 		for (const blockId of this.trackedBlocks) {
-			const key = textEncoder.encode(blockId)
+			const key = routingKeyForBlock(blockId)
 			const coord = await hashKey(key)
 
 			// Check eligibility: only middle peers spread
@@ -224,18 +223,33 @@ export class SpreadOnChurnMonitor implements Startable {
 			const targets = expanded.filter(id => !cohortSet.has(id) && id !== selfId)
 			if (targets.length === 0) continue
 
-			// Read block data from local storage
-			const result = await this.deps.repo.get({ blockIds: [blockId] })
-			const blockResult = result[blockId]
-			if (blockResult?.unavailable !== undefined) {
+			// The shared read-certify-push loop, to every target. Both per-target deadlines are set:
+			// a target that connects but never replies would otherwise hang this sequential loop
+			// forever during churn (exactly when slow/dying peers are common). A receiver running
+			// the default `requirePushCertificate` rejects an uncertified push, so a block this node
+			// holds no proof for simply fails to spread (logged by the receiver as
+			// `push:reject-uncertified`) rather than being planted.
+			//
+			// NOTE: no memory of earlier spreads — every debounced departure re-pushes every eligible block
+			// to every expansion target, including targets a previous pass already confirmed. Targets are
+			// only peers OUTSIDE the cohort, so a deployment no larger than its cohort (a two-member pair)
+			// spreads nothing. If churn on a larger network shows the same (block, target) pushed pass
+			// after pass, remember confirmed targets per block the way RebalanceMonitor's `cohortPeers` does.
+			const outcome = await pushBlockToPeers(this.deps.repo, this.deps.peerNetwork, blockId, targets, {
+				reason: 'replication',
+				protocolPrefix: this.deps.protocolPrefix,
+				dialTimeoutMs: this.config.pushDialTimeoutMs,
+				responseTimeoutMs: this.config.pushResponseTimeoutMs,
+			})
+			if (outcome.status === 'unavailable') {
 				// The repo could not work out whether it still holds this block (unmaterializable
 				// history / failed restore). Untracking on that answer would silently drop the block
 				// from the spread set on a guess, and only a later re-commit would put it back — so
 				// keep it tracked and let the next sweep (or a heal) settle it.
-				log('unavailable block=%s reason=%s (keeping tracked)', blockId, blockResult.unavailable)
+				log('unavailable block=%s reason=%s (keeping tracked)', blockId, outcome.reason)
 				continue
 			}
-			if (!blockResult?.block) {
+			if (outcome.status === 'no-local-data') {
 				// The block has left local storage. No deletion event exists today to evict it
 				// from the tracked set, so prune here. Deleting the current element of a Set mid
 				// for...of is safe - it does not disturb the rest of the iteration. A later
@@ -245,50 +259,16 @@ export class SpreadOnChurnMonitor implements Startable {
 				continue
 			}
 
-			const blockData = textEncoder.encode(JSON.stringify(blockResult.block))
-
-			// Carry the source's revision metadata so the replica's `latest` matches the
-			// source instead of being fabricated as rev 1 on the receiver, plus the cohort commit
-			// proof for that same revision — a receiver running the default `requirePushCertificate`
-			// rejects an uncertified push, so a block this node holds no proof for simply fails to
-			// spread (logged by the receiver as `push:reject-uncertified`) rather than being planted.
-			const certification = await sourceBlockCertification(this.deps.repo, blockId, blockResult)
-
-			// Push to each target
-			const succeeded: string[] = []
-			const failed: string[] = []
-
-			for (const targetId of targets) {
-				try {
-					const peerId = peerIdFromString(targetId)
-					const client = new BlockTransferClient(
-						peerId,
-						this.deps.peerNetwork,
-						this.deps.protocolPrefix
-					)
-					// Bound both the dial and the response read. A target that connects but
-					// never replies would otherwise hang this sequential loop forever during
-					// churn (exactly when slow/dying peers are common); the deadline makes the
-					// push throw, which the catch below records as `failed` so the pass advances.
-					const response = await client.pushBlocks([blockId], [blockData], 'replication', certification, {
-						dialTimeoutMs: this.config.pushDialTimeoutMs,
-						responseTimeoutMs: this.config.pushResponseTimeoutMs,
-					})
-					// A round-trip that does not throw still does not mean the replica
-					// landed: handlePush reports a block in `missing` when it could not
-					// parse or persist it. Treat that as a failed push so the resilience
-					// mechanism does not falsely count the new owner as holding the block.
-					if (response.missing.includes(blockId)) {
-						failed.push(targetId)
-						log('push:rejected block=%s target=%s (receiver did not persist)', blockId, targetId)
-					} else {
-						succeeded.push(targetId)
-						log('push:ok block=%s target=%s', blockId, targetId)
-					}
-				} catch (err) {
-					failed.push(targetId)
-					log('push:fail block=%s target=%s err=%s',
-						blockId, targetId, (err as Error).message)
+			const succeeded = outcome.confirmed
+			const failed = outcome.refusals.map(refusal => refusal.peerId)
+			for (const targetId of succeeded) {
+				log('push:ok block=%s target=%s', blockId, targetId)
+			}
+			for (const refusal of outcome.refusals) {
+				if (refusal.reason === 'rejected') {
+					log('push:rejected block=%s target=%s (receiver did not persist)', blockId, refusal.peerId)
+				} else {
+					log('push:fail block=%s target=%s err=%s', blockId, refusal.peerId, refusal.error)
 				}
 			}
 

package/src/cohort-topic/host.ts

@@ -167,7 +167,7 @@ import { createPoWVerifier, createReputationVerifier, type BootstrapReputationVi
 import { createParentReferenceVerifier, createDefaultParentTopicView, type BootstrapParentTopicView } from "./bootstrap-parent-reference.js";
 import { createBootstrapEvidenceBuilder } from "./bootstrap-evidence-builder.js";
 import { DEFAULT_COHORT_TOPIC_PROTOCOLS, cohortTopicProtocolList, type CohortTopicProtocols } from "./protocols.js";
-import { requestResponse, DEFAULT_STREAM_MAX_BYTES } from "./stream-util.js";
+import { requestResponse, requireReply, DEFAULT_STREAM_MAX_BYTES } from "./stream-util.js";
 import { createLogger } from "../logger.js";
 
 const log = createLogger("cohort-topic");
@@ -697,10 +697,11 @@ export async function createCohortTopicHost(node: Libp2p, fret: FretService, opt
 	// The real k − x assembly lives in each CoordEngine's own threshold signer (constructed per coord).
 	const verifyingSigner = createCohortSigner(createVerifyOnlyThresholdCrypto(), minSigs);
 
-	// Collect one cohort member's `/sign` endorsement over the new fifth protocol.
+	// Collect one cohort member's `/sign` endorsement over the new fifth protocol. The `/sign` responder always
+	// writes a frame, so a no-result reply is a non-conforming peer: reject, and `collectFrom` counts no signature.
 	const dialSign = async (peerIdStr: string, request: SignRequestV1): Promise<SignReplyV1> => {
 		const reply = await requestResponse(node, peerIdFromString(peerIdStr), protocols.sign, encodeCohortMessage(request, maxBytes), maxBytes);
-		return validateSignReplyV1(decodeCohortMessage(reply, maxBytes));
+		return validateSignReplyV1(decodeCohortMessage(requireReply(reply, "cohort sign"), maxBytes));
 	};
 
 	/** FRET assembly around `coord`: self prepended + deduped; epoch = H(sorted member join). */
@@ -3175,9 +3176,10 @@ async function registerCohortTopicProtocols(
  *
  * `handle` cannot return `undefined`, and that is the point. The dialer's `readFramed` treats bare
  * end-of-stream as a truncation error rather than an empty reply, so a reply-reading protocol
- * (register, membership, sign) must always put a frame on the wire — an empty one for "no result".
- * Making that a separate constructor from {@link makeOneWayHandler} puts the invariant in the type,
- * where a later edit cannot silently opt out of it. (`stream-util.ts#handleRequestResponse` takes
+ * (register, membership, sign) must always put a frame on the wire — an empty one for "no result",
+ * which the dialer's `requestResponse` resolves as `undefined`. Making that a separate constructor
+ * from {@link makeOneWayHandler} puts the invariant in the type, where a later edit cannot silently
+ * opt out of it. (`stream-util.ts#handleRequestResponse` takes
  * the other route for the same reason: every consumer of it is a reply-reading protocol, so it maps
  * a handler's `undefined` onto an explicit zero-length frame itself.)
  */

package/src/cohort-topic/membership-source.ts

@@ -50,7 +50,7 @@ export class FretMembershipSource implements IMembershipSource {
 		for (const peerStr of this.resolver.cohortPeers(coord, this.wants)) {
 			try {
 				const reply = await requestResponse(this.node, peerIdFromString(peerStr), this.membershipProtocol, request, this.maxBytes);
-				if (reply.length > 0) {
+				if (reply !== undefined) {
 					this.cache(coord, reply);
 					return reply;
 				}

package/src/cohort-topic/peer-codec.ts

@@ -1,31 +1,34 @@
-/**
- * Cohort-topic peer-id ↔ bytes bridge.
- *
- * db-core's substrate logic references peers as opaque `Uint8Array` ids ({@link PeerRef}`.id`); FRET +
- * libp2p reference them as `PeerId` / peer-id strings. The cohort-member ids the substrate carries on
- * the wire (a reply's `primary` / `backups` / `cohortMembers`) must round-trip back to a *dialable*
- * libp2p peer, so this module pins one unambiguous encoding for them: the UTF-8 bytes of the canonical
- * peer-id string. (The participant's own addressing coordinate `P` is a separate ring-coord value — see
- * the host — so this encoding never needs to feed the ring hash.)
- */
-
-import { peerIdFromString } from "@libp2p/peer-id";
-import type { PeerId } from "@libp2p/interface";
-
-const utf8Encoder = new TextEncoder();
-const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
-
-/** A cohort-member id as the substrate's opaque bytes: UTF-8 of the canonical peer-id string. */
-export function peerIdToBytes(peerId: PeerId | string): Uint8Array {
-	return utf8Encoder.encode(typeof peerId === "string" ? peerId : peerId.toString());
-}
-
-/** Reverse of {@link peerIdToBytes}: decode member bytes back to the canonical peer-id string. */
-export function bytesToPeerIdString(bytes: Uint8Array): string {
-	return utf8Decoder.decode(bytes);
-}
-
-/** Reverse of {@link peerIdToBytes}: decode member bytes back to a dialable {@link PeerId}. */
-export function bytesToPeerId(bytes: Uint8Array): PeerId {
-	return peerIdFromString(bytesToPeerIdString(bytes));
-}
+/**
+ * Cohort-topic peer-id ↔ bytes bridge.
+ *
+ * db-core's substrate logic references peers as opaque `Uint8Array` ids ({@link PeerRef}`.id`); FRET +
+ * libp2p reference them as `PeerId` / peer-id strings. The cohort-member ids the substrate carries on
+ * the wire (a reply's `primary` / `backups` / `cohortMembers`) must round-trip back to a *dialable*
+ * libp2p peer, so this module pins one unambiguous encoding for them: the UTF-8 bytes of the canonical
+ * peer-id string. (The participant's own addressing coordinate `P` is a separate ring-coord value — see
+ * the host — so this encoding never needs to feed the ring hash.)
+ */
+
+import { peerIdFromString } from "@libp2p/peer-id";
+import type { PeerId } from "@libp2p/interface";
+
+const utf8Encoder = new TextEncoder();
+// Built on first use, not at module load: Hermes (React Native) has no native `TextDecoder`, so a
+// module-scope construction fails the import itself whenever it runs ahead of the host's polyfill.
+let utf8DecoderInstance: TextDecoder | undefined;
+const utf8Decoder = (): TextDecoder => utf8DecoderInstance ??= new TextDecoder("utf-8", { fatal: true });
+
+/** A cohort-member id as the substrate's opaque bytes: UTF-8 of the canonical peer-id string. */
+export function peerIdToBytes(peerId: PeerId | string): Uint8Array {
+	return utf8Encoder.encode(typeof peerId === "string" ? peerId : peerId.toString());
+}
+
+/** Reverse of {@link peerIdToBytes}: decode member bytes back to the canonical peer-id string. */
+export function bytesToPeerIdString(bytes: Uint8Array): string {
+	return utf8Decoder().decode(bytes);
+}
+
+/** Reverse of {@link peerIdToBytes}: decode member bytes back to a dialable {@link PeerId}. */
+export function bytesToPeerId(bytes: Uint8Array): PeerId {
+	return peerIdFromString(bytesToPeerIdString(bytes));
+}

package/src/cohort-topic/stream-util.ts

@@ -34,6 +34,13 @@ export const DEFAULT_STREAM_MAX_BYTES = 512 * 1024;
 /**
  * Open `protocol` to `peer`, send `frame`, and read the bounded reply frame.
  *
+ * Resolves `undefined` when the peer replied with a **zero-length frame** — the in-band "I have no
+ * result" signal {@link handleRequestResponse} sends for a handler that returned nothing. A returned
+ * `Uint8Array` is therefore never empty, and every caller must decide what "no result" means for its
+ * protocol: fall through to another peer, map it to a benign default, or {@link requireReply} when the
+ * protocol always carries a reply. Genuine failures still reject — a dial failure, a stream the peer
+ * aborted (`FrameTruncationError`), an over-ceiling reply (`PayloadTooLargeError`).
+ *
  * NOTE: takes no `AbortSignal`, so a caller cannot set its own deadline. Bounded today anyway —
  * `readFramed` self-times-out at 5s and `dialProtocol` falls back to libp2p's default dial
  * timeout (~30s) — so an unresponsive peer is slow, not hung. If a caller ever needs a tighter
@@ -47,14 +54,18 @@ export async function requestResponse(
 	protocol: string,
 	frame: Uint8Array,
 	maxBytes = DEFAULT_STREAM_MAX_BYTES,
-): Promise<Uint8Array> {
+): Promise<Uint8Array | undefined> {
 	let stream: Stream | undefined;
 	try {
 		// `negotiateFully` deliberately omitted — see the accepted tradeoff in the module docblock.
 		stream = await openProtocolStream(node, peer, protocol);
 		sendFramed(stream, frame);
 		await stream.close();
-		return await readFramed(stream, maxBytes);
+		const reply = await readFramed(stream, maxBytes);
+		// NOTE: every zero-length reply maps to "no result". Safe while no protocol has a meaningful empty reply
+		// (cohort frames carry an inner length prefix; query/recover replies are encoded objects). If one ever
+		// needs to answer "empty" as data, it must send a non-empty envelope rather than bare empty bytes.
+		return reply.length === 0 ? undefined : reply;
 	} finally {
 		if (stream != null) {
 			try {
@@ -66,6 +77,25 @@ export async function requestResponse(
 	}
 }
 
+/** Thrown when a request/response peer replied with a zero-length frame where the protocol requires a reply. */
+export class NoResultReplyError extends Error {
+	constructor(context: string) {
+		super(`${context}: peer replied with no result (zero-length reply frame)`);
+		this.name = "NoResultReplyError";
+	}
+}
+
+/**
+ * Unwrap a {@link requestResponse} reply for a protocol whose responder always carries a frame; throw
+ * {@link NoResultReplyError} (naming `context`) when the peer had no result.
+ */
+export function requireReply(reply: Uint8Array | undefined, context: string): Uint8Array {
+	if (reply === undefined) {
+		throw new NoResultReplyError(context);
+	}
+	return reply;
+}
+
 /** Open `protocol` to `peer` and send `frame` without awaiting a reply (fire-and-forget gossip). */
 export async function sendOneWay(node: Libp2p, peer: PeerId, protocol: string, frame: Uint8Array): Promise<void> {
 	let stream: Stream | undefined;
@@ -90,8 +120,13 @@ export async function sendOneWay(node: Libp2p, peer: PeerId, protocol: string, f
  *
  * A `handle` that returns `undefined` (a drop, a gate rejection, no serving engine) replies with an
  * explicit **zero-length frame** rather than silence: `readFramed` treats end-of-stream as a
- * truncation error, so "no reply" must travel in-band — the dialer's {@link requestResponse}
- * resolves it as empty bytes, exactly what the old read-to-EOF returned for a silent close.
+ * truncation error, so "no result" must travel in-band — the dialer's {@link requestResponse}
+ * resolves it as `undefined`. Returning `new Uint8Array(0)` puts the same zero-length frame on the
+ * wire, so it is the same signal (host.ts's membership responder says "no certificate" that way).
+ * A `handle` that throws aborts the stream instead, which the dialer sees as a rejection.
+ *
+ * Only the reply direction carries "no result": the request frame `handle` receives is always bytes,
+ * and an empty request arrives as a zero-length `Uint8Array`.
  */
 export function handleRequestResponse(
 	node: Libp2p,

package/src/cohort-topic/topic-router.ts

@@ -3,7 +3,7 @@ import { bytesToB64url, b64urlToBytes, encodeCohortMessage } from "@optimystic/d
 import type { Libp2p } from "libp2p";
 import type { FretService, RouteAndMaybeActV1, NearAnchorV1 } from "p2p-fret";
 import { bytesToPeerId } from "./peer-codec.js";
-import { requestResponse, DEFAULT_STREAM_MAX_BYTES } from "./stream-util.js";
+import { requestResponse, requireReply, DEFAULT_STREAM_MAX_BYTES, type NoResultReplyError } from "./stream-util.js";
 import { PROTOCOL_COHORT_REGISTER } from "./protocols.js";
 
 /** A FRET `routeAct` result carrying a cohort reply. */
@@ -70,8 +70,18 @@ export class FretTopicRouter implements ITopicRouter {
 		return encodeCohortMessage({ v: 1, result: "no_state" }, this.maxBytes);
 	}
 
+	/**
+	 * Dial `member`'s `/register` directly and return its encoded reply.
+	 *
+	 * The `/register` responder always writes a frame, so a no-result (zero-length) reply only comes from a
+	 * non-conforming peer; it rejects with {@link NoResultReplyError}, reaching the caller exactly as a dial
+	 * failure does (renewal counts a failed ping; the walk's direct dial propagates the rejection). db-core's {@link ITopicRouter.dialMember} port deliberately stays
+	 * `Promise<Uint8Array>` rather than widening to `| undefined`: that would ripple through the walk and
+	 * renewal decision logic for a state only a misbehaving peer can produce, so the decision is made here.
+	 */
 	async dialMember(member: PeerRef, activity: Uint8Array): Promise<Uint8Array> {
 		const peer = bytesToPeerId(member.id);
-		return requestResponse(this.node, peer, this.registerProtocol, activity, this.maxBytes);
+		const reply = await requestResponse(this.node, peer, this.registerProtocol, activity, this.maxBytes);
+		return requireReply(reply, "cohort-topic register dial");
 	}
 }

package/src/dispute/client.ts

@@ -29,13 +29,23 @@ export class DisputeClient extends ProtocolClient {
 		// arbitrator" behavior. Also apply the default dial cap so a challenge to an
 		// unreachable arbitrator fails the dial fast even when no `timeoutMs` is given;
 		// this does not alter the response semantics (still bounded only by the signal).
-		const signal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
-		const response = await this.processMessage<{ type: 'vote'; vote: ArbitrationVote }>(
-			message,
-			this.protocol,
-			{ signal, dialTimeoutMs: DEFAULT_DIAL_TIMEOUT_MS, maxDataLength: MAX_CONTROL_MESSAGE_BYTES }
-		);
-		return response.vote;
+		//
+		// Explicit AbortController + timer rather than `AbortSignal.timeout`, which Hermes
+		// (React Native's JS engine) does not provide — same pattern as `dialRelay` in
+		// network/relay-reservation.ts. The timer is cleared on every exit path below so a
+		// finished call never holds a timer (and the node it references) alive.
+		const controller = timeoutMs ? new AbortController() : undefined;
+		const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+		try {
+			const response = await this.processMessage<{ type: 'vote'; vote: ArbitrationVote }>(
+				message,
+				this.protocol,
+				{ signal: controller?.signal, dialTimeoutMs: DEFAULT_DIAL_TIMEOUT_MS, maxDataLength: MAX_CONTROL_MESSAGE_BYTES }
+			);
+			return response.vote;
+		} finally {
+			if (timer) clearTimeout(timer);
+		}
 	}
 
 	/** Send a resolution to a peer (broadcast) */

package/src/index.ts

@@ -1,59 +1,64 @@
-export * from "./cluster/client.js";
-export * from "./cluster/client-signature-verifier.js";
-export * from "./cluster/cluster-repo.js";
-export * from "./cluster/cluster-policy.js";
-export * from "./cluster/commit-cert.js";
-export * from "./cluster/commit-proof.js";
-export * from "./cluster/service.js";
-export * from "./cluster/rebalance-monitor.js";
-export * from "./cluster/spread-on-churn.js";
-export * from "./cluster/block-transfer.js";
-export * from "./cluster/block-transfer-service.js";
-export * from "./inbound-authorization.js";
-export * from "./protocol-client.js";
-export * from "./repo/client.js";
-export * from "./repo/cluster-coordinator.js";
-export * from "./repo/coordinator-repo.js";
-export * from "./repo/served-repo-proxy.js";
-export * from "./repo/service.js";
-export * from "./storage/block-storage.js";
-export * from "./storage/block-latch.js";
-export * from "./storage/store-identity.js";
-export * from "./storage/raw-store-driver.js";
-export * from "./storage/kv-raw-storage.js";
-export * from "./storage/shared-cache-pool.js";
-export * from "./storage/cached-store-driver.js";
-export * from "./storage/cached-raw-storage.js";
-export * from "./storage/with-read-cache.js";
-export * from "./storage/memory-store-driver.js";
-export * from "./storage/memory-storage.js";
-export * from "./storage/i-block-storage.js";
-export * from "./storage/i-raw-storage.js";
-export * from "./storage/struct.js";
-export * from "./storage/block-archive.js";
-export * from "./storage/storage-repo.js";
-export * from "./storage/restoration-coordinator.js";
-export * from "./storage/ring-selector.js";
-export * from "./storage/storage-monitor.js";
-export * from "./storage/arachnode-fret-adapter.js";
-export * from "./sync/protocol.js";
-export * from "./sync/client.js";
-export * from "./sync/service.js";
-export * from "./it-utility.js";
-export * from "./libp2p-key-network.js";
-export * from "./libp2p-node.js";
-export * from "./optimystic-node.js";
-export * from "./routing/responsibility.js";
-export * from "./routing/libp2p-known-peers.js";
-export * from "./network/network-manager-service.js";
-export * from "./network/get-network-manager.js";
-export * from "./reputation/index.js";
-export * from "./dispute/index.js";
-export * from "./cohort-topic/index.js";
-export * from "./matchmaking/index.js";
-export * from "./reactivity/index.js";
-export * from "./cluster/i-transaction-state-store.js";
-export * from "./cluster/memory-transaction-state-store.js";
-export * from "./cluster/persistent-transaction-state-store.js";
-export * from "./storage/i-kv-store.js";
-export * from "./storage/memory-kv-store.js";
+export * from "./cluster/client.js";
+export * from "./cluster/client-signature-verifier.js";
+export * from "./cluster/cluster-repo.js";
+export * from "./cluster/cluster-policy.js";
+export * from "./cluster/commit-cert.js";
+export * from "./cluster/commit-proof.js";
+export * from "./cluster/service.js";
+export * from "./cluster/rebalance-monitor.js";
+export * from "./cluster/spread-on-churn.js";
+export * from "./cluster/block-transfer.js";
+export * from "./cluster/block-transfer-service.js";
+export * from "./inbound-authorization.js";
+export * from "./protocol-client.js";
+export * from "./repo/client.js";
+export * from "./repo/cluster-coordinator.js";
+export * from "./repo/coordinator-repo.js";
+export * from "./repo/i-under-replication-ledger.js";
+export * from "./repo/kv-under-replication-ledger.js";
+export * from "./repo/under-replication-drain.js";
+export * from "./repo/responsibility.js";
+export * from "./repo/served-repo-proxy.js";
+export * from "./repo/service.js";
+export * from "./storage/block-storage.js";
+export * from "./storage/block-latch.js";
+export * from "./storage/store-identity.js";
+export * from "./storage/raw-store-driver.js";
+export * from "./storage/kv-raw-storage.js";
+export * from "./storage/shared-cache-pool.js";
+export * from "./storage/cached-store-driver.js";
+export * from "./storage/cached-raw-storage.js";
+export * from "./storage/with-read-cache.js";
+export * from "./storage/memory-store-driver.js";
+export * from "./storage/memory-storage.js";
+export * from "./storage/i-block-storage.js";
+export * from "./storage/i-raw-storage.js";
+export * from "./storage/struct.js";
+export * from "./storage/pending-claim.js";
+export * from "./storage/block-archive.js";
+export * from "./storage/storage-repo.js";
+export * from "./storage/restoration-coordinator.js";
+export * from "./storage/ring-selector.js";
+export * from "./storage/storage-monitor.js";
+export * from "./storage/arachnode-fret-adapter.js";
+export * from "./sync/protocol.js";
+export * from "./sync/client.js";
+export * from "./sync/service.js";
+export * from "./it-utility.js";
+export * from "./libp2p-key-network.js";
+export * from "./libp2p-node.js";
+export * from "./optimystic-node.js";
+export * from "./routing/responsibility.js";
+export * from "./routing/libp2p-known-peers.js";
+export * from "./network/network-manager-service.js";
+export * from "./network/get-network-manager.js";
+export * from "./reputation/index.js";
+export * from "./dispute/index.js";
+export * from "./cohort-topic/index.js";
+export * from "./matchmaking/index.js";
+export * from "./reactivity/index.js";
+export * from "./cluster/i-transaction-state-store.js";
+export * from "./cluster/memory-transaction-state-store.js";
+export * from "./cluster/persistent-transaction-state-store.js";
+export * from "./storage/i-kv-store.js";
+export * from "./storage/memory-kv-store.js";