@peerbit/shared-log 12.3.5 → 13.0.0

package/dist/src/index.js

@@ -32,19 +32,19 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { BorshError, field, variant } from "@dao-xyz/borsh";
+import { BorshError, deserialize, field, serialize, variant } from "@dao-xyz/borsh";
 import { AnyBlockStore, RemoteBlocks } from "@peerbit/blocks";
 import { cidifyString } from "@peerbit/blocks-interface";
 import { Cache } from "@peerbit/cache";
-import { AccessError, PublicSignKey, sha256Base64Sync, sha256Sync, } from "@peerbit/crypto";
+import { AccessError, PublicSignKey, getPublicKeyFromPeerId, sha256Base64Sync, sha256Sync, } from "@peerbit/crypto";
 import { And, ByteMatchQuery, NotStartedError as IndexNotStartedError, Or, Sort, StringMatch, toId, } from "@peerbit/indexer-interface";
 import { Entry, Log, Meta, ShallowEntry, } from "@peerbit/log";
 import { logger as loggerFn } from "@peerbit/logger";
 import { ClosedError, Program } from "@peerbit/program";
-import { waitForSubscribers } from "@peerbit/pubsub";
+import { FanoutChannel, waitForSubscribers, } from "@peerbit/pubsub";
 import { SubscriptionEvent, UnsubcriptionEvent, } from "@peerbit/pubsub-interface";
 import { RPC } from "@peerbit/rpc";
-import { AcknowledgeDelivery, AnyWhere, NotStartedError, SeekDelivery, SilentDelivery, } from "@peerbit/stream-interface";
+import { AcknowledgeDelivery, AnyWhere, DataMessage, MessageHeader, NotStartedError, SilentDelivery, } from "@peerbit/stream-interface";
 import { AbortError, TimeoutError, debounceAccumulator, debounceFixedInterval, waitFor, } from "@peerbit/time";
 import pDefer, {} from "p-defer";
 import PQueue from "p-queue";
@@ -54,6 +54,7 @@ import { CPUUsageIntervalLag } from "./cpu.js";
 import { debouncedAccumulatorMap, } from "./debounce.js";
 import { NoPeersError } from "./errors.js";
 import { EntryWithRefs, ExchangeHeadsMessage, RequestIPrune, ResponseIPrune, createExchangeHeadsMessages, } from "./exchange-heads.js";
+import { FanoutEnvelope } from "./fanout-envelope.js";
 import { MAX_U32, MAX_U64, bytesToNumber, createNumbers, denormalizer, } from "./integers.js";
 import { TransportMessage } from "./message.js";
 import { PIDReplicationController } from "./pid.js";
@@ -84,6 +85,34 @@ const getLatestEntry = (entries) => {
     }
     return latest;
 };
