@peerbit/shared-log 16.0.33 → 16.0.35

package/dist/src/sync/index.d.ts

@@ -75,8 +75,8 @@ export type SyncOptions<R extends "u32" | "u64"> = {
     /**
      * Optional profiling callback. It is only invoked when provided, and should
      * avoid blocking because it runs inline during open, provider resolution,
-     * and sync paths. Open-phase events describe setup progress only; they are
-     * not replication or durable-write readiness barriers.
+     * and sync paths, including bounded persisted-delivery observations.
+     * Profiling events are not replication/readiness barriers or durable receipts.
      */
     profile?: SyncProfileFn;
 };

package/dist/src/sync/persisted-delivery-profile.d.ts

@@ -0,0 +1,18 @@
+import { type DiagnosticValue } from "@peerbit/diagnostics";
+import type { SyncProfileFn } from "./profile.js";
+export declare const PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT = 16;
+/** Bounded, invocation-owned diagnostics. No retained entries or peer objects. */
+export declare const createPersistedDeliveryProfile: (sink: SyncProfileFn | undefined, entries: number, minAcks: number, leaderDegree: number) => {
+    now: () => number;
+    emit: (name: string, details: Record<string, DiagnosticValue>, peer?: string, phaseStartedAt?: number) => void;
+    phase: (phase: string, options: {
+        round: number;
+        peer: string;
+        requestedEntries: number;
+        attempt?: number;
+        timeoutMs?: number;
+        startedAt?: number;
+    }) => (outcome: string, acceptedEntries?: number) => void;
+    finish: (details: Record<string, DiagnosticValue>) => void;
+} | undefined;
+//# sourceMappingURL=persisted-delivery-profile.d.ts.map

package/dist/src/sync/persisted-delivery-profile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted-delivery-profile.d.ts","sourceRoot":"","sources":["../../../src/sync/persisted-delivery-profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,sBAAsB,CAAC;AAC3E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAKlD,eAAO,MAAM,sCAAsC,KAAK,CAAC;AAEzD,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,GAC1C,MAAM,aAAa,GAAG,SAAS,EAC/B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,cAAc,MAAM;;iBAqDb,MAAM,WACH,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,SACjC,MAAM,mBACI,MAAM;mBAcf,MAAM,WACJ;QACR,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB,MASO,SAAS,MAAM,EAAE,kBAAkB,MAAM;sBAQhC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;aAUlD,CAAC"}

package/dist/src/sync/persisted-delivery-profile.js

@@ -0,0 +1,77 @@
+import { diagnosticNow } from "@peerbit/diagnostics";
+// Process-local correlation only, never a receipt, wire id or persistent key.
+let nextTrace = 0;
+const MAX_EVENTS = 256;
+export const PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT = 16;
+/** Bounded, invocation-owned diagnostics. No retained entries or peer objects. */
+export const createPersistedDeliveryProfile = (sink, entries, minAcks, leaderDegree) => {
+    if (!sink)
+        return undefined;
+    nextTrace = (nextTrace % Number.MAX_SAFE_INTEGER) + 1;
+    const traceId = `persisted:${nextTrace}`;
+    const startedAt = diagnosticNow();
+    let emitted = 0;
+    let dropped = 0;
+    let closed = false;
+    const send = (name, details, peer, phaseStartedAt = startedAt) => {
+        try {
+            const now = diagnosticNow();
+            const result = sink({
+                name: `sharedLog.persistedDelivery.${name}`,
+                component: "shared-log",
+                traceId,
+                entries,
+                peer,
+                durationMs: Math.max(0, now - phaseStartedAt),
+                details: {
+                    ...details,
+                    v: 1,
+                    minAcks,
+                    leaderDegree,
+                    entrySampleWindow: Math.min(entries, PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT),
+                    entriesOutsideSampleWindow: Math.max(0, entries - PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT),
+                    elapsedMs: Math.max(0, now - startedAt),
+                },
+            });
+            // A void callback can still be async in TypeScript. Never await it, and
+            // own its rejection just as we isolate a synchronous diagnostic throw.
+            if (result &&
+                typeof result.then === "function") {
+                void Promise.resolve(result).catch(() => undefined);
+            }
+        }
+        catch {
+            // Diagnostics must not enter protocol recovery or replace its outcome.
+        }
+    };
+    const emit = (name, details, peer, phaseStartedAt) => {
+        if (closed)
+            return;
+        if (emitted >= MAX_EVENTS) {
+            dropped = Math.min(Number.MAX_SAFE_INTEGER, dropped + 1);
+            return;
+        }
+        emitted++;
+        send(name, details, peer, phaseStartedAt);
+    };
+    return {
+        now: diagnosticNow,
+        emit,
+        phase: (phase, options) => {
+            const { peer, startedAt = diagnosticNow(), ...details } = options;
+            emit("peerPhase", { ...details, phase, edge: "start", outcome: "pending" }, peer, startedAt);
+            return (outcome, acceptedEntries) => emit("peerPhase", { ...details, phase, edge: "end", outcome, acceptedEntries }, peer, startedAt);
+        },
+        finish: (details) => {
+            if (closed)
+                return;
+            closed = true;
+            send("settle", {
+                ...details,
+                emittedEvents: emitted + 1,
+                droppedEvents: dropped,
+            });
+        },
+    };
+};
+//# sourceMappingURL=persisted-delivery-profile.js.map

