@peerbit/shared-log 13.2.27 → 13.2.29

package/dist/src/index.js

@@ -475,7 +475,7 @@ const cloneRepairPendingPeersByMode = (pending) => new Map(REPAIR_DISPATCH_MODES
     new Set(pending.get(mode) ?? []),
 ]));
 const createRepairFrontierByMode = () => new Map(REPAIR_DISPATCH_MODES.map((mode) => [mode, new Map()]));
-const createRepairActiveTargetsByMode = () => new Map(REPAIR_DISPATCH_MODES.map((mode) => [mode, new Set()]));
+const createRepairActiveTargetsByMode = () => new Map(REPAIR_DISPATCH_MODES.map((mode) => [mode, new Map()]));
 const createRepairFrontierBypassKnownPeersByMode = () => new Map(REPAIR_DISPATCH_MODES.map((mode) => [mode, new Set()]));
 const getRepairRetrySchedule = (mode) => {
     switch (mode) {
@@ -4964,7 +4964,10 @@ let SharedLog = (() => {
                 !this.isRepairLifecycleActive(repairLifecycleController)) {
                 return;
             }
-            activeTargets.add(target);
+            const runnerToken = {};
+            activeTargets.set(target, runnerToken);
+            const isCurrentRunner = () => activeTargets.get(target) === runnerToken &&
+                this.isRepairLifecycleActive(repairLifecycleController);
             const retrySchedule = resolveRepairRetrySchedule(mode, retryScheduleMs, this.isFrontierTrackedRepairMode(mode));
             const steadyStateDelay = retrySchedule.length > 1
                 ? Math.max(1, retrySchedule[retrySchedule.length - 1] -
@@ -4974,12 +4977,12 @@ let SharedLog = (() => {
                 let attemptIndex = 0;
                 try {
                     for (;;) {
-                        if (!this.isRepairLifecycleActive(repairLifecycleController)) {
+                        if (!isCurrentRunner()) {
                             return;
                         }
                         const pending = this._repairFrontierByMode.get(mode)?.get(target);
                         if (!pending || pending.size === 0) {
-                            if (!this.isRepairLifecycleActive(repairLifecycleController)) {
+                            if (!isCurrentRunner()) {
                                 return;
                             }
                             this._repairFrontierBypassKnownPeersByMode
@@ -4994,7 +4997,7 @@ let SharedLog = (() => {
                             }
                             continue;
                         }
-                        if (!this.isRepairLifecycleActive(repairLifecycleController)) {
+                        if (!isCurrentRunner()) {
                             return;
                         }
                         await this.sendMaybeMissingEntriesNow(target, pending, {
@@ -5005,7 +5008,7 @@ let SharedLog = (() => {
                                 .get(mode)
                                 ?.has(target) === true,
                         }, repairLifecycleController);
-                        if (!this.isRepairLifecycleActive(repairLifecycleController)) {
+                        if (!isCurrentRunner()) {
                             return;
                         }
                         const remaining = this._repairFrontierByMode.get(mode)?.get(target);
@@ -5022,14 +5025,18 @@ let SharedLog = (() => {
                     }
                 }
                 finally {
-                    activeTargets.delete(target);
-                    if (this.isRepairLifecycleActive(repairLifecycleController) &&
-                        (this._repairFrontierByMode.get(mode)?.get(target)?.size || 0) > 0) {
-                        this.ensureRepairFrontierRunner(mode, target, retryScheduleMs, repairLifecycleController);
+                    if (activeTargets.get(target) === runnerToken) {
+                        activeTargets.delete(target);
+                        if (this.isRepairLifecycleActive(repairLifecycleController) &&
+                            (this._repairFrontierByMode.get(mode)?.get(target)?.size || 0) > 0) {
+                            this.ensureRepairFrontierRunner(mode, target, retryScheduleMs, repairLifecycleController);
+                        }
                     }
                 }
             })().catch((error) => {
-                activeTargets.delete(target);
+                if (activeTargets.get(target) === runnerToken) {
+                    activeTargets.delete(target);
+                }
                 if (this.isRepairLifecycleActive(repairLifecycleController)) {
                     logger.error(error);
                 }
@@ -11264,6 +11271,241 @@ let SharedLog = (() => {
                 resolveReleasedBlock: (hash) => backbone.rawReceiveBlockBytes(hash),
             });
         }
+        /**
+         * Normalize a raw exchange-heads receive into the regular exchange message
+         * consumed by the rest of the receive path. An undefined result means the
+         * message was fully handled (all heads were already present or the native
+         * receive plan dropped every head).
+         *
+         * This helper intentionally runs inside `onMessage`'s shared try/finally
+         * envelope so receive errors keep their existing classification and a
+         * wire-backed message keeps its single outer stash-release boundary.
+         */
+        async materializeRawReceiveMessage(msg, properties) {
+            const { from: rawFrom, stashBackedRawMessage, syncProfile, receiveOwnershipRevision, } = properties;
+            const fromIsSelf = rawFrom.equals(this.node.identity.publicKey);
+            if (syncProfile && !stashBackedRawMessage) {
+                // Per-message JS-side entry decode: the heads were
+                // borsh-decoded in TS (regular RPC path) instead of being
+                // resolved from the native wire stash. Zero on the fused
+                // hot path.
+                emitSyncProfileEvent(syncProfile, {
+                    name: "sharedLog.rawReceive.jsEntryDecode",
+                    component: "shared-log",
+                    entries: msg.heads.length,
+                    messages: 1,
+                });
+            }
+            const rawExistingStartedAt = syncProfileStart(syncProfile);
+            const rawExistingHashes = await this.log.hasMany(msg.heads.map((head) => head.hash));
+            if (syncProfile) {
+                emitSyncProfileDuration(syncProfile, rawExistingStartedAt, {
+                    name: "sharedLog.rawReceive.existingHeads",
+                    component: "shared-log",
+                    entries: msg.heads.length,
+                    messages: 1,
+                });
+            }
+            const rawMissingHeads = [];
+            const rawConfirmedHashes = new Set();
+            let rawMissingBytes = 0;
+            for (const head of msg.heads) {
+                if (rawExistingHashes.has(head.hash)) {
+                    rawConfirmedHashes.add(head.hash);
+                }
+                else {
+                    rawMissingHeads.push(head);
+                    rawMissingBytes += getRawExchangeHeadByteLength(head);
+                }
+            }
+            if (rawConfirmedHashes.size > 0 && !fromIsSelf) {
+                const rawConfirmStartedAt = syncProfileStart(syncProfile);
+                this.markEntriesKnownByPeer(rawConfirmedHashes, rawFrom.hashcode());
+                await this.sendRepairConfirmation(rawFrom, rawConfirmedHashes);
+                if (syncProfile) {
+                    emitSyncProfileDuration(syncProfile, rawConfirmStartedAt, {
+                        name: "sharedLog.rawReceive.confirmExisting",
+                        component: "shared-log",
+                        entries: rawConfirmedHashes.size,
+                        messages: 1,
+                    });
+                }
+            }
+            if (rawMissingHeads.length === 0) {
+                return undefined;
+            }
+            const rawIsRepairHint = (msg.reserved[0] & EXCHANGE_HEADS_REPAIR_HINT) !== 0;
+            const rawPrepareVerifySetting = this._logProperties?.sync?.rawExchangeHeadsVerifySignaturesDuringPrepare;
+            // A program-level canAppend hook must observe every entry before
+            // it commits, so the native join commit (which validates and
+            // commits entirely in wasm) is not used for programs that
+            // register one; those joins run through the lower-log batch
+            // join where the hook fires per entry.
+            const programCanAppend = !!this._logProperties?.canAppend;
+            const canVerifyPreparedRawReceiveOnCommit = !programCanAppend &&
+                !!this._nativeBackbone?.graph.commitVerifiedPreparedRawReceiveJoinBatch;
+            const canDeferRawReceiveVerificationUntilNativeSelection = !rawIsRepairHint &&
+                !!this._nativeBackbone?.verifyPreparedRawReceiveEntries &&
+                !this._isReplicating &&
+                !this.keep &&
+                !this.closed &&
+                !!this.syncronizer.onReceivedEntryHashes &&
+                rawMissingHeads.every((head) => head.gidRefrences.length === 0);
+            const verifyNativeBackboneSignaturesDuringPrepare = rawPrepareVerifySetting === true ||
+                (rawPrepareVerifySetting !== false &&
+                    (canDeferRawReceiveVerificationUntilNativeSelection ||
+                        (this._isReplicating &&
+                            !rawIsRepairHint &&
+                            !canVerifyPreparedRawReceiveOnCommit)));
+            const deferNativeBackboneSignatureVerificationUntilSelection = verifyNativeBackboneSignaturesDuringPrepare &&
+                canDeferRawReceiveVerificationUntilNativeSelection;
+            const deferNativeBackboneSignatureVerificationUntilCommit = deferNativeBackboneSignatureVerificationUntilSelection &&
+                !programCanAppend &&
+                !!this._nativeBackbone?.graph.commitVerifiedPreparedRawReceiveJoinBatch;
+            let rawPreparedReceiveSelectionValue;
+            let rawPreparedReceiveSelection;
+            const getRawPreparedReceiveSelection = async (heads, hashes) => {
+                if (rawPreparedReceiveSelectionValue) {
+                    return rawPreparedReceiveSelectionValue;
+                }
+                rawPreparedReceiveSelection ??=
+                    this.planNativePreparedRawReceiveSelection({
+                        heads,
+                        hashes,
+                        from: rawFrom,
+                    });
+                rawPreparedReceiveSelectionValue = await rawPreparedReceiveSelection;
+                return rawPreparedReceiveSelectionValue;
+            };
+            // Receive fusion: when this message was resolved from the wire
+            // stash, the prepared receive reads entry block bytes straight
+            // out of wasm memory (indexed into the stashed frame) instead
+            // of copying a JS blocks array across the boundary.
+            const rawStashIndexes = stashBackedRawMessage
+                ? getRawExchangeHeadStashIndexes(rawMissingHeads)
+                : undefined;
+            const prepareNativeBackboneExpectedColumns = stashBackedRawMessage && rawStashIndexes
+                ? ({ hashes, verifySignatures, }) => {
+                    const backbone = this._nativeBackbone;
+                    const wireSession = this._wireSyncSession;
+                    if (!backbone || !wireSession) {
+                        return undefined;
+                    }
+                    try {
+                        return backbone.prepareStashedRawReceiveExpectedColumnsBatch(wireSession, stashBackedRawMessage.messageId, rawStashIndexes, hashes, { verifySignatures });
+                    }
+                    catch {
+                        return undefined;
+                    }
+                }
+                : undefined;
+            const prepareNativeBackboneExpectedColumnsAndSelection = rawIsRepairHint
+                ? undefined
+                : async ({ blocks, hashes, verifySignatures, }) => {
+                    if (verifySignatures ||
+                        !canDeferRawReceiveVerificationUntilNativeSelection) {
+                        return undefined;
+                    }
+                    try {
+                        const replicaOptions = {
+                            minReplicas: this.replicas.min?.getValue(this) || 1,
+                            maxReplicas: this.replicas.max?.getValue(this),
+                        };
+                        const leaderSelectionContext = await this.createLeaderSelectionContext();
+                        const prepareOptions = {
+                            verifySignatures: false,
+                            ...replicaOptions,
+                            leaderOptions: this.createNativeLeaderOptions(leaderSelectionContext),
+                            fromHash: rawFrom.hashcode(),
+                        };
+                        let prepared;
+                        const wireSession = this._wireSyncSession;
+                        if (stashBackedRawMessage &&
+                            rawStashIndexes &&
+                            wireSession &&
+                            this._nativeBackbone) {
+                            prepared =
+                                this._nativeBackbone.prepareStashedRawReceiveExpectedColumnsAndSelectionBatch(wireSession, stashBackedRawMessage.messageId, rawStashIndexes, hashes, prepareOptions);
+                        }
+                        if (!prepared &&
+                            this._nativeBackbone
+                                ?.prepareRawReceiveExpectedColumnsAndSelectionBatch) {
+                            prepared =
+                                this._nativeBackbone.prepareRawReceiveExpectedColumnsAndSelectionBatch(blocks(), hashes, prepareOptions);
+                        }
+                        if (!prepared) {
+                            return undefined;
+                        }
+                        rawPreparedReceiveSelectionValue = prepared.selection;
+                        rawPreparedReceiveSelection = Promise.resolve(rawPreparedReceiveSelectionValue);
+                        return { columns: prepared.columns };
+                    }
+                    catch {
+                        this.throwIfReplicationOwnershipPoisoned();
+                        return undefined;
+                    }
+                };
+            const rawMaterializeStartedAt = syncProfileStart(syncProfile);
+            const materializedRawMessage = await materializeVerifiedRawExchangeHeadsMessage(new RawExchangeHeadsMessage({
+                heads: rawMissingHeads,
+                reserved: msg.reserved,
+            }), this.log, syncProfile, {
+                nativeBackbone: this._nativeBackbone,
+                verifyNativeBackboneSignaturesDuringPrepare: verifyNativeBackboneSignaturesDuringPrepare,
+                deferNativeBackboneSignatureVerificationUntilSelection: deferNativeBackboneSignatureVerificationUntilSelection,
+                deferNativeBackboneSignatureVerificationUntilCommit: deferNativeBackboneSignatureVerificationUntilCommit,
+                prepareNativeBackboneExpectedColumnsAndSelection: prepareNativeBackboneExpectedColumnsAndSelection,
+                prepareNativeBackboneExpectedColumns: prepareNativeBackboneExpectedColumns,
+                tryPreparedRawReceiveFastDrop: rawIsRepairHint
+                    ? undefined
+                    : async ({ heads, hashes }) => this.tryFastDropPreparedRawReceive({
+                        heads,
+                        hashes,
+                        from: rawFrom,
+                        fromIsSelf,
+                        syncProfile,
+                        selection: await getRawPreparedReceiveSelection(heads, hashes),
+                        receiveOwnershipRevision,
+                    }),
+                selectPreparedRawReceiveHashes: rawIsRepairHint
+                    ? undefined
+                    : async ({ heads, hashes }) => this.selectNativePreparedRawReceiveHashes({
+                        heads,
+                        hashes,
+                        from: rawFrom,
+                        fromIsSelf,
+                        syncProfile,
+                        selection: await getRawPreparedReceiveSelection(heads, hashes),
+                        receiveOwnershipRevision,
+                    }),
+            });
+            if (materializedRawMessage === undefined) {
+                if (syncProfile) {
+                    emitSyncProfileDuration(syncProfile, rawMaterializeStartedAt, {
+                        name: "sharedLog.rawReceive.materialize",
+                        component: "shared-log",
+                        entries: rawMissingHeads.length,
+                        bytes: rawMissingBytes,
+                        messages: 1,
+                        details: { nativeFastDropEarly: true },
+                    });
+                }
+                return undefined;
+            }
+            if (syncProfile) {
+                emitSyncProfileDuration(syncProfile, rawMaterializeStartedAt, {
+                    name: "sharedLog.rawReceive.materialize",
+                    component: "shared-log",
+                    entries: rawMissingHeads.length,
+                    bytes: rawMissingBytes,
+                    messages: 1,
+                });
+            }
+            return {
+                message: materializedRawMessage,
+                preparedSelection: rawPreparedReceiveSelectionValue,
+            };
+        }
         // Callback for receiving a message from the network
         async onMessage(msg, context) {
             const stashBackedRawMessage = isStashBackedRawExchangeHeadsMessage(msg)
@@ -11323,229 +11565,19 @@ let SharedLog = (() => {
                 let rawMaterializedKnownMissing = false;
                 let rawPreparedReceiveSelectionValue;
                 if (msg instanceof RawExchangeHeadsMessage) {
-                    const rawFrom = context.from;
-                    const fromIsSelf = rawFrom.equals(this.node.identity.publicKey);
-                    if (syncProfile && !stashBackedRawMessage) {
-                        // Per-message JS-side entry decode: the heads were
-                        // borsh-decoded in TS (regular RPC path) instead of being
-                        // resolved from the native wire stash. Zero on the fused
-                        // hot path.
-                        emitSyncProfileEvent(syncProfile, {
-                            name: "sharedLog.rawReceive.jsEntryDecode",
-                            component: "shared-log",
-                            entries: msg.heads.length,
-                            messages: 1,
-                        });
-                    }
-                    const rawExistingStartedAt = syncProfileStart(syncProfile);
-                    const rawExistingHashes = await this.log.hasMany(msg.heads.map((head) => head.hash));
-                    if (syncProfile) {
-                        emitSyncProfileDuration(syncProfile, rawExistingStartedAt, {
-                            name: "sharedLog.rawReceive.existingHeads",
-                            component: "shared-log",
-                            entries: msg.heads.length,
-                            messages: 1,
-                        });
-                    }
-                    const rawMissingHeads = [];
-                    const rawConfirmedHashes = new Set();
-                    let rawMissingBytes = 0;
-                    for (const head of msg.heads) {
-                        if (rawExistingHashes.has(head.hash)) {
-                            rawConfirmedHashes.add(head.hash);
-                        }
-                        else {
-                            rawMissingHeads.push(head);
-                            rawMissingBytes += getRawExchangeHeadByteLength(head);
-                        }
-                    }
-                    if (rawConfirmedHashes.size > 0 && !fromIsSelf) {
-                        const rawConfirmStartedAt = syncProfileStart(syncProfile);
-                        this.markEntriesKnownByPeer(rawConfirmedHashes, rawFrom.hashcode());
-                        await this.sendRepairConfirmation(rawFrom, rawConfirmedHashes);
-                        if (syncProfile) {
-                            emitSyncProfileDuration(syncProfile, rawConfirmStartedAt, {
-                                name: "sharedLog.rawReceive.confirmExisting",
-                                component: "shared-log",
-                                entries: rawConfirmedHashes.size,
-                                messages: 1,
-                            });
-                        }
-                    }
-                    if (rawMissingHeads.length === 0) {
-                        return;
-                    }
-                    const rawIsRepairHint = (msg.reserved[0] & EXCHANGE_HEADS_REPAIR_HINT) !== 0;
-                    const rawPrepareVerifySetting = this._logProperties?.sync
-                        ?.rawExchangeHeadsVerifySignaturesDuringPrepare;
-                    // A program-level canAppend hook must observe every entry before
-                    // it commits, so the native join commit (which validates and
-                    // commits entirely in wasm) is not used for programs that
-                    // register one; those joins run through the lower-log batch
-                    // join where the hook fires per entry.
-                    const programCanAppend = !!this._logProperties?.canAppend;
-                    const canVerifyPreparedRawReceiveOnCommit = !programCanAppend &&
-                        !!this._nativeBackbone?.graph
-                            .commitVerifiedPreparedRawReceiveJoinBatch;
-                    const canDeferRawReceiveVerificationUntilNativeSelection = !rawIsRepairHint &&
-                        !!this._nativeBackbone?.verifyPreparedRawReceiveEntries &&
-                        !this._isReplicating &&
-                        !this.keep &&
-                        !this.closed &&
-                        !!this.syncronizer.onReceivedEntryHashes &&
-                        rawMissingHeads.every((head) => head.gidRefrences.length === 0);
-                    const verifyNativeBackboneSignaturesDuringPrepare = rawPrepareVerifySetting === true ||
-                        (rawPrepareVerifySetting !== false &&
-                            (canDeferRawReceiveVerificationUntilNativeSelection ||
-                                (this._isReplicating &&
-                                    !rawIsRepairHint &&
-                                    !canVerifyPreparedRawReceiveOnCommit)));
-                    const deferNativeBackboneSignatureVerificationUntilSelection = verifyNativeBackboneSignaturesDuringPrepare &&
-                        canDeferRawReceiveVerificationUntilNativeSelection;
-                    const deferNativeBackboneSignatureVerificationUntilCommit = deferNativeBackboneSignatureVerificationUntilSelection &&
-                        !programCanAppend &&
-                        !!this._nativeBackbone?.graph
-                            .commitVerifiedPreparedRawReceiveJoinBatch;
-                    let rawPreparedReceiveSelection;
-                    const getRawPreparedReceiveSelection = async (heads, hashes) => {
-                        if (rawPreparedReceiveSelectionValue) {
-                            return rawPreparedReceiveSelectionValue;
-                        }
-                        rawPreparedReceiveSelection ??=
-                            this.planNativePreparedRawReceiveSelection({
-                                heads,
-                                hashes,
-                                from: rawFrom,
-                            });
-                        rawPreparedReceiveSelectionValue = await rawPreparedReceiveSelection;
-                        return rawPreparedReceiveSelectionValue;
-                    };
-                    // Receive fusion: when this message was resolved from the wire
-                    // stash, the prepared receive reads entry block bytes straight
-                    // out of wasm memory (indexed into the stashed frame) instead
-                    // of copying a JS blocks array across the boundary.
-                    const rawStashIndexes = stashBackedRawMessage
-                        ? getRawExchangeHeadStashIndexes(rawMissingHeads)
-                        : undefined;
-                    const prepareNativeBackboneExpectedColumns = stashBackedRawMessage && rawStashIndexes
-                        ? ({ hashes, verifySignatures, }) => {
-                            const backbone = this._nativeBackbone;
-                            const wireSession = this._wireSyncSession;
-                            if (!backbone || !wireSession) {
-                                return undefined;
-                            }
-                            try {
-                                return backbone.prepareStashedRawReceiveExpectedColumnsBatch(wireSession, stashBackedRawMessage.messageId, rawStashIndexes, hashes, { verifySignatures });
-                            }
-                            catch {
-                                return undefined;
-                            }
-                        }
-                        : undefined;
-                    const prepareNativeBackboneExpectedColumnsAndSelection = rawIsRepairHint
-                        ? undefined
-                        : async ({ blocks, hashes, verifySignatures, }) => {
-                            if (verifySignatures ||
-                                !canDeferRawReceiveVerificationUntilNativeSelection) {
-                                return undefined;
-                            }
-                            try {
-                                const replicaOptions = {
-                                    minReplicas: this.replicas.min?.getValue(this) || 1,
-                                    maxReplicas: this.replicas.max?.getValue(this),
-                                };
-                                const leaderSelectionContext = await this.createLeaderSelectionContext();
-                                const prepareOptions = {
-                                    verifySignatures: false,
-                                    ...replicaOptions,
-                                    leaderOptions: this.createNativeLeaderOptions(leaderSelectionContext),
-                                    fromHash: rawFrom.hashcode(),
-                                };
-                                let prepared;
-                                const wireSession = this._wireSyncSession;
-                                if (stashBackedRawMessage &&
-                                    rawStashIndexes &&
-                                    wireSession &&
-                                    this._nativeBackbone) {
-                                    prepared =
-                                        this._nativeBackbone.prepareStashedRawReceiveExpectedColumnsAndSelectionBatch(wireSession, stashBackedRawMessage.messageId, rawStashIndexes, hashes, prepareOptions);
-                                }
-                                if (!prepared &&
-                                    this._nativeBackbone
-                                        ?.prepareRawReceiveExpectedColumnsAndSelectionBatch) {
-                                    prepared =
-                                        this._nativeBackbone.prepareRawReceiveExpectedColumnsAndSelectionBatch(blocks(), hashes, prepareOptions);
-                                }
-                                if (!prepared) {
-                                    return undefined;
-                                }
-                                rawPreparedReceiveSelectionValue = prepared.selection;
-                                rawPreparedReceiveSelection = Promise.resolve(rawPreparedReceiveSelectionValue);
-                                return { columns: prepared.columns };
-                            }
-                            catch {
-                                this.throwIfReplicationOwnershipPoisoned();
-                                return undefined;
-                            }
-                        };
-                    const rawMaterializeStartedAt = syncProfileStart(syncProfile);
-                    const materializedRawMessage = await materializeVerifiedRawExchangeHeadsMessage(new RawExchangeHeadsMessage({
-                        heads: rawMissingHeads,
-                        reserved: msg.reserved,
-                    }), this.log, syncProfile, {
-                        nativeBackbone: this._nativeBackbone,
-                        verifyNativeBackboneSignaturesDuringPrepare: verifyNativeBackboneSignaturesDuringPrepare,
-                        deferNativeBackboneSignatureVerificationUntilSelection: deferNativeBackboneSignatureVerificationUntilSelection,
-                        deferNativeBackboneSignatureVerificationUntilCommit: deferNativeBackboneSignatureVerificationUntilCommit,
-                        prepareNativeBackboneExpectedColumnsAndSelection: prepareNativeBackboneExpectedColumnsAndSelection,
-                        prepareNativeBackboneExpectedColumns: prepareNativeBackboneExpectedColumns,
-                        tryPreparedRawReceiveFastDrop: rawIsRepairHint
-                            ? undefined
-                            : async ({ heads, hashes }) => this.tryFastDropPreparedRawReceive({
-                                heads,
-                                hashes,
-                                from: rawFrom,
-                                fromIsSelf,
-                                syncProfile,
-                                selection: await getRawPreparedReceiveSelection(heads, hashes),
-                                receiveOwnershipRevision,
-                            }),
-                        selectPreparedRawReceiveHashes: rawIsRepairHint
-                            ? undefined
-                            : async ({ heads, hashes }) => this.selectNativePreparedRawReceiveHashes({
-                                heads,
-                                hashes,
-                                from: rawFrom,
-                                fromIsSelf,
-                                syncProfile,
-                                selection: await getRawPreparedReceiveSelection(heads, hashes),
-                                receiveOwnershipRevision,
-                            }),
+                    const materializedRawReceive = await this.materializeRawReceiveMessage(msg, {
+                        from: context.from,
+                        stashBackedRawMessage,
+                        syncProfile,
+                        receiveOwnershipRevision,
                     });
-                    if (materializedRawMessage === undefined) {
-                        if (syncProfile) {
-                            emitSyncProfileDuration(syncProfile, rawMaterializeStartedAt, {
-                                name: "sharedLog.rawReceive.materialize",
-                                component: "shared-log",
-                                entries: rawMissingHeads.length,
-                                bytes: rawMissingBytes,
-                                messages: 1,
-                                details: { nativeFastDropEarly: true },
-                            });
-                        }
+                    if (materializedRawReceive === undefined) {
                         return;
                     }
-                    msg = materializedRawMessage;
+                    msg = materializedRawReceive.message;
+                    rawPreparedReceiveSelectionValue =
+                        materializedRawReceive.preparedSelection;
                     rawMaterializedKnownMissing = true;
-                    if (syncProfile) {
-                        emitSyncProfileDuration(syncProfile, rawMaterializeStartedAt, {
-                            name: "sharedLog.rawReceive.materialize",
-                            component: "shared-log",
-                            entries: rawMissingHeads.length,
-                            bytes: rawMissingBytes,
-                            messages: 1,
-                        });
-                    }
                 }
                 if (msg instanceof ExchangeHeadsMessage) {
                     /**