+const hashToSeed32 = (str) => {
+    // FNV-1a 32-bit, fast and deterministic.
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+};
+const pickDeterministicSubset = (peers, seed, max) => {
+    if (peers.length <= max)
+        return peers;
+    const subset = [];
+    const used = new Set();
+    let x = seed || 1;
+    while (subset.length < max) {
+        // xorshift32
+        x ^= x << 13;
+        x ^= x >>> 17;
+        x ^= x << 5;
+        const peer = peers[(x >>> 0) % peers.length];
+        if (!used.has(peer)) {
+            used.add(peer);
+            subset.push(peer);
+        }
+    }
+    return subset;
+};
 export { BlocksMessage };
 const isAdaptiveReplicatorOption = (options) => {
     if (typeof options === "number") {
@@ -176,6 +205,10 @@ export const WAIT_FOR_REPLICATOR_REQUEST_MIN_ATTEMPTS = 3;
 // Prefer making pruning robust without timing-based heuristics.
 export const WAIT_FOR_PRUNE_DELAY = 0;
 const PRUNE_DEBOUNCE_INTERVAL = 500;
+const CHECKED_PRUNE_RESEND_INTERVAL_MIN_MS = 250;
+const CHECKED_PRUNE_RESEND_INTERVAL_MAX_MS = 5_000;
+const CHECKED_PRUNE_RETRY_MAX_ATTEMPTS = 3;
+const CHECKED_PRUNE_RETRY_MAX_DELAY_MS = 30_000;
 // DONT SET THIS ANY LOWER, because it will make the pid controller unstable as the system responses are not fast enough to updates from the pid controller
 const RECALCULATE_PARTICIPATION_DEBOUNCE_INTERVAL = 1000;
 const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE = 0.01;
@@ -183,6 +216,27 @@ const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE_WITH_CPU_LIMIT = 0.005;
 const RECALCULATE_PARTICIPATION_MIN_RELATIVE_CHANGE_WITH_MEMORY_LIMIT = 0.001;
 const RECALCULATE_PARTICIPATION_RELATIVE_DENOMINATOR_FLOOR = 1e-3;
 const DEFAULT_DISTRIBUTION_DEBOUNCE_TIME = 500;
+const RECENT_REPAIR_DISPATCH_TTL_MS = 5_000;
+const REPAIR_SWEEP_ENTRY_BATCH_SIZE = 1_000;
+const REPAIR_SWEEP_TARGET_BUFFER_SIZE = 1024;
+const FORCE_FRESH_RETRY_SCHEDULE_MS = [0, 1_000, 3_000, 7_000];
+const JOIN_WARMUP_RETRY_SCHEDULE_MS = [0, 1_000, 3_000];
+const toPositiveInteger = (value, fallback, label) => {
+    if (value == null) {
+        return fallback;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`${label} must be a positive number`);
+    }
+    return Math.max(1, Math.floor(value));
+};
+const DEFAULT_SHARED_LOG_FANOUT_CHANNEL_OPTIONS = {
+    msgRate: 30,
+    msgSize: 1024,
+    uploadLimitBps: 5_000_000,
+    maxChildren: 24,
+    repair: true,
+};
 const getIdForDynamicRange = (publicKey) => {
     return sha256Sync(concat([publicKey.bytes, new TextEncoder().encode("dynamic")]));
 };
@@ -226,12 +280,17 @@ let SharedLog = (() => {
         coordinateToHash;
         recentlyRebalanced;
         uniqueReplicators;
+        _replicatorJoinEmitted;
         _replicatorsReconciled;
         /* private _totalParticipation!: number; */
         // gid -> coordinate -> publicKeyHash list (of owners)
         _gidPeersHistory;
         _onSubscriptionFn;
         _onUnsubscriptionFn;
+        _onFanoutDataFn;
+        _onFanoutUnicastFn;
+        _fanoutChannel;
+        _providerHandle;
         _isTrustedReplicator;
         _logProperties;
         _closeController;
@@ -241,6 +300,12 @@ let SharedLog = (() => {
         // public key hash to range id to range
         pendingMaturity; // map of peerId to timeout
         latestReplicationInfoMessage;
+        // Peers that have unsubscribed from this log's topic. We ignore replication-info
+        // messages from them until we see a new subscription, to avoid re-introducing
+        // stale membership state during close/unsubscribe races.
+        _replicationInfoBlockedPeers;
+        _replicationInfoRequestByPeer;
+        _replicationInfoApplyQueueByPeer;
         remoteBlocks;
         openTime;
         oldestOpenTime;
@@ -252,7 +317,13 @@ let SharedLog = (() => {
         responseToPruneDebouncedFn;
         _requestIPruneSent; // tracks entry hash to peer hash for requesting I prune messages
         _requestIPruneResponseReplicatorSet; // tracks entry hash to peer hash
+        _checkedPruneRetries;
         replicationChangeDebounceFn;
+        _repairRetryTimers;
+        _recentRepairDispatch;
+        _repairSweepRunning;
+        _repairSweepForceFreshPending;
+        _repairSweepAddedPeersPending;
         // regular distribution checks
         distributeQueue;
         syncronizer;
@@ -264,6 +335,7 @@ let SharedLog = (() => {
         waitForReplicatorRequestMaxAttempts;
         waitForPruneDelay;
         distributionDebounceTime;
+        repairSweepTargetBufferSize;
         replicationController;
         history;
         domain;
@@ -283,6 +355,561 @@ let SharedLog = (() => {
         get v8Behaviour() {
             return (this.compatibility ?? Number.MAX_VALUE) < 9;
         }
+        getFanoutChannelOptions(options) {
+            return {
+                ...DEFAULT_SHARED_LOG_FANOUT_CHANNEL_OPTIONS,
+                ...(options?.channel ?? {}),
+            };
+        }
+        async _openFanoutChannel(options) {
+            this._closeFanoutChannel();
+            if (!options) {
+                return;
+            }
+            const fanoutService = this.node.services.fanout;
+            if (!fanoutService) {
+                throw new Error(`Fanout is configured for shared-log topic ${this.topic}, but no fanout service is available on this client`);
+            }
+            const resolvedRoot = options.root ??
+                (await fanoutService?.topicRootControlPlane?.resolveTopicRoot?.(this.topic));
+            if (!resolvedRoot) {
+                throw new Error(`Fanout is configured for shared-log topic ${this.topic}, but no fanout root was provided and none could be resolved`);
+            }
+            const channel = new FanoutChannel(fanoutService, {
+                topic: this.topic,
+                root: resolvedRoot,
+            });
+            this._fanoutChannel = channel;
+            this._onFanoutDataFn =
+                this._onFanoutDataFn ||
+                    ((evt) => {
+                        const detail = evt?.detail;
+                        if (!detail) {
+                            return;
+                        }
+                        void this._onFanoutData(detail).catch((error) => logger.error(error));
+                    });
+            channel.addEventListener("data", this._onFanoutDataFn);
+            this._onFanoutUnicastFn =
+                this._onFanoutUnicastFn ||
+                    ((evt) => {
+                        const detail = evt?.detail;
+                        if (!detail) {
+                            return;
+                        }
+                        void this._onFanoutUnicast(detail).catch((error) => logger.error(error));
+                    });
+            channel.addEventListener("unicast", this._onFanoutUnicastFn);
+            try {
+                const channelOptions = this.getFanoutChannelOptions(options);
+                if (resolvedRoot === fanoutService.publicKeyHash) {
+                    await channel.openAsRoot(channelOptions);
+                    return;
+                }
+                await channel.join(channelOptions, options.join);
+            }
+            catch (error) {
+                this._closeFanoutChannel();
+                throw error;
+            }
+        }
+        _closeFanoutChannel() {
+            if (this._fanoutChannel) {
+                if (this._onFanoutDataFn) {
+                    this._fanoutChannel.removeEventListener("data", this._onFanoutDataFn);
+                }
+                if (this._onFanoutUnicastFn) {
+                    this._fanoutChannel.removeEventListener("unicast", this._onFanoutUnicastFn);
+                }
+                this._fanoutChannel.close();
+            }
+            this._fanoutChannel = undefined;
+        }
+        async _onFanoutData(detail) {
+            let envelope;
+            try {
+                envelope = deserialize(detail.payload, FanoutEnvelope);
+            }
+            catch (error) {
+                if (error instanceof BorshError) {
+                    return;
+                }
+                throw error;
+            }
+            let message;
+            try {
+                message = deserialize(envelope.payload, TransportMessage);
+            }
+            catch (error) {
+                if (error instanceof BorshError) {
+                    return;
+                }
+                throw error;
+            }
+            if (!(message instanceof ExchangeHeadsMessage)) {
+                return;
+            }
+            const from = (await this._resolvePublicKeyFromHash(envelope.from)) ??
+                { hashcode: () => envelope.from };
+            const contextMessage = new DataMessage({
+                header: new MessageHeader({
+                    session: 0,
+                    mode: new AnyWhere(),
+                    priority: 0,
+                }),
+            });
+            contextMessage.header.timestamp = envelope.timestamp;
+            await this.onMessage(message, {
+                from,
+                message: contextMessage,
+            });
+        }
+        async _onFanoutUnicast(detail) {
+            let message;
+            try {
+                message = deserialize(detail.payload, TransportMessage);
+            }
+            catch (error) {
+                if (error instanceof BorshError) {
+                    return;
+                }
+                throw error;
+            }
+            const fromHash = detail.origin || detail.from;
+            const from = (await this._resolvePublicKeyFromHash(fromHash)) ??
+                { hashcode: () => fromHash };
+            const contextMessage = new DataMessage({
+                header: new MessageHeader({
+                    session: 0,
+                    mode: new AnyWhere(),
+                    priority: 0,
+                }),
+            });
+            contextMessage.header.timestamp = detail.timestamp;
+            await this.onMessage(message, {
+                from,
+                message: contextMessage,
+            });
+        }
+        async _publishExchangeHeadsViaFanout(message) {
+            if (!this._fanoutChannel) {
+                throw new Error(`No fanout channel configured for shared-log topic ${this.topic}`);
+            }
+            const envelope = new FanoutEnvelope({
+                from: this.node.identity.publicKey.hashcode(),
+                timestamp: BigInt(Date.now()),
+                payload: serialize(message),
+            });
+            await this._fanoutChannel.publish(serialize(envelope));
+        }
+        _parseDeliveryOptions(deliveryArg) {
+            const delivery = deliveryArg === undefined || deliveryArg === false
+                ? undefined
+                : deliveryArg === true
+                    ? { reliability: "ack" }
+                    : deliveryArg;
+            if (!delivery) {
+                return {
+                    delivery: undefined,
+                    reliability: "best-effort",
+                    requireRecipients: false,
+                    minAcks: undefined,
+                    wrap: undefined,
+                };
+            }
+            const reliability = delivery.reliability ?? "ack";
+            const deliveryTimeout = delivery.timeout;
+            const deliverySignal = delivery.signal;
+            const requireRecipients = delivery.requireRecipients === true;
+            const minAcks = delivery.minAcks != null && Number.isFinite(delivery.minAcks)
+                ? Math.max(0, Math.floor(delivery.minAcks))
+                : undefined;
+            const wrap = deliveryTimeout == null && deliverySignal == null
+                ? undefined
+                : (promise) => new Promise((resolve, reject) => {
+                    let settled = false;
+                    let timer = undefined;
+                    const onAbort = () => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        promise.catch(() => { });
+                        cleanup();
+                        reject(new AbortError());
+                    };
+                    const cleanup = () => {
+                        if (timer != null) {
+                            clearTimeout(timer);
+                            timer = undefined;
+                        }
+                        deliverySignal?.removeEventListener("abort", onAbort);
+                    };
+                    if (deliverySignal) {
+                        if (deliverySignal.aborted) {
+                            onAbort();
+                            return;
+                        }
+                        deliverySignal.addEventListener("abort", onAbort);
+                    }
+                    if (deliveryTimeout != null) {
+                        timer = setTimeout(() => {
+                            if (settled) {
+                                return;
+                            }
+                            settled = true;
+                            promise.catch(() => { });
+                            cleanup();
+                            reject(new TimeoutError(`Timeout waiting for delivery`));
+                        }, deliveryTimeout);
+                    }
+                    promise
+                        .then(() => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        cleanup();
+                        resolve();
+                    })
+                        .catch((error) => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        cleanup();
+                        reject(error);
+                    });
+                });
+            return {
+                delivery,
+                reliability,
+                requireRecipients,
+                minAcks,
+                wrap,
+            };
+        }
+        async _getSortedRouteHints(targetHash) {
+            const pubsub = this.node.services.pubsub;
+            const maybeHints = await pubsub?.getUnifiedRouteHints?.(this.topic, targetHash);
+            const hints = Array.isArray(maybeHints) ? maybeHints : [];
+            const now = Date.now();
+            return hints
+                .filter((hint) => hint.expiresAt == null || hint.expiresAt > now)
+                .sort((a, b) => {
+                const rankA = a.kind === "directstream-ack" ? 0 : 1;
+                const rankB = b.kind === "directstream-ack" ? 0 : 1;
+                if (rankA !== rankB) {
+                    return rankA - rankB;
+                }
+                const costA = a.kind === "directstream-ack"
+                    ? a.distance
+                    : Math.max(0, (a.route?.length ?? 1) - 1);
+                const costB = b.kind === "directstream-ack"
+                    ? b.distance
+                    : Math.max(0, (b.route?.length ?? 1) - 1);
+                if (costA !== costB) {
+                    return costA - costB;
+                }
+                return (b.updatedAt ?? 0) - (a.updatedAt ?? 0);
+            });
+        }
+        async _sendAckWithUnifiedHints(properties) {
+            const { peer, message, payload, fanoutUnicastOptions } = properties;
+            const hints = await this._getSortedRouteHints(peer);
+            const hasDirectHint = hints.some((hint) => hint.kind === "directstream-ack");
+            const fanoutHint = hints.find((hint) => hint.kind === "fanout-token");
+            if (hasDirectHint) {
+                try {
+                    await this.rpc.send(message, {
+                        mode: new AcknowledgeDelivery({
+                            redundancy: 1,
+                            to: [peer],
+                        }),
+                    });
+                    return;
+                }
+                catch {
+                    // Fall back to fanout token/direct fanout unicast below.
+                }
+            }
+            if (fanoutHint && this._fanoutChannel) {
+                try {
+                    await this._fanoutChannel.unicastAck(fanoutHint.route, payload, fanoutUnicastOptions);
+                    return;
+                }
+                catch {
+                    // Fall back below.
+                }
+            }
+            if (this._fanoutChannel) {
+                try {
+                    await this._fanoutChannel.unicastToAck(peer, payload, fanoutUnicastOptions);
+                    return;
+                }
+                catch {
+                    // Fall back below.
+                }
+            }
+            await this.rpc.send(message, {
+                mode: new AcknowledgeDelivery({
+                    redundancy: 1,
+                    to: [peer],
+                }),
+            });
+        }
+        async _appendDeliverToReplicators(entry, minReplicasValue, leaders, selfHash, isLeader, deliveryArg) {
+            const { delivery, reliability, requireRecipients, minAcks, wrap } = this._parseDeliveryOptions(deliveryArg);
+            const pending = [];
+            const track = (promise) => {
+                pending.push(wrap ? wrap(promise) : promise);
+            };
+            const fanoutUnicastOptions = delivery?.timeout != null || delivery?.signal != null
+                ? { timeoutMs: delivery.timeout, signal: delivery.signal }
+                : undefined;
+            for await (const message of createExchangeHeadsMessages(this.log, [entry])) {
+                await this._mergeLeadersFromGidReferences(message, minReplicasValue, leaders);
+                const leadersForDelivery = delivery ? new Set(leaders.keys()) : undefined;
+                const set = this.addPeersToGidPeerHistory(entry.meta.gid, leaders.keys());
+                let hasRemotePeers = set.has(selfHash) ? set.size > 1 : set.size > 0;
+                const allowSubscriberFallback = this.syncronizer instanceof SimpleSyncronizer ||
+                    (this.compatibility ?? Number.MAX_VALUE) < 10;
+                if (!hasRemotePeers && allowSubscriberFallback) {
+                    try {
+                        const subscribers = await this._getTopicSubscribers(this.topic);
+                        if (subscribers && subscribers.length > 0) {
+                            for (const subscriber of subscribers) {
+                                const hash = subscriber.hashcode();
+                                if (hash === selfHash) {
+                                    continue;
+                                }
+                                set.add(hash);
+                                leadersForDelivery?.add(hash);
+                            }
+                            hasRemotePeers = set.has(selfHash) ? set.size > 1 : set.size > 0;
+                        }
+                    }
+                    catch {
+                        // Best-effort only; keep discovered recipients as-is.
+                    }
+                }
+                if (!hasRemotePeers) {
+                    if (requireRecipients) {
+                        throw new NoPeersError(this.rpc.topic);
+                    }
+                    continue;
+                }
+                if (!delivery) {
+                    this.rpc
+                        .send(message, {
+                        mode: isLeader
+                            ? new SilentDelivery({ redundancy: 1, to: set })
+                            : new AcknowledgeDelivery({ redundancy: 1, to: set }),
+                    })
+                        .catch((error) => logger.error(error));
+                    continue;
+                }
+                const orderedRemoteRecipients = [];
+                for (const peer of leadersForDelivery) {
+                    if (peer === selfHash) {
+                        continue;
+                    }
+                    orderedRemoteRecipients.push(peer);
+                }
+                for (const peer of set) {
+                    if (peer === selfHash) {
+                        continue;
+                    }
+                    if (leadersForDelivery.has(peer)) {
+                        continue;
+                    }
+                    orderedRemoteRecipients.push(peer);
+                }
+                const ackTo = [];
+                let silentTo;
+                // Default delivery semantics: require enough remote ACKs to reach the requested
+                // replication degree (local append counts as 1).
+                const defaultMinAcks = Math.max(0, minReplicasValue - 1);
+                const ackLimitRaw = reliability === "ack" ? (minAcks ?? defaultMinAcks) : 0;
+                const ackLimit = Math.max(0, Math.min(Math.floor(ackLimitRaw), orderedRemoteRecipients.length));
+                for (const peer of orderedRemoteRecipients) {
+                    if (ackTo.length < ackLimit) {
+                        ackTo.push(peer);
+                    }
+                    else {
+                        silentTo ||= [];
+                        silentTo.push(peer);
+                    }
+                }
+                if (requireRecipients && orderedRemoteRecipients.length === 0) {
+                    throw new NoPeersError(this.rpc.topic);
+                }
+                if (requireRecipients && ackTo.length + (silentTo?.length || 0) === 0) {
+                    throw new NoPeersError(this.rpc.topic);
+                }
+                if (ackTo.length > 0) {
+                    const payload = serialize(message);
+                    for (const peer of ackTo) {
+                        track((async () => {
+                            await this._sendAckWithUnifiedHints({
+                                peer,
+                                message,
+                                payload,
+                                fanoutUnicastOptions,
+                            });
+                        })());
+                    }
+                }
+                if (silentTo?.length) {
+                    this.rpc
+                        .send(message, {
+                        mode: new SilentDelivery({ redundancy: 1, to: silentTo }),
+                    })
+                        .catch((error) => logger.error(error));
+                }
+            }
+            if (pending.length > 0) {
+                await Promise.all(pending);
+            }
+        }
+        async _mergeLeadersFromGidReferences(message, minReplicasValue, leaders) {
+            const gidReferences = message.heads[0]?.gidRefrences;
+            if (!gidReferences || gidReferences.length === 0) {
+                return;
+            }
+            for (const gidReference of gidReferences) {
+                const entryFromGid = this.log.entryIndex.getHeads(gidReference, false);
+                for (const gidEntry of await entryFromGid.all()) {
+                    let coordinates = await this.getCoordinates(gidEntry);
+                    if (coordinates == null) {
+                        coordinates = await this.createCoordinates(gidEntry, minReplicasValue);
+                    }
+                    const found = await this._findLeaders(coordinates);
+                    for (const [key, value] of found) {
+                        leaders.set(key, value);
+                    }
+                }
+            }
+        }
+        async _appendDeliverToAllFanout(entry) {
+            for await (const message of createExchangeHeadsMessages(this.log, [entry])) {
+                await this._publishExchangeHeadsViaFanout(message);
+            }
+        }
+        async _resolvePublicKeyFromHash(hash) {
+            const fanoutService = this.node.services.fanout;
+            return (fanoutService?.getPublicKey?.(hash) ??
+                this.node.services.pubsub.getPublicKey(hash));
+        }
+        async _getTopicSubscribers(topic) {
+            const maxPeers = 64;
+            // Prefer the bounded peer set we already know from the fanout overlay.
+            if (this._fanoutChannel && (topic === this.topic || topic === this.rpc.topic)) {
+                const hashes = this._fanoutChannel
+                    .getPeerHashes({ includeSelf: false })
+                    .slice(0, maxPeers);
+                if (hashes.length === 0)
+                    return [];
+                const keys = await Promise.all(hashes.map((hash) => this._resolvePublicKeyFromHash(hash)));
+                const uniqueKeys = [];
+                const seen = new Set();
+                const selfHash = this.node.identity.publicKey.hashcode();
+                for (const key of keys) {
+                    if (!key)
+                        continue;
+                    const hash = key.hashcode();
+                    if (hash === selfHash)
+                        continue;
+                    if (seen.has(hash))
+                        continue;
+                    seen.add(hash);
+                    uniqueKeys.push(key);
+                }
+                return uniqueKeys;
+            }
+            const selfHash = this.node.identity.publicKey.hashcode();
+            const hashes = [];
+            // Best-effort provider discovery (bounded). This requires bootstrap trackers.
+            try {
+                const fanoutService = this.node.services.fanout;
+                if (fanoutService?.queryProviders) {
+                    const ns = `shared-log|${this.topic}`;
+                    const seed = hashToSeed32(topic);
+                    const providers = await fanoutService.queryProviders(ns, {
+                        want: maxPeers,
+                        seed,
+                    });
+                    for (const h of providers ?? []) {
+                        if (!h || h === selfHash)
+                            continue;
+                        hashes.push(h);
+                        if (hashes.length >= maxPeers)
+                            break;
+                    }
+                }
+            }
+            catch {
+                // Best-effort only.
+            }
+            // Next, use already-connected peer streams (bounded and cheap).
+            const peerMap = this.node.services.pubsub
+                ?.peers;
+            if (peerMap?.keys) {
+                for (const h of peerMap.keys()) {
+                    if (!h || h === selfHash)
+                        continue;
+                    hashes.push(h);
+                    if (hashes.length >= maxPeers)
+                        break;
+                }
+            }
+            // Finally, fall back to libp2p connections (e.g. bootstrap peers) without requiring
+            // any global topic membership view.
+            if (hashes.length < maxPeers) {
+                const connectionManager = this.node.services.pubsub?.components
+                    ?.connectionManager;
+                const connections = connectionManager?.getConnections?.() ?? [];
+                for (const conn of connections) {
+                    const peerId = conn?.remotePeer;
+                    if (!peerId)
+                        continue;
+                    try {
+                        const h = getPublicKeyFromPeerId(peerId).hashcode();
+                        if (!h || h === selfHash)
+                            continue;
+                        hashes.push(h);
+                        if (hashes.length >= maxPeers)
+                            break;
+                    }
+                    catch {
+                        // Best-effort only.
+                    }
+                }
+            }
+            if (hashes.length === 0)
+                return [];
+            const uniqueHashes = [];
+            const seen = new Set();
+            for (const h of hashes) {
+                if (seen.has(h))
+                    continue;
+                seen.add(h);
+                uniqueHashes.push(h);
+                if (uniqueHashes.length >= maxPeers)
+                    break;
+            }
+            const keys = await Promise.all(uniqueHashes.map((hash) => this._resolvePublicKeyFromHash(hash)));
+            const uniqueKeys = [];
+            for (const key of keys) {
+                if (!key)
+                    continue;
+                const hash = key.hashcode();
+                if (hash === selfHash)
+                    continue;
+                uniqueKeys.push(key);
+            }
+            return uniqueKeys;
+        }
         // @deprecated
         async getRole() {
             const segments = await this.getMyReplicationSegments();
@@ -586,6 +1213,7 @@ let SharedLog = (() => {
             })
                 .all();
             this.uniqueReplicators.delete(keyHash);
+            this._replicatorJoinEmitted.delete(keyHash);
             await this.replicationIndex.del({ query: { hash: keyHash } });
             await this.updateOldestTimestampFromIndex();
             const isMe = this.node.identity.publicKey.hashcode() === keyHash;
@@ -620,6 +1248,13 @@ let SharedLog = (() => {
                 }
                 this.pendingMaturity.delete(keyHash);
             }
+            // Keep local sync/prune state consistent even when a peer disappears
+            // through replication-info updates without a topic unsubscribe event.
+            this.removePeerFromGidPeerHistory(keyHash);
+            this._recentRepairDispatch.delete(keyHash);
+            if (!isMe) {
+                this.syncronizer.onPeerDisconnected(keyHash);
+            }
             if (!isMe) {
                 this.rebalanceParticipationDebounced?.call();
             }
@@ -668,6 +1303,7 @@ let SharedLog = (() => {
             const otherSegmentsIterator = this.replicationIndex.iterate({ query: { hash: from.hashcode() } }, { shape: { id: true } });
             if ((await otherSegmentsIterator.next(1)).length === 0) {
                 this.uniqueReplicators.delete(from.hashcode());
+                this._replicatorJoinEmitted.delete(from.hashcode());
             }
             await otherSegmentsIterator.close();
             await this.updateOldestTimestampFromIndex();
@@ -687,6 +1323,7 @@ let SharedLog = (() => {
             rebalance = rebalance == null ? true : rebalance;
             let diffs;
             let deleted = undefined;
+            let isStoppedReplicating = false;
             if (reset) {
                 deleted = (await this.replicationIndex
                     .iterate({
@@ -718,6 +1355,7 @@ let SharedLog = (() => {
                     ];
                 }
                 isNewReplicator = prevCount === 0 && ranges.length > 0;
+                isStoppedReplicating = prevCount > 0 && ranges.length === 0;
             }
             else {
                 let batchSize = 100;
@@ -791,7 +1429,16 @@ let SharedLog = (() => {
                     .flat();
                 diffs = changes;
             }
-            this.uniqueReplicators.add(from.hashcode());
+            const fromHash = from.hashcode();
+            // Track replicator membership transitions synchronously so join/leave events are
+            // idempotent even if we process concurrent reset messages/unsubscribes.
+            const stoppedTransition = ranges.length === 0 ? this.uniqueReplicators.delete(fromHash) : false;
+            if (ranges.length === 0) {
+                this._replicatorJoinEmitted.delete(fromHash);
+            }
+            else {
+                this.uniqueReplicators.add(fromHash);
+            }
             let now = +new Date();
             let minRoleAge = await this.getDefaultMinRoleAge();
             let isAllMature = true;
@@ -867,15 +1514,23 @@ let SharedLog = (() => {
                     detail: { publicKey: from },
                 }));
                 if (isNewReplicator) {
-                    this.events.dispatchEvent(new CustomEvent("replicator:join", {
-                        detail: { publicKey: from },
-                    }));
+                    if (!this._replicatorJoinEmitted.has(fromHash)) {
+                        this._replicatorJoinEmitted.add(fromHash);
+                        this.events.dispatchEvent(new CustomEvent("replicator:join", {
+                            detail: { publicKey: from },
+                        }));
+                    }
                     if (isAllMature) {
                         this.events.dispatchEvent(new CustomEvent("replicator:mature", {
                             detail: { publicKey: from },
                         }));
                     }
                 }
+                if (isStoppedReplicating && stoppedTransition) {
+                    this.events.dispatchEvent(new CustomEvent("replicator:leave", {
+                        detail: { publicKey: from },
+                    }));
+                }
                 if (rebalance) {
                     for (const diff of diffs) {
                         this.replicationChangeDebounceFn.add(diff);
@@ -895,6 +1550,20 @@ let SharedLog = (() => {
             if (change) {
                 let addedOrReplaced = change.filter((x) => x.type !== "removed");
                 if (addedOrReplaced.length > 0) {
+                    // Provider discovery keep-alive (best-effort). This enables bounded targeted fetches
+                    // without relying on any global subscriber list.
+                    try {
+                        const fanoutService = this.node.services.fanout;
+                        if (fanoutService?.provide && !this._providerHandle) {
+                            this._providerHandle = fanoutService.provide(`shared-log|${this.topic}`, {
+                                ttlMs: 120_000,
+                                announceIntervalMs: 60_000,
+                            });
+                        }
+                    }
+                    catch {
+                        // Best-effort only.
+                    }
                     let message = undefined;
                     if (options.reset) {
                         message = new AllReplicatingSegmentsMessage({
@@ -949,11 +1618,255 @@ let SharedLog = (() => {
             }
             return set;
         }
+        dispatchMaybeMissingEntries(target, entries, options) {
+            if (entries.size === 0) {
+                return;
+            }
+            const now = Date.now();
+            let recentlyDispatchedByHash = this._recentRepairDispatch.get(target);
+            if (!recentlyDispatchedByHash) {
+                recentlyDispatchedByHash = new Map();
+                this._recentRepairDispatch.set(target, recentlyDispatchedByHash);
+            }
+            for (const [hash, ts] of recentlyDispatchedByHash) {
+                if (now - ts > RECENT_REPAIR_DISPATCH_TTL_MS) {
+                    recentlyDispatchedByHash.delete(hash);
+                }
+            }
+            const filteredEntries = options?.bypassRecentDedupe === true
+                ? new Map(entries)
+                : new Map();
+            if (options?.bypassRecentDedupe !== true) {
+                for (const [hash, entry] of entries) {
+                    const prev = recentlyDispatchedByHash.get(hash);
+                    if (prev != null && now - prev <= RECENT_REPAIR_DISPATCH_TTL_MS) {
+                        continue;
+                    }
+                    recentlyDispatchedByHash.set(hash, now);
+                    filteredEntries.set(hash, entry);
+                }
+            }
+            else {
+                for (const hash of entries.keys()) {
+                    recentlyDispatchedByHash.set(hash, now);
+                }
+            }
+            if (filteredEntries.size === 0) {
+                return;
+            }
+            const run = () => {
+                // For force-fresh churn repair we intentionally bypass rateless IBLT and
+                // use simple hash-based sync. This path is a directed "push these hashes
+                // to that peer" recovery flow; using simple sync here avoids occasional
+                // single-hash gaps seen with IBLT-oriented maybe-sync batches under churn.
+                if (options?.forceFreshDelivery &&
+                    this.syncronizer instanceof RatelessIBLTSynchronizer) {
+                    return Promise.resolve(this.syncronizer.simple.onMaybeMissingEntries({
+                        entries: filteredEntries,
+                        targets: [target],
+                    })).catch((error) => logger.error(error));
+                }
+                return Promise.resolve(this.syncronizer.onMaybeMissingEntries({
+                    entries: filteredEntries,
+                    targets: [target],
+                })).catch((error) => logger.error(error));
+            };
+            const retrySchedule = options?.retryScheduleMs && options.retryScheduleMs.length > 0
+                ? options.retryScheduleMs
+                : options?.forceFreshDelivery
+                    ? FORCE_FRESH_RETRY_SCHEDULE_MS
+                    : [0];
+            for (const delayMs of retrySchedule) {
+                if (delayMs === 0) {
+                    void run();
+                    continue;
+                }
+                const timer = setTimeout(() => {
+                    this._repairRetryTimers.delete(timer);
+                    if (this.closed) {
+                        return;
+                    }
+                    void run();
+                }, delayMs);
+                timer.unref?.();
+                this._repairRetryTimers.add(timer);
+            }
+        }
+        scheduleRepairSweep(options) {
+            if (options.forceFreshDelivery) {
+                this._repairSweepForceFreshPending = true;
+            }
+            for (const peer of options.addedPeers) {
+                this._repairSweepAddedPeersPending.add(peer);
+            }
+            if (!this._repairSweepRunning && !this.closed) {
+                this._repairSweepRunning = true;
+                void this.runRepairSweep();
+            }
+        }
+        async runRepairSweep() {
+            try {
+                while (!this.closed) {
+                    const forceFreshDelivery = this._repairSweepForceFreshPending;
+                    const addedPeers = new Set(this._repairSweepAddedPeersPending);
+                    this._repairSweepForceFreshPending = false;
+                    this._repairSweepAddedPeersPending.clear();
+                    if (!forceFreshDelivery && addedPeers.size === 0) {
+                        return;
+                    }
+                    const pendingByTarget = new Map();
+                    const flushTarget = (target) => {
+                        const entries = pendingByTarget.get(target);
+                        if (!entries || entries.size === 0) {
+                            return;
+                        }
+                        const isJoinWarmupTarget = addedPeers.has(target);
+                        const bypassRecentDedupe = isJoinWarmupTarget || forceFreshDelivery;
+                        this.dispatchMaybeMissingEntries(target, entries, {
+                            bypassRecentDedupe,
+                            retryScheduleMs: isJoinWarmupTarget
+                                ? JOIN_WARMUP_RETRY_SCHEDULE_MS
+                                : undefined,
+                            forceFreshDelivery,
+                        });
+                        pendingByTarget.delete(target);
+                    };
+                    const queueEntryForTarget = (target, entry) => {
+                        let set = pendingByTarget.get(target);
+                        if (!set) {
+                            set = new Map();
+                            pendingByTarget.set(target, set);
+                        }
+                        if (set.has(entry.hash)) {
+                            return;
+                        }
+                        set.set(entry.hash, entry);
+                        if (set.size >= this.repairSweepTargetBufferSize) {
+                            flushTarget(target);
+                        }
+                    };
+                    const iterator = this.entryCoordinatesIndex.iterate({});
+                    try {
+                        while (!this.closed && !iterator.done()) {
+                            const entries = await iterator.next(REPAIR_SWEEP_ENTRY_BATCH_SIZE);
+                            for (const entry of entries) {
+                                const entryReplicated = entry.value;
+                                const currentPeers = await this.findLeaders(entryReplicated.coordinates, entryReplicated, { roleAge: 0 });
+                                if (forceFreshDelivery) {
+                                    for (const [currentPeer] of currentPeers) {
+                                        if (currentPeer === this.node.identity.publicKey.hashcode()) {
+                                            continue;
+                                        }
+                                        queueEntryForTarget(currentPeer, entryReplicated);
+                                    }
+                                }
+                                if (addedPeers.size > 0) {
+                                    for (const peer of addedPeers) {
+                                        if (currentPeers.has(peer)) {
+                                            queueEntryForTarget(peer, entryReplicated);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    finally {
+                        await iterator.close();
+                    }
+                    for (const target of [...pendingByTarget.keys()]) {
+                        flushTarget(target);
+                    }
+                }
+            }
+            catch (error) {
+                if (!isNotStartedError(error)) {
+                    logger.error(`Repair sweep failed: ${error?.message ?? error}`);
+                }
+            }
+            finally {
+                this._repairSweepRunning = false;
+                if (!this.closed &&
+                    (this._repairSweepForceFreshPending ||
+                        this._repairSweepAddedPeersPending.size > 0)) {
+                    this._repairSweepRunning = true;
+                    void this.runRepairSweep();
+                }
+            }
+        }
         async pruneDebouncedFnAddIfNotKeeping(args) {
             if (!this.keep || !(await this.keep(args.value.entry))) {
                 return this.pruneDebouncedFn.add(args);
             }
         }
+        clearCheckedPruneRetry(hash) {
+            const state = this._checkedPruneRetries.get(hash);
+            if (state?.timer) {
+                clearTimeout(state.timer);
+            }
+            this._checkedPruneRetries.delete(hash);
+        }
+        scheduleCheckedPruneRetry(args) {
+            if (this.closed)
+                return;
+            if (this._pendingDeletes.has(args.entry.hash))
+                return;
+            const hash = args.entry.hash;
+            const state = this._checkedPruneRetries.get(hash) ?? { attempts: 0 };
+            if (state.timer)
+                return;
+            if (state.attempts >= CHECKED_PRUNE_RETRY_MAX_ATTEMPTS) {
+                // Avoid unbounded background retries; a new replication-change event can
+                // always re-enqueue pruning with fresh leader info.
+                return;
+            }
+            const attempt = state.attempts + 1;
+            const jitterMs = Math.floor(Math.random() * 250);
+            const delayMs = Math.min(CHECKED_PRUNE_RETRY_MAX_DELAY_MS, 1_000 * 2 ** (attempt - 1) + jitterMs);
+            state.attempts = attempt;
+            state.timer = setTimeout(async () => {
+                const st = this._checkedPruneRetries.get(hash);
+                if (st)
+                    st.timer = undefined;
+                if (this.closed)
+                    return;
+                if (this._pendingDeletes.has(hash))
+                    return;
+                let leadersMap;
+                try {
+                    const replicas = decodeReplicas(args.entry).getValue(this);
+                    leadersMap = await this.findLeadersFromEntry(args.entry, replicas, {
+                        roleAge: 0,
+                    });
+                }
+                catch {
+                    // Best-effort only.
+                }
+                if (!leadersMap || leadersMap.size === 0) {
+                    if (args.leaders instanceof Map) {
+                        leadersMap = args.leaders;
+                    }
+                    else {
+                        leadersMap = new Map();
+                        for (const k of args.leaders) {
+                            leadersMap.set(k, { intersecting: true });
+                        }
+                    }
+                }
+                try {
+                    const leadersForRetry = leadersMap ?? new Map();
+                    await this.pruneDebouncedFnAddIfNotKeeping({
+                        key: hash,
+                        // TODO types
+                        value: { entry: args.entry, leaders: leadersForRetry },
+                    });
+                }
+                catch {
+                    // Best-effort only; pruning will be re-attempted on future changes.
+                }
+            }, delayMs);
+            state.timer.unref?.();
+            this._checkedPruneRetries.set(hash, state);
+        }
         async append(data, options) {
             const appendOptions = { ...options };
             const minReplicas = this.getClampedReplicas(options?.replicas
@@ -1002,239 +1915,18 @@ let SharedLog = (() => {
             if (options?.target !== "none") {
                 const target = options?.target;
                 const deliveryArg = options?.delivery;
-                const delivery = deliveryArg === undefined || deliveryArg === false
-                    ? undefined
-                    : deliveryArg === true
-                        ? {}
-                        : deliveryArg;
-                let requireRecipients = false;
-                let settleMin;
-                let guardDelivery = undefined;
-                let firstDeliveryPromise;
-                let deliveryPromises;
-                let addDeliveryPromise;
-                const leadersForDelivery = delivery && (target === "replicators" || !target)
-                    ? new Set(leaders.keys())
-                    : undefined;
-                if (delivery) {
-                    const deliverySettle = delivery.settle ?? true;
-                    const deliveryTimeout = delivery.timeout;
-                    const deliverySignal = delivery.signal;
-                    requireRecipients = delivery.requireRecipients === true;
-                    settleMin =
-                        typeof deliverySettle === "object" &&
-                            Number.isFinite(deliverySettle.min)
-                            ? Math.max(0, Math.floor(deliverySettle.min))
-                            : undefined;
-                    guardDelivery =
-                        deliveryTimeout == null && deliverySignal == null
-                            ? undefined
-                            : (promise) => new Promise((resolve, reject) => {
-                                let settled = false;
-                                let timer = undefined;
-                                const onAbort = () => {
-                                    if (settled) {
-                                        return;
-                                    }
-                                    settled = true;
-                                    promise.catch(() => { });
-                                    cleanup();
-                                    reject(new AbortError());
-                                };
-                                const cleanup = () => {
-                                    if (timer != null) {
-                                        clearTimeout(timer);
-                                        timer = undefined;
-                                    }
-                                    deliverySignal?.removeEventListener("abort", onAbort);
-                                };
-                                if (deliverySignal) {
-                                    if (deliverySignal.aborted) {
-                                        onAbort();
-                                        return;
-                                    }
-                                    deliverySignal.addEventListener("abort", onAbort);
-                                }
-                                if (deliveryTimeout != null) {
-                                    timer = setTimeout(() => {
-                                        if (settled) {
-                                            return;
-                                        }
-                                        settled = true;
-                                        promise.catch(() => { });
-                                        cleanup();
-                                        reject(new TimeoutError(`Timeout waiting for delivery`));
-                                    }, deliveryTimeout);
-                                }
-                                promise
-                                    .then(() => {
-                                    if (settled) {
-                                        return;
-                                    }
-                                    settled = true;
-                                    cleanup();
-                                    resolve();
-                                })
-                                    .catch((e) => {
-                                    if (settled) {
-                                        return;
-                                    }
-                                    settled = true;
-                                    cleanup();
-                                    reject(e);
-                                });
-                            });
-                    addDeliveryPromise = (promise) => {
-                        if (!firstDeliveryPromise) {
-                            firstDeliveryPromise = promise;
-                            return;
-                        }
-                        if (!deliveryPromises) {
-                            deliveryPromises = [firstDeliveryPromise, promise];
-                            firstDeliveryPromise = undefined;
-                            return;
-                        }
-                        deliveryPromises.push(promise);
-                    };
+                const hasDelivery = !(deliveryArg === undefined || deliveryArg === false);
+                if (target === "all" && hasDelivery) {
+                    throw new Error(`delivery options are not supported with target="all"; fanout broadcast is fire-and-forward`);
                 }
-                for await (const message of createExchangeHeadsMessages(this.log, [
-                    result.entry,
-                ])) {
-                    if (target === "replicators" || !target) {
-                        if (message.heads[0].gidRefrences.length > 0) {
-                            for (const ref of message.heads[0].gidRefrences) {
-                                const entryFromGid = this.log.entryIndex.getHeads(ref, false);
-                                for (const entry of await entryFromGid.all()) {
-                                    let coordinates = await this.getCoordinates(entry);
-                                    if (coordinates == null) {
-                                        coordinates = await this.createCoordinates(entry, minReplicasValue);
-                                        // TODO are we every to come here?
-                                    }
-                                    const result = await this._findLeaders(coordinates);
-                                    for (const [k, v] of result) {
-                                        leaders.set(k, v);
-                                    }
-                                }
-                            }
-                        }
-                        const set = this.addPeersToGidPeerHistory(result.entry.meta.gid, leaders.keys());
-                        let hasRemotePeers = set.has(selfHash) ? set.size > 1 : set.size > 0;
-                        if (!hasRemotePeers) {
-                            if (requireRecipients) {
-                                throw new NoPeersError(this.rpc.topic);
-                            }
-                            continue;
-                        }
-                        if (!delivery) {
-                            this.rpc
-                                .send(message, {
-                                mode: isLeader
-                                    ? new SilentDelivery({ redundancy: 1, to: set })
-                                    : new AcknowledgeDelivery({ redundancy: 1, to: set }),
-                            })
-                                .catch((e) => logger.error(e));
-                            continue;
-                        }
-                        let expectedRemoteRecipientsCount = 0;
-                        const ackTo = [];
-                        let silentTo;
-                        const ackLimit = settleMin == null ? Number.POSITIVE_INFINITY : settleMin;
-                        // Always settle towards the current expected replicators for this entry,
-                        // not the entire gid peer history.
-                        for (const peer of leadersForDelivery) {
-                            if (peer === selfHash) {
-                                continue;
-                            }
-                            expectedRemoteRecipientsCount++;
-                            if (ackTo.length < ackLimit) {
-                                ackTo.push(peer);
-                            }
-                            else {
-                                silentTo ||= [];
-                                silentTo.push(peer);
-                            }
-                        }
-                        // Still deliver to known peers for the gid (best-effort), but don't let them
-                        // satisfy the settle requirement.
-                        for (const peer of set) {
-                            if (peer === selfHash) {
-                                continue;
-                            }
-                            if (leadersForDelivery.has(peer)) {
-                                continue;
-                            }
-                            silentTo ||= [];
-                            silentTo.push(peer);
-                        }
-                        if (requireRecipients && expectedRemoteRecipientsCount === 0) {
-                            throw new NoPeersError(this.rpc.topic);
-                        }
-                        if (requireRecipients &&
-                            ackTo.length + (silentTo?.length || 0) === 0) {
-                            throw new NoPeersError(this.rpc.topic);
-                        }
-                        if (ackTo.length > 0) {
-                            const promise = this.rpc.send(message, {
-                                mode: new AcknowledgeDelivery({
-                                    redundancy: 1,
-                                    to: ackTo,
-                                }),
-                            });
-                            addDeliveryPromise(guardDelivery ? guardDelivery(promise) : promise);
-                        }
-                        if (silentTo?.length) {
-                            this.rpc
-                                .send(message, {
-                                mode: new SilentDelivery({ redundancy: 1, to: silentTo }),
-                            })
-                                .catch((e) => logger.error(e));
-                        }
-                    }
-                    else {
-                        if (!delivery) {
-                            this.rpc.send(message).catch((e) => logger.error(e));
-                            continue;
-                        }
-                        const subscribers = await this.node.services.pubsub.getSubscribers(this.rpc.topic);
-                        const ackTo = [];
-                        let silentTo;
-                        const ackLimit = settleMin == null ? Number.POSITIVE_INFINITY : settleMin;
-                        for (const subscriber of subscribers || []) {
-                            if (subscriber.hashcode() === selfHash) {
-                                continue;
-                            }
-                            if (ackTo.length < ackLimit) {
-                                ackTo.push(subscriber);
-                            }
-                            else {
-                                silentTo ||= [];
-                                silentTo.push(subscriber);
-                            }
-                        }
-                        if (requireRecipients &&
-                            ackTo.length + (silentTo?.length || 0) === 0) {
-                            throw new NoPeersError(this.rpc.topic);
-                        }
-                        if (ackTo.length > 0) {
-                            const promise = this.rpc.send(message, {
-                                mode: new AcknowledgeDelivery({ redundancy: 1, to: ackTo }),
-                            });
-                            addDeliveryPromise(guardDelivery ? guardDelivery(promise) : promise);
-                        }
-                        if (silentTo?.length) {
-                            this.rpc
-                                .send(message, {
-                                mode: new SilentDelivery({ redundancy: 1, to: silentTo }),
-                            })
-                                .catch((e) => logger.error(e));
-                        }
-                    }
+                if (target === "all" && !this._fanoutChannel) {
+                    throw new Error(`No fanout channel configured for shared-log topic ${this.topic}`);
                 }
-                if (deliveryPromises) {
-                    await Promise.all(deliveryPromises);
+                if (target === "all") {
+                    await this._appendDeliverToAllFanout(result.entry);
                 }
-                else if (firstDeliveryPromise) {
-                    await firstDeliveryPromise;
+                else {
+                    await this._appendDeliverToReplicators(result.entry, minReplicasValue, leaders, selfHash, isLeader, deliveryArg);
                 }
             }
             if (!isLeader) {
@@ -1269,14 +1961,24 @@ let SharedLog = (() => {
             this._pendingDeletes = new Map();
             this._pendingIHave = new Map();
             this.latestReplicationInfoMessage = new Map();
+            this._replicationInfoBlockedPeers = new Set();
+            this._replicationInfoRequestByPeer = new Map();
+            this._replicationInfoApplyQueueByPeer = new Map();
+            this._repairRetryTimers = new Set();
+            this._recentRepairDispatch = new Map();
+            this._repairSweepRunning = false;
+            this._repairSweepForceFreshPending = false;
+            this._repairSweepAddedPeersPending = new Set();
             this.coordinateToHash = new Cache({ max: 1e6, ttl: 1e4 });
             this.recentlyRebalanced = new Cache({ max: 1e4, ttl: 1e5 });
             this.uniqueReplicators = new Set();
+            this._replicatorJoinEmitted = new Set();
             this._replicatorsReconciled = false;
             this.openTime = +new Date();
             this.oldestOpenTime = this.openTime;
             this.distributionDebounceTime =
                 options?.distributionDebounceTime || DEFAULT_DISTRIBUTION_DEBOUNCE_TIME; // expect > 0
+            this.repairSweepTargetBufferSize = toPositiveInteger(options?.sync?.repairSweepTargetBufferSize, REPAIR_SWEEP_TARGET_BUFFER_SIZE, "sync.repairSweepTargetBufferSize");
             this.timeUntilRoleMaturity =
                 options?.timeUntilRoleMaturity ?? WAIT_FOR_ROLE_MATURITY;
             this.waitForReplicatorTimeout =
@@ -1298,18 +2000,70 @@ let SharedLog = (() => {
                 throw new Error("waitForReplicatorRequestMaxAttempts must be a positive number");
             }
             this._closeController = new AbortController();
+            this._closeController.signal.addEventListener("abort", () => {
+                for (const [_peer, state] of this._replicationInfoRequestByPeer) {
+                    if (state.timer)
+                        clearTimeout(state.timer);
+                }
+                this._replicationInfoRequestByPeer.clear();
+            });
             this._isTrustedReplicator = options?.canReplicate;
             this.keep = options?.keep;
             this.pendingMaturity = new Map();
             const id = sha256Base64Sync(this.log.id);
             const storage = await this.node.storage.sublevel(id);
             const localBlocks = await new AnyBlockStore(await storage.sublevel("blocks"));
+            const fanoutService = this.node.services.fanout;
+            const blockProviderNamespace = (cid) => `cid:${cid}`;
             this.remoteBlocks = new RemoteBlocks({
                 local: localBlocks,
-                publish: (message, options) => this.rpc.send(new BlocksMessage(message), options.mode instanceof AnyWhere ? undefined : options),
+                publish: (message, options) => this.rpc.send(new BlocksMessage(message), options),
                 waitFor: this.rpc.waitFor.bind(this.rpc),
                 publicKey: this.node.identity.publicKey,
                 eagerBlocks: options?.eagerBlocks ?? true,
+                resolveProviders: async (cid, opts) => {
+                    // 1) tracker-backed provider directory (best-effort, bounded)
+                    try {
+                        const providers = await fanoutService?.queryProviders(blockProviderNamespace(cid), {
+                            want: 8,
+                            timeoutMs: 2_000,
+                            queryTimeoutMs: 500,
+                            bootstrapMaxPeers: 2,
+                            signal: opts?.signal,
+                        });
+                        if (providers && providers.length > 0)
+                            return providers;
+                    }
+                    catch {
+                        // ignore discovery failures
+                    }
+                    // 2) fallback to currently connected RPC peers
+                    const self = this.node.identity.publicKey.hashcode();
+                    const out = [];
+                    const peers = this.rpc?.peers;
+                    for (const h of peers?.keys?.() ?? []) {
+                        if (h === self)
+                            continue;
+                        if (out.includes(h))
+                            continue;
+                        out.push(h);
+                        if (out.length >= 32)
+                            break;
+                    }
+                    return out;
+                },
+                onPut: async (cid) => {
+                    // Best-effort directory announce for "get without remote.from" workflows.
+                    try {
+                        await fanoutService?.announceProvider(blockProviderNamespace(cid), {
+                            ttlMs: 120_000,
+                            bootstrapMaxPeers: 2,
+                        });
+                    }
+                    catch {
+                        // ignore announce failures
+                    }
+                },
             });
             await this.remoteBlocks.start();
             const logScope = await this.node.indexer.scope(id);
@@ -1332,6 +2086,7 @@ let SharedLog = (() => {
             this._gidPeersHistory = new Map();
             this._requestIPruneSent = new Map();
             this._requestIPruneResponseReplicatorSet = new Map();
+            this._checkedPruneRetries = new Map();
             this.replicationChangeDebounceFn = debounceAggregationChanges((change) => this.onReplicationChange(change).then(() => this.rebalanceParticipationDebounced?.call()), this.distributionDebounceTime);
             this.pruneDebouncedFn = debouncedAccumulatorMap((map) => {
                 this.prune(map);
@@ -1389,6 +2144,83 @@ let SharedLog = (() => {
             }, PRUNE_DEBOUNCE_INTERVAL);
             await this.log.open(this.remoteBlocks, this.node.identity, {
                 keychain: this.node.services.keychain,
+                resolveRemotePeers: async (hash, options) => {
+                    if (options?.signal?.aborted)
+                        return undefined;
+                    const maxPeers = 8;
+                    const self = this.node.identity.publicKey.hashcode();
+                    const seed = hashToSeed32(hash);
+                    // Best hint: peers that have recently confirmed having this entry hash.
+                    const hinted = this._requestIPruneResponseReplicatorSet.get(hash);
+                    if (hinted && hinted.size > 0) {
+                        const peers = [...hinted].filter((p) => p !== self);
+                        return peers.length > 0
+                            ? pickDeterministicSubset(peers, seed, maxPeers)
+                            : undefined;
+                    }
+                    // Next: peers we already contacted about this hash (may still have it).
+                    const contacted = this._requestIPruneSent.get(hash);
+                    if (contacted && contacted.size > 0) {
+                        const peers = [...contacted].filter((p) => p !== self);
+                        return peers.length > 0
+                            ? pickDeterministicSubset(peers, seed, maxPeers)
+                            : undefined;
+                    }
+                    let candidates;
+                    // Prefer the replicator cache; fall back to subscribers if we have no other signal.
+                    const replicatorCandidates = [...this.uniqueReplicators].filter((p) => p !== self);
+                    if (replicatorCandidates.length > 0) {
+                        candidates = replicatorCandidates;
+                    }
+                    else {
+                        try {
+                            const subscribers = await this._getTopicSubscribers(this.topic);
+                            const subscriberCandidates = subscribers?.map((k) => k.hashcode()).filter((p) => p !== self) ??
+                                [];
+                            candidates =
+                                subscriberCandidates.length > 0 ? subscriberCandidates : undefined;
+                        }
+                        catch {
+                            // Best-effort only.
+                        }
+                        if (!candidates || candidates.length === 0) {
+                            // Last resort: peers we are already directly connected to. This avoids
+                            // depending on global membership knowledge in early-join scenarios.
+                            const peerMap = this.node.services.pubsub?.peers;
+                            if (peerMap?.keys) {
+                                candidates = [...peerMap.keys()];
+                            }
+                        }
+                        if (!candidates || candidates.length === 0) {
+                            // Even if the pubsub stream has no established peer streams yet, we may
+                            // still have a libp2p connection to one or more peers (e.g. bootstrap).
+                            const connectionManager = this.node.services.pubsub?.components
+                                ?.connectionManager;
+                            const connections = connectionManager?.getConnections?.() ?? [];
+                            const connectionHashes = [];
+                            for (const conn of connections) {
+                                const peerId = conn?.remotePeer;
+                                if (!peerId)
+                                    continue;
+                                try {
+                                    connectionHashes.push(getPublicKeyFromPeerId(peerId).hashcode());
+                                }
+                                catch {
+                                    // Best-effort only.
+                                }
+                            }
+                            if (connectionHashes.length > 0) {
+                                candidates = connectionHashes;
+                            }
+                        }
+                    }
+                    if (!candidates || candidates.length === 0)
+                        return undefined;
+                    const peers = candidates.filter((p) => p !== self);
+                    if (peers.length === 0)
+                        return undefined;
+                    return pickDeterministicSubset(peers, seed, maxPeers);
+                },
                 ...this._logProperties,
                 onChange: async (change) => {
                     await this.onChange(change);
@@ -1456,6 +2288,7 @@ let SharedLog = (() => {
                 this._onUnsubscriptionFn || this._onUnsubscription.bind(this);
             await this.node.services.pubsub.addEventListener("unsubscribe", this._onUnsubscriptionFn);
             await this.rpc.subscribe();
+            await this._openFanoutChannel(options?.fanout);
             // mark all our replicaiton ranges as "new", this would allow other peers to understand that we recently reopend our database and might need some sync and warmup
             await this.updateTimestampOfOwnedReplicationRanges(); // TODO do we need to do this before subscribing?
             // if we had a previous session with replication info, and new replication info dictates that we unreplicate
@@ -1518,7 +2351,7 @@ let SharedLog = (() => {
             });
             await this.rebalanceParticipation();
             // Take into account existing subscription
-            (await this.node.services.pubsub.getSubscribers(this.topic))?.forEach((v, k) => {
+            (await this._getTopicSubscribers(this.topic))?.forEach((v) => {
                 if (v.equals(this.node.identity.publicKey)) {
                     return;
                 }
@@ -1551,18 +2384,22 @@ let SharedLog = (() => {
                         })
                             .then(async () => {
                             // is reachable, announce change events
-                            const key = await this.node.services.pubsub.getPublicKey(segment.value.hash);
+                            const key = await this._resolvePublicKeyFromHash(segment.value.hash);
                             if (!key) {
                                 throw new Error("Failed to resolve public key from hash: " +
                                     segment.value.hash);
                             }
-                            this.uniqueReplicators.add(key.hashcode());
-                            this.events.dispatchEvent(new CustomEvent("replicator:join", {
-                                detail: { publicKey: key },
-                            }));
-                            this.events.dispatchEvent(new CustomEvent("replication:change", {
-                                detail: { publicKey: key },
-                            }));
+                            const keyHash = key.hashcode();
+                            this.uniqueReplicators.add(keyHash);
+                            if (!this._replicatorJoinEmitted.has(keyHash)) {
+                                this._replicatorJoinEmitted.add(keyHash);
+                                this.events.dispatchEvent(new CustomEvent("replicator:join", {
+                                    detail: { publicKey: key },
+                                }));
+                                this.events.dispatchEvent(new CustomEvent("replication:change", {
+                                    detail: { publicKey: key },
+                                }));
+                            }
                         })
                             .catch(async (e) => {
                             if (isNotStartedError(e)) {
@@ -1672,26 +2509,33 @@ let SharedLog = (() => {
                 for (const [key, _] of this.syncronizer.syncInFlight) {
                     set.add(key);
                 }
+                const selfHash = this.node.identity.publicKey.hashcode();
                 if (options?.reachableOnly) {
-                    // Prefer the live pubsub subscriber set when filtering reachability.
-                    // `uniqueReplicators` is primarily driven by replication messages and can lag during
-                    // joins/restarts; using subscribers prevents excluding peers that are reachable but
-                    // whose replication ranges were loaded from disk or haven't been processed yet.
-                    const subscribers = (await this.node.services.pubsub.getSubscribers(this.topic)) ??
-                        undefined;
+                    const directPeers = this.node.services
+                        .pubsub?.peers;
+                    // Prefer the live pubsub subscriber set when filtering reachability. In some
+                    // flows peers can be reachable/active even before (or without) subscriber
+                    // state converging, so also consider direct pubsub peers.
+                    const subscribers = (await this._getTopicSubscribers(this.topic)) ?? undefined;
                     const subscriberHashcodes = subscribers
                         ? new Set(subscribers.map((key) => key.hashcode()))
                         : undefined;
+                    // If reachability is requested but we have no basis for filtering yet
+                    // (subscriber snapshot hasn't converged), return the full cover set.
+                    // Otherwise, only keep peers we can currently reach.
+                    const canFilter = directPeers != null ||
+                        (subscriberHashcodes && subscriberHashcodes.size > 0);
+                    if (!canFilter) {
+                        return [...set];
+                    }
                     const reachable = [];
-                    const selfHash = this.node.identity.publicKey.hashcode();
                     for (const peer of set) {
                         if (peer === selfHash) {
                             reachable.push(peer);
                             continue;
                         }
-                        if (subscriberHashcodes
-                            ? subscriberHashcodes.has(peer)
-                            : this.uniqueReplicators.has(peer)) {
+                        if ((subscriberHashcodes && subscriberHashcodes.has(peer)) ||
+                            (directPeers && directPeers.has(peer))) {
                             reachable.push(peer);
                         }
                     }
@@ -1716,6 +2560,14 @@ let SharedLog = (() => {
             }
             this.pendingMaturity.clear();
             this.distributeQueue?.clear();
+            this._closeFanoutChannel();
+            try {
+                this._providerHandle?.close();
+            }
+            catch {
+                // ignore
+            }
+            this._providerHandle = undefined;
             this.coordinateToHash.clear();
             this.recentlyRebalanced.clear();
             this.uniqueReplicators.clear();
@@ -1723,6 +2575,14 @@ let SharedLog = (() => {
             clearInterval(this.interval);
             this.node.services.pubsub.removeEventListener("subscribe", this._onSubscriptionFn);
             this.node.services.pubsub.removeEventListener("unsubscribe", this._onUnsubscriptionFn);
+            for (const timer of this._repairRetryTimers) {
+                clearTimeout(timer);
+            }
+            this._repairRetryTimers.clear();
+            this._recentRepairDispatch.clear();
+            this._repairSweepRunning = false;
+            this._repairSweepForceFreshPending = false;
+            this._repairSweepAddedPeersPending.clear();
             for (const [_k, v] of this._pendingDeletes) {
                 v.clear();
                 v.promise.resolve(); // TODO or reject?
@@ -1730,13 +2590,24 @@ let SharedLog = (() => {
             for (const [_k, v] of this._pendingIHave) {
                 v.clear();
             }
+            for (const [_k, v] of this._checkedPruneRetries) {
+                if (v.timer)
+                    clearTimeout(v.timer);
+            }
             await this.remoteBlocks.stop();
             this._pendingDeletes.clear();
             this._pendingIHave.clear();
+            this._checkedPruneRetries.clear();
             this.latestReplicationInfoMessage.clear();
             this._gidPeersHistory.clear();
             this._requestIPruneSent.clear();
             this._requestIPruneResponseReplicatorSet.clear();
+            // Cancel any pending debounced timers so they can't fire after we've torn down
+            // indexes/RPC state.
+            this.rebalanceParticipationDebounced?.close();
+            this.replicationChangeDebounceFn?.close?.();
+            this.pruneDebouncedFn?.close?.();
+            this.responseToPruneDebouncedFn?.close?.();
             this.pruneDebouncedFn = undefined;
             this.rebalanceParticipationDebounced = undefined;
             this._replicationRangeIndex.stop();
@@ -1747,6 +2618,53 @@ let SharedLog = (() => {
             /* this._totalParticipation = 0; */
         }
         async close(from) {
+            // Best-effort: announce that we are going offline before tearing down
+            // RPC/subscription state.
+            //
+            // Important: do not delete our local replication ranges here. Keeping them
+            // allows `replicate: { type: "resume" }` to restore the previous role on
+            // restart. Explicit `unreplicate()` still clears local state.
+            try {
+                if (!this.closed) {
+                    // Prevent any late debounced timers (rebalance/prune) from publishing
+                    // replication info after we announce "segments: []". These races can leave
+                    // stale segments on remotes after rapid open/close cycles.
+                    this._isReplicating = false;
+                    this._isAdaptiveReplicating = false;
+                    this.rebalanceParticipationDebounced?.close();
+                    this.replicationChangeDebounceFn?.close?.();
+                    this.pruneDebouncedFn?.close?.();
+                    this.responseToPruneDebouncedFn?.close?.();
+                    // Ensure the "I'm leaving" replication reset is actually published before
+                    // the RPC child program closes and unsubscribes from its topic. If we fire
+                    // and forget here, the publish can race with `super.close()` and get dropped,
+                    // leaving stale replication segments on remotes (flaky join/leave tests).
+                    // Also ensure close is bounded even when shard overlays are mid-reconcile.
+                    const abort = new AbortController();
+                    const abortTimer = setTimeout(() => {
+                        try {
+                            abort.abort(new TimeoutError("shared-log close replication reset timed out"));
+                        }
+                        catch {
+                            abort.abort();
+                        }
+                    }, 2_000);
+                    try {
+                        await this.rpc
+                            .send(new AllReplicatingSegmentsMessage({ segments: [] }), {
+                            priority: 1,
+                            signal: abort.signal,
+                        })
+                            .catch(() => { });
+                    }
+                    finally {
+                        clearTimeout(abortTimer);
+                    }
+                }
+            }
+            catch {
+                // ignore: close should be resilient even if we were never fully started
+            }
             const superClosed = await super.close(from);
             if (!superClosed) {
                 return superClosed;
@@ -1756,6 +2674,41 @@ let SharedLog = (() => {
             return true;
         }
         async drop(from) {
+            // Best-effort: announce that we are going offline before tearing down
+            // RPC/subscription state (same reasoning as in `close()`).
+            try {
+                if (!this.closed) {
+                    this._isReplicating = false;
+                    this._isAdaptiveReplicating = false;
+                    this.rebalanceParticipationDebounced?.close();
+                    this.replicationChangeDebounceFn?.close?.();
+                    this.pruneDebouncedFn?.close?.();
+                    this.responseToPruneDebouncedFn?.close?.();
+                    const abort = new AbortController();
+                    const abortTimer = setTimeout(() => {
+                        try {
+                            abort.abort(new TimeoutError("shared-log drop replication reset timed out"));
+                        }
+                        catch {
+                            abort.abort();
+                        }
+                    }, 2_000);
+                    try {
+                        await this.rpc
+                            .send(new AllReplicatingSegmentsMessage({ segments: [] }), {
+                            priority: 1,
+                            signal: abort.signal,
+                        })
+                            .catch(() => { });
+                    }
+                    finally {
+                        clearTimeout(abortTimer);
+                    }
+                }
+            }
+            catch {
+                // ignore: drop should be resilient even if we were never fully started
+            }
             const superDropped = await super.drop(from);
             if (!superDropped) {
                 return superDropped;
@@ -2041,7 +2994,7 @@ let SharedLog = (() => {
                     const segments = (await this.getMyReplicationSegments()).map((x) => x.toReplicationRange());
                     this.rpc
                         .send(new AllReplicatingSegmentsMessage({ segments }), {
-                        mode: new SeekDelivery({ to: [context.from], redundancy: 1 }),
+                        mode: new AcknowledgeDelivery({ to: [context.from], redundancy: 1 }),
                     })
                         .catch((e) => logger.error(e.toString()));
                     // for backwards compatibility (v8) remove this when we are sure that all nodes are v9+
@@ -2072,33 +3025,55 @@ let SharedLog = (() => {
                     // `Program.waitFor()`. Dropping these messages can lead to missing replicator info
                     // (and downstream `waitForReplicator()` timeouts) under timing-sensitive joins.
                     const from = context.from;
+                    const fromHash = from.hashcode();
+                    if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                        return;
+                    }
                     const messageTimestamp = context.message.header.timestamp;
-                    (async () => {
-                        const prev = this.latestReplicationInfoMessage.get(from.hashcode());
-                        if (prev && prev > messageTimestamp) {
-                            return;
-                        }
-                        this.latestReplicationInfoMessage.set(from.hashcode(), messageTimestamp);
-                        if (this.closed) {
-                            return;
+                    await this.withReplicationInfoApplyQueue(fromHash, async () => {
+                        try {
+                            // The peer may have unsubscribed after this message was queued.
+                            if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                                return;
+                            }
+                            // Process in-order to avoid races where repeated reset messages arrive
+                            // concurrently and trigger spurious "added" diffs / rebalancing.
+                            const prev = this.latestReplicationInfoMessage.get(fromHash);
+                            if (prev && prev > messageTimestamp) {
+                                return;
+                            }
+                            this.latestReplicationInfoMessage.set(fromHash, messageTimestamp);
+                            if (this.closed) {
+                                return;
+                            }
+                            const reset = msg instanceof AllReplicatingSegmentsMessage;
+                            await this.addReplicationRange(replicationInfoMessage.segments.map((x) => x.toReplicationRangeIndexable(from)), from, {
+                                reset,
+                                checkDuplicates: true,
+                                timestamp: Number(messageTimestamp),
+                            });
+                            // If the peer reports any replication segments, stop re-requesting.
+                            // (Empty reports can be transient during startup.)
+                            if (replicationInfoMessage.segments.length > 0) {
+                                this.cancelReplicationInfoRequests(fromHash);
+                            }
                         }
-                        const reset = msg instanceof AllReplicatingSegmentsMessage;
-                        await this.addReplicationRange(replicationInfoMessage.segments.map((x) => x.toReplicationRangeIndexable(from)), from, {
-                            reset,
-                            checkDuplicates: true,
-                            timestamp: Number(messageTimestamp),
-                        });
-                    })().catch((e) => {
-                        if (isNotStartedError(e)) {
-                            return;
+                        catch (e) {
+                            if (isNotStartedError(e)) {
+                                return;
+                            }
+                            logger.error(`Failed to apply replication settings from '${fromHash}': ${e?.message ?? e}`);
                         }
-                        logger.error(`Failed to apply replication settings from '${from.hashcode()}': ${e?.message ?? e}`);
                     });
                 }
                 else if (msg instanceof StoppedReplicating) {
                     if (context.from.equals(this.node.identity.publicKey)) {
                         return;
                     }
+                    const fromHash = context.from.hashcode();
+                    if (this._replicationInfoBlockedPeers.has(fromHash)) {
+                        return;
+                    }
                     const rangesToRemove = await this.resolveReplicationRangesFromIdsAndKey(msg.segmentIds, context.from);
                     await this.removeReplicationRanges(rangesToRemove, context.from);
                     const timestamp = BigInt(+new Date());
@@ -2363,12 +3338,17 @@ let SharedLog = (() => {
                     requestTimer = undefined;
                 }
             };
-            const resolve = () => {
+            const resolve = async () => {
                 if (settled) {
                     return;
                 }
                 settled = true;
                 clear();
+                // `waitForReplicator()` is typically used as a precondition before join/replicate
+                // flows. A replicator can become mature and enqueue a debounced rebalance
+                // (`replicationChangeDebounceFn`) slightly later. Flush here so callers don't
+                // observe a "late" rebalance after the wait resolves.
+                await this.replicationChangeDebounceFn?.flush?.();
                 deferred.resolve();
             };
             const reject = (error) => {
@@ -2400,13 +3380,14 @@ let SharedLog = (() => {
                 requestAttempts++;
                 this.rpc
                     .send(new RequestReplicationInfoMessage(), {
-                    mode: new SeekDelivery({ redundancy: 1, to: [key] }),
+                    mode: new AcknowledgeDelivery({ redundancy: 1, to: [key] }),
                 })
                     .catch((e) => {
                     // Best-effort: missing peers / unopened RPC should not fail the wait logic.
                     if (isNotStartedError(e)) {
                         return;
                     }
+                    logger.error(e?.toString?.() ?? String(e));
                 });
                 if (requestAttempts < maxRequestAttempts) {
                     requestTimer = setTimeout(requestReplicationInfo, requestIntervalMs);
@@ -2425,7 +3406,7 @@ let SharedLog = (() => {
                             return;
                         }
                     }
-                    resolve();
+                    await resolve();
                 }
                 catch (error) {
                     reject(error instanceof Error ? error : new Error(String(error)));
@@ -2441,12 +3422,6 @@ let SharedLog = (() => {
             return deferred.promise.finally(clear);
         }
         async waitForReplicators(options) {
-            // if no remotes, just return
-            const subscribers = await this.node.services.pubsub.getSubscribers(this.rpc.topic);
-            let waitForNewPeers = options?.waitForNewPeers;
-            if (!waitForNewPeers && (subscribers?.length ?? 0) === 0) {
-                throw new NoPeersError(this.rpc.topic);
-            }
             let coverageThreshold = options?.coverageThreshold ?? 1;
             let deferred = pDefer();
             let settled = false;
@@ -2529,19 +3504,33 @@ let SharedLog = (() => {
         async _waitForReplicators(cursors, entry, waitFor, options = { timeout: this.waitForReplicatorTimeout }) {
             const timeout = options.timeout ?? this.waitForReplicatorTimeout;
             return new Promise((resolve, reject) => {
+                let settled = false;
                 const removeListeners = () => {
                     this.events.removeEventListener("replication:change", roleListener);
                     this.events.removeEventListener("replicator:mature", roleListener); // TODO replication:change event  ?
                     this._closeController.signal.removeEventListener("abort", abortListener);
                 };
-                const abortListener = () => {
+                const settleResolve = (value) => {
+                    if (settled)
+                        return;
+                    settled = true;
                     removeListeners();
                     clearTimeout(timer);
-                    resolve(false);
+                    resolve(value);
                 };
-                const timer = setTimeout(async () => {
+                const settleReject = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
                     removeListeners();
-                    resolve(false);
+                    clearTimeout(timer);
+                    reject(error);
+                };
+                const abortListener = () => {
+                    settleResolve(false);
+                };
+                const timer = setTimeout(async () => {
+                    settleResolve(false);
                 }, timeout);
                 const check = async () => {
                     let leaderKeys = new Set();
@@ -2561,17 +3550,20 @@ let SharedLog = (() => {
                         }
                     }
                     options?.onLeader && leaderKeys.forEach(options.onLeader);
-                    removeListeners();
-                    clearTimeout(timer);
-                    resolve(leaders);
+                    settleResolve(leaders);
+                };
+                const runCheck = () => {
+                    void check().catch((error) => {
+                        settleReject(error);
+                    });
                 };
                 const roleListener = () => {
-                    check();
+                    runCheck();
                 };
                 this.events.addEventListener("replication:change", roleListener); // TODO replication:change event  ?
                 this.events.addEventListener("replicator:mature", roleListener); // TODO replication:change event  ?
                 this._closeController.signal.addEventListener("abort", abortListener);
-                check();
+                runCheck();
             });
         }
         async createCoordinates(entry, minReplicas) {
@@ -2628,9 +3620,7 @@ let SharedLog = (() => {
             let subscribers = 1;
             if (!this.rpc.closed) {
                 try {
-                    subscribers =
-                        (await this.node.services.pubsub.getSubscribers(this.rpc.topic))
-                            ?.length ?? 1;
+                    subscribers = (await this._getTopicSubscribers(this.rpc.topic))?.length ?? 1;
                 }
                 catch {
                     // Best-effort only; fall back to 1.
@@ -2697,22 +3687,48 @@ let SharedLog = (() => {
         async _findLeaders(cursors, options) {
             const roleAge = options?.roleAge ?? (await this.getDefaultMinRoleAge()); // TODO -500 as is added so that i f someone else is just as new as us, then we treat them as mature as us. without -500 we might be slower syncing if two nodes starts almost at the same time
             const selfHash = this.node.identity.publicKey.hashcode();
-            // Use `uniqueReplicators` (replicator cache) once we've reconciled it against the
-            // persisted replication index. Until then, fall back to live pubsub subscribers
-            // and avoid relying on `uniqueReplicators` being complete.
+            // Prefer `uniqueReplicators` (replicator cache) as soon as it has any data.
+            // If it is still warming up (for example, only contains self), supplement with
+            // current subscribers until we have enough candidates for this decision.
             let peerFilter = undefined;
-            if (this._replicatorsReconciled && this.uniqueReplicators.size > 0) {
-                peerFilter = this.uniqueReplicators.has(selfHash)
-                    ? this.uniqueReplicators
-                    : new Set([...this.uniqueReplicators, selfHash]);
+            const selfReplicating = await this.isReplicating();
+            if (this.uniqueReplicators.size > 0) {
+                peerFilter = new Set(this.uniqueReplicators);
+                if (selfReplicating) {
+                    peerFilter.add(selfHash);
+                }
+                else {
+                    peerFilter.delete(selfHash);
+                }
+                try {
+                    const subscribers = await this._getTopicSubscribers(this.topic);
+                    if (subscribers && subscribers.length > 0) {
+                        for (const subscriber of subscribers) {
+                            peerFilter.add(subscriber.hashcode());
+                        }
+                        if (selfReplicating) {
+                            peerFilter.add(selfHash);
+                        }
+                        else {
+                            peerFilter.delete(selfHash);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort only; keep current peerFilter.
+                }
             }
             else {
                 try {
-                    const subscribers = (await this.node.services.pubsub.getSubscribers(this.topic)) ??
-                        undefined;
+                    const subscribers = (await this._getTopicSubscribers(this.topic)) ?? undefined;
                     if (subscribers && subscribers.length > 0) {
                         peerFilter = new Set(subscribers.map((key) => key.hashcode()));
-                        peerFilter.add(selfHash);
+                        if (selfReplicating) {
+                            peerFilter.add(selfHash);
+                        }
+                        else {
+                            peerFilter.delete(selfHash);
+                        }
                     }
                 }
                 catch {
@@ -2735,28 +3751,110 @@ let SharedLog = (() => {
                 replicas: maxReplicas(this, [entry]),
             }, options);
         }
+        withReplicationInfoApplyQueue(peerHash, fn) {
+            const prev = this._replicationInfoApplyQueueByPeer.get(peerHash);
+            const next = (prev ?? Promise.resolve())
+                .catch(() => {
+                // Avoid stuck queues if a previous apply failed.
+            })
+                .then(fn);
+            this._replicationInfoApplyQueueByPeer.set(peerHash, next);
+            return next.finally(() => {
+                if (this._replicationInfoApplyQueueByPeer.get(peerHash) === next) {
+                    this._replicationInfoApplyQueueByPeer.delete(peerHash);
+                }
+            });
+        }
+        cancelReplicationInfoRequests(peerHash) {
+            const state = this._replicationInfoRequestByPeer.get(peerHash);
+            if (!state)
+                return;
+            if (state.timer) {
+                clearTimeout(state.timer);
+            }
+            this._replicationInfoRequestByPeer.delete(peerHash);
+        }
+        scheduleReplicationInfoRequests(peer) {
+            const peerHash = peer.hashcode();
+            if (this._replicationInfoRequestByPeer.has(peerHash)) {
+                return;
+            }
+            const state = {
+                attempts: 0,
+            };
+            this._replicationInfoRequestByPeer.set(peerHash, state);
+            const intervalMs = Math.max(50, this.waitForReplicatorRequestIntervalMs);
+            const maxAttempts = Math.min(5, this.waitForReplicatorRequestMaxAttempts ??
+                WAIT_FOR_REPLICATOR_REQUEST_MIN_ATTEMPTS);
+            const tick = () => {
+                if (this.closed || this._closeController.signal.aborted) {
+                    this.cancelReplicationInfoRequests(peerHash);
+                    return;
+                }
+                state.attempts++;
+                this.rpc
+                    .send(new RequestReplicationInfoMessage(), {
+                    mode: new AcknowledgeDelivery({ redundancy: 1, to: [peer] }),
+                })
+                    .catch((e) => {
+                    // Best-effort: missing peers / unopened RPC should not fail join flows.
+                    if (isNotStartedError(e)) {
+                        return;
+                    }
+                    logger.error(e?.toString?.() ?? String(e));
+                });
+                if (state.attempts >= maxAttempts) {
+                    this.cancelReplicationInfoRequests(peerHash);
+                    return;
+                }
+                state.timer = setTimeout(tick, intervalMs);
+                state.timer.unref?.();
+            };
+            tick();
+        }
         async handleSubscriptionChange(publicKey, topics, subscribed) {
             if (!topics.includes(this.topic)) {
                 return;
             }
+            const peerHash = publicKey.hashcode();
+            if (subscribed) {
+                this._replicationInfoBlockedPeers.delete(peerHash);
+            }
+            else {
+                this._replicationInfoBlockedPeers.add(peerHash);
+            }
             if (!subscribed) {
-                this.removePeerFromGidPeerHistory(publicKey.hashcode());
+                const wasReplicator = this.uniqueReplicators.has(peerHash);
+                try {
+                    // Unsubscribe can race with the peer's final replication reset message.
+                    // Proactively evict its ranges so leader selection doesn't keep stale owners.
+                    await this.removeReplicator(publicKey, { noEvent: true });
+                }
+                catch (error) {
+                    if (!isNotStartedError(error)) {
+                        throw error;
+                    }
+                }
+                // Emit replicator:leave at most once per (join -> leave) transition, even if we
+                // concurrently process unsubscribe + replication reset messages for the same peer.
+                const stoppedTransition = wasReplicator;
+                this._replicatorJoinEmitted.delete(peerHash);
+                this.cancelReplicationInfoRequests(peerHash);
+                this.removePeerFromGidPeerHistory(peerHash);
                 for (const [k, v] of this._requestIPruneSent) {
-                    v.delete(publicKey.hashcode());
+                    v.delete(peerHash);
                     if (v.size === 0) {
                         this._requestIPruneSent.delete(k);
                     }
                 }
                 for (const [k, v] of this._requestIPruneResponseReplicatorSet) {
-                    v.delete(publicKey.hashcode());
+                    v.delete(peerHash);
                     if (v.size === 0) {
                         this._requestIPruneResponseReplicatorSet.delete(k);
                     }
                 }
                 this.syncronizer.onPeerDisconnected(publicKey);
-                (await this.replicationIndex.count({
-                    query: { hash: publicKey.hashcode() },
-                })) > 0 &&
+                stoppedTransition &&
                     this.events.dispatchEvent(new CustomEvent("replicator:leave", {
                         detail: { publicKey },
                     }));
@@ -2768,14 +3866,14 @@ let SharedLog = (() => {
                         .send(new AllReplicatingSegmentsMessage({
                         segments: replicationSegments.map((x) => x.toReplicationRange()),
                     }), {
-                        mode: new SeekDelivery({ redundancy: 1, to: [publicKey] }),
+                        mode: new AcknowledgeDelivery({ redundancy: 1, to: [publicKey] }),
                     })
                         .catch((e) => logger.error(e.toString()));
                     if (this.v8Behaviour) {
                         // for backwards compatibility
                         this.rpc
                             .send(new ResponseRoleMessage({ role: await this.getRole() }), {
-                            mode: new SeekDelivery({ redundancy: 1, to: [publicKey] }),
+                            mode: new AcknowledgeDelivery({ redundancy: 1, to: [publicKey] }),
                         })
                             .catch((e) => logger.error(e.toString()));
                     }
@@ -2783,11 +3881,7 @@ let SharedLog = (() => {
                 // Request the remote peer's replication info. This makes joins resilient to
                 // timing-sensitive delivery/order issues where we may miss their initial
                 // replication announcement.
-                this.rpc
-                    .send(new RequestReplicationInfoMessage(), {
-                    mode: new SeekDelivery({ redundancy: 1, to: [publicKey] }),
-                })
-                    .catch((e) => logger.error(e.toString()));
+                this.scheduleReplicationInfoRequests(publicKey);
             }
             else {
                 await this.removeReplicator(publicKey);
@@ -2841,6 +3935,7 @@ let SharedLog = (() => {
             const promises = [];
             let peerToEntries = new Map();
             let cleanupTimer = [];
+            const explicitTimeout = options?.timeout != null;
             for (const { entry, leaders } of entries.values()) {
                 for (const leader of leaders.keys()) {
                     let set = peerToEntries.get(leader);
@@ -2852,7 +3947,28 @@ let SharedLog = (() => {
                 }
                 const pendingPrev = this._pendingDeletes.get(entry.hash);
                 if (pendingPrev) {
-                    promises.push(pendingPrev.promise.promise);
+                    // If a background prune is already in-flight, an explicit prune request should
+                    // still respect the caller's timeout. Otherwise, tests (and user calls) can
+                    // block on the longer "checked prune" timeout derived from
+                    // `_respondToIHaveTimeout + waitForReplicatorTimeout`, which is intentionally
+                    // large for resiliency.
+                    if (explicitTimeout) {
+                        const timeoutMs = Math.max(0, Math.floor(options?.timeout ?? 0));
+                        promises.push(new Promise((resolve, reject) => {
+                            // Mirror the checked-prune error prefix so existing callers/tests can
+                            // match on the message substring.
+                            const timer = setTimeout(() => {
+                                reject(new Error(`Timeout for checked pruning after ${timeoutMs}ms (pending=true closed=${this.closed})`));
+                            }, timeoutMs);
+                            timer.unref?.();
+                            pendingPrev.promise.promise
+                                .then(resolve, reject)
+                                .finally(() => clearTimeout(timer));
+                        }));
+                    }
+                    else {
+                        promises.push(pendingPrev.promise.promise);
+                    }
                     continue;
                 }
                 const minReplicas = decodeReplicas(entry);
@@ -2866,6 +3982,7 @@ let SharedLog = (() => {
                 };
                 const resolve = () => {
                     clear();
+                    this.clearCheckedPruneRetry(entry.hash);
                     cleanupTimer.push(setTimeout(async () => {
                         this._gidPeersHistory.delete(entry.meta.gid);
                         this.removePruneRequestSent(entry.hash);
@@ -2903,6 +4020,12 @@ let SharedLog = (() => {
                 };
                 const reject = (e) => {
                     clear();
+                    const isCheckedPruneTimeout = e instanceof Error &&
+                        typeof e.message === "string" &&
+                        e.message.startsWith("Timeout for checked pruning");
+                    if (explicitTimeout || !isCheckedPruneTimeout) {
+                        this.clearCheckedPruneRetry(entry.hash);
+                    }
                     this.removePruneRequestSent(entry.hash);
                     this._requestIPruneResponseReplicatorSet.delete(entry.hash);
                     deferredPromise.reject(e);
@@ -2918,6 +4041,12 @@ let SharedLog = (() => {
                         this.waitForReplicatorTimeout +
                         PRUNE_DEBOUNCE_INTERVAL * 2);
                 const timeout = setTimeout(() => {
+                    // For internal/background prune flows (no explicit timeout), retry a few times
+                    // to avoid "permanently prunable" entries when `_pendingIHave` expires under
+                    // heavy load.
+                    if (!explicitTimeout) {
+                        this.scheduleCheckedPruneRetry({ entry, leaders });
+                    }
                     reject(new Error(`Timeout for checked pruning after ${checkedPruneTimeoutMs}ms (closed=${this.closed})`));
                 }, checkedPruneTimeoutMs);
                 timeout.unref?.();
@@ -2947,6 +4076,8 @@ let SharedLog = (() => {
                             this._requestIPruneResponseReplicatorSet.set(entry.hash, existCounter);
                         }
                         existCounter.add(publicKeyHash);
+                        // Seed provider hints so future remote reads can avoid extra round-trips.
+                        this.remoteBlocks.hintProviders(entry.hash, [publicKeyHash]);
                         if (minReplicasValue <= existCounter.size) {
                             resolve();
                         }
@@ -2984,6 +4115,37 @@ let SharedLog = (() => {
             for (const [k, v] of peerToEntries) {
                 emitMessages(v, k);
             }
+            // Keep remote `_pendingIHave` alive in the common "leader doesn't have entry yet"
+            // case. This is intentionally disabled when an explicit timeout is provided to
+            // preserve unit tests that assert remote `_pendingIHave` clears promptly.
+            if (!explicitTimeout && peerToEntries.size > 0) {
+                const respondToIHaveTimeout = Number(this._respondToIHaveTimeout ?? 0);
+                const resendIntervalMs = Math.min(CHECKED_PRUNE_RESEND_INTERVAL_MAX_MS, Math.max(CHECKED_PRUNE_RESEND_INTERVAL_MIN_MS, Math.floor(respondToIHaveTimeout / 2) || 1_000));
+                let inFlight = false;
+                const timer = setInterval(() => {
+                    if (inFlight)
+                        return;
+                    if (this.closed)
+                        return;
+                    const pendingByPeer = [];
+                    for (const [peer, hashes] of peerToEntries) {
+                        const pending = hashes.filter((h) => this._pendingDeletes.has(h));
+                        if (pending.length > 0) {
+                            pendingByPeer.push([peer, pending]);
+                        }
+                    }
+                    if (pendingByPeer.length === 0) {
+                        clearInterval(timer);
+                        return;
+                    }
+                    inFlight = true;
+                    Promise.allSettled(pendingByPeer.map(([peer, hashes]) => emitMessages(hashes, peer).catch(() => { }))).finally(() => {
+                        inFlight = false;
+                    });
+                }, resendIntervalMs);
+                timer.unref?.();
+                cleanupTimer.push(timer);
+            }
             let cleanup = () => {
                 for (const timer of cleanupTimer) {
                     clearTimeout(timer);
@@ -3040,14 +4202,96 @@ let SharedLog = (() => {
                 return;
             }
             await this.log.trim();
+            const batchedChanges = Array.isArray(changeOrChanges[0])
+                ? changeOrChanges
+                : [changeOrChanges];
+            const changes = batchedChanges.flat();
+            const selfHash = this.node.identity.publicKey.hashcode();
+            // On removed ranges (peer leaves / shrink), gid-level history can hide
+            // per-entry gaps. Force a fresh delivery pass for reassigned entries.
+            const forceFreshDelivery = changes.some((change) => change.type === "removed" && change.range.hash !== selfHash);
+            const gidPeersHistorySnapshot = new Map();
+            const dedupeCutoff = Date.now() - RECENT_REPAIR_DISPATCH_TTL_MS;
+            for (const [target, hashes] of this._recentRepairDispatch) {
+                for (const [hash, ts] of hashes) {
+                    if (ts <= dedupeCutoff) {
+                        hashes.delete(hash);
+                    }
+                }
+                if (hashes.size === 0) {
+                    this._recentRepairDispatch.delete(target);
+                }
+            }
             const changed = false;
+            const replacedPeers = new Set();
+            for (const change of changes) {
+                if (change.type === "replaced" && change.range.hash !== selfHash) {
+                    replacedPeers.add(change.range.hash);
+                }
+            }
+            const addedPeers = new Set();
+            for (const change of changes) {
+                if (change.type === "added" || change.type === "replaced") {
+                    const hash = change.range.hash;
+                    if (hash !== selfHash) {
+                        // Range updates can reassign entries to an existing peer shortly after it
+                        // already received a subset. Avoid suppressing legitimate follow-up repair.
+                        this._recentRepairDispatch.delete(hash);
+                    }
+                }
+                if (change.type === "added") {
+                    const hash = change.range.hash;
+                    if (hash !== selfHash && !replacedPeers.has(hash)) {
+                        addedPeers.add(hash);
+                    }
+                }
+            }
             try {
                 const uncheckedDeliver = new Map();
-                for await (const entryReplicated of toRebalance(changeOrChanges, this.entryCoordinatesIndex, this.recentlyRebalanced)) {
+                const flushUncheckedDeliverTarget = (target) => {
+                    const entries = uncheckedDeliver.get(target);
+                    if (!entries || entries.size === 0) {
+                        return;
+                    }
+                    const isJoinWarmupTarget = addedPeers.has(target);
+                    const bypassRecentDedupe = isJoinWarmupTarget || forceFreshDelivery;
+                    this.dispatchMaybeMissingEntries(target, entries, {
+                        bypassRecentDedupe,
+                        retryScheduleMs: isJoinWarmupTarget
+                            ? JOIN_WARMUP_RETRY_SCHEDULE_MS
+                            : undefined,
+                        forceFreshDelivery,
+                    });
+                    uncheckedDeliver.delete(target);
+                };
+                const queueUncheckedDeliver = (target, entry) => {
+                    let set = uncheckedDeliver.get(target);
+                    if (!set) {
+                        set = new Map();
+                        uncheckedDeliver.set(target, set);
+                    }
+                    if (set.has(entry.hash)) {
+                        return;
+                    }
+                    set.set(entry.hash, entry);
+                    if (set.size >= this.repairSweepTargetBufferSize) {
+                        flushUncheckedDeliverTarget(target);
+                    }
+                };
+                for await (const entryReplicated of toRebalance(changes, this.entryCoordinatesIndex, this.recentlyRebalanced, { forceFresh: forceFreshDelivery })) {
                     if (this.closed) {
                         break;
                     }
-                    let oldPeersSet = this._gidPeersHistory.get(entryReplicated.gid);
+                    let oldPeersSet;
+                    if (!forceFreshDelivery) {
+                        const gid = entryReplicated.gid;
+                        oldPeersSet = gidPeersHistorySnapshot.get(gid);
+                        if (!gidPeersHistorySnapshot.has(gid)) {
+                            const existing = this._gidPeersHistory.get(gid);
+                            oldPeersSet = existing ? new Set(existing) : undefined;
+                            gidPeersHistorySnapshot.set(gid, oldPeersSet);
+                        }
+                    }
                     let isLeader = false;
                     let currentPeers = await this.findLeaders(entryReplicated.coordinates, entryReplicated, {
                         // we do this to make sure new replicators get data even though they are not mature so they can figure out if they want to replicate more or less
@@ -3060,14 +4304,7 @@ let SharedLog = (() => {
                             continue;
                         }
                         if (!oldPeersSet?.has(currentPeer)) {
-                            let set = uncheckedDeliver.get(currentPeer);
-                            if (!set) {
-                                set = new Map();
-                                uncheckedDeliver.set(currentPeer, set);
-                            }
-                            if (!set.has(entryReplicated.hash)) {
-                                set.set(entryReplicated.hash, entryReplicated);
-                            }
+                            queueUncheckedDeliver(currentPeer, entryReplicated);
                         }
                     }
                     if (oldPeersSet) {
@@ -3093,11 +4330,13 @@ let SharedLog = (() => {
                         this.removePruneRequestSent(entryReplicated.hash);
                     }
                 }
-                for (const [target, entries] of uncheckedDeliver) {
-                    this.syncronizer.onMaybeMissingEntries({
-                        entries,
-                        targets: [target],
-                    });
+                if (forceFreshDelivery || addedPeers.size > 0) {
+                    // Schedule a coalesced background sweep for churn/join windows instead of
+                    // scanning the whole index synchronously on each replication change.
+                    this.scheduleRepairSweep({ forceFreshDelivery, addedPeers });
+                }
+                for (const target of [...uncheckedDeliver.keys()]) {
+                    flushUncheckedDeliverTarget(target);
                 }
                 return changed;
             }
@@ -3111,13 +4350,30 @@ let SharedLog = (() => {
         }
         async _onUnsubscription(evt) {
             logger.trace(`Peer disconnected '${evt.detail.from.hashcode()}' from '${JSON.stringify(evt.detail.topics.map((x) => x))} '`);
-            this.latestReplicationInfoMessage.delete(evt.detail.from.hashcode());
+            if (!evt.detail.topics.includes(this.topic)) {
+                return;
+            }
+            const fromHash = evt.detail.from.hashcode();
+            this._replicationInfoBlockedPeers.add(fromHash);
+            this._recentRepairDispatch.delete(fromHash);
+            // Keep a per-peer timestamp watermark when we observe an unsubscribe. This
+            // prevents late/out-of-order replication-info messages from re-introducing
+            // stale segments for a peer that has already left the topic.
+            const now = BigInt(+new Date());
+            const prev = this.latestReplicationInfoMessage.get(fromHash);
+            if (!prev || prev < now) {
+                this.latestReplicationInfoMessage.set(fromHash, now);
+            }
             return this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, false);
         }
         async _onSubscription(evt) {
             logger.trace(`New peer '${evt.detail.from.hashcode()}' connected to '${JSON.stringify(evt.detail.topics.map((x) => x))}'`);
+            if (!evt.detail.topics.includes(this.topic)) {
+                return;
+            }
             this.remoteBlocks.onReachable(evt.detail.from);
-            return this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true);
+            this._replicationInfoBlockedPeers.delete(evt.detail.from.hashcode());
+            await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true);
         }
         async rebalanceParticipation() {
             // update more participation rate to converge to the average expected rate or bounded by