package/dist/src/sync/persisted-delivery-profile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"persisted-delivery-profile.js","sourceRoot":"","sources":["../../../src/sync/persisted-delivery-profile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAG3E,8EAA8E;AAC9E,IAAI,SAAS,GAAG,CAAC,CAAC;AAClB,MAAM,UAAU,GAAG,GAAG,CAAC;AACvB,MAAM,CAAC,MAAM,sCAAsC,GAAG,EAAE,CAAC;AAEzD,kFAAkF;AAClF,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAC7C,IAA+B,EAC/B,OAAe,EACf,OAAe,EACf,YAAoB,EACnB,EAAE;IACH,IAAI,CAAC,IAAI;QAAE,OAAO,SAAS,CAAC;IAC5B,SAAS,GAAG,CAAC,SAAS,GAAG,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACtD,MAAM,OAAO,GAAG,aAAa,SAAS,EAAE,CAAC;IACzC,MAAM,SAAS,GAAG,aAAa,EAAE,CAAC;IAClC,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,IAAI,MAAM,GAAG,KAAK,CAAC;IACnB,MAAM,IAAI,GAAG,CACZ,IAAY,EACZ,OAAwC,EACxC,IAAa,EACb,cAAc,GAAG,SAAS,EACzB,EAAE;QACH,IAAI,CAAC;YACJ,MAAM,GAAG,GAAG,aAAa,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAY,IAAI,CAAC;gBAC5B,IAAI,EAAE,+BAA+B,IAAI,EAAE;gBAC3C,SAAS,EAAE,YAAY;gBACvB,OAAO;gBACP,OAAO;gBACP,IAAI;gBACJ,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC;gBAC7C,OAAO,EAAE;oBACR,GAAG,OAAO;oBACV,CAAC,EAAE,CAAC;oBACJ,OAAO;oBACP,YAAY;oBACZ,iBAAiB,EAAE,IAAI,CAAC,GAAG,CAC1B,OAAO,EACP,sCAAsC,CACtC;oBACD,0BAA0B,EAAE,IAAI,CAAC,GAAG,CACnC,CAAC,EACD,OAAO,GAAG,sCAAsC,CAChD;oBACD,SAAS,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;iBACvC;aACD,CAAC,CAAC;YACH,wEAAwE;YACxE,uEAAuE;YACvE,IACC,MAAM;gBACN,OAAQ,MAA+B,CAAC,IAAI,KAAK,UAAU,EAC1D,CAAC;gBACF,KAAK,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC;YACrD,CAAC;QACF,CAAC;QAAC,MAAM,CAAC;YACR,uEAAuE;QACxE,CAAC;IACF,CAAC,CAAC;IACF,MAAM,IAAI,GAAG,CACZ,IAAY,EACZ,OAAwC,EACxC,IAAa,EACb,cAAuB,EACtB,EAAE;QACH,IAAI,MAAM;YAAE,OAAO;QACnB,IAAI,OAAO,IAAI,UAAU,EAAE,CAAC;YAC3B,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,gBAAgB,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YACzD,OAAO;QACR,CAAC;QACD,OAAO,EAAE,CAAC;QACV,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IAC3C,CAAC,CAAC;IACF,OAAO;QACN,GAAG,EAAE,aAAa;QAClB,IAAI;QACJ,KAAK,EAAE,CACN,KAAa,EACb,OAOC,EACA,EAAE;YACH,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,aAAa,EAAE,EAAE,GAAG,OAAO,EAAE,GAAG,OAAO,CAAC;YAClE,IAAI,CACH,WAAW,EACX,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,EACxD,IAAI,EACJ,SAAS,CACT,CAAC;YACF,OAAO,CAAC,OAAe,EAAE,eAAwB,EAAE,EAAE,CACpD,IAAI,CACH,WAAW,EACX,EAAE,GAAG,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,EAC5D,IAAI,EACJ,SAAS,CACT,CAAC;QACJ,CAAC;QACD,MAAM,EAAE,CAAC,OAAwC,EAAE,EAAE;YACpD,IAAI,MAAM;gBAAE,OAAO;YACnB,MAAM,GAAG,IAAI,CAAC;YACd,IAAI,CAAC,QAAQ,EAAE;gBACd,GAAG,OAAO;gBACV,aAAa,EAAE,OAAO,GAAG,CAAC;gBAC1B,aAAa,EAAE,OAAO;aACtB,CAAC,CAAC;QACJ,CAAC;KACD,CAAC;AACH,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@peerbit/shared-log",
-  "version": "16.0.33",
+  "version": "16.0.35",
   "description": "Shared log",
   "sideEffects": false,
   "type": "module",
@@ -62,37 +62,37 @@
     "pidusage": "^4.0.1",
     "pino": "^9.4.0",
     "uint8arrays": "^5.1.0",
+    "@peerbit/any-store": "2.2.17",
+    "@peerbit/cache": "3.1.1",
     "@peerbit/blocks": "4.3.2",
     "@peerbit/blocks-interface": "2.2.1",
     "@peerbit/crypto": "3.1.6",
-    "@peerbit/cache": "3.1.1",
-    "@peerbit/any-store": "2.2.17",
-    "@peerbit/indexer-interface": "3.0.13",
-    "@peerbit/indexer-sqlite3": "3.0.20",
+    "@peerbit/indexer-interface": "3.1.0",
     "@peerbit/diagnostics": "0.0.1",
-    "@peerbit/log": "6.2.34",
-    "@peerbit/program": "6.0.61",
+    "@peerbit/log": "6.2.35",
     "@peerbit/logger": "2.0.2",
-    "@peerbit/pubsub": "5.4.7",
-    "@peerbit/pubsub-interface": "5.2.2",
+    "@peerbit/indexer-sqlite3": "3.0.21",
+    "@peerbit/program": "6.0.63",
     "@peerbit/riblt": "1.2.0",
-    "@peerbit/rpc": "6.1.29",
+    "@peerbit/pubsub": "5.4.8",
+    "@peerbit/rpc": "6.1.31",
+    "@peerbit/pubsub-interface": "5.2.2",
     "@peerbit/stream-interface": "6.0.16",
     "@peerbit/time": "3.0.1"
   },
   "optionalDependencies": {
-    "@peerbit/native-backbone": "0.2.16",
-    "@peerbit/shared-log-rust": "0.1.7"
+    "@peerbit/native-backbone": "0.2.17",
+    "@peerbit/shared-log-rust": "0.1.8"
   },
   "devDependencies": {
     "@types/libsodium-wrappers": "^0.7.14",
     "@types/pidusage": "^2.0.5",
     "uuid": "^11.1.1",
-    "@peerbit/indexer-rust": "1.0.14",
     "@peerbit/any-store-rust": "0.1.7",
-    "@peerbit/indexer-simple": "1.2.17",
-    "@peerbit/test-utils": "3.1.42",
-    "peerbit": "5.4.3"
+    "@peerbit/indexer-rust": "1.0.15",
+    "@peerbit/indexer-simple": "1.3.0",
+    "@peerbit/test-utils": "3.1.44",
+    "peerbit": "5.4.5"
   },
   "repository": {
     "type": "git",

package/src/index.ts

@@ -307,6 +307,10 @@ import type {
 	SynchronizerConstructor,
 	Syncronizer,
 } from "./sync/index.js";
+import {
+	PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT,
+	createPersistedDeliveryProfile,
+} from "./sync/persisted-delivery-profile.js";
 import {
 	emitSyncProfileDuration,
 	emitSyncProfileEvent,
@@ -6356,6 +6360,18 @@ export class SharedLog<
 				records.size,
 			);
 		const signal = deadline.signal;
+		const profile = createPersistedDeliveryProfile(
+			this._logProperties?.sync?.profile,
+			records.size,
+			minAcks,
+			replicas,
+		);
+		const profiledHashes = profile
+			? committedHashes.slice(0, PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT)
+			: undefined;
+		let profileRounds = 0;
+		let profileOutcome = "failed";
+		let profileReason: string | undefined;
 		const recoveryController = new AbortController();
 		const recoverySignal = AbortSignal.any([signal, recoveryController.signal]);
 		const recoveryByPeer = new Map<
@@ -6469,6 +6485,7 @@ export class SharedLog<
 		};
 		try {
 			while (true) {
+				const profileRound = profile ? ++profileRounds : 0;
 				if (signal.aborted) {
 					throw signal.reason ?? new AbortError();
 				}
@@ -6524,13 +6541,20 @@ export class SharedLog<
 				const selfHash = this.node.identity.publicKey.hashcode();
 				if (needsInitialLeaderCheck) {
 					needsInitialLeaderCheck = false;
-					if (
-						leadersByEntry.some(
-							(leaders) =>
-								leaders.size === 0 ||
-								(leaders.size === 1 && leaders.has(selfHash)),
-						)
-					) {
+					const noRemoteIndex = leadersByEntry.findIndex(
+						(leaders) =>
+							leaders.size === 0 ||
+							(leaders.size === 1 && leaders.has(selfHash)),
+					);
+					if (noRemoteIndex >= 0) {
+						if (noRemoteIndex < PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT)
+							profile?.emit("plan", {
+								round: profileRound,
+								entryIndex: noRemoteIndex,
+								remoteLeaderCount: 0,
+								selectedRequestPeerCount: 0,
+								carriedAckCount: 0,
+							});
 						throw new NoPeersError(this.rpc.topic, "persisted");
 					}
 				}
@@ -6542,6 +6566,10 @@ export class SharedLog<
 					}
 					if (!isRoundOwnershipCurrent()) break;
 					const acknowledgements = carriedAcknowledgements.get(hash)!;
+					const entryProfile =
+						index < PERSISTED_DELIVERY_PROFILE_ENTRY_LIMIT
+							? profile
+							: undefined;
 					for (const [peer, captured] of acknowledgements) {
 						const current = this.persistedReceiptPeerSession(peer);
 						if (
@@ -6551,19 +6579,67 @@ export class SharedLog<
 							current.peerSession !== captured.peerSession
 						) {
 							acknowledgements.delete(peer);
+						} else {
+							entryProfile?.emit(
+								"candidate",
+								{
+									round: profileRound,
+									entryIndex: index,
+									status: "carried-receipt",
+								},
+								peer,
+							);
 						}
 					}
-					if (acknowledgements.size >= minAcks) continue;
+					if (acknowledgements.size >= minAcks) {
+						entryProfile?.emit("plan", {
+							round: profileRound,
+							entryIndex: index,
+							remoteLeaderCount: leaders.size - Number(leaders.has(selfHash)),
+							selectedRequestPeerCount: 0,
+							carriedAckCount: acknowledgements.size,
+						});
+						continue;
+					}
+					let selectedRequestPeerCount = 0;
 					for (const peer of leaders.keys()) {
 						if (peer === selfHash) continue;
 						recoveryCandidates.add(peer);
 						const current = this.persistedReceiptPeerSession(peer);
-						if (!current) continue;
+						if (!current) {
+							entryProfile?.emit(
+								"candidate",
+								{
+									round: profileRound,
+									entryIndex: index,
+									status: "leader-no-current-session",
+								},
+								peer,
+							);
+							continue;
+						}
 						if (acknowledgements.has(peer)) continue;
 						const hashes = hashesByPeer.get(peer) ?? [];
 						hashes.push(hash);
 						hashesByPeer.set(peer, hashes);
+						selectedRequestPeerCount++;
+						entryProfile?.emit(
+							"candidate",
+							{
+								round: profileRound,
+								entryIndex: index,
+								status: "selected-for-request",
+							},
+							peer,
+						);
 					}
+					entryProfile?.emit("plan", {
+						round: profileRound,
+						entryIndex: index,
+						remoteLeaderCount: leaders.size - Number(leaders.has(selfHash)),
+						selectedRequestPeerCount,
+						carriedAckCount: acknowledgements.size,
+					});
 				}
 				if (!isRoundOwnershipCurrent()) continue;
 				recoverSelectedPeers(recoveryCandidates);
@@ -6644,17 +6720,30 @@ export class SharedLog<
 										signal: roundSignal,
 									});
 								}
