@peerbit/shared-log 16.0.29 → 16.0.31

package/dist/src/index.js

@@ -186,7 +186,7 @@ const emitAdvisorySyncProfileDuration = (profile, startedAt, event) => {
         emitSyncProfileDuration(profile, startedAt, event);
     }
     catch {
-        // Diagnostics must not change open or provider-resolution correctness.
+        // Advisory diagnostics must not change replication or lifecycle behavior.
     }
 };
 const canUseOptionalNativeModuleImports = () => {
@@ -1964,7 +1964,7 @@ let SharedLog = (() => {
                 bumpSimpleFallbackPasses: () => {
                     this._repairMetrics["join-warmup"].simpleFallbackPasses += 1;
                 },
-                sendEntriesSimple: (target, entries, options) => this.sendRepairEntriesWithTransport(target, entries, "simple", options),
+                sendEntriesSimple: (target, entries, options) => this.sendRepairEntriesWithTransport(target, entries, "simple", options, "join-warmup"),
                 logError: (error) => logger.error(error),
             });
         }
@@ -3694,6 +3694,76 @@ let SharedLog = (() => {
             const deadline = persistedDeadline ??
                 this.createPersistedDeliveryDeadline(delivery, ownershipLifecycleController, records.size);
             const signal = deadline.signal;
+            const recoveryController = new AbortController();
+            const recoverySignal = AbortSignal.any([signal, recoveryController.signal]);
+            const recoveryByPeer = new Map();
+            let recoveryCursor = 0;
+            const recoverSelectedPeers = (selected) => {
+                // Recovery is advisory work, not a receipt or a replacement leader plan.
+                // Never occupy transfer/request slots while waiting for it. The separate
+                // bounded pool rotates through fresh candidates so quiet/incomplete peers
+                // cannot indefinitely hide a later recoverable peer.
+                for (const [peer, state] of recoveryByPeer) {
+                    if (!selected.has(peer)) {
+                        clearTimeout(state.timer);
+                        state.controller.abort();
+                    }
+                }
+                const peers = [...selected];
+                for (let visited = 0; visited < peers.length &&
+                    recoveryByPeer.size < MAX_PERSISTED_RECEIPT_REQUESTS_GLOBAL &&
+                    !recoverySignal.aborted; visited++) {
+                    const peer = peers[recoveryCursor++ % peers.length];
+                    if (recoveryByPeer.has(peer))
+                        continue;
+                    const current = this.persistedReceiptPeerSession(peer);
+                    if (current &&
+                        this._v2Send.isLatestConfirmedForPeer({
+                            peerHash: peer,
+                            peerSession: current.peerSession,
+                            receiverTransportSession: current.capabilitySession,
+                        })) {
+                        continue;
+                    }
+                    const expiresAt = Math.min(deadline.deadline, Date.now() + MAX_PERSISTED_RECEIPT_ATTEMPT_MS);
+                    const controller = new AbortController();
+                    const attemptSignal = AbortSignal.any([
+                        recoverySignal,
+                        controller.signal,
+                    ]);
+                    const timer = setTimeout(() => controller.abort(), Math.max(1, expiresAt - Date.now()));
+                    timer.unref?.();
+                    const state = { controller, timer };
+                    recoveryByPeer.set(peer, state);
+                    void (async () => {
+                        // Resolve only an authenticated transport-cache key. Keep this slot
+                        // reserved until the lookup actually settles, even if a custom
+                        // resolver ignores cancellation, rather than launching duplicates.
+                        const key = await this._resolvePublicKeyFromHash(peer);
+                        if (attemptSignal.aborted ||
+                            !key ||
+                            key.hashcode() !== peer ||
+                            Date.now() >= expiresAt) {
+                            return;
+                        }
+                        // Reuse the exact-session watchdog, capability/subscriber recovery,
+                        // and replacement-session handling from the public preflight. Its
+                        // result is ignored: settlement still checks the exact entry leaders
+                        // and accepts only the subsequent durable, session-bound receipts.
+                        await this.waitForPersistedReceiptPeerReadiness(key, {
+                            timeout: Math.max(1, expiresAt - Date.now()),
+                            signal: attemptSignal,
+                        });
+                    })()
+                        .catch(() => undefined)
+                        .finally(() => {
+                        clearTimeout(timer);
+                        if (recoveryByPeer.get(peer) === state) {
+                            recoveryByPeer.delete(peer);
+                        }
+                    });
+                }
+            };
             let maxAttemptMs = MAX_PERSISTED_RECEIPT_ATTEMPT_MS;
             let initialTransferPending = transferOnFirstRound;
             let needsInitialLeaderCheck = true;
@@ -3741,6 +3811,7 @@ let SharedLog = (() => {
                     // transport epoch. A revision/session change purges them before they can
                     // survive an away-and-back leader transition or combine with a later peer.
                     const hashesByPeer = new Map();
+                    const recoveryCandidates = new Set();
                     const entryArray = [...records.values()];
                     const leadersByEntry = await this.planPersistedDeliveryLeaders(entryArray, replicas, ownershipLifecycleController);
                     if (!isRoundOwnershipCurrent())
@@ -3779,6 +3850,7 @@ let SharedLog = (() => {
                         for (const peer of leaders.keys()) {
                             if (peer === selfHash)
                                 continue;
+                            recoveryCandidates.add(peer);
                             const current = this.persistedReceiptPeerSession(peer);
                             if (!current)
                                 continue;
@@ -3791,6 +3863,7 @@ let SharedLog = (() => {
                     }
                     if (!isRoundOwnershipCurrent())
                         continue;
+                    recoverSelectedPeers(recoveryCandidates);
                     const operationQueue = new PQueue({
                         concurrency: MAX_PERSISTED_RECEIPT_REQUESTS_GLOBAL,
                     });
@@ -4100,6 +4173,11 @@ let SharedLog = (() => {
                 throw new PersistedDeliveryError(error, committedHashes);
             }
             finally {
+                recoveryController.abort();
+                for (const state of recoveryByPeer.values()) {
+                    clearTimeout(state.timer);
+                    state.controller.abort();
+                }
                 if (ownedDeadline)
                     deadline.dispose();
             }
@@ -6857,47 +6935,88 @@ let SharedLog = (() => {
                 signal,
             });
         }
-        async sendRepairEntriesWithTransport(target, entries, transport, options) {
+        async sendRepairEntriesWithTransport(target, entries, transport, options, mode) {
             const isStillCurrent = options?.isStillCurrent ?? (() => true);
             if (!isStillCurrent()) {
                 return;
             }
             const unknownEntries = new Map();
             const knownHashes = [];
-            for (const [hash, entry] of entries) {
-                if ((options?.bypassRecentKnownPeers ||
-                    !this.isEntryRecentlyKnownByPeer(hash, target, RECENT_KNOWN_REPAIR_SUPPRESSION_MS)) &&
-                    (options?.bypassKnownPeers || !this.isEntryKnownByPeer(hash, target))) {
-                    unknownEntries.set(hash, entry);
+            const profile = this._logProperties?.sync?.profile;
+            const startedAt = syncProfileStart(profile);
+            const inputEntries = profile ? entries.size : 0;
+            let selectedEntries = 0;
+            let lastObservedCurrent = true;
+            let outcome = "stale";
+            try {
+                for (const [hash, entry] of entries) {
+                    if ((options?.bypassRecentKnownPeers ||
+                        !this.isEntryRecentlyKnownByPeer(hash, target, RECENT_KNOWN_REPAIR_SUPPRESSION_MS)) &&
+                        (options?.bypassKnownPeers || !this.isEntryKnownByPeer(hash, target))) {
+                        unknownEntries.set(hash, entry);
+                    }
+                    else {
+                        knownHashes.push(hash);
+                    }
+                }
+                // A custom synchronizer may mutate the Map once it receives it.
+                if (profile)
+                    selectedEntries = unknownEntries.size;
+                if (!isStillCurrent())
+                    return;
+                this.clearRepairFrontierHashes(target, knownHashes);
+                if (unknownEntries.size === 0) {
+                    outcome = "known-suppressed";
+                    return;
+                }
+                if (transport === "simple") {
+                    // Observe only checks the lower path already makes, without adding
+                    // lifecycle decisions or wrapping the disabled-profiling path.
+                    const dispatchIsStillCurrent = profile
+                        ? () => (lastObservedCurrent = isStillCurrent())
+                        : isStillCurrent;
+                    // Fallback repair does not wait for the maybe-sync round trip.
+                    await this.pushRepairEntries(target, unknownEntries, dispatchIsStillCurrent, options?.signal);
                 }
                 else {
-                    knownHashes.push(hash);
+                    const syncEntries = this._logProperties?.sync?.priority
+                        ? this._coordinates.materializeRepairDispatchEntries(unknownEntries)
+                        : unknownEntries;
+                    if (!isStillCurrent())
+                        return;
+                    await this.syncronizer.onMaybeMissingEntries({
+                        entries: syncEntries,
+                        targets: [target],
+                        signal: options?.signal,
+                    });
                 }
+                outcome = !lastObservedCurrent
+                    ? "stale"
+                    : options?.signal?.aborted
+                        ? "cancelled"
+                        : "dispatched";
             }
-            if (!isStillCurrent()) {
-                return;
-            }
-            this.clearRepairFrontierHashes(target, knownHashes);
-            if (unknownEntries.size === 0) {
-                return;
-            }
-            if (transport === "simple") {
-                // Fallback repair should not depend on the target completing the
-                // RequestMaybeSync -> ResponseMaybeSync round trip.
-                await this.pushRepairEntries(target, unknownEntries, isStillCurrent, options?.signal);
-                return;
+            catch (error) {
+                outcome = "error";
+                throw error;
             }
-            const syncEntries = this._logProperties?.sync?.priority
-                ? this._coordinates.materializeRepairDispatchEntries(unknownEntries)
-                : unknownEntries;
-            if (!isStillCurrent()) {
-                return;
+            finally {
+                if (profile) {
+                    emitAdvisorySyncProfileDuration(profile, startedAt, {
+                        name: "sharedLog.repair.dispatch",
+                        component: "shared-log",
+                        entries: inputEntries,
+                        count: selectedEntries,
+                        targets: 1,
+                        details: {
+                            mode,
+                            transport,
+                            outcome,
+                            knownSuppressedEntries: knownHashes.length,
+                        },
+                    });
+                }
             }
-            await this.syncronizer.onMaybeMissingEntries({
-                entries: syncEntries,
-                targets: [target],
-                signal: options?.signal,
-            });
         }
         async sendMaybeMissingEntriesNow(target, entries, options, repairLifecycleController = this._instanceLifecycle
             ?.ownershipLifecycleController) {
@@ -6955,7 +7074,7 @@ let SharedLog = (() => {
                 bypassRecentKnownPeers: bypassKnownPeerHints,
                 isStillCurrent: () => this.isRepairLifecycleActive(repairLifecycleController),
                 signal: repairLifecycleController.signal,
-            })).catch((error) => logger.error(error));
+            }, options.mode)).catch((error) => logger.error(error));
         }
         ensureRepairFrontierRunner(mode, target, retryScheduleMs, repairLifecycleController = this._instanceLifecycle
             ?.ownershipLifecycleController) {
@@ -7215,7 +7334,7 @@ let SharedLog = (() => {
                     bypassRecentKnownPeers: bypassKnownPeerHints,
                     isStillCurrent: () => this.isRepairLifecycleActive(repairLifecycleController),
                     signal: repairLifecycleController.signal,
-                })).catch((error) => logger.error(error));
+                }, options.mode)).catch((error) => logger.error(error));
             };
             const delayedJoinWarmupRetries = [];
             retrySchedule.forEach((delayMs, index) => {
@@ -7320,6 +7439,18 @@ let SharedLog = (() => {
         }
         async runRepairSweep(repairLifecycleController = this._instanceLifecycle
             ?.ownershipLifecycleController) {
+            const profile = this._logProperties?.sync?.profile;
+            const startedAt = syncProfileStart(profile);
+            const profileCounts = profile
+                ? {
+                    passes: 0,
+                    inputEntries: 0,
+                    nativePasses: 0,
+                    repairCandidates: 0,
+                    repairBatches: 0,
+                    outcome: "stale",
+                }
+                : undefined;
             try {
                 while (this.isRepairLifecycleActive(repairLifecycleController)) {
                     if (!this.isRepairLifecycleActive(repairLifecycleController)) {
@@ -7351,8 +7482,12 @@ let SharedLog = (() => {
                     };
                     pruneStaleJoinWarmupPeers();
                     if (pendingModes.size === 0) {
+                        if (profileCounts)
+                            profileCounts.outcome = "completed";
                         return;
                     }
+                    if (profileCounts)
+                        profileCounts.passes += 1;
                     const optimisticGidPeersByMode = new Map();
                     const optimisticGidPeersConsumedByMode = new Map();
                     for (const mode of pendingModes) {
@@ -7423,6 +7558,10 @@ let SharedLog = (() => {
                             }
                             return;
                         }
+                        if (profileCounts) {
+                            profileCounts.repairCandidates += entries.size;
+                            profileCounts.repairBatches += 1;
+                        }
                         this.dispatchMaybeMissingEntries(target, entries, {
                             bypassRecentDedupe: true,
                             bypassKnownPeerHints: mode === "churn" ||
@@ -7473,6 +7612,10 @@ let SharedLog = (() => {
                     if ((this._nativeBackbone ?? this._nativeSharedLogState) &&
                         residentEntriesByHash &&
                         !this.hasCustomFindLeaders()) {
+                        if (profileCounts) {
+                            profileCounts.nativePasses += 1;
+                            profileCounts.inputEntries += residentEntriesByHash.size;
+                        }
                         const repairDispatchPlan = pruneStaleJoinWarmupPeers()
                             ? await this.planResidentRepairDispatchBatch({
                                 pendingModes,
@@ -7505,6 +7648,8 @@ let SharedLog = (() => {
                                 !iterator.done() &&
                                 pruneStaleJoinWarmupPeers()) {
                                 const entries = await iterator.next(REPAIR_SWEEP_ENTRY_BATCH_SIZE);
+                                if (profileCounts)
+                                    profileCounts.inputEntries += entries.length;
                                 if (!this.isRepairLifecycleActive(repairLifecycleController)) {
                                     return;
                                 }
@@ -7619,6 +7764,8 @@ let SharedLog = (() => {
                 }
             }
             catch (error) {
+                if (profileCounts)
+                    profileCounts.outcome = "error";
                 if (this.isRepairLifecycleActive(repairLifecycleController) &&
                     !isNotStartedError(error)) {
                     logger.error(`Repair sweep failed: ${error?.message ?? error}`);
@@ -7635,6 +7782,21 @@ let SharedLog = (() => {
                         void this.runRepairSweep(repairLifecycleController);
                     }
                 }
+                if (profileCounts) {
+                    emitAdvisorySyncProfileDuration(profile, startedAt, {
+                        name: "sharedLog.placement.pass",
+                        component: "shared-log",
+                        entries: profileCounts.inputEntries,
+                        count: profileCounts.repairCandidates,
+                        details: {
+                            phase: "repair-sweep",
+                            outcome: profileCounts.outcome,
+                            passes: profileCounts.passes,
+                            nativePasses: profileCounts.nativePasses,
+                            repairBatches: profileCounts.repairBatches,
+                        },
+                    });
+                }
             }
         }
         async pruneDebouncedFnAddIfNotKeeping(args, ownershipLifecycleController = this.captureReplicationOwnershipLifecycle(), additionalCurrentCheck) {
@@ -14013,6 +14175,10 @@ let SharedLog = (() => {
             const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
             try {
                 this.stopSubscriptionChangeCallbackAdmission();
+                // A receive may be awaiting a synchronizer response shipment. Cancel
+                // its dispatch generation before draining that receive, rather than
+                // waiting for _close() to reach the synchronizer's final teardown.
+                this.syncronizer?.beginClose?.();
                 this.joinWarmup.cancelAllJoinWarmupTargets();
                 await this.drainSubscriptionChangeCallbacks();
                 // An already-admitted subscription callback can create a fresh warmup
@@ -14149,6 +14315,7 @@ let SharedLog = (() => {
             const pruneRemoveTerminalFence = this.acquirePruneRemoveTerminalFence();
             try {
                 this.stopSubscriptionChangeCallbackAdmission();
+                this.syncronizer?.beginClose?.();
                 this.joinWarmup.cancelAllJoinWarmupTargets();
                 await this.drainSubscriptionChangeCallbacks();
                 // An already-admitted subscription callback can create a fresh warmup
@@ -14391,10 +14558,11 @@ let SharedLog = (() => {
             const rawExistingStartedAt = syncProfileStart(syncProfile);
             const rawExistingHashes = await this.log.hasMany(msg.heads.map((head) => head.hash));
             if (syncProfile) {
-                emitSyncProfileDuration(syncProfile, rawExistingStartedAt, {
+                emitAdvisorySyncProfileDuration(syncProfile, rawExistingStartedAt, {
                     name: "sharedLog.rawReceive.existingHeads",
                     component: "shared-log",
                     entries: msg.heads.length,
+                    count: rawExistingHashes.size,
                     messages: 1,
                 });
             }
@@ -14711,10 +14879,11 @@ let SharedLog = (() => {
                             ? undefined
                             : await this.log.hasMany(headHashes);
                         if (syncProfile) {
-                            emitSyncProfileDuration(syncProfile, existingStartedAt, {
+                            emitAdvisorySyncProfileDuration(syncProfile, existingStartedAt, {
                                 name: "sharedLog.receive.existingHeads",
                                 component: "shared-log",
                                 entries: heads.length,
+                                count: existingHashes?.size,
                                 messages: 1,
                                 details: { rawMaterializedKnownMissing },
                             });
@@ -20429,6 +20598,17 @@ let SharedLog = (() => {
                     warmupSessions.get(target);
             const areJoinWarmupGenerationsCurrent = () => isOwnershipLifecycleCurrent() &&
                 [...warmupPeers].every(isCurrentJoinWarmupTarget);
+            const profile = this._logProperties?.sync?.profile;
+            const profileStartedAt = syncProfileStart(profile);
+            const profileCounts = profile
+                ? {
+                    examinedEntries: 0,
+                    repairCandidates: 0,
+                    repairBatches: 0,
+                    pruneScan: false,
+                    outcome: "stale",
+                }
+                : undefined;
             try {
                 const uncheckedDeliver = new Map();
                 const flushUncheckedDeliverTarget = (target) => {
@@ -20449,6 +20629,10 @@ let SharedLog = (() => {
                         : isWarmupTarget
                             ? "join-warmup"
                             : "join-authoritative";
+                    if (profileCounts) {
+                        profileCounts.repairCandidates += entries.size;
+                        profileCounts.repairBatches += 1;
+                    }
                     this.dispatchMaybeMissingEntries(target, entries, {
                         bypassRecentDedupe: isWarmupTarget || forceFreshDelivery,
                         bypassKnownPeerHints: forceFreshDelivery ||
@@ -20487,6 +20671,8 @@ let SharedLog = (() => {
                     for await (const entryReplicated of toRebalance(immediateRebalanceChanges, this.entryCoordinatesIndex, this.recentlyRebalanced, {
                         forceFresh: forceFreshDelivery || useJoinWarmupFastPath,
                     })) {
+                        if (profileCounts)
+                            profileCounts.examinedEntries += 1;
                         if (!isOwnershipLifecycleCurrent() ||
                             (useJoinWarmupFastPath && !areJoinWarmupGenerationsCurrent())) {
                             break;
@@ -20683,6 +20869,8 @@ let SharedLog = (() => {
                             change.type === "removed" ||
                             change.type === "replaced"));
                 if (shouldRunLocalPruneScan) {
+                    if (profileCounts)
+                        profileCounts.pruneScan = true;
                     throwIfOwnershipLifecycleInactive();
                     // Adaptive range changes and fixed zero-width updates can make already-indexed
                     // local heads prunable even when the incremental rebalance scan misses them
@@ -20701,6 +20889,8 @@ let SharedLog = (() => {
                         return false;
                     }
                 }
+                if (profileCounts)
+                    profileCounts.outcome = "completed";
                 return changed;
             }
             catch (error) {
@@ -20710,9 +20900,30 @@ let SharedLog = (() => {
                 if (isNotStartedError(error)) {
                     return false; // we are not started yet, so no changes
                 }
+                if (profileCounts)
+                    profileCounts.outcome = "error";
                 logger.error(error.toString());
                 throw error;
             }
+            finally {
+                if (profileCounts) {
+                    emitAdvisorySyncProfileDuration(profile, profileStartedAt, {
+                        name: "sharedLog.placement.pass",
+                        component: "shared-log",
+                        entries: profileCounts.examinedEntries,
+                        count: profileCounts.repairCandidates,
+                        details: {
+                            phase: "range-change",
+                            outcome: profileCounts.outcome,
+                            changes: changes.length,
+                            repairBatches: profileCounts.repairBatches,
+                            pruneScan: profileCounts.pruneScan,
+                            forceFreshDelivery,
+                            joinWarmupFastPath: useJoinWarmupFastPath,
+                        },
+                    });
+                }
+            }
         }
         async _onUnsubscription(evt) {
             logger.trace(`Peer disconnected '${evt.detail.from.hashcode()}' from '${JSON.stringify(evt.detail.topics.map((x) => x))} '`);
@@ -20741,6 +20952,13 @@ let SharedLog = (() => {
             await this.handleSubscriptionChange(evt.detail.from, evt.detail.topics, true, subscriptionEpoch, evt.detail.session);
         }
         async rebalanceParticipation(ownershipLifecycleController = this.captureReplicationOwnershipLifecycle(), rebalanceParticipationDebounced = this.rebalanceParticipationDebounced) {
+            const profile = this._isAdaptiveReplicating
+                ? this._logProperties?.sync?.profile
+                : undefined;
+            const profileStartedAt = syncProfileStart(profile);
+            const profileDetails = profile
+                ? { outcome: "stale", idleRemainingMs: 0 }
+                : undefined;
             // Stage 3: the lifecycle owns all three identity terms. `lifecycle` may
             // go stale later; its deps late-bind to the host, so the debouncer term
             // still reads the current host field, and the role term can disagree
@@ -20772,6 +20990,11 @@ let SharedLog = (() => {
                 }
                 if (this._isAdaptiveReplicating) {
                     if (this.shouldDelayAdaptiveRebalance()) {
+                        if (profileDetails) {
+                            profileDetails.outcome = "idle-deferred";
+                            profileDetails.idleRemainingMs = Math.max(0, this.adaptiveRebalanceIdleMs -
+                                (Date.now() - this._lastLocalAppendAt));
+                        }
                         if (isCurrent()) {
                             void rebalanceParticipationDebounced?.call();
                         }
@@ -20781,11 +21004,18 @@ let SharedLog = (() => {
                     const usedMemory = await this.getMemoryUsage();
                     if (!isCurrent())
                         return false;
+                    if (profileDetails) {
+                        profileDetails.storageUsedBytes = usedMemory;
+                        profileDetails.storageObjectiveBytes =
+                            this.replicationController.maxMemoryLimit;
+                    }
                     this.scheduleReplicationStatusRefreshForStorage(usedMemory);
                     let dynamicRange = await this.getDynamicRange();
                     if (!isCurrent())
                         return false;
                     if (!dynamicRange) {
+                        if (profileDetails)
+                            profileDetails.outcome = "not-permitted";
                         return; // not allowed to replicate
                     }
                     if (this.replicationController.maxMemoryLimit != null &&
@@ -20805,13 +21035,24 @@ let SharedLog = (() => {
                     const totalParticipation = await this.calculateTotalParticipation();
                     if (!isCurrent())
                         return false;
+                    const cpuUsage = this.cpuUsage?.value();
+                    const stepStartedAt = syncProfileStart(profile);
                     const newFactor = this.replicationController.step({
                         memoryUsage: usedMemory,
                         currentFactor: dynamicRange.widthNormalized,
                         totalFactor: totalParticipation, // TODO use this._totalParticipation when flakiness is fixed
                         peerCount: peersSize,
-                        cpuUsage: this.cpuUsage?.value(),
+                        cpuUsage,
                     });
+                    if (profileDetails) {
+                        profileDetails.preStepMs = stepStartedAt - profileStartedAt;
+                        profileDetails.stepMs = syncProfileStart(profile) - stepStartedAt;
+                        profileDetails.currentFactor = dynamicRange.widthNormalized;
+                        profileDetails.proposedFactor = newFactor;
+                        profileDetails.totalFactor = totalParticipation;
+                        profileDetails.controllerPeerCount = peersSize;
+                        profileDetails.cpuUsage = cpuUsage;
+                    }
                     const absoluteDifference = Math.abs(dynamicRange.widthNormalized - newFactor);
                     const relativeDifference = absoluteDifference /
                         Math.max(dynamicRange.widthNormalized, RECALCULATE_PARTICIPATION_RELATIVE_DENOMINATOR_FLOOR);
@@ -20839,8 +21080,11 @@ let SharedLog = (() => {
                         if (!isCurrent())
                             return false;
                         if (!canReplicate) {
+                            if (profileDetails)
+                                profileDetails.outcome = "not-permitted";
                             return false;
                         }
+                        const applyStartedAt = syncProfileStart(profile);
                         await this.startAnnounceReplicating([dynamicRange], {
                             checkDuplicates: false,
                             reset: false,
@@ -20848,6 +21092,10 @@ let SharedLog = (() => {
                         }, ownershipLifecycleController);
                         if (!isCurrent())
                             return false;
+                        if (profileDetails) {
+                            profileDetails.outcome = "apply-settled";
+                            profileDetails.applyMs = syncProfileStart(profile) - applyStartedAt;
+                        }
                         /* await this._updateRole(newRole, onRoleChange); */
                         if (isCurrent()) {
                             void rebalanceParticipationDebounced?.call();
@@ -20855,6 +21103,8 @@ let SharedLog = (() => {
                         return true;
                     }
                     else {
+                        if (profileDetails)
+                            profileDetails.outcome = "unchanged";
                         if (isCurrent()) {
                             void rebalanceParticipationDebounced?.call();
                         }
@@ -20863,13 +21113,27 @@ let SharedLog = (() => {
                 }
                 return false;
             };
-            const resp = await fn().catch((error) => {
-                if (isNotStartedError(error) || isClosedStoreRace(error)) {
-                    return false;
+            try {
+                return await fn().catch((error) => {
+                    if (isNotStartedError(error) || isClosedStoreRace(error)) {
+                        if (profileDetails)
+                            profileDetails.outcome = "stale";
+                        return false;
+                    }
+                    if (profileDetails)
+                        profileDetails.outcome = "error";
+                    throw error;
+                });
+            }
+            finally {
+                if (profileDetails) {
+                    emitAdvisorySyncProfileDuration(profile, profileStartedAt, {
+                        name: "sharedLog.adaptive.rebalance",
+                        component: "shared-log",
+                        details: profileDetails,
+                    });
                 }
-                throw error;
-            });
-            return resp;
+            }
         }
         getDynamicRangeOffset() {
             const options = this._logProperties