@optimystic/db-p2p 0.11.2 → 0.12.0

package/src/repo/cluster-coordinator.ts

@@ -1,5 +1,5 @@
 import { peerIdFromString } from "@libp2p/peer-id";
-import type { ClusterRecord, IKeyNetwork, RepoMessage, BlockId, ClusterPeers, MessageOptions, Signature, ClusterConsensusConfig } from "@optimystic/db-core";
+import type { ClusterRecord, IKeyNetwork, RepoMessage, BlockId, ClusterPeers, MessageOptions, ClusterConsensusConfig } from "@optimystic/db-core";
 import { base58btc } from "multiformats/bases/base58";
 import { sha256 } from "multiformats/hashes/sha2";
 import { ClusterClient } from "../cluster/client.js";
@@ -123,7 +123,7 @@ export class ClusterCoordinator {
 	 * Initiates a 2-phase transaction for a specific block ID.
 	 * Returns the cluster record and whether the local cluster already executed the operations.
 	 */
-	async executeClusterTransaction(blockId: BlockId, message: RepoMessage, options?: MessageOptions): Promise<{
+	async executeClusterTransaction(blockId: BlockId, message: RepoMessage, _options?: MessageOptions): Promise<{
 		record: ClusterRecord;
 		localExecuted: boolean;
 	}> {
@@ -298,7 +298,7 @@ export class ClusterCoordinator {
 	 * Validate that a small cluster size is legitimate by querying remote peers
 	 * for their network size estimates. Returns true if estimates roughly agree.
 	 */
-	private async validateSmallCluster(localSize: number, peers: ClusterPeers): Promise<boolean> {
+	private async validateSmallCluster(localSize: number, _peers: ClusterPeers): Promise<boolean> {
 		// If we have FRET and it shows confident estimate
 		if (this.fretService) {
 			try {
@@ -581,7 +581,7 @@ export class ClusterCoordinator {
 		});
 	}
 
-	private scheduleCommitRetry(messageHash: string, record: ClusterRecord, missingPeers: string[]): void {
+	private scheduleCommitRetry(messageHash: string, _record: ClusterRecord, missingPeers: string[]): void {
 		const state = this.transactions.get(messageHash);
 		if (!state) {
 			return;

package/src/repo/coordinator-repo.ts

@@ -1,5 +1,5 @@
-import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, RepoMessage, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionRev, ActionContext } from "@optimystic/db-core";
-import { LruMap } from "@optimystic/db-core";
+import type { PendRequest, ActionBlocks, IRepo, MessageOptions, CommitResult, GetBlockResults, PendResult, BlockGets, CommitRequest, RepoMessage, IKeyNetwork, ICluster, ClusterConsensusConfig, BlockId, ActionRev, ActionContext, ClusterRecord } from "@optimystic/db-core";
+import { LruMap, blockIdsForTransforms } from "@optimystic/db-core";
 import { ClusterCoordinator } from "./cluster-coordinator.js";
 import type { ClusterClient } from "../cluster/client.js";
 import type { PeerId } from "@libp2p/interface";
@@ -187,8 +187,25 @@ export class CoordinatorRepo implements IRepo {
 	private async fetchBlockFromCluster(blockId: BlockId, context?: ActionContext): Promise<void> {
 		if (!this.clusterLatestCallback) return;
 
-		// Query cluster for the block
-		const clusterLatest = await this.queryClusterForLatest(blockId, context);
+		const blockIdBytes = new TextEncoder().encode(blockId);
+		const peers = await this.keyNetwork.findCluster(blockIdBytes);
+		const peerIds = peers ? Object.keys(peers) : [];
+		if (peerIds.length === 0) return;
+
+		// Solo-cluster short-circuit: the only responsible peer is us. There is no
+		// remote to sync from, so skip the callback entirely. Querying ourselves
+		// would dial self via SyncClient — pointless at best, and on nodes without
+		// listen addresses (e.g. solo WebSocket-only) the dial can hang.
+		if (
+			peerIds.length === 1
+			&& this.localPeerId
+			&& peerIds[0] === this.localPeerId.toString()
+		) {
+			log('cluster-fetch:solo-self-skip', { blockId });
+			return;
+		}
+
+		const clusterLatest = await this.queryClusterForLatest(peerIds, blockId, context);
 		if (clusterLatest) {
 			// Found on cluster - trigger restoration to sync the block
 			await this.storageRepo.get({ blockIds: [blockId], context: { committed: [clusterLatest], rev: clusterLatest.rev } });
@@ -199,14 +216,7 @@ export class CoordinatorRepo implements IRepo {
 	/**
 	 * Query cluster peers to find the maximum latest revision for a block.
 	 */
-	private async queryClusterForLatest(blockId: BlockId, context?: ActionContext): Promise<ActionRev | undefined> {
-		const blockIdBytes = new TextEncoder().encode(blockId);
-		const peers = await this.keyNetwork.findCluster(blockIdBytes);
-		if (!peers || Object.keys(peers).length === 0) {
-			return undefined;
-		}
-
-		const peerIds = Object.keys(peers);
+	private async queryClusterForLatest(peerIds: string[], blockId: BlockId, context?: ActionContext): Promise<ActionRev | undefined> {
 		let maxLatest: ActionRev | undefined;
 
 		// Add timeout wrapper to prevent hanging on unresponsive peers
@@ -237,7 +247,7 @@ export class CoordinatorRepo implements IRepo {
 	}
 
 	async pend(request: PendRequest, options?: MessageOptions): Promise<PendResult> {
-		const allBlockIds = Object.keys(request.transforms);
+		const allBlockIds = blockIdsForTransforms(request.transforms);
 		await this.verifyResponsibility(allBlockIds);
 		const coordinatingBlockIds = (options as any)?.coordinatingBlockIds ?? allBlockIds;
 
@@ -273,7 +283,7 @@ export class CoordinatorRepo implements IRepo {
 			return {
 				success: true,
 				pending: [],
-				blockIds: Object.keys(request.transforms)
+				blockIds: allBlockIds
 			};
 		} catch (error) {
 			log('coordinator-repo:pend-error', { actionId: request.actionId, error: (error as Error).message });
@@ -326,16 +336,38 @@ export class CoordinatorRepo implements IRepo {
 		};
 
 		try {
-			const { localExecuted } = await this.coordinator.executeClusterTransaction(blockIds[0]!, message, options);
-			// Only call storageRepo if local cluster didn't already execute during consensus
-			if (!localExecuted) {
+			const { record, localExecuted } = await this.coordinator.executeClusterTransaction(blockIds[0]!, message, options);
+			if (localExecuted) {
+				return { success: true };
+			}
+			// Local cluster didn't execute during consensus. Attempt a local commit,
+			// but tolerate failure (e.g., "pending action not found") when the cluster
+			// already reached consensus — this coordinator was likely picked for commit
+			// after missing the pend phase (unreachable during pend, fresh join, etc.).
+			// The cluster's majority is authoritative; this peer will catch up via sync.
+			try {
 				return await this.storageRepo.commit(request, options);
+			} catch (err) {
+				if (clusterReachedCommitConsensus(record)) {
+					log('coordinator-repo:commit-local-failed-cluster-succeeded', {
+						actionId: request.actionId,
+						error: (err as Error).message
+					});
+					return { success: true };
+				}
+				throw err;
 			}
-			// Local cluster already executed - return success
-			return { success: true };
 		} catch (error) {
 			log('coordinator-repo:commit-error', { actionId: request.actionId, error: (error as Error).message });
 			throw error;
 		}
 	}
 }
+
+/** True if a simple majority of cluster peers signed an approving commit. */
+function clusterReachedCommitConsensus(record: ClusterRecord): boolean {
+	const peerCount = Object.keys(record.peers).length;
+	if (peerCount === 0) return false;
+	const approvedCommits = Object.values(record.commits).filter(s => s.type === 'approve').length;
+	return approvedCommits > peerCount / 2;
+}

package/src/repo/service.ts

@@ -63,7 +63,6 @@ export class RepoService implements Startable {
 	private readonly repo: IRepo
 	private readonly components: RepoServiceComponents
 	private running: boolean
-	private readonly k: number
 	/** Responsibility K - how many peers are responsible for a key (for redirect decisions) */
 	private readonly responsibilityK: number
 
@@ -76,7 +75,6 @@ export class RepoService implements Startable {
 		this.log = components.logger.forComponent(init.logPrefix ?? 'db-p2p:repo-service')
 		this.repo = components.repo
 		this.running = false
-		this.k = init.kBucketSize ?? 10
 		this.responsibilityK = init.responsibilityK ?? 1
 	}
 

package/src/routing/simple-cluster-coordinator.ts

@@ -57,13 +57,13 @@ export class ModuloCoordinator implements SimpleClusterCoordinator {
  * For very small clusters, just replicate everywhere
  */
 export class FullReplicationCoordinator implements SimpleClusterCoordinator {
-  async selectCoordinator(key: Uint8Array, peers: PeerId[]): Promise<PeerId> {
+  async selectCoordinator(_key: Uint8Array, peers: PeerId[]): Promise<PeerId> {
     // Always select first peer as primary
     if (peers.length === 0) throw new Error('No peers available')
     return peers[0]!
   }
 
-  async selectReplicas(key: Uint8Array, peers: PeerId[], replicationFactor: number): Promise<PeerId[]> {
+  async selectReplicas(_key: Uint8Array, peers: PeerId[], _replicationFactor: number): Promise<PeerId[]> {
     // Replicate to all peers in small clusters
     return [...peers]
   }

package/src/storage/block-storage.ts

@@ -91,6 +91,38 @@ export class BlockStorage implements IBlockStorage {
 		await this.storage.saveMetadata(this.blockId, meta);
 	}
 
+	async recover(): Promise<{ reconciled: boolean; latest?: ActionRev }> {
+		const meta = await this.storage.getMetadata(this.blockId);
+		if (!meta) {
+			return { reconciled: false };
+		}
+
+		const currentRev = meta.latest?.rev ?? 0;
+		let maxRev = currentRev;
+		let maxActionId = meta.latest?.actionId;
+
+		// Probe forward until we hit a gap or a revision whose action is not yet
+		// in the committed log (Crash-D2 state — retry-commit owns that advance).
+		for (let next = currentRev + 1; ; next++) {
+			const actionId = await this.storage.getRevision(this.blockId, next);
+			if (actionId === undefined) break;
+			const promoted = await this.storage.getTransaction(this.blockId, actionId);
+			if (promoted === undefined) break;
+			maxRev = next;
+			maxActionId = actionId;
+		}
+
+		if (maxRev > currentRev && maxActionId !== undefined) {
+			const advanced: ActionRev = { rev: maxRev, actionId: maxActionId };
+			meta.latest = advanced;
+			await this.storage.saveMetadata(this.blockId, meta);
+			log('recover blockId=%s advanced latest from rev=%d to rev=%d', this.blockId, currentRev, maxRev);
+			return { reconciled: true, latest: advanced };
+		}
+
+		return { reconciled: false, latest: meta.latest };
+	}
+
 	private async ensureRevision(meta: BlockMetadata, rev: number): Promise<void> {
 		if (this.inRanges(rev, meta.ranges)) {
 			return;

package/src/storage/i-block-storage.ts

@@ -43,4 +43,19 @@ export interface IBlockStorage {
 
     /** Sets the latest revision information */
     setLatest(latest: ActionRev): Promise<void>;
+
+    /**
+     * Reconciles `metadata.latest` with the highest contiguous fully-promoted revision in
+     * the revisions table. Intended for post-crash recovery of the Crash-D3 gap, where
+     * `promotePendingTransaction` succeeded but `setLatest` did not: the revision and
+     * committed-log entry are durable, but `meta.latest` still points at the prior rev
+     * (or is undefined), and retry-commit is rejected because the pending record is gone.
+     *
+     * Stops at the first rev whose action is not yet in the committed log, preserving the
+     * Crash-D2 invariant that retry-commit — not recovery — owns advancement past a half-
+     * promoted state.
+     *
+     * Idempotent and monotonic (latest only advances forward).
+     */
+    recover(): Promise<{ reconciled: boolean; latest?: ActionRev }>;
 }

package/src/storage/i-raw-storage.ts

@@ -27,4 +27,14 @@ export interface IRawStorage {
 
 	// Promote a pending action to a committed action
 	promotePendingTransaction(blockId: BlockId, actionId: ActionId): Promise<void>;
+
+	/**
+	 * Approximate bytes currently stored by this backend.
+	 *
+	 * Used by `StorageMonitor` to feed real used-space figures into ring selection.
+	 * Implementations should return their best cheap estimate (e.g. on-disk size for
+	 * filesystem backends, tracked footprint for in-memory backends). The result is
+	 * advisory — `StorageMonitor` treats a missing implementation as 0.
+	 */
+	getApproximateBytesUsed?(): Promise<number>;
 }

package/src/storage/memory-storage.ts

@@ -17,12 +17,30 @@ export class MemoryRawStorage implements IRawStorage {
 		return `${blockId}:${actionId}`;
 	}
 
+	/**
+	 * Retrieves metadata for a block.
+	 *
+	 * @pitfall **MUST return a clone** - `BlockStorage.setLatest` mutates the returned
+	 * metadata in place (`meta.latest = latest`) before calling `saveMetadata`. Returning
+	 * the stored reference leaks that mutation into RAM even when a subsequent
+	 * `saveMetadata` call fails, masking mid-commit crashes that a persistent store
+	 * (file/sqlite/leveldb) would surface correctly.
+	 * @see docs/internals.md "Storage Returns References" pitfall
+	 */
 	async getMetadata(blockId: BlockId): Promise<BlockMetadata | undefined> {
-		return this.metadata.get(blockId);
+		const meta = this.metadata.get(blockId);
+		return meta ? structuredClone(meta) : undefined;
 	}
 
+	/**
+	 * Stores metadata for a block.
+	 *
+	 * @pitfall **MUST store a clone** - callers may continue mutating the metadata object
+	 * after saving; storing the reference lets those mutations corrupt persisted state.
+	 * @see docs/internals.md "Storage Returns References" pitfall
+	 */
 	async saveMetadata(blockId: BlockId, metadata: BlockMetadata): Promise<void> {
-		this.metadata.set(blockId, metadata);
+		this.metadata.set(blockId, structuredClone(metadata));
 	}
 
 	async getRevision(blockId: BlockId, rev: number): Promise<ActionId | undefined> {
@@ -124,4 +142,32 @@ export class MemoryRawStorage implements IRawStorage {
 			this.pendingActions.delete(key);
 		}
 	}
+
+	async getApproximateBytesUsed(): Promise<number> {
+		let total = 0;
+		for (const [blockId, meta] of this.metadata) {
+			total += blockId.length + jsonByteSize(meta);
+		}
+		for (const [key, actionId] of this.revisions) {
+			total += key.length + actionId.length;
+		}
+		for (const [key, transform] of this.pendingActions) {
+			total += key.length + jsonByteSize(transform);
+		}
+		for (const [key, transform] of this.actions) {
+			total += key.length + jsonByteSize(transform);
+		}
+		for (const [key, block] of this.materializedBlocks) {
+			total += key.length + jsonByteSize(block);
+		}
+		return total;
+	}
+}
+
+function jsonByteSize(value: unknown): number {
+	try {
+		return JSON.stringify(value)?.length ?? 0;
+	} catch {
+		return 0;
+	}
 }

package/src/storage/ring-selector.ts

@@ -42,11 +42,32 @@ export class RingSelector {
 			return -1;
 		}
 
-		// Estimate total network size from FRET
-		// We use a simple heuristic: assume average block size and typical data distribution
-		const avgBlockSize = 100 * 1024; // 100KB typical block
-		const estimatedTotalBlocks = 1000; // Conservative estimate
-		const estimatedTotalData = estimatedTotalBlocks * avgBlockSize;
+		// Estimate total network spare capacity by aggregating observed per-ring stats.
+		// See docs/arachnode.md §"Capacity Management and Ring Adjustment": ring selection
+		// should reflect observed network demand, not a hard-coded constant. We treat
+		// Σ (peerCount × avgCapacity) over known rings as a proxy for total network spare
+		// capacity, so `coverage` becomes our share of it. More peers (or richer peers) →
+		// smaller share → higher ring depth (more specialization). On bootstrap, when no
+		// ring stats are observed yet, we fall back to a conservative fixed estimate so
+		// first-boot behavior is deterministic.
+		const ringStats = this.fretAdapter.getRingStats();
+		let estimatedTotalData: number;
+		if (ringStats.length > 0) {
+			estimatedTotalData = ringStats.reduce(
+				(sum, stat) => sum + stat.peerCount * stat.avgCapacity,
+				0
+			);
+		} else {
+			const avgBlockSize = 100 * 1024; // 100KB typical block
+			const estimatedTotalBlocks = 1000; // Conservative estimate
+			estimatedTotalData = estimatedTotalBlocks * avgBlockSize;
+		}
+
+		// Guard against pathological zero-aggregate (e.g. all peers report 0 available);
+		// fall back to local capacity so coverage = 1.0 (ring 0).
+		if (estimatedTotalData <= 0) {
+			estimatedTotalData = capacity.available;
+		}
 
 		// Calculate what fraction of keyspace we can cover
 		const coverage = capacity.available / estimatedTotalData;

package/src/storage/storage-monitor.ts

@@ -28,22 +28,15 @@ export class StorageMonitor {
 		const usedOverride = this.config.usedBytes;
 		const availableOverride = this.config.availableBytes;
 
-		if (
-			usedOverride !== undefined ||
-			availableOverride !== undefined ||
-			this.config.totalBytes !== undefined
-		) {
-			const used = usedOverride ?? Math.max(0, total - (availableOverride ?? total));
-			const available = availableOverride ?? Math.max(0, total - used);
-			return {
-				total,
-				used: Math.min(total, Math.max(0, used)),
-				available: Math.max(0, Math.min(total, available))
-			};
-		}
-
-		const used = await this.estimateUsedSpace();
-		const available = Math.max(0, total - used);
+		// Only short-circuit the backend when used/available is explicitly supplied;
+		// a bare `totalBytes` is just the disk-size hint and should still let the
+		// backend report actual used bytes.
+		const rawUsed = usedOverride
+			?? (availableOverride !== undefined ? total - availableOverride : await this.estimateUsedSpace());
+		const used = Math.min(total, Math.max(0, rawUsed));
+		const available = availableOverride !== undefined
+			? Math.max(0, Math.min(total, availableOverride))
+			: Math.max(0, total - used);
 
 		return {
 			total,
@@ -53,7 +46,7 @@ export class StorageMonitor {
 	}
 
 	private async estimateUsedSpace(): Promise<number> {
-		return 0; // TODO: Implement actual space calculation
+		return (await this.storage.getApproximateBytesUsed?.()) ?? 0;
 	}
 }
 

package/src/storage/storage-repo.ts

@@ -1,7 +1,6 @@
 import type {
 	IRepo, MessageOptions, BlockId, CommitRequest, CommitResult, GetBlockResults, PendRequest, PendResult, ActionBlocks,
 	ActionId, BlockGets, ActionPending, PendSuccess, ActionTransform, ActionTransforms,
-	Transforms,
 	GetBlockResult,
 	PendValidationHook
 } from "@optimystic/db-core";
@@ -30,7 +29,7 @@ export class StorageRepo implements IRepo {
 		this.validatePend = options?.validatePend;
 	}
 
-	async get({ blockIds, context }: BlockGets, options?: MessageOptions): Promise<GetBlockResults> {
+	async get({ blockIds, context }: BlockGets, _options?: MessageOptions): Promise<GetBlockResults> {
 		const distinctBlockIds = Array.from(new Set(blockIds));
 		log('get blockIds=%d', distinctBlockIds.length);
 		const results = await Promise.all(distinctBlockIds.map(async (blockId) => {
@@ -191,7 +190,7 @@ export class StorageRepo implements IRepo {
 		}));
 	}
 
-	async commit(request: CommitRequest, options?: MessageOptions): Promise<CommitResult> {
+	async commit(request: CommitRequest, _options?: MessageOptions): Promise<CommitResult> {
 		log('commit actionId=%s rev=%d blockIds=%d', request.actionId, request.rev, request.blockIds.length);
 		const uniqueBlockIds = Array.from(new Set(request.blockIds)).sort();
 		const releases: (() => void)[] = [];
@@ -211,11 +210,23 @@ export class StorageRepo implements IRepo {
 				storage: this.createBlockStorage(blockId)
 			}));
 
-			// Check for stale revisions and collect missing actions
+			// Partition blocks into:
+			//   - alreadyDone: latest.rev === request.rev && latest.actionId === request.actionId
+			//     (idempotent retry — a prior commit of this same action already landed here;
+			//     skip rather than treat as a conflict. Needed to rollforward stranded blocks
+			//     after a mid-batch crash committed some but not all blocks.)
+			//   - missedCommits: latest.rev >= request.rev but not the same actionId → real stale conflict.
+			//   - toCommit: latest.rev < request.rev or no latest yet → run internalCommit.
+			const toCommit: { blockId: BlockId, storage: IBlockStorage }[] = [];
 			const missedCommits: { blockId: BlockId, transforms: ActionTransform[] }[] = [];
-			for (const { blockId, storage } of blockStorages) {
+			for (const entry of blockStorages) {
+				const { blockId, storage } = entry;
 				const latest = await storage.getLatest();
 				if (latest && latest.rev >= request.rev) {
+					if (latest.rev === request.rev && latest.actionId === request.actionId) {
+						// Idempotent no-op for this block — already committed with this exact (actionId, rev).
+						continue;
+					}
 					const transforms: ActionTransform[] = [];
 					for await (const actionRev of storage.listRevisions(request.rev, latest.rev)) {
 						const transform = await storage.getTransaction(actionRev.actionId);
@@ -229,7 +240,9 @@ export class StorageRepo implements IRepo {
 						});
 					}
 					missedCommits.push({ blockId, transforms });	// Push, even if transforms is empty, because we want to reject the older version
+					continue;
 				}
+				toCommit.push(entry);
 			}
 
 			if (missedCommits.length) {
@@ -240,9 +253,11 @@ export class StorageRepo implements IRepo {
 				};
 			}
 
-			// Check for missing pending actions
+			// Check for missing pending actions only on blocks that still need to commit.
+			// Already-done blocks will have had their pending promoted, so skipping them here
+			// is what makes the idempotent rollforward work.
 			const missingPends: { blockId: BlockId, actionId: ActionId }[] = [];
-			for (const { blockId, storage } of blockStorages) {
+			for (const { blockId, storage } of toCommit) {
 				const pendingAction = await storage.getPendingTransaction(request.actionId);
 				if (!pendingAction) {
 					missingPends.push({ blockId, actionId: request.actionId });
@@ -253,14 +268,15 @@ export class StorageRepo implements IRepo {
 				throw new Error(`Pending action ${request.actionId} not found for block(s): ${missingPends.map(p => p.blockId).join(', ')}`);
 			}
 
-			// Commit the action for each block
-			// This loop will execute atomically for all blocks due to the acquired locks
-			for (const { blockId, storage } of blockStorages) {
+			// Commit the action for each block that still needs it.
+			// This loop will execute atomically for all blocks due to the acquired locks.
+			for (const { blockId, storage } of toCommit) {
 				try {
 					// internalCommit will throw if it encounters an issue
 					await this.internalCommit(blockId, request.actionId, request.rev, storage);
 				} catch (err) {
-					// TODO: Recover as best we can. Rollback or handle partial commit? For now, return failure.
+					// Partial-commit recovery: a retry with the same (actionId, rev) will treat
+					// already-done blocks as idempotent no-ops and advance the remainder.
 					return {
 						success: false,
 						reason: err instanceof Error ? err.message : 'Unknown error during commit'
@@ -276,6 +292,19 @@ export class StorageRepo implements IRepo {
 		return { success: true };
 	}
 
+	/**
+	 * Reconciles `metadata.latest` for a single block with the highest contiguous
+	 * fully-promoted revision in durable storage. Use after a crash between
+	 * `promotePendingTransaction` and `setLatest` when retry-commit cannot help
+	 * (the pending record is already gone) but the revision and committed-log entry
+	 * are durable. Idempotent and monotonic.
+	 */
+	async recoverBlock(blockId: BlockId): Promise<void> {
+		log('recoverBlock blockId=%s', blockId);
+		const storage = this.createBlockStorage(blockId);
+		await storage.recover();
+	}
+
 	private async internalCommit(blockId: BlockId, actionId: ActionId, rev: number, storage: IBlockStorage): Promise<void> {
 		// Note: This method is called within the locked critical section of commit()
 		// So, operations like getPendingTransaction, getLatest, getBlock, saveMaterializedBlock,

package/src/sync/service.ts

@@ -1,8 +1,7 @@
-import type { ComponentLogger, Startable, Stream } from '@libp2p/interface';
+import type { ComponentLogger, Startable } from '@libp2p/interface';
 import type { IRepo } from '@optimystic/db-core';
 import { buildSyncProtocol, type SyncRequest, type SyncResponse } from './protocol.js';
 import { pipe } from 'it-pipe';
-import { fromString as u8FromString } from 'uint8arrays/from-string';
 import { toString as u8ToString } from 'uint8arrays/to-string';
 import * as lp from 'it-length-prefixed';
 import type { Uint8ArrayList } from 'uint8arraylist';
@@ -37,7 +36,7 @@ export class SyncService implements Startable {
 	private readonly registrar: { handle: (...args: any[]) => Promise<void>, unhandle: (...args: any[]) => Promise<void> };
 
 	constructor(
-		private readonly components: SyncServiceComponents,
+		components: SyncServiceComponents,
 		init: SyncServiceInit = {}
 	) {
 		this.log = components.logger.forComponent('db-p2p:sync-service');

package/src/testing/index.ts

@@ -0,0 +1 @@
+export * from './mesh-harness.js';