-								await this._v2Send.confirmLatestForPeer(
-									{
-										peerHash: peer,
-										peerSession: captured.peerSession,
-										receiverTransportSession: captured.capabilitySession,
-									},
-									{
-										timeout: getAttemptTimeout(),
-										signal: roundSignal,
-									},
-								);
+								const confirmationTimeout = getAttemptTimeout();
+								const endConfirmation = profile?.phase("confirmation", {
+									round: profileRound,
+									requestedEntries: hashes.length,
+									timeoutMs: confirmationTimeout,
+									peer,
+								});
+								try {
+									await this._v2Send.confirmLatestForPeer(
+										{
+											peerHash: peer,
+											peerSession: captured.peerSession,
+											receiverTransportSession: captured.capabilitySession,
+										},
+										{
+											timeout: confirmationTimeout,
+											signal: roundSignal,
+										},
+									);
+									endConfirmation?.("fulfilled");
+								} catch (error) {
+									endConfirmation?.("rejected");
+									throw error;
+								}
 							} catch {
 								// The exact receiver generation did not prove that it applied
 								// our latest role state. Replan instead of transferring to a
@@ -6691,13 +6780,32 @@ export class SharedLog<
 											}
 										},
 										onChunkSent: async (chunk) => {
-											return this.waitForPersistedTransferAdmission(
+											const startedAt = profile?.now();
+											const pending = this.waitForPersistedTransferAdmission(
 												peer,
 												chunk,
 												captured,
 												roundSignal,
 												isPeerRoundCurrent,
 											);
+											const endAdmission = profile?.phase(
+												"transfer-admission",
+												{
+													round: profileRound,
+													peer,
+													requestedEntries: chunk.length,
+													startedAt,
+												},
+											);
+											if (endAdmission)
+												void pending.then(
+													(admitted) =>
+														endAdmission(
+															admitted ? "fulfilled" : "not-admitted",
+														),
+													() => endAdmission("rejected"),
+												);
+											return pending;
 										},
 										operationQueue,
 										priority: delivery.priority,
@@ -6742,19 +6850,37 @@ export class SharedLog<
 									break;
 								}
 								let responses;
