@peerbit/shared-log 13.1.18 → 13.2.1

package/dist/src/exchange-heads.js

@@ -32,15 +32,215 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
-import { field, fixedArray, variant, vec } from "@dao-xyz/borsh";
-import { Entry, EntryType } from "@peerbit/log";
+import { deserialize, field, fixedArray, variant, vec } from "@dao-xyz/borsh";
+import { cidifyString } from "@peerbit/blocks-interface";
+import { LamportClock as Clock, Entry, EntryType, Meta, ShallowEntry, ShallowMeta, Timestamp, calculateRawCidV1Batch, prepareRawEntryV0Batch, verifyEntryV0Ed25519StorageBatch, } from "@peerbit/log";
 import { Log } from "@peerbit/log";
 import { logger as loggerFn } from "@peerbit/logger";
 import { TransportMessage } from "./message.js";
+import { emitSyncProfileDuration, emitSyncProfileEvent, syncProfileStart, } from "./sync/profile.js";
 const logger = loggerFn("peerbit:shared-log:exchange-heads");
 const warn = logger.newScope("warn");
+const emitNativeBackboneRawPrepareProfile = (profile, nativeProfile, entries, bytes) => {
+    if (!profile || !nativeProfile) {
+        return;
+    }
+    const events = [
+        [
+            "sharedLog.rawReceive.nativePrepare.inputCopy",
+            nativeProfile.nativeBackboneRawReceiveInputCopyMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.prepare",
+            nativeProfile.nativeBackboneRawReceivePrepareMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.digest",
+            nativeProfile.nativeBackboneRawReceiveDigestMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.cidString",
+            nativeProfile.nativeBackboneRawReceiveCidStringMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.expectedCid",
+            nativeProfile.nativeBackboneRawReceiveExpectedCidMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.storageParse",
+            nativeProfile.nativeBackboneRawReceiveStorageParseMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.metaParse",
+            nativeProfile.nativeBackboneRawReceiveMetaParseMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.payloadParse",
+            nativeProfile.nativeBackboneRawReceivePayloadParseMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.signatureParse",
+            nativeProfile.nativeBackboneRawReceiveSignatureParseMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.signable",
+            nativeProfile.nativeBackboneRawReceiveSignableMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.verifyBatch",
+            nativeProfile.nativeBackboneRawReceiveVerifyBatchMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.verifyFallback",
+            nativeProfile.nativeBackboneRawReceiveVerifyFallbackMs,
+        ],
+        [
+            "sharedLog.rawReceive.nativePrepare.columns",
+            nativeProfile.nativeBackboneRawReceivePrepareColumnsMs,
+        ],
+    ];
+    for (const [name, durationMs] of events) {
+        if (durationMs > 0 ||
+            name === "sharedLog.rawReceive.nativePrepare.prepare") {
+            emitSyncProfileEvent(profile, {
+                name,
+                component: "shared-log",
+                durationMs,
+                entries,
+                bytes,
+                messages: 1,
+            });
+        }
+    }
+};
+const isPreparedRawEntryV0FactsColumns = (facts) => Array.isArray(facts);
+const preparedRawColumnValue = (values, index, label) => {
+    const value = values[index];
+    if (value === undefined) {
+        throw new Error(`Missing prepared raw receive ${label}`);
+    }
+    return value;
+};
+const preparedRawCid = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[0], index, "cid")
+    : facts.cid;
+const preparedRawHashDigestBytes = (facts, index, fallbackCid) => {
+    if (!isPreparedRawEntryV0FactsColumns(facts)) {
+        return facts.hashDigestBytes;
+    }
+    const digest = facts[1][index];
+    if (digest) {
+        return digest;
+    }
+    const cid = facts[0][index] ?? fallbackCid;
+    if (!cid) {
+        throw new Error("Missing prepared raw receive cid");
+    }
+    return cidifyString(cid).multihash.digest;
+};
+const preparedRawByteLength = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[2], index, "byte length")
+    : facts.byteLength;
+const preparedRawClockId = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[3], index, "clock id")
+    : facts.clockId;
+const preparedRawWallTime = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[4], index, "wall time")
+    : facts.wallTime;
+const preparedRawLogical = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[5], index, "logical time")
+    : facts.logical;
+const preparedRawGid = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[6], index, "gid")
+    : facts.gid;
+const preparedRawNext = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[7], index, "next hashes")
+    : facts.next;
+const preparedRawType = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[8], index, "entry type")
+    : facts.type;
+const preparedRawMetaBytes = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[9], index, "meta bytes")
+    : facts.metaBytes;
+const preparedRawMetaData = (facts, index) => isPreparedRawEntryV0FactsColumns(facts) ? facts[10][index] : facts.metaData;
+const preparedRawPayloadByteLength = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[11], index, "payload byte length")
+    : facts.payloadByteLength;
+const preparedRawSignatureVerified = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? preparedRawColumnValue(facts[12], index, "signature flag") !== 0
+    : facts.signatureVerified;
+const preparedRawRequestedReplicas = (facts, index) => {
+    const value = isPreparedRawEntryV0FactsColumns(facts)
+        ? facts[13]?.[index]
+        : facts.requestedReplicas;
+    return value && value > 0 ? value : undefined;
+};
+const preparedRawHashNumber = (facts, index) => isPreparedRawEntryV0FactsColumns(facts)
+    ? facts[14]?.[index]
+    : facts.hashNumber;
+const preparedRawFactsCount = (facts) => facts[0].length || facts[2].length;
+const preparedRawFactsHashes = (facts) => Array.isArray(facts[0])
+    ? [...facts[0]]
+    : facts.map((entry) => entry.cid);
+const attachPreparedRawShallowFacts = (shallow, facts, index, fallbackCid) => {
+    Object.defineProperties(shallow, {
+        getMetaBytes: {
+            value: () => preparedRawMetaBytes(facts, index),
+            configurable: true,
+        },
+        getHashDigestBytes: {
+            value: () => preparedRawHashDigestBytes(facts, index, fallbackCid),
+            configurable: true,
+        },
+    });
+    return shallow;
+};
 // Stored in the reserved bytes so older peers ignore the hint.
 export const EXCHANGE_HEADS_REPAIR_HINT = 1;