+								const attempt = offset / PERSISTED_RECEIPT_CHUNK_SIZE + 1;
+								let requestStartedAt: number | undefined;
+								let endRequest:
+									| ((outcome: string, acceptedEntries?: number) => void)
+									| undefined;
 								try {
-									await this.waitForPersistedReceiptEgressAdmission(
+									const endEgress = profile?.phase("receipt-egress", {
+										round: profileRound,
+										attempt,
+										requestedEntries: requestedHashes.length,
 										peer,
-										captured.capabilitySession,
-										requestedHashes.length,
-										roundSignal,
-									);
+									});
+									try {
+										await this.waitForPersistedReceiptEgressAdmission(
+											peer,
+											captured.capabilitySession,
+											requestedHashes.length,
+											roundSignal,
+										);
+										endEgress?.("fulfilled");
+									} catch (error) {
+										endEgress?.("rejected");
+										throw error;
+									}
 									if (!isPeerRoundCurrent()) break;
 									const attemptTimeout = getAttemptTimeout();
 									responses =
 										(await operationQueue.add(async () => {
 											if (!isPeerRoundCurrent()) return [];
-											return this.rpc.request(
+											requestStartedAt = profile?.now();
+											const pending = this.rpc.request(
 												new RequestPersistedEntriesV1({
 													expectedReceiverSession: captured.capabilitySession,
 													hashes: requestedHashes,
@@ -6770,14 +6896,25 @@ export class SharedLog<
 													signal: roundSignal,
 												},
 											);
+											endRequest = profile?.phase("receipt-request", {
+												round: profileRound,
+												attempt,
+												requestedEntries: requestedHashes.length,
+												timeoutMs: attemptTimeout,
+												peer,
+												startedAt: requestStartedAt,
+											});
+											return pending;
 										})) ?? [];
 								} catch {
+									endRequest?.("rejected", 0);
 									if (roundSignal.aborted) break;
 									// A peer can disconnect or miss this retry while the overall
 									// quorum deadline remains active. Replan on the next round.
 									break;
 								}
 								if (!isRoundOwnershipCurrent()) {
+									endRequest?.("stale", 0);
 									roundController.abort();
 									break;
 								}
@@ -6788,6 +6925,7 @@ export class SharedLog<
 									current.peerSession !== captured.peerSession
 								) {
 									purgePeerDeliveryState(peer);
+									endRequest?.("stale", 0);
 									break;
 								}
 								const requested = new Set(requestedHashes);
@@ -6824,6 +6962,26 @@ export class SharedLog<
 										}
 									}
 								}
+								endRequest?.("fulfilled", confirmed.size);
+								for (
+									let entryIndex = 0;
+									entryIndex < (profiledHashes?.length ?? 0);
+									entryIndex++
+								) {
+									const hash = profiledHashes![entryIndex]!;
+									if (confirmed.has(hash))
+										profile?.emit(
+											"progress",
+											{
+												round: profileRound,
+												attempt,
+												entryIndex,
+												carriedAckCount:
+													carriedAcknowledgements.get(hash)!.size,
+											},
+											peer,
+										);
+								}
 							}
 						})()
 							.then(() => undefined)
@@ -6891,10 +7049,12 @@ export class SharedLog<
 					while (requests.size > 0) {
 						await Promise.race(requests);
 						if (await roundComplete()) {
+							profileOutcome = "quorum-validated";
 							return;
 						}
 					}
 					if (await roundComplete()) {
+						profileOutcome = "quorum-validated";
 						return;
 					}
 				} finally {
@@ -6922,6 +7082,16 @@ export class SharedLog<
 				);
 			}
 		} catch (error) {
+			profileReason =
+				signal.reason instanceof TimeoutError
+					? "timeout"
+					: signal.aborted
+						? "signal"
+						: error instanceof NoPeersError
+							? "no-peers"
+							: "error";
+			profileOutcome =
+				signal.aborted && profileReason !== "timeout" ? "aborted" : "failed";
 			if (error instanceof PersistedDeliveryError) {
 				throw error;
 			}
@@ -6933,6 +7103,11 @@ export class SharedLog<
 				state.controller.abort();
 			}
 			if (ownedDeadline) deadline.dispose();