+/**
+ * Capability bit: the peer can receive `RawExchangeHeadsMessage` ([0, 7]).
+ * Advertised once per peer via {@link SyncCapabilitiesMessage} (and echoed by
+ * the per-request capability messages of the simple synchronizer), so live
+ * append gossip can pick the raw path without a per-request round trip.
+ */
+export const SYNC_CAPABILITY_RAW_EXCHANGE_HEADS = 1;
+/**
+ * One-shot capability advertisement, sent to a peer when it (or we) subscribe
+ * to the program topic and `sync.rawExchangeHeads` is enabled. Peers that do
+ * not know this message drop it as an unknown variant; peers that never
+ * advertise keep receiving the plain `ExchangeHeadsMessage` path.
+ */
+let SyncCapabilitiesMessage = (() => {
+    let _classDecorators = [variant([0, 10])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = TransportMessage;
+    let _capabilities_decorators;
+    let _capabilities_initializers = [];
+    let _capabilities_extraInitializers = [];
+    var SyncCapabilitiesMessage = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _capabilities_decorators = [field({ type: "u32" })];
+            __esDecorate(null, null, _capabilities_decorators, { kind: "field", name: "capabilities", static: false, private: false, access: { has: obj => "capabilities" in obj, get: obj => obj.capabilities, set: (obj, value) => { obj.capabilities = value; } }, metadata: _metadata }, _capabilities_initializers, _capabilities_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            SyncCapabilitiesMessage = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        capabilities = __runInitializers(this, _capabilities_initializers, void 0);
+        constructor(props) {
+            super();
+            __runInitializers(this, _capabilities_extraInitializers);
+            this.capabilities =
+                props?.capabilities ?? SYNC_CAPABILITY_RAW_EXCHANGE_HEADS;
+        }
+    };
+    return SyncCapabilitiesMessage = _classThis;
+})();
+export { SyncCapabilitiesMessage };
 /**
  * This thing allows use to faster sync since we can provide
  * references that can be read concurrently to
@@ -81,6 +281,48 @@ let EntryWithRefs = (() => {
     return EntryWithRefs = _classThis;
 })();
 export { EntryWithRefs };
+let RawEntryWithRefs = (() => {
+    let _classDecorators = [variant(1)];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _hash_decorators;
+    let _hash_initializers = [];
+    let _hash_extraInitializers = [];
+    let _bytes_decorators;
+    let _bytes_initializers = [];
+    let _bytes_extraInitializers = [];
+    let _gidRefrences_decorators;
+    let _gidRefrences_initializers = [];
+    let _gidRefrences_extraInitializers = [];
+    var RawEntryWithRefs = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _hash_decorators = [field({ type: "string" })];
+            _bytes_decorators = [field({ type: Uint8Array })];
+            _gidRefrences_decorators = [field({ type: vec("string") })];
+            __esDecorate(null, null, _hash_decorators, { kind: "field", name: "hash", static: false, private: false, access: { has: obj => "hash" in obj, get: obj => obj.hash, set: (obj, value) => { obj.hash = value; } }, metadata: _metadata }, _hash_initializers, _hash_extraInitializers);
+            __esDecorate(null, null, _bytes_decorators, { kind: "field", name: "bytes", static: false, private: false, access: { has: obj => "bytes" in obj, get: obj => obj.bytes, set: (obj, value) => { obj.bytes = value; } }, metadata: _metadata }, _bytes_initializers, _bytes_extraInitializers);
+            __esDecorate(null, null, _gidRefrences_decorators, { kind: "field", name: "gidRefrences", static: false, private: false, access: { has: obj => "gidRefrences" in obj, get: obj => obj.gidRefrences, set: (obj, value) => { obj.gidRefrences = value; } }, metadata: _metadata }, _gidRefrences_initializers, _gidRefrences_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RawEntryWithRefs = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        hash = __runInitializers(this, _hash_initializers, void 0);
+        bytes = (__runInitializers(this, _hash_extraInitializers), __runInitializers(this, _bytes_initializers, void 0));
+        gidRefrences = (__runInitializers(this, _bytes_extraInitializers), __runInitializers(this, _gidRefrences_initializers, void 0));
+        constructor(properties) {
+            __runInitializers(this, _gidRefrences_extraInitializers);
+            this.hash = properties.hash;
+            this.bytes = properties.bytes;
+            this.gidRefrences = properties.gidRefrences;
+        }
+    };
+    return RawEntryWithRefs = _classThis;
+})();
+export { RawEntryWithRefs };
 let ExchangeHeadsMessage = (() => {
     let _classDecorators = [variant([0, 0])];
     let _classDescriptor;
@@ -108,15 +350,491 @@ let ExchangeHeadsMessage = (() => {
         }
         heads = __runInitializers(this, _heads_initializers, void 0);
         reserved = (__runInitializers(this, _heads_extraInitializers), __runInitializers(this, _reserved_initializers, new Uint8Array(4)));
+        preparedHashes = __runInitializers(this, _reserved_extraInitializers);
         constructor(props) {
             super();
-            __runInitializers(this, _reserved_extraInitializers);
             this.heads = props.heads;
+            this.preparedHashes = props.preparedHashes;
         }
     };
     return ExchangeHeadsMessage = _classThis;
 })();
 export { ExchangeHeadsMessage };
+let RawExchangeHeadsMessage = (() => {
+    let _classDecorators = [variant([0, 7])];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = TransportMessage;
+    let _heads_decorators;
+    let _heads_initializers = [];
+    let _heads_extraInitializers = [];
+    let _reserved_decorators;
+    let _reserved_initializers = [];
+    let _reserved_extraInitializers = [];
+    var RawExchangeHeadsMessage = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _heads_decorators = [field({ type: vec(RawEntryWithRefs) })];
+            _reserved_decorators = [field({ type: fixedArray("u8", 4) })];
+            __esDecorate(null, null, _heads_decorators, { kind: "field", name: "heads", static: false, private: false, access: { has: obj => "heads" in obj, get: obj => obj.heads, set: (obj, value) => { obj.heads = value; } }, metadata: _metadata }, _heads_initializers, _heads_extraInitializers);
+            __esDecorate(null, null, _reserved_decorators, { kind: "field", name: "reserved", static: false, private: false, access: { has: obj => "reserved" in obj, get: obj => obj.reserved, set: (obj, value) => { obj.reserved = value; } }, metadata: _metadata }, _reserved_initializers, _reserved_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RawExchangeHeadsMessage = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        heads = __runInitializers(this, _heads_initializers, void 0);
+        reserved = (__runInitializers(this, _heads_extraInitializers), __runInitializers(this, _reserved_initializers, new Uint8Array(4)));
+        constructor(props) {
+            super();
+            __runInitializers(this, _reserved_extraInitializers);
+            this.heads = props.heads;
+            if (props.reserved) {
+                this.reserved = props.reserved;
+            }
+        }
+    };
+    return RawExchangeHeadsMessage = _classThis;
+})();
+export { RawExchangeHeadsMessage };
+/**
+ * A head of a stash-backed raw exchange message: hash/refs/length come from
+ * stash metadata; `bytes` materializes lazily (and is counted) because the
+ * fused receive path never needs the block bytes in JS.
+ */
+export class StashBackedRawEntryWithRefs {
+    message;
+    stashIndex;
+    hash;
+    gidRefrences;
+    byteLength;
+    bytesValue;
+    constructor(message, stashIndex, hash, gidRefrences, byteLength) {
+        this.message = message;
+        this.stashIndex = stashIndex;
+        this.hash = hash;
+        this.gidRefrences = gidRefrences;
+        this.byteLength = byteLength;
+    }
+    get bytes() {
+        return (this.bytesValue ??= this.message.materializeHeadBytes(this.stashIndex, this.hash));
+    }
+}
+/**
+ * A raw exchange-heads message resolved from the native wire stash instead of
+ * a TS borsh decode: JS holds only head facts while the entry block bytes stay
+ * in wasm memory until `prepareStashedRawReceive*` consumes them there — or a
+ * fallback path materializes them per head.
+ */
+export class StashBackedRawExchangeHeadsMessage extends RawExchangeHeadsMessage {
+    messageId;
+    /** Wasm-to-JS head byte materializations (0 on the fully fused path). */
+    bytesMaterializedCount = 0;
+    released = false;
+    stash;
+    resolveReleasedBlock;
+    constructor(properties) {
+        const heads = new Array(properties.hashes.length);
+        super({ heads, reserved: properties.reserved });
+        this.messageId = properties.messageId;
+        this.stash = properties.stash;
+        this.resolveReleasedBlock = properties.resolveReleasedBlock;
+        for (let i = 0; i < properties.hashes.length; i++) {
+            heads[i] = new StashBackedRawEntryWithRefs(this, i, properties.hashes[i], properties.gidRefrences[i] ?? [], properties.byteLengths[i]);
+        }
+    }
+    materializeHeadBytes(index, hash) {
+        if (!this.released) {
+            const bytes = this.stash.stashedBlocks(this.messageId, Uint32Array.of(index))?.[0];
+            if (bytes) {
+                this.bytesMaterializedCount++;
+                return bytes;
+            }
+        }
+        const bytes = this.resolveReleasedBlock?.(hash);
+        if (bytes) {
+            this.bytesMaterializedCount++;
+            return bytes;
+        }
+        throw new Error("Stashed raw exchange head bytes are no longer available: " + hash);
+    }
+    release() {
+        if (this.released) {
+            return false;
+        }
+        this.released = true;
+        return this.stash.release(this.messageId);
+    }
+}
+export const isStashBackedRawExchangeHeadsMessage = (message) => message instanceof StashBackedRawExchangeHeadsMessage;
+export const getRawExchangeHeadByteLength = (head) => head instanceof StashBackedRawEntryWithRefs
+    ? head.byteLength
+    : head.bytes.byteLength;
+/**
+ * Stash indexes for a subset of a stash-backed message's heads (in subset
+ * order), or undefined when any head is not stash-backed.
+ */
+export const getRawExchangeHeadStashIndexes = (heads) => {
+    const indexes = new Uint32Array(heads.length);
+    for (let i = 0; i < heads.length; i++) {
+        const head = heads[i];
+        if (!(head instanceof StashBackedRawEntryWithRefs)) {
+            return undefined;
+        }
+        indexes[i] = head.stashIndex;
+    }
+    return indexes;
+};
+const isIterableRawReceiveHashSelection = (selection) => typeof selection[Symbol.iterator] === "function";
+const materializeRawExchangeEntry = (options) => {
+    const entry = deserialize(options.bytes, Entry);
+    entry.hash = undefined;
+    Entry.prepareMultihashBytes(entry, options.bytes, options.hash);
+    entry.hash = options.hash;
+    entry.size = options.size;
+    entry.init({
+        keychain: options.keychain,
+        encoding: options.encoding,
+    });
+    prepareRawExchangeHeadEntryFacts(entry, {
+        hash: options.hash,
+        bytes: options.bytes,
+        gidRefrences: options.gidRefrences,
+    });
+    return entry;
+};
+class PreparedRawExchangeEntry extends Entry {
+    bytesSource;
+    facts;
+    factsIndex;
+    onJsEntryDecode;
+    hash;
+    size;
+    createdLocally;
+    materialized;
+    metaValue;
+    shallowHeadValue;
+    keychain;
+    encodingValue;
+    bytesValue;
+    constructor(bytesSource, facts, factsIndex = 0, onJsEntryDecode) {
+        super();
+        this.bytesSource = bytesSource;
+        this.facts = facts;
+        this.factsIndex = factsIndex;
+        this.onJsEntryDecode = onJsEntryDecode;
+        this.size = preparedRawByteLength(facts, factsIndex);
+    }
+    /**
+     * Lazy: stash-backed heads keep the block bytes in wasm memory; they are
+     * copied out only when a consumer actually needs them (payload/signature
+     * materialization, storage bytes).
+     */
+    get bytes() {
+        return (this.bytesValue ??= this.bytesSource());
+    }
+    get meta() {
+        return (this.metaValue ??= new Meta({
+            gid: preparedRawGid(this.facts, this.factsIndex),
+            clock: new Clock({
+                id: preparedRawClockId(this.facts, this.factsIndex),
+                timestamp: new Timestamp({
+                    wallTime: preparedRawWallTime(this.facts, this.factsIndex),
+                    logical: preparedRawLogical(this.facts, this.factsIndex),
+                }),
+            }),
+            next: preparedRawNext(this.facts, this.factsIndex),
+            type: preparedRawType(this.facts, this.factsIndex),
+            data: preparedRawMetaData(this.facts, this.factsIndex),
+        }));
+    }
+    set meta(value) {
+        this.metaValue = value;
+    }
+    init(props) {
+        this.keychain = props.keychain ?? props._keychain;
+        this.encodingValue = props.encoding ?? props._encoding;
+        this.materialized?.init(props);
+        return this;
+    }
+    get encoding() {
+        if (!this.encodingValue) {
+            throw new Error("Not initialized");
+        }
+        return this.encodingValue;
+    }
+    get payload() {
+        return this.materialize().payload;
+    }
+    get signatures() {
+        return this.materialize().signatures;
+    }
+    get publicKeys() {
+        return this.materialize().publicKeys;
+    }
+    get __peerbitSignatureVerified() {
+        return preparedRawSignatureVerified(this.facts, this.factsIndex);
+    }
+    get __peerbitRequestedReplicas() {
+        return preparedRawRequestedReplicas(this.facts, this.factsIndex);
+    }
+    get __peerbitHashNumber() {
+        return preparedRawHashNumber(this.facts, this.factsIndex);
+    }
+    get __peerbitGid() {
+        return preparedRawGid(this.facts, this.factsIndex);
+    }
+    get __peerbitWallTime() {
+        return preparedRawWallTime(this.facts, this.factsIndex);
+    }
+    get __peerbitLogical() {
+        return preparedRawLogical(this.facts, this.factsIndex);
+    }
+    get __peerbitNext() {
+        return preparedRawNext(this.facts, this.factsIndex);
+    }
+    getMeta() {
+        return this.meta;
+    }
+    getMetaBytes() {
+        return preparedRawMetaBytes(this.facts, this.factsIndex);
+    }
+    getHashDigestBytes() {
+        return preparedRawHashDigestBytes(this.facts, this.factsIndex, this.hash);
+    }
+    getClock() {
+        return this.meta.clock;
+    }
+    getNext() {
+        return this.meta.next;
+    }
+    getSignatures() {
+        return this.materialize().getSignatures();
+    }
+    getPayloadValue() {
+        return this.materialize().getPayloadValue();
+    }
+    getStorageBytes() {
+        return this.bytes;
+    }
+    async verifySignatures() {
+        if (preparedRawSignatureVerified(this.facts, this.factsIndex)) {
+            return true;
+        }
+        try {
+            const result = await verifyEntryV0Ed25519StorageBatch([this.bytes]);
+            if (result) {
+                return result.every(Boolean);
+            }
+        }
+        catch {
+            // Fall back to full materialization for encrypted or non-Ed25519 entries.
+        }
+        return this.materialize().verifySignatures();
+    }
+    equals(other) {
+        return this.hash === other.hash || this.materialize().equals(other);
+    }
+    toSignable() {
+        return this.materialize().toSignable();
+    }
+    toShallow(isHead) {
+        if (isHead && this.shallowHeadValue) {
+            this.shallowHeadValue.head = true;
+            return this.shallowHeadValue;
+        }
+        const clock = this.getClock();
+        const shallow = attachPreparedRawShallowFacts(new ShallowEntry({
+            hash: this.hash,
+            payloadSize: preparedRawPayloadByteLength(this.facts, this.factsIndex),
+            head: isHead,
+            meta: new ShallowMeta({
+                gid: preparedRawGid(this.facts, this.factsIndex),
+                data: preparedRawMetaData(this.facts, this.factsIndex),
+                clock,
+                next: preparedRawNext(this.facts, this.factsIndex),
+                type: preparedRawType(this.facts, this.factsIndex),
+            }),
+        }), this.facts, this.factsIndex, this.hash);
+        if (isHead) {
+            this.shallowHeadValue = shallow;
+        }
+        return shallow;
+    }
+    toPreparedAppendJoinFacts() {
+        const shallow = this.toShallow(true);
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        return {
+            hash: this.hash,
+            // Lazy: stash-backed heads keep entry bytes in wasm memory and the
+            // native prepared-join commit never reads them in JS.
+            get bytes() {
+                return self.bytes;
+            },
+            byteLength: this.size,
+            meta: shallow.meta,
+            getShallowEntry: (isHead = true) => this.toShallow(isHead),
+            materializeEntry: () => this,
+        };
+    }
+    materialize() {
+        if (this.materialized) {
+            return this.materialized;
+        }
+        this.onJsEntryDecode?.();
+        const entry = materializeRawExchangeEntry({
+            hash: this.hash,
+            bytes: this.bytes,
+            size: this.size,
+            keychain: this.keychain,
+            encoding: this.encoding,
+            gidRefrences: [],
+        });
+        this.materialized = entry;
+        return entry;
+    }
+}
+class PreparedRawEntryWithRefs {
+    head;
+    facts;
+    factsIndex;
+    onJsEntryDecode;
+    gidRefrences;
+    entryValue;
+    shallowHeadValue;
+    keychain;
+    encodingValue;
+    constructor(head, facts, factsIndex = 0, onJsEntryDecode) {
+        this.head = head;
+        this.facts = facts;
+        this.factsIndex = factsIndex;
+        this.onJsEntryDecode = onJsEntryDecode;
+        this.gidRefrences = head.gidRefrences;
+    }
+    get entry() {
+        if (!this.entryValue) {
+            const head = this.head;
+            const entry = new PreparedRawExchangeEntry(() => head.bytes, this.facts, this.factsIndex, this.onJsEntryDecode);
+            // Lazy block registration: stash-backed heads keep the bytes in
+            // wasm memory until a consumer (block store put, payload
+            // materialization) actually pulls them.
+            Entry.prepareMultihashBytesLazy(entry, head.hash, preparedRawByteLength(this.facts, this.factsIndex), () => head.bytes);
+            entry.hash = head.hash;
+            entry.size = preparedRawByteLength(this.facts, this.factsIndex);
+            if (this.keychain || this.encodingValue) {
+                entry.init({
+                    keychain: this.keychain,
+                    encoding: this.encodingValue,
+                });
+            }
+            this.entryValue = entry;
+        }
+        return this.entryValue;
+    }
+    set entry(value) {
+        if (value) {
+            this.entryValue = value;
+        }
+    }
+    initEntry(props) {
+        this.keychain = props.keychain ?? props._keychain;
+        this.encodingValue = props.encoding ?? props._encoding;
+        this.entryValue?.init(props);
+    }
+    get hash() {
+        return this.head.hash;
+    }
+    get preparedGid() {
+        return preparedRawGid(this.facts, this.factsIndex);
+    }
+    get preparedRequestedReplicas() {
+        return preparedRawRequestedReplicas(this.facts, this.factsIndex);
+    }
+    get preparedSignatureVerified() {
+        return preparedRawSignatureVerified(this.facts, this.factsIndex);
+    }
+    toShallow(isHead = true) {
+        if (isHead && this.shallowHeadValue) {
+            this.shallowHeadValue.head = true;
+            return this.shallowHeadValue;
+        }
+        const clock = new Clock({
+            id: preparedRawClockId(this.facts, this.factsIndex),
+            timestamp: new Timestamp({
+                wallTime: preparedRawWallTime(this.facts, this.factsIndex),
+                logical: preparedRawLogical(this.facts, this.factsIndex),
+            }),
+        });
+        const shallow = attachPreparedRawShallowFacts(new ShallowEntry({
+            hash: this.head.hash,
+            payloadSize: preparedRawPayloadByteLength(this.facts, this.factsIndex),
+            head: isHead,
+            meta: new ShallowMeta({
+                gid: preparedRawGid(this.facts, this.factsIndex),
+                data: preparedRawMetaData(this.facts, this.factsIndex),
+                clock,
+                next: preparedRawNext(this.facts, this.factsIndex),
+                type: preparedRawType(this.facts, this.factsIndex),
+            }),
+        }), this.facts, this.factsIndex, this.head.hash);
+        if (isHead) {
+            this.shallowHeadValue = shallow;
+        }
+        return shallow;
+    }
+    toPreparedAppendJoinFacts() {
+        const shallow = this.toShallow(true);
+        const head = this.head;
+        return {
+            hash: head.hash,
+            // Lazy: stash-backed heads keep entry bytes in wasm memory and the
+            // native prepared-join commit never reads them in JS.
+            get bytes() {
+                return head.bytes;
+            },
+            byteLength: preparedRawByteLength(this.facts, this.factsIndex),
+            meta: shallow.meta,
+            getShallowEntry: (isHead = true) => this.toShallow(isHead),
+            materializeEntry: () => this.entry,
+        };
+    }
+}
+export const isPreparedRawEntryWithRefs = (head) => head instanceof PreparedRawEntryWithRefs;
+export const getExchangeHeadHash = (head) => isPreparedRawEntryWithRefs(head) ? head.hash : head.entry.hash;
+export const initExchangeHeadEntry = (head, props) => {
+    if (isPreparedRawEntryWithRefs(head)) {
+        head.initEntry(props);
+        return;
+    }
+    head.entry.init(props);
+};
+export const getPreparedRawExchangeHeadGid = (head) => isPreparedRawEntryWithRefs(head) ? head.preparedGid : undefined;
+export const getPreparedRawExchangeHeadRequestedReplicas = (head) => isPreparedRawEntryWithRefs(head) ? head.preparedRequestedReplicas : undefined;
+export const getPreparedRawExchangeHeadSignatureVerified = (head) => isPreparedRawEntryWithRefs(head) ? head.preparedSignatureVerified : undefined;
+export const getPreparedRawExchangeHeadShallowEntry = (head) => isPreparedRawEntryWithRefs(head) ? head.toShallow(true) : undefined;
+export const getPreparedRawExchangeHeadAppendFacts = (head) => isPreparedRawEntryWithRefs(head)
+    ? head.toPreparedAppendJoinFacts()
+    : getPreparedRawExchangeAppendFacts(head.entry);
+export const getPreparedRawExchangeAppendFacts = (entry) => entry instanceof PreparedRawExchangeEntry
+    ? entry.toPreparedAppendJoinFacts()
+    : undefined;
+export const getPreparedRawExchangeRequestedReplicas = (entry) => entry instanceof PreparedRawExchangeEntry
+    ? entry.__peerbitRequestedReplicas
+    : undefined;
+export const getPreparedRawExchangeHashNumber = (entry) => entry instanceof PreparedRawExchangeEntry
+    ? entry.__peerbitHashNumber
+    : undefined;
+export const getPreparedRawExchangeGid = (entry) => entry instanceof PreparedRawExchangeEntry ? entry.__peerbitGid : undefined;
+export const getPreparedRawExchangeTimestamp = (entry) => entry instanceof PreparedRawExchangeEntry
+    ? {
+        wallTime: entry.__peerbitWallTime,
+        logical: entry.__peerbitLogical,
+    }
+    : undefined;
+export const getPreparedRawExchangeNext = (entry) => entry instanceof PreparedRawExchangeEntry ? entry.__peerbitNext : undefined;
 let RequestIPrune = (() => {
     let _classDecorators = [variant([0, 3])];
     let _classDescriptor;
@@ -180,40 +898,101 @@ let ResponseIPrune = (() => {
 })();
 export { ResponseIPrune };
 const MAX_EXCHANGE_MESSAGE_SIZE = 1e5; // 100kb. Too large size might not be faster (even if we can do 5mb)
+export const MAX_RAW_EXCHANGE_MESSAGE_SIZE = 512 * 1024;
+export const EXCHANGE_HEADS_RESOLVE_BATCH_SIZE = 256;
 export const createExchangeHeadsMessages = async function* (log, heads) {
     let size = 0;
     let current = [];
     const visitedHeads = new Set();
-    for (const fromHead of heads) {
-        let entry = fromHead instanceof Entry ? fromHead : await log.get(fromHead);
-        if (!entry) {
-            continue; // missing this entry, could be deleted while iterating
-        }
-        visitedHeads.add(entry.hash);
-        // TODO eventually we don't want to load all refs
-        // since majority of the old leader would not be interested in these anymore
-        const refs = (await allEntriesWithUniqueGids(log, entry)).filter((x) => {
-            if (visitedHeads.has(x.hash)) {
-                return false;
-            }
-            visitedHeads.add(x.hash);
-            return true;
-        });
-        if (refs.length > 1000) {
-            warn("Large refs count: ", refs.length);
-        }
-        current.push(new EntryWithRefs({
-            entry,
-            gidRefrences: refs.map((x) => x.meta.gid),
-        }));
-        size += entry.size;
-        if (size > MAX_EXCHANGE_MESSAGE_SIZE) {
-            size = 0;
-            yield new ExchangeHeadsMessage({
-                heads: current,
+    const headArray = Array.isArray(heads) ? heads : [...heads];
+    const canUseNativeReferenceGids = headArray.length === 1;
+    for (let offset = 0; offset < headArray.length; offset += EXCHANGE_HEADS_RESOLVE_BATCH_SIZE) {
+        const headBatch = headArray.slice(offset, offset + EXCHANGE_HEADS_RESOLVE_BATCH_SIZE);
+        const nativeReferenceRowsByPosition = canUseNativeReferenceGids === false
+            ? getNativeReferenceRowsByHeadInput(log, headBatch, visitedHeads)
+            : undefined;
+        const resolvedHeads = await resolveExchangeHeadEntries(log, headBatch, visitedHeads);
+        for (let i = 0; i < resolvedHeads.length; i++) {
+            const entry = resolvedHeads[i];
+            if (!entry) {
+                continue; // missing this entry, could be deleted while iterating
+            }
+            if (visitedHeads.has(entry.hash)) {
+                continue;
+            }
+            visitedHeads.add(entry.hash);
+            const nativeGidReferences = canUseNativeReferenceGids
+                ? log.entryIndex.getUniqueReferenceGids(entry.hash)
+                : undefined;
+            if (nativeGidReferences) {
+                if (nativeGidReferences.length > 1000) {
+                    warn("Large refs count: ", nativeGidReferences.length);
+                }
+                current.push(new EntryWithRefs({
+                    entry,
+                    gidRefrences: nativeGidReferences,
+                }));
+                size += entry.size;
+                if (size > MAX_EXCHANGE_MESSAGE_SIZE) {
+                    size = 0;
+                    yield new ExchangeHeadsMessage({
+                        heads: current,
+                    });
+                    current = [];
+                }
+                continue;
+            }
+            const nativeReferenceRows = nativeReferenceRowsByPosition?.[i];
+            if (nativeReferenceRows) {
+                const gidRefrences = [];
+                for (const [hash, gid] of nativeReferenceRows) {
+                    if (visitedHeads.has(hash)) {
+                        continue;
+                    }
+                    visitedHeads.add(hash);
+                    gidRefrences.push(gid);
+                }
+                if (gidRefrences.length > 1000) {
+                    warn("Large refs count: ", gidRefrences.length);
+                }
+                current.push(new EntryWithRefs({
+                    entry,
+                    gidRefrences,
+                }));
+                size += entry.size;
+                if (size > MAX_EXCHANGE_MESSAGE_SIZE) {
+                    size = 0;
+                    yield new ExchangeHeadsMessage({
+                        heads: current,
+                    });
+                    current = [];
+                }
+                continue;
+            }
+            // Fallback for logs without native reference rows.
+            const refs = (await allEntriesWithUniqueGids(log, entry)).filter((x) => {
+                if (visitedHeads.has(x.hash)) {
+                    return false;
+                }
+                visitedHeads.add(x.hash);
+                return true;
             });
-            current = [];
-            continue;
+            if (refs.length > 1000) {
+                warn("Large refs count: ", refs.length);
+            }
+            current.push(new EntryWithRefs({
+                entry,
+                gidRefrences: refs.map((x) => x.meta.gid),
+            }));
+            size += entry.size;
+            if (size > MAX_EXCHANGE_MESSAGE_SIZE) {
+                size = 0;
+                yield new ExchangeHeadsMessage({
+                    heads: current,
+                });
+                current = [];
+                continue;
+            }
         }
     }
     if (current.length > 0) {
@@ -222,6 +1001,684 @@ export const createExchangeHeadsMessages = async function* (log, heads) {
         });
     }
 };
+export const createRawExchangeHeadsMessages = async function* (log, heads, profile) {
+    let size = 0;
+    let current = [];
+    const visitedHeads = new Set();
+    const headArray = Array.isArray(heads) ? heads : [...heads];
+    // This path materializes entry block bytes as JS values (log.blocks reads)
+    // and TS-serializes the message; the fused wasm send path replaces it.
+    // The event makes the remaining JS-side outbound block copies countable.
+    const emitJsBlockBytes = (heads, bytes) => {
+        if (profile) {
+            emitSyncProfileEvent(profile, {
+                name: "sharedLog.rawSend.jsBlockBytes",
+                component: "shared-log",
+                entries: heads.length,
+                bytes,
+                messages: 1,
+            });
+        }
+    };
+    for (let offset = 0; offset < headArray.length; offset += EXCHANGE_HEADS_RESOLVE_BATCH_SIZE) {
+        const headBatch = headArray.slice(offset, offset + EXCHANGE_HEADS_RESOLVE_BATCH_SIZE);
+        const nativeReferenceRowsByPosition = getNativeReferenceRowsByHeadInput(log, headBatch, visitedHeads);
+        if (!nativeReferenceRowsByPosition) {
+            for await (const message of createExchangeHeadsMessages(log, headBatch)) {
+                yield message;
+            }
+            continue;
+        }
+        const blockRows = await resolveExchangeHeadBlocks(log, headBatch, visitedHeads);
+        if (!blockRows) {
+            for await (const message of createExchangeHeadsMessages(log, headBatch)) {
+                yield message;
+            }
+            continue;
+        }
+        for (let i = 0; i < blockRows.length; i++) {
+            const block = blockRows[i];
+            if (!block) {
+                continue;
+            }
+            if (visitedHeads.has(block.hash)) {
+                continue;
+            }
+            visitedHeads.add(block.hash);
+            const nativeReferenceRows = nativeReferenceRowsByPosition[i];
+            if (!nativeReferenceRows) {
+                continue;
+            }
+            const gidRefrences = [];
+            for (const [hash, gid] of nativeReferenceRows) {
+                if (visitedHeads.has(hash)) {
+                    continue;
+                }
+                visitedHeads.add(hash);
+                gidRefrences.push(gid);
+            }
+            if (gidRefrences.length > 1000) {
+                warn("Large refs count: ", gidRefrences.length);
+            }
+            current.push(new RawEntryWithRefs({
+                hash: block.hash,
+                bytes: block.bytes,
+                gidRefrences,
+            }));
+            size += block.bytes.byteLength;
+            if (size > MAX_RAW_EXCHANGE_MESSAGE_SIZE) {
+                emitJsBlockBytes(current, size);
+                size = 0;
+                yield new RawExchangeHeadsMessage({ heads: current });
+                current = [];
+            }
+        }
+    }
+    if (current.length > 0) {
+        emitJsBlockBytes(current, size);
+        yield new RawExchangeHeadsMessage({ heads: current });
+    }
+};
+/**
+ * The head/reference selection of {@link createRawExchangeHeadsMessages}
+ * without resolving any block bytes: same visited-head deduplication, same
+ * reference-gid collection, same batching of the native index lookups. Used
+ * by the fused send path, where the block bytes stay in the native store and
+ * the payload is serialized in wasm. Returns `undefined` when the log has no
+ * native reference rows (callers fall back to the TS message path).
+ */
+export const collectRawExchangeHeadSendPlan = (log, heads) => {
+    const headArray = Array.isArray(heads) ? heads : [...heads];
+    const visitedHeads = new Set();
+    const hashes = [];
+    const gidRefrences = [];
+    for (let offset = 0; offset < headArray.length; offset += EXCHANGE_HEADS_RESOLVE_BATCH_SIZE) {
+        const headBatch = headArray.slice(offset, offset + EXCHANGE_HEADS_RESOLVE_BATCH_SIZE);
+        const nativeReferenceRowsByPosition = getNativeReferenceRowsByHeadInput(log, headBatch, visitedHeads);
+        if (!nativeReferenceRowsByPosition) {
+            return undefined;
+        }
+        for (let i = 0; i < headBatch.length; i++) {
+            const hash = headBatch[i];
+            if (visitedHeads.has(hash)) {
+                continue;
+            }
+            visitedHeads.add(hash);
+            const nativeReferenceRows = nativeReferenceRowsByPosition[i];
+            if (!nativeReferenceRows) {
+                continue;
+            }
+            const refs = [];
+            for (const [refHash, gid] of nativeReferenceRows) {
+                if (visitedHeads.has(refHash)) {
+                    continue;
+                }
+                visitedHeads.add(refHash);
+                refs.push(gid);
+            }
+            if (refs.length > 1000) {
+                warn("Large refs count: ", refs.length);
+            }
+            hashes.push(hash);
+            gidRefrences.push(refs);
+        }
+    }
+    return { hashes, gidRefrences };
+};
+export const materializeRawExchangeHeadsMessage = (message, log) => {
+    const materialized = new ExchangeHeadsMessage({
+        heads: message.heads.map((head) => {
+            const entry = deserialize(head.bytes, Entry);
+            entry.hash = head.hash;
+            entry.size = head.bytes.byteLength;
+            entry.init({
+                keychain: log.keychain,
+                encoding: log.encoding,
+            });
+            return new EntryWithRefs({
+                entry,
+                gidRefrences: head.gidRefrences,
+            });
+        }),
+    });
+    materialized.reserved = message.reserved;
+    return materialized;
+};
+const prepareRawExchangeHeadEntryFacts = (entry, head) => {
+    const meta = entry.meta;
+    const payload = entry.payload;
+    const payloadSize = payload.byteLength;
+    const shallowEntry = new ShallowEntry({
+        hash: head.hash,
+        payloadSize,
+        head: true,
+        meta: new ShallowMeta({
+            gid: meta.gid,
+            data: meta.data,
+            clock: meta.clock,
+            next: meta.next,
+            type: meta.type,
+        }),
+    });
+    const nativeEntry = {
+        hash: head.hash,
+        gid: meta.gid,
+        next: meta.next,
+        type: meta.type,
+        head: true,
+        payloadSize,
+        data: meta.data,
+        clock: {
+            timestamp: {
+                wallTime: meta.clock.timestamp.wallTime,
+                logical: meta.clock.timestamp.logical,
+            },
+        },
+    };
+    Entry.prepareShallowEntry(entry, shallowEntry);
+    Entry.prepareNativeLogEntry(entry, nativeEntry);
+};
+export const materializeVerifiedRawExchangeHeadsMessage = async (message, log, profile, options) => {
+    const hashes = new Array(message.heads.length);
+    let rawBytes = 0;
+    for (let i = 0; i < message.heads.length; i++) {
+        const head = message.heads[i];
+        hashes[i] = head.hash;
+        rawBytes += getRawExchangeHeadByteLength(head);
+    }
+    // Built lazily: the fused (stash-backed) prepare paths keep the entry
+    // block bytes in wasm memory and never need a JS blocks array.
+    let blocksValue;
+    const blocks = () => (blocksValue ??= message.heads.map((head) => head.bytes));
+    const nativePrepareStartedAt = syncProfileStart(profile);
+    let preparedFacts;
+    let preparedColumns;
+    let nativePrepareSource;
+    let hashesVerifiedByNative = false;
+    const requestedVerifyDuringPrepare = options?.verifyNativeBackboneSignaturesDuringPrepare === true;
+    const canDeferPreparedSelectionVerification = requestedVerifyDuringPrepare &&
+        options?.deferNativeBackboneSignatureVerificationUntilSelection === true &&
+        !!options?.nativeBackbone?.verifyPreparedRawReceiveEntries &&
+        (!!options?.tryPreparedRawReceiveFastDrop ||
+            !!options?.selectPreparedRawReceiveHashes);
+    const verifySignaturesInPrepare = requestedVerifyDuringPrepare && !canDeferPreparedSelectionVerification;
+    if (options?.nativeBackbone) {
+        const profileNativeBackbone = !!profile &&
+            !!options.nativeBackbone.setAppendProfileEnabled &&
+            !!options.nativeBackbone.resetAppendProfile &&
+            !!options.nativeBackbone.appendProfile;
+        if (profileNativeBackbone) {
+            options.nativeBackbone.resetAppendProfile?.();
+            options.nativeBackbone.setAppendProfileEnabled?.(true);
+        }
+        try {
+            const preparedColumnsAndSelection = await options.prepareNativeBackboneExpectedColumnsAndSelection?.({
+                blocks,
+                hashes,
+                verifySignatures: verifySignaturesInPrepare,
+            });
+            preparedColumns = preparedColumnsAndSelection?.columns;
+            preparedColumns ??= options.prepareNativeBackboneExpectedColumns?.({
+                hashes,
+                verifySignatures: verifySignaturesInPrepare,
+            });
+            preparedColumns ??=
+                options.nativeBackbone.prepareRawReceiveExpectedColumnsBatch?.(blocks(), hashes, { verifySignatures: verifySignaturesInPrepare });
+            hashesVerifiedByNative = !!preparedColumns;
+            preparedColumns ??=
+                options.nativeBackbone.prepareRawReceiveColumnsBatch?.(blocks(), hashes, {
+                    verifySignatures: verifySignaturesInPrepare,
+                });
+            if (preparedColumns) {
+                nativePrepareSource = "backbone-columns";
+            }
+            else {
+                preparedFacts = options.nativeBackbone.prepareRawReceiveBatch(blocks());
+                nativePrepareSource = "backbone";
+            }
+        }
+        catch {
+            preparedColumns = undefined;
+            preparedFacts = undefined;
+        }
+        finally {
+            if (profileNativeBackbone) {
+                options.nativeBackbone.setAppendProfileEnabled?.(false);
+                emitNativeBackboneRawPrepareProfile(profile, options.nativeBackbone.appendProfile?.(), message.heads.length, rawBytes);
+            }
+        }
+    }
+    if (!preparedColumns && !preparedFacts) {
+        preparedFacts = await prepareRawEntryV0Batch(blocks())
+            .then((facts) => {
+            nativePrepareSource = "log";
+            return facts;
+        })
+            .catch(() => undefined);
+    }
+    if (preparedColumns || preparedFacts) {
+        const clearPreparedRawHashes = (hashesToClear) => {
+            if (nativePrepareSource === "backbone") {
+                options?.nativeBackbone?.clearPreparedRawReceiveEntries?.(hashesToClear);
+                return;
+            }
+            if (nativePrepareSource === "backbone-columns") {
+                options?.nativeBackbone?.clearPreparedRawReceiveEntries?.(hashesToClear);
+            }
+        };
+        const clearPreparedRaw = () => {
+            clearPreparedRawHashes(nativePrepareSource === "backbone"
+                ? preparedRawFactsHashes(preparedFacts)
+                : hashes);
+        };
+        emitSyncProfileDuration(profile, nativePrepareStartedAt, {
+            name: "sharedLog.rawReceive.prepareFacts",
+            component: "shared-log",
+            entries: message.heads.length,
+            bytes: rawBytes,
+            messages: 1,
+            details: {
+                native: true,
+                source: nativePrepareSource,
+                verifySignatures: verifySignaturesInPrepare,
+                deferredVerifySignatures: canDeferPreparedSelectionVerification,
+                deferredVerifySignaturesUntilCommit: canDeferPreparedSelectionVerification &&
+                    options?.deferNativeBackboneSignatureVerificationUntilCommit ===
+                        true,
+            },
+        });
+        try {
+            if (preparedColumns &&
+                preparedRawFactsCount(preparedColumns) !== message.heads.length) {
+                throw new Error("Raw exchange head prepared column count mismatch");
+            }
+            if (preparedFacts && preparedFacts.length !== message.heads.length) {
+                throw new Error("Raw exchange head prepared fact count mismatch");
+            }
+            if (!hashesVerifiedByNative) {
+                const rowFacts = preparedFacts;
+                for (let i = 0; i < message.heads.length; i++) {
+                    const head = message.heads[i];
+                    const facts = preparedColumns ?? rowFacts[i];
+                    if (preparedRawCid(facts, i) !== head.hash) {
+                        throw new Error("Raw exchange head hash did not match bytes");
+                    }
+                }
+            }
+            if (options?.tryPreparedRawReceiveFastDrop &&
+                (await options.tryPreparedRawReceiveFastDrop({
+                    heads: message.heads,
+                    hashes,
+                }))) {
+                return undefined;
+            }
+            let selectedHeads = message.heads;
+            let selectedHashes = hashes;
+            let selectedIndexes;
+            const selectedHashSelection = await options?.selectPreparedRawReceiveHashes?.({
+                heads: message.heads,
+                hashes,
+            });
+            if (selectedHashSelection) {
+                const selectedHashSelectionObject = !isIterableRawReceiveHashSelection(selectedHashSelection)
+                    ? selectedHashSelection
+                    : undefined;
+                const selectedIndexIterable = selectedHashSelectionObject?.indexes;
+                if (selectedIndexIterable) {
+                    const selectedFlags = new Uint8Array(hashes.length);
+                    selectedHeads = [];
+                    selectedHashes = [];
+                    selectedIndexes = [];
+                    for (const rawIndex of selectedIndexIterable) {
+                        if (!Number.isInteger(rawIndex) ||
+                            rawIndex < 0 ||
+                            rawIndex >= hashes.length) {
+                            throw new Error("Selected unknown raw receive index");
+                        }
+                        const index = rawIndex;
+                        if (selectedFlags[index]) {
+                            throw new Error("Selected duplicate raw receive index");
+                        }
+                        selectedFlags[index] = 1;
+                        selectedHeads.push(message.heads[index]);
+                        selectedHashes.push(hashes[index]);
+                        selectedIndexes.push(index);
+                    }
+                    let droppedHashes;
+                    if (selectedHashSelectionObject.droppedIndexes) {
+                        const droppedFlags = new Uint8Array(hashes.length);
+                        droppedHashes = [];
+                        for (const rawIndex of selectedHashSelectionObject.droppedIndexes) {
+                            if (!Number.isInteger(rawIndex) ||
+                                rawIndex < 0 ||
+                                rawIndex >= hashes.length) {
+                                throw new Error("Dropped unknown raw receive index");
+                            }
+                            const index = rawIndex;
+                            if (selectedFlags[index]) {
+                                throw new Error("Raw receive index selected and dropped");
+                            }
+                            if (droppedFlags[index]) {
+                                throw new Error("Dropped duplicate raw receive index");
+                            }
+                            droppedFlags[index] = 1;
+                            droppedHashes.push(hashes[index]);
+                        }
+                        if (selectedHashes.length + droppedHashes.length !== hashes.length) {
+                            throw new Error("Raw receive selection did not cover every index");
+                        }
+                    }
+                    const expectedHashes = selectedHashSelectionObject.hashes
+                        ? Array.from(selectedHashSelectionObject.hashes)
+                        : undefined;
+                    if (expectedHashes &&
+                        (expectedHashes.length !== selectedHashes.length ||
+                            expectedHashes.some((hash, index) => hash !== selectedHashes[index]))) {
+                        throw new Error("Selected raw receive hashes did not match indexes");
+                    }
+                    if (!droppedHashes) {
+                        droppedHashes = [];
+                        for (let i = 0; i < hashes.length; i++) {
+                            if (!selectedFlags[i]) {
+                                droppedHashes.push(hashes[i]);
+                            }
+                        }
+                    }
+                    if (droppedHashes.length > 0) {
+                        clearPreparedRawHashes(droppedHashes);
+                    }
+                    if (selectedHashes.length === 0) {
+                        return undefined;
+                    }
+                }
+                else {
+                    const selectedHashIterable = isIterableRawReceiveHashSelection(selectedHashSelection)
+                        ? selectedHashSelection
+                        : selectedHashSelectionObject?.hashes;
+                    if (!selectedHashIterable) {
+                        throw new Error("Missing selected raw receive hashes");
+                    }
+                    const selectedHashSet = new Set(selectedHashIterable);
+                    const knownHashes = new Set(hashes);
+                    for (const hash of selectedHashSet) {
+                        if (!knownHashes.has(hash)) {
+                            throw new Error("Selected unknown raw receive hash");
+                        }
+                    }
+                    selectedHeads = [];
+                    selectedHashes = [];
+                    selectedIndexes = [];
+                    const droppedHashes = [];
+                    for (let i = 0; i < hashes.length; i++) {
+                        const hash = hashes[i];
+                        if (selectedHashSet.has(hash)) {
+                            selectedHeads.push(message.heads[i]);
+                            selectedHashes.push(hash);
+                            selectedIndexes.push(i);
+                        }
+                        else {
+                            droppedHashes.push(hash);
+                        }
+                    }
+                    if (droppedHashes.length > 0) {
+                        clearPreparedRawHashes(droppedHashes);
+                    }
+                    if (selectedHashes.length === 0) {
+                        return undefined;
+                    }
+                }
+            }
+            if (canDeferPreparedSelectionVerification) {
+                if (options?.deferNativeBackboneSignatureVerificationUntilCommit === true) {
+                    emitSyncProfileDuration(profile, syncProfileStart(profile), {
+                        name: "sharedLog.rawReceive.deferVerifySelected",
+                        component: "shared-log",
+                        entries: selectedHashes.length,
+                        count: message.heads.length - selectedHashes.length,
+                        messages: 1,
+                    });
+                }
+                else {
+                    const verifyStartedAt = syncProfileStart(profile);
+                    const verified = options?.nativeBackbone?.verifyPreparedRawReceiveEntries?.(selectedHashes);
+                    if (!verified ||
+                        verified.length !== selectedHashes.length ||
+                        verified.some((ok) => !ok)) {
+                        throw new Error("Raw exchange head signature verification failed");
+                    }
+                    if (preparedColumns) {
+                        for (let selectedIndex = 0; selectedIndex < selectedHashes.length; selectedIndex++) {
+                            preparedColumns[12][selectedIndexes?.[selectedIndex] ?? selectedIndex] = 1;
+                        }
+                    }
+                    else if (preparedFacts) {
+                        for (let selectedIndex = 0; selectedIndex < selectedHashes.length; selectedIndex++) {
+                            preparedFacts[selectedIndexes?.[selectedIndex] ?? selectedIndex].signatureVerified = true;
+                        }
+                    }
+                    emitSyncProfileDuration(profile, verifyStartedAt, {
+                        name: "sharedLog.rawReceive.verifySelected",
+                        component: "shared-log",
+                        entries: selectedHashes.length,
+                        count: message.heads.length - selectedHashes.length,
+                        messages: 1,
+                    });
+                }
+            }
+            const headsToWrap = selectedHeads;
+            const hashesToWrap = selectedHashes;
+            const indexesToWrap = selectedIndexes;
+            const wrapStartedAt = syncProfileStart(profile);
+            // Lazy per-entry JS materialization (a change consumer reading
+            // payload/signatures) is counted on the existing counter so the
+            // fused no-consumer path stays assertable at zero.
+            const onJsEntryDecode = profile
+                ? () => emitSyncProfileEvent(profile, {
+                    name: "sharedLog.rawReceive.jsEntryDecode",
+                    component: "shared-log",
+                    entries: 1,
+                    messages: 0,
+                    details: { lazy: true },
+                })
+                : undefined;
+            let materializedHeads;
+            try {
+                const rowFacts = preparedFacts;
+                materializedHeads = headsToWrap.map((head, selectedIndex) => {
+                    const factsIndex = indexesToWrap?.[selectedIndex] ?? selectedIndex;
+                    const facts = preparedColumns ?? rowFacts[factsIndex];
+                    const preparedHead = new PreparedRawEntryWithRefs(head, facts, factsIndex, onJsEntryDecode);
+                    preparedHead.initEntry({
+                        keychain: log.keychain,
+                        encoding: log.encoding,
+                    });
+                    return preparedHead;
+                });
+            }
+            catch (error) {
+                clearPreparedRaw();
+                throw error;
+            }
+            const materialized = new ExchangeHeadsMessage({
+                heads: materializedHeads,
+                preparedHashes: hashesToWrap,
+            });
+            materialized.reserved = message.reserved;
+            emitSyncProfileDuration(profile, wrapStartedAt, {
+                name: "sharedLog.rawReceive.wrapPrepared",
+                component: "shared-log",
+                entries: headsToWrap.length,
+                count: message.heads.length - headsToWrap.length,
+                messages: 1,
+            });
+            return materialized;
+        }
+        catch (error) {
+            clearPreparedRaw();
+            throw error;
+        }
+    }
+    emitSyncProfileDuration(profile, nativePrepareStartedAt, {
+        name: "sharedLog.rawReceive.prepareFacts",
+        component: "shared-log",
+        entries: message.heads.length,
+        bytes: rawBytes,
+        messages: 1,
+        details: { native: false },
+    });
+    const hashStartedAt = syncProfileStart(profile);
+    const calculatedHashes = await calculateRawCidV1Batch(blocks());
+    emitSyncProfileDuration(profile, hashStartedAt, {
+        name: "sharedLog.rawReceive.calculateHashes",
+        component: "shared-log",
+        entries: message.heads.length,
+        messages: 1,
+    });
+    const deserializeStartedAt = syncProfileStart(profile);
+    const materialized = new ExchangeHeadsMessage({
+        heads: message.heads.map((head, index) => {
+            if (calculatedHashes[index] !== head.hash) {
+                throw new Error("Raw exchange head hash did not match bytes");
+            }
+            const entry = materializeRawExchangeEntry({
+                hash: head.hash,
+                bytes: head.bytes,
+                size: head.bytes.byteLength,
+                keychain: log.keychain,
+                encoding: log.encoding,
+                gidRefrences: head.gidRefrences,
+            });
+            return new EntryWithRefs({
+                entry,
+                gidRefrences: head.gidRefrences,
+            });
+        }),
+    });
+    materialized.reserved = message.reserved;
+    emitSyncProfileDuration(profile, deserializeStartedAt, {
+        name: "sharedLog.rawReceive.deserializeFallback",
+        component: "shared-log",
+        entries: message.heads.length,
+        messages: 1,
+    });
+    return materialized;
+};
+const getNativeReferenceRowsByHeadInput = (log, heads, visitedHeads) => {
+    const positions = [];
+    const hashes = [];
+    for (let i = 0; i < heads.length; i++) {
+        const head = heads[i];
+        const hash = head instanceof Entry ? head.hash : head;
+        if (visitedHeads.has(hash)) {
+            continue;
+        }
+        positions.push(i);
+        hashes.push(hash);
+    }
+    if (hashes.length === 0) {
+        return [];
+    }
+    const flatRows = log.entryIndex.getUniqueReferenceGidRowsFlatBatch(hashes);
+    if (flatRows) {
+        const byPosition = new Array(heads.length);
+        for (const position of positions) {
+            byPosition[position] = [];
+        }
+        for (const [hashPosition, hash, gid] of flatRows) {
+            const position = positions[hashPosition];
+            if (position === undefined) {
+                continue;
+            }
+            byPosition[position].push([hash, gid]);
+        }
+        return byPosition;
+    }
+    const rows = log.entryIndex.getUniqueReferenceGidRowsBatch(hashes);
+    if (!rows) {
+        return undefined;
+    }
+    const byPosition = new Array(heads.length);
+    for (let i = 0; i < rows.length; i++) {
+        byPosition[positions[i]] = rows[i];
+    }
+    return byPosition;
+};
+const resolveExchangeHeadBlocks = async (log, headArray, visitedHeads) => {
+    const resolved = new Array(headArray.length);
+    const hashes = [];
+    const positionsByHash = new Map();
+    for (let i = 0; i < headArray.length; i++) {
+        const hash = headArray[i];
+        if (visitedHeads?.has(hash)) {
+            continue;
+        }
+        const positions = positionsByHash.get(hash);
+        if (positions) {
+            positions.push(i);
+            continue;
+        }
+        hashes.push(hash);
+        positionsByHash.set(hash, [i]);
+    }
+    if (hashes.length === 0) {
+        return resolved;
+    }
+    const blocks = log.blocks;
+    const values = typeof blocks.getMany === "function"
+        ? await blocks.getMany(hashes)
+        : await Promise.all(hashes.map((hash) => blocks.get(hash)));
+    for (let i = 0; i < values.length; i++) {
+        const hash = hashes[i];
+        const bytes = values[i];
+        if (!bytes) {
+            return undefined;
+        }
+        for (const position of positionsByHash.get(hash)) {
+            resolved[position] = { hash, bytes };
+        }
+    }
+    return resolved;
+};
+const resolveExchangeHeadEntries = async (log, headArray, visitedHeads) => {
+    const resolved = new Array(headArray.length);
+    const hashes = [];
+    const positionsByHash = new Map();
+    for (let i = 0; i < headArray.length; i++) {
+        const head = headArray[i];
+        if (head instanceof Entry) {
+            if (visitedHeads?.has(head.hash)) {
+                continue;
+            }
+            resolved[i] = head;
+            continue;
+        }
+        if (visitedHeads?.has(head)) {
+            continue;
+        }
+        const positions = positionsByHash.get(head);
+        if (positions) {
+            positions.push(i);
+            continue;
+        }
+        hashes.push(head);
+        positionsByHash.set(head, [i]);
+    }
+    if (hashes.length === 0) {
+        return resolved;
+    }
+    const entries = hashes.length === 1
+        ? [await log.get(hashes[0])]
+        : await log.entryIndex.getMany(hashes, {
+            type: "full",
+            ignoreMissing: true,
+        });
+    for (let i = 0; i < entries.length; i++) {
+        for (const position of positionsByHash.get(hashes[i])) {
+            resolved[position] = entries[i];
+        }
+    }
+    return resolved;
+};
 export const allEntriesWithUniqueGids = async (log, entry) => {
     // TODO optimize this
     const map = new Map();
@@ -247,9 +1704,28 @@ export const allEntriesWithUniqueGids = async (log, entry) => {
             curr = nexts;
         }
     }
-    const value = [
-        ...(await Promise.all([...map.values()].map((x) => x instanceof Entry ? x : log.entryIndex.get(x.hash)))),
-    ].filter((x) => !!x);
-    return value;
+    const values = [...map.values()];
+    const resolved = new Array(values.length);
+    const unresolvedHashes = [];
+    const unresolvedPositions = [];
+    for (let i = 0; i < values.length; i++) {
+        const value = values[i];
+        if (value instanceof Entry) {
+            resolved[i] = value;
+            continue;
+        }
+        unresolvedHashes.push(value.hash);
+        unresolvedPositions.push(i);
+    }
+    if (unresolvedHashes.length > 0) {
+        const entries = await log.entryIndex.getMany(unresolvedHashes, {
+            type: "full",
+            ignoreMissing: true,
+        });
+        for (let i = 0; i < entries.length; i++) {
+            resolved[unresolvedPositions[i]] = entries[i];
+        }
+    }
+    return resolved.filter((x) => !!x);
 };
 //# sourceMappingURL=exchange-heads.js.map