+			profile?.finish({
+				outcome: profileOutcome,
+				reason: profileReason,
+				round: profileRounds,
+			});
 		}
 	}
 
@@ -27046,8 +27221,9 @@ export class SharedLog<
 			);
 		}
 
+		let fullReplicaPlan;
 		if (!options?.candidates) {
-			const fullReplicaLeaders = await this.findFullReplicaLeaders(
+			fullReplicaPlan = await this.findFullReplicaLeaderPlan(
 				cursors.length,
 				context.roleAge,
 				peerFilter,
@@ -27055,8 +27231,8 @@ export class SharedLog<
 			this.throwIfReplicationOwnershipLifecycleInactive(
 				ownershipLifecycleController,
 			);
-			if (fullReplicaLeaders) {
-				return fullReplicaLeaders;
+			if (fullReplicaPlan?.complete) {
+				return fullReplicaPlan.leaders;
 			}
 		}
 
@@ -27073,6 +27249,16 @@ export class SharedLog<
 		this.throwIfReplicationOwnershipLifecycleInactive(
 			ownershipLifecycleController,
 		);
+		if (fullReplicaPlan) {
+			// Retain the existing mature global fallback (including strict owners).
+			// Young owners still need coordinate sampling before the plan is complete.
+			for (const [hash, leader] of leaders) {
+				if (!fullReplicaPlan.leaders.has(hash)) {
+					fullReplicaPlan.leaders.set(hash, leader);
+				}
+			}
+			return fullReplicaPlan.leaders;
+		}
 		return leaders;
 	}
 
@@ -27117,16 +27303,20 @@ export class SharedLog<
 		return peerFilter;
 	}
 
-	private async findFullReplicaLeaders(
+	private async findFullReplicaLeaderPlan(
 		replicas: number,
 		roleAge: number,
 		peerFilter?: Set<string>,
-	): Promise<Map<string, { intersecting: boolean }> | undefined> {
+	): Promise<
+		| { leaders: Map<string, { intersecting: boolean }>; complete: boolean }
+		| undefined
+	> {
 		const now = Date.now();
 		const leaders = new Map<string, { intersecting: boolean }>();
 		// Strict-only peers are not global fallbacks, but may still own an entry's
 		// coordinates. Remember them so a partial fallback cannot bypass sampling.
 		const excludedStrictPeers = new Set<string>();
+		const youngPeers = new Set<string>();
 		const includeStrict =
 			this._logProperties?.strictFullReplicaFallback !== false;
 		const iterator = this.replicationIndex.iterate(
@@ -27150,6 +27340,7 @@ export class SharedLog<
 						continue;
 					}
 					if (!isMatured(range, now, roleAge)) {
+						youngPeers.add(range.hash);
 						continue;
 					}
 					leaders.set(range.hash, { intersecting: true });
@@ -27168,7 +27359,12 @@ export class SharedLog<
 			}
 		}
 
-		return leaders.size > 0 ? leaders : undefined;
+		return leaders.size > 0
+			? {
+					leaders,
+					complete: [...youngPeers].every((hash) => leaders.has(hash)),
+				}
+			: undefined;
 	}
 
 	private async findEntryReplicatedLeaderBatch(

package/src/sync/index.ts

@@ -94,8 +94,8 @@ export type SyncOptions<R extends "u32" | "u64"> = {
 	/**
 	 * Optional profiling callback. It is only invoked when provided, and should
 	 * avoid blocking because it runs inline during open, provider resolution,
-	 * and sync paths. Open-phase events describe setup progress only; they are
-	 * not replication or durable-write readiness barriers.
+	 * and sync paths, including bounded persisted-delivery observations.
+	 * Profiling events are not replication/readiness barriers or durable receipts.
 	 */
 	profile?: SyncProfileFn;
 };