@peerbit/native-backbone 0.1.0

package/dist/src/index.js

@@ -0,0 +1,3406 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { calculateRawCid, cidifyString } from "@peerbit/blocks-interface";
+const nativeBackboneHeadFlagsToBytes = (headFlags) => headFlags instanceof Uint8Array
+    ? headFlags
+    : new Uint8Array(headFlags.map((head) => (head ? 1 : 0)));
+let wasmModulePromise;
+let wasmInitialized = false;
+const loadWasm = async () => {
+    if (!wasmModulePromise) {
+        const wasmModulePath = "../wasm/native_backbone.js";
+        wasmModulePromise = import(__rewriteRelativeImportExtension(
+        /* @vite-ignore */ wasmModulePath));
+    }
+    const wasm = await wasmModulePromise;
+    if (!wasmInitialized) {
+        const processLike = globalThis.process;
+        if (processLike?.versions?.node) {
+            const fsPromises = "fs/promises";
+            const { readFile } = (await import(__rewriteRelativeImportExtension(
+            /* @vite-ignore */ fsPromises)));
+            const bytes = await readFile(new URL("../wasm/native_backbone_bg.wasm", import.meta.url));
+            wasm.initSync({ module: bytes });
+        }
+        else {
+            await wasm.default({
+                module_or_path: new URL("../wasm/native_backbone_bg.wasm", import.meta.url),
+            });
+        }
+        wasmInitialized = true;
+    }
+    return wasm;
+};
+/**
+ * Per-node receive-fusion session (`NativeWireSyncSession` in the wasm
+ * module). `decodeAndVerifyBatch` is a drop-in for the `nativeWire` option of
+ * `@peerbit/stream`'s DirectStream; frames carrying shared-log raw
+ * exchange-head payloads for registered topics are kept in wasm memory and
+ * consumed by `NativePeerbitBackbone.prepareStashedRawReceive*` without a
+ * second boundary copy. Shared-log programs register their RPC topic on open
+ * and release stash entries once a message is processed.
+ */
+export class NativeBackboneWireSyncSession {
+    /** Raw wasm handle; consumed by `NativePeerbitBackbone.prepareStashedRawReceive*`. */
+    handle;
+    constructor(handle) {
+        this.handle = handle;
+    }
+    static async create(options) {
+        const wasm = await loadWasm();
+        return new NativeBackboneWireSyncSession(new wasm.NativeWireSyncSession(options.selfHash));
+    }
+    registerTopic(topic) {
+        this.handle.register_topic(topic);
+    }
+    unregisterTopic(topic) {
+        return this.handle.unregister_topic(topic);
+    }
+    get topicCount() {
+        return this.handle.topic_count();
+    }
+    decodeAndVerifyBatch(frames, nowMs) {
+        return this.handle.decode_and_verify_batch(frames, nowMs);
+    }
+    stashedMeta(id) {
+        const row = this.handle.stashed_meta(id);
+        if (!row) {
+            return undefined;
+        }
+        const [hashes, gidRefrences, byteLengths, reserved, payloadLength] = row;
+        return { hashes, gidRefrences, byteLengths, reserved, payloadLength };
+    }
+    stashedBlocks(id, indexes) {
+        return this.handle.stashed_blocks(id, indexes) ?? undefined;
+    }
+    release(id) {
+        return this.handle.release(id);
+    }
+    get stashLength() {
+        return this.handle.stash_len();
+    }
+    counters() {
+        const [stashed, evicted, metaReads, blockCopyOuts, released] = this.handle.counters();
+        return {
+            stashed: stashed,
+            evicted: evicted,
+            metaReads: metaReads,
+            blockCopyOuts: blockCopyOuts,
+            released: released,
+        };
+    }
+}
+export const createNativeWireSyncSession = NativeBackboneWireSyncSession.create;
+const nativeBackboneAppendProfileKeys = [
+    "nativeBackboneStorageAppendInnerMs",
+    "nativeBackboneInputCopyMs",
+    "nativeBackboneLogTotalMs",
+    "nativeBackboneLogNextCloneMs",
+    "nativeBackboneLogEntryCoreMs",
+    "nativeBackboneLogEncodeMetaMs",
+    "nativeBackboneLogEncodePayloadMs",
+    "nativeBackboneLogEncodeSignableMs",
+    "nativeBackboneLogSignMs",
+    "nativeBackboneLogEncodeSignatureMs",
+    "nativeBackboneLogEncodeStorageMs",
+    "nativeBackboneLogCidMs",
+    "nativeBackboneLogCidHashMs",
+    "nativeBackboneLogCidStringMs",
+    "nativeBackboneLogIndexEntryMs",
+    "nativeBackboneLogFactsMs",
+    "nativeBackboneLogBlockPutMs",
+    "nativeBackboneLogGraphPutMs",
+    "nativeBackboneLogTrimMs",
+    "nativeBackboneEntryRowMs",
+    "nativeBackboneTrimRowsMs",
+    "nativeBackboneHashNumberMs",
+    "nativeBackboneCoordinatePlanMs",
+    "nativeBackboneCoordinateCoreMs",
+    "nativeBackboneCoordinateFieldsBuildMs",
+    "nativeBackboneCoordinateValueEncodeMs",
+    "nativeBackboneCoordinateJournalPutMs",
+    "nativeBackboneCoordinateIndexPutMs",
+    "nativeBackboneCoordinateValuePutMs",
+    "nativeBackboneCoordinateDeleteMs",
+    "nativeBackboneDocumentIndexCommitMs",
+    "nativeBackboneDocumentIndexContextEncodeMs",
+    "nativeBackboneDocumentIndexExtractMs",
+    "nativeBackboneDocumentIndexValueBuildMs",
+    "nativeBackboneDocumentIndexPutMs",
+    "nativeBackboneDocumentValuePutMs",
+    "nativeBackboneDocumentIndexTrimDeleteMs",
+    "nativeBackboneResultRowMs",
+    "nativeBackboneRawReceiveInputCopyMs",
+    "nativeBackboneRawReceivePrepareMs",
+    "nativeBackboneRawReceiveDigestMs",
+    "nativeBackboneRawReceiveCidStringMs",
+    "nativeBackboneRawReceiveExpectedCidMs",
+    "nativeBackboneRawReceiveStorageParseMs",
+    "nativeBackboneRawReceiveMetaParseMs",
+    "nativeBackboneRawReceivePayloadParseMs",
+    "nativeBackboneRawReceiveSignatureParseMs",
+    "nativeBackboneRawReceiveSignableMs",
+    "nativeBackboneRawReceiveVerifyBatchMs",
+    "nativeBackboneRawReceiveVerifyFallbackMs",
+    "nativeBackboneRawReceivePrepareColumnsMs",
+    "nativeBackboneRawReceivePendingCheckMs",
+    "nativeBackboneRawReceiveVerifyMs",
+    "nativeBackboneRawReceiveVerifyStatusMs",
+    "nativeBackboneRawReceiveJoinPlanMs",
+    "nativeBackboneRawReceiveRemoveMs",
+    "nativeBackboneRawReceiveBlockPutMs",
+    "nativeBackboneRawReceiveGraphPutMs",
+    "nativeBackboneRawReceiveCoordinateCommitMs",
+];
+const nativeBackboneCoordinatePersistenceFiles = {
+    snapshot: "coordinates.bin",
+    journal: "coordinates.wal",
+    documentSnapshot: "document-values.bin",
+    documentJournal: "document-values.wal",
+    documentSignerSnapshot: "document-signers.bin",
+    documentSignerJournal: "document-signers.wal",
+};
+export const defaultNativeBackboneCoordinateFlushMaxPendingBytes = 1024 * 1024;
+export const defaultNativeBackboneCoordinateCompactMaxJournalBytes = 64 * 1024 * 1024;
+const resolveCoordinateFlushMaxPendingBytes = (options) => options.flushMaxPendingBytes != null
+    ? Math.max(0, options.flushMaxPendingBytes)
+    : options.flushOnAppend === false
+        ? defaultNativeBackboneCoordinateFlushMaxPendingBytes
+        : undefined;
+const isNotFoundError = (error) => {
+    const maybeError = error;
+    return maybeError?.code === "ENOENT" || maybeError?.name === "NotFoundError";
+};
+let nodeFsModule;
+const importNodeFs = () => (nodeFsModule ??= import("node:fs/promises"));
+let nodePathJoin;
+const importNodePathJoin = () => (nodePathJoin ??= import("node:path").then((mod) => mod.join));
+const validateCoordinatePersistenceName = (name) => {
+    if (name.length === 0 ||
+        name === "." ||
+        name === ".." ||
+        name.includes("/") ||
+        name.includes("\\")) {
+        throw new Error(`Invalid native backbone coordinate persistence file: ${name}`);
+    }
+    return name;
+};
+const concatBytes = (chunks) => {
+    const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+};
+const copyBytes = (bytes) => new Uint8Array(bytes);
+const rowsToNumbers = (resolution, rows) => rows.map((row) => {
+    const value = row;
+    return resolution === "u64" ? BigInt(value) : Number(value);
+});
+const rowsToHashNumberMap = (rows) => {
+    const out = new Map();
+    for (const row of rows) {
+        const [hashNumber, hashes] = row;
+        out.set(BigInt(hashNumber), hashes);
+    }
+    return out;
+};
+const rowsToSamples = (rows) => {
+    if (!rows) {
+        return undefined;
+    }
+    const out = new Map();
+    for (const row of rows) {
+        const [hash, intersecting] = row;
+        out.set(hash, { intersecting });
+    }
+    return out;
+};
+const rowsToRepairDispatchPlan = (rows) => {
+    const plan = new Map();
+    for (const row of rows) {
+        const [mode, target, hashes] = row;
+        let targets = plan.get(mode);
+        if (!targets) {
+            targets = new Map();
+            plan.set(mode, targets);
+        }
+        targets.set(target, hashes);
+    }
+    return plan;
+};
+// Coordinate plans frequently cross the wasm boundary with many decimal-string
+// values while callers typically read only one representation, so the numeric
+// and string views are materialized lazily on first access (and cached, so
+// repeated reads return the same array instance).
+const lazyCoordinatePlan = (resolution, hash, hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas) => {
+    let hashNumberValue;
+    let coordinates;
+    let coordinateStrings;
+    return {
+        hash,
+        get hashNumber() {
+            return (hashNumberValue ??= rowsToNumbers(resolution, [hashNumber])[0]);
+        },
+        set hashNumber(value) {
+            hashNumberValue = value;
+        },
+        hashNumberString: typeof hashNumber === "string" ? hashNumber : String(hashNumber),
+        gid,
+        get coordinates() {
+            return (coordinates ??= rowsToNumbers(resolution, coordinateRows));
+        },
+        set coordinates(value) {
+            coordinates = value;
+        },
+        get coordinateStrings() {
+            return (coordinateStrings ??= coordinateRows.map((coordinate) => String(coordinate)));
+        },
+        set coordinateStrings(value) {
+            coordinateStrings = value;
+        },
+        assignedToRangeBoundary,
+        requestedReplicas,
+    };
+};
+const lazyLeaderPlanFromRows = (resolution, coordinateRows, leaderRows) => {
+    let coordinates;
+    let coordinateStrings;
+    return {
+        get coordinates() {
+            return (coordinates ??= rowsToNumbers(resolution, coordinateRows));
+        },
+        set coordinates(value) {
+            coordinates = value;
+        },
+        get coordinateStrings() {
+            return (coordinateStrings ??= coordinateRows.map((coordinate) => String(coordinate)));
+        },
+        set coordinateStrings(value) {
+            coordinateStrings = value;
+        },
+        leaders: rowsToSamples(leaderRows) ?? new Map(),
+    };
+};
+const appendCoordinatePlanFromRow = (resolution, row) => {
+    const [hash, hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas,] = row;
+    return lazyCoordinatePlan(resolution, hash, hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas);
+};
+const appendCoordinatePlanFromCompactNoNextRow = (resolution, hash, row) => {
+    const [hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas,] = row;
+    return lazyCoordinatePlan(resolution, hash, hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas);
+};
+const documentContextFactsFromRow = (row) => {
+    if (!row) {
+        return undefined;
+    }
+    const [created, modified, head, gid, size] = row;
+    return {
+        created: BigInt(created),
+        modified: BigInt(modified),
+        head,
+        gid,
+        size,
+    };
+};
+const coordinateFieldsFromRow = (resolution, row) => {
+    const [hash, hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas, wallTime, metaBytes,] = row;
+    // Extend the lazy plan in place; spreading it would eagerly invoke the
+    // memoized getters and defeat the lazy materialization.
+    const fields = appendCoordinatePlanFromRow(resolution, [
+        hash,
+        hashNumber,
+        gid,
+        coordinateRows,
+        assignedToRangeBoundary,
+        requestedReplicas,
+    ]);
+    const wallTimeString = typeof wallTime === "string" ? wallTime : String(wallTime);
+    let wallTimeValue;
+    Object.defineProperty(fields, "wallTime", {
+        configurable: true,
+        enumerable: true,
+        get: () => (wallTimeValue ??= BigInt(wallTimeString)),
+        set: (value) => {
+            wallTimeValue = value;
+        },
+    });
+    fields.wallTimeString = wallTimeString;
+    fields.metaBytes = metaBytes;
+    return fields;
+};
+const appendDeliveryPlanFromRow = (row) => ({
+    hasRemoteRecipients: row[0],
+    noPeerError: row[1],
+    defaultSendSilent: row[2],
+    sendTo: row[3],
+    ackTo: row[4],
+    silentTo: row[5],
+    repairTargets: row[6],
+    authoritativeRecipients: row[7],
+});
+const committedEntryFromRow = (row) => {
+    const [hash, metaBytes, byteLength, hashDigestBytes] = row;
+    return {
+        cid: hash,
+        hash,
+        next: [],
+        metaBytes,
+        byteLength,
+        hashDigestBytes,
+    };
+};
+const committedStorageFactsEntryFromRow = (row) => {
+    if (row.length === 4) {
+        return committedEntryFromRow(row);
+    }
+    const [hash, next, metaBytes, byteLength, hashDigestBytes] = row;
+    return {
+        cid: hash,
+        hash,
+        next,
+        metaBytes,
+        byteLength,
+        hashDigestBytes,
+    };
+};
+const storageFactsEntryFromRow = (row) => {
+    const [bytes, cid, next, byteLength, metaBytes, hashDigestBytes] = row;
+    return {
+        cid,
+        hash: cid,
+        next,
+        bytes,
+        byteLength,
+        metaBytes,
+        hashDigestBytes,
+    };
+};
+const trimmedEntryFromRow = (row) => {
+    const [hash, gid, next, type, wallTime, logical, payloadSize, data] = row;
+    return {
+        hash,
+        gid,
+        next,
+        type,
+        payloadSize,
+        data,
+        clock: {
+            timestamp: {
+                wallTime: BigInt(wallTime),
+                logical,
+            },
+        },
+    };
+};
+const trimmedHashFromRow = (row) => row[0];
+const trimmedRowsResult = (rows) => {
+    let trimmed;
+    const trimmedHashes = rows.map(trimmedHashFromRow);
+    return {
+        get trimmed() {
+            return (trimmed ??= rows.map(trimmedEntryFromRow));
+        },
+        trimmedHashes,
+    };
+};
+const trimmedRowsAndHashesResult = (rows, hashRows) => {
+    if (!hashRows) {
+        return trimmedRowsResult(rows);
+    }
+    let trimmed;
+    const trimmedHashes = hashRows;
+    return {
+        get trimmed() {
+            return (trimmed ??= rows.map(trimmedEntryFromRow));
+        },
+        trimmedHashes,
+    };
+};
+const nativeLogEntryFromTrimRow = (row) => {
+    const entry = trimmedEntryFromRow(row);
+    return {
+        ...entry,
+        clock: {
+            timestamp: {
+                wallTime: entry.clock.timestamp.wallTime,
+                logical: entry.clock.timestamp.logical,
+            },
+        },
+    };
+};
+const headEntryFromRow = (row) => {
+    const [hash, gid, wallTime, logical] = row;
+    return {
+        hash,
+        meta: {
+            gid,
+            clock: { timestamp: { wallTime: BigInt(wallTime), logical } },
+        },
+    };
+};
+const joinHeadEntryFromRow = (row) => {
+    const [hash, gid, wallTime, logical, type, next] = row;
+    return {
+        hash,
+        meta: {
+            gid,
+            type,
+            next,
+            clock: { timestamp: { wallTime: BigInt(wallTime), logical } },
+        },
+    };
+};
+const headDataEntryFromRow = (row) => {
+    const [hash, data] = row;
+    return { hash, meta: { data } };
+};
+const metadataEntryFromRow = (row) => {
+    if (row == null) {
+        return undefined;
+    }
+    const [hash, gid, data, replicas] = row;
+    const entry = { hash, gid, data };
+    if (replicas != null) {
+        entry.replicas = replicas;
+    }
+    return entry;
+};
+const requestPruneEntryFromRow = (row) => {
+    const [hash, gid, replicas, data] = row;
+    const entry = { hash, gid };
+    if (replicas != null) {
+        entry.replicas = replicas;
+    }
+    if (data != null) {
+        entry.data = data;
+    }
+    return entry;
+};
+const storageAppendResultFromRow = (resolution, row) => {
+    const [entryRow, leaderRows, isLeader, assignedToRangeBoundary, coordinateRow, trimRows, trimHashRows, documentTrimmedHeadsProcessed, documentPreviousContextRow,] = row;
+    return {
+        entry: storageFactsEntryFromRow(entryRow),
+        leaders: rowsToSamples(leaderRows),
+        isLeader,
+        assignedToRangeBoundary,
+        coordinate: appendCoordinatePlanFromRow(resolution, coordinateRow),
+        ...trimmedRowsAndHashesResult(trimRows, trimHashRows),
+        documentTrimmedHeadsProcessed,
+        documentPreviousContext: documentContextFactsFromRow(documentPreviousContextRow),
+    };
+};
+const committedStorageAppendResultFromRow = (resolution, row) => {
+    const [entryRow, leaderRows, isLeader, assignedToRangeBoundary, coordinateRow, trimRows, trimHashRows, documentTrimmedHeadsProcessed, documentPreviousContextRow,] = row;
+    return {
+        entry: committedStorageFactsEntryFromRow(entryRow),
+        leaders: rowsToSamples(leaderRows),
+        isLeader,
+        assignedToRangeBoundary,
+        coordinate: appendCoordinatePlanFromRow(resolution, coordinateRow),
+        ...trimmedRowsAndHashesResult(trimRows, trimHashRows),
+        documentTrimmedHeadsProcessed,
+        documentPreviousContext: documentContextFactsFromRow(documentPreviousContextRow),
+    };
+};
+const compactCommittedNoNextStorageAppendResultFromRow = (resolution, row) => {
+    const [hash, byteLength, metaBytes, fourth] = row;
+    const hasDigestRow = fourth instanceof Uint8Array;
+    const hashDigestBytes = hasDigestRow ? fourth : undefined;
+    const rest = row.slice(hasDigestRow ? 4 : 3);
+    const usesNestedCoordinateRow = Array.isArray(rest[0]);
+    let coordinate;
+    let leaderRows;
+    let isLeader;
+    let trimHashRows;
+    let documentTrimmedHeadsProcessed;
+    let bytes;
+    if (usesNestedCoordinateRow) {
+        const [coordinateRow, nestedLeaderRows, nestedIsLeader, nestedTrimHashRows, nestedDocumentTrimmedHeadsProcessed, nestedBytes,] = rest;
+        coordinate = appendCoordinatePlanFromRow(resolution, coordinateRow);
+        leaderRows = nestedLeaderRows;
+        isLeader = nestedIsLeader;
+        trimHashRows = nestedTrimHashRows;
+        documentTrimmedHeadsProcessed = nestedDocumentTrimmedHeadsProcessed;
+        bytes = nestedBytes instanceof Uint8Array ? nestedBytes : undefined;
+    }
+    else {
+        const [hashNumber, gid, coordinateRows, assignedToRangeBoundary, requestedReplicas, flatLeaderRows, flatIsLeader, flatTrimHashRows, flatDocumentTrimmedHeadsProcessed, flatBytes,] = rest;
+        coordinate = appendCoordinatePlanFromCompactNoNextRow(resolution, hash, [
+            hashNumber,
+            gid,
+            coordinateRows,
+            assignedToRangeBoundary,
+            requestedReplicas,
+        ]);
+        leaderRows = flatLeaderRows;
+        isLeader = flatIsLeader;
+        trimHashRows = flatTrimHashRows;
+        documentTrimmedHeadsProcessed = flatDocumentTrimmedHeadsProcessed;
+        bytes = flatBytes instanceof Uint8Array ? flatBytes : undefined;
+    }
+    return {
+        entry: {
+            cid: hash,
+            hash,
+            next: [],
+            bytes,
+            metaBytes,
+            byteLength,
+            hashDigestBytes,
+        },
+        leaders: rowsToSamples(leaderRows),
+        isLeader,
+        assignedToRangeBoundary: coordinate.assignedToRangeBoundary,
+        coordinate,
+        trimmed: [],
+        trimmedHashes: trimHashRows ?? [],
+        documentTrimmedHeadsProcessed,
+    };
+};
+const compactCommittedLatestStorageAppendResultFromRow = (resolution, row) => {
+    const [hash, byteLength, metaBytes, fourth, fifth, sixth, seventh, eighth, ninth, tenth, eleventh, twelfth,] = row;
+    const hasDigestRow = fourth instanceof Uint8Array;
+    const hashDigestBytes = hasDigestRow ? fourth : undefined;
+    const next = (hasDigestRow ? fifth : fourth);
+    const coordinateRow = (hasDigestRow ? sixth : fifth);
+    const leaderRows = (hasDigestRow ? seventh : sixth);
+    const isLeader = (hasDigestRow ? eighth : seventh);
+    const trimHashRows = (hasDigestRow ? ninth : eighth);
+    const documentTrimmedHeadsProcessed = (hasDigestRow ? tenth : ninth);
+    const documentPreviousContextRow = (hasDigestRow ? eleventh : tenth);
+    const bytes = (hasDigestRow ? twelfth : eleventh);
+    const coordinate = appendCoordinatePlanFromRow(resolution, coordinateRow);
+    return {
+        entry: {
+            cid: hash,
+            hash,
+            next,
+            bytes: bytes instanceof Uint8Array ? bytes : undefined,
+            metaBytes,
+            byteLength,
+            hashDigestBytes,
+        },
+        leaders: rowsToSamples(leaderRows),
+        isLeader,
+        assignedToRangeBoundary: coordinate.assignedToRangeBoundary,
+        coordinate,
+        trimmed: [],
+        trimmedHashes: trimHashRows ?? [],
+        documentTrimmedHeadsProcessed,
+        documentPreviousContext: documentContextFactsFromRow(documentPreviousContextRow),
+    };
+};
+const preparedCommitFactsFromRow = (row) => {
+    const isTrimRow = Array.isArray(row) &&
+        row.length === 2 &&
+        Array.isArray(row[0]) &&
+        Array.isArray(row[1]);
+    const entryRow = (isTrimRow ? row[0] : row);
+    const prepared = committedStorageFactsEntryFromRow(entryRow);
+    if (isTrimRow) {
+        return {
+            ...prepared,
+            trimmedEntries: row[1].map(nativeLogEntryFromTrimRow),
+        };
+    }
+    return prepared;
+};
+const preparedCommitFactsWithLatestDocumentContextFromRow = (row) => {
+    const [entryRow, trimHashRows, documentTrimmedHeadsProcessed, contextRow] = row;
+    return {
+        ...committedStorageFactsEntryFromRow(entryRow),
+        trimmedEntryHashes: trimHashRows ?? [],
+        documentTrimmedHeadsProcessed,
+        documentPreviousContext: documentContextFactsFromRow(contextRow),
+    };
+};
+const compactPreparedCommitFactsWithTrimHashesFromRow = (row) => {
+    const [hash, byteLength, metaBytes, fourth] = row;
+    const hasDigestRow = fourth instanceof Uint8Array;
+    const hashDigestBytes = hasDigestRow ? fourth : undefined;
+    const trimHashOffset = hasDigestRow ? 4 : 3;
+    const trimHashRows = row[trimHashOffset];
+    const documentTrimmedHeadsProcessed = row[trimHashOffset + 1];
+    return {
+        cid: hash,
+        hash,
+        next: [],
+        metaBytes,
+        byteLength,
+        hashDigestBytes,
+        trimmedEntryHashes: trimHashRows ?? [],
+        documentTrimmedHeadsProcessed,
+    };
+};
+const nativeLogCommitEntryColumns = (entries) => {
+    const hashes = new Array(entries.length);
+    const blockBytes = new Array(entries.length);
+    const gids = new Array(entries.length);
+    const nexts = new Array(entries.length);
+    const entryTypes = new Uint8Array(entries.length);
+    const wallTimes = new BigUint64Array(entries.length);
+    const logicals = new Uint32Array(entries.length);
+    const payloadSizes = new Uint32Array(entries.length);
+    const heads = new Uint8Array(entries.length);
+    const datas = new Array(entries.length);
+    for (let i = 0; i < entries.length; i++) {
+        const entry = entries[i];
+        hashes[i] = entry.hash;
+        blockBytes[i] = entry.bytes;
+        gids[i] = entry.gid;
+        nexts[i] = entry.next;
+        entryTypes[i] = entry.type;
+        wallTimes[i] = BigInt(entry.clock.timestamp.wallTime);
+        logicals[i] = entry.clock.timestamp.logical ?? 0;
+        payloadSizes[i] = entry.payloadSize ?? 0;
+        heads[i] = (entry.head ?? true) ? 1 : 0;
+        datas[i] = entry.data;
+    }
+    return {
+        hashes,
+        blockBytes,
+        gids,
+        nexts,
+        entryTypes,
+        wallTimes,
+        logicals,
+        payloadSizes,
+        heads,
+        datas,
+    };
+};
+const validateNativeBackboneCoordinateCommitColumns = (columns) => {
+    const length = columns.hashes.length;
+    if (columns.gids.length !== length ||
+        columns.nextHashBatches.length !== length ||
+        columns.assignedToRangeBoundaries.length !== length) {
+        throw new Error("Expected equal native coordinate commit column lengths");
+    }
+    if (columns.hashNumberValues || columns.coordinateCounts || columns.coordinateValues) {
+        if (!columns.hashNumberValues ||
+            !columns.coordinateCounts ||
+            !columns.coordinateValues ||
+            columns.hashNumberValues.length !== length ||
+            columns.coordinateCounts.length !== length) {
+            throw new Error("Expected equal native coordinate numeric column lengths");
+        }
+        let coordinateCount = 0;
+        for (const count of columns.coordinateCounts) {
+            coordinateCount += count;
+        }
+        if (coordinateCount !== columns.coordinateValues.length) {
+            throw new Error("Expected equal native coordinate value lengths");
+        }
+    }
+    if (columns.requestedReplicaValues &&
+        columns.requestedReplicaValues.length !== length) {
+        throw new Error("Expected equal native coordinate replica column lengths");
+    }
+    if (columns.hashNumbers || columns.coordinateBatches || columns.requestedReplicas) {
+        if (!columns.hashNumbers ||
+            !columns.coordinateBatches ||
+            !columns.requestedReplicas ||
+            columns.hashNumbers.length !== length ||
+            columns.coordinateBatches.length !== length ||
+            columns.requestedReplicas.length !== length) {
+            throw new Error("Expected equal native coordinate string column lengths");
+        }
+    }
+};
+const emptyNativeBackboneCoordinateCommitColumns = () => ({
+    hashes: [],
+    gids: [],
+    nextHashBatches: [],
+    assignedToRangeBoundaries: new Uint8Array(0),
+    hashNumberValues: new BigUint64Array(0),
+    coordinateCounts: new Uint32Array(0),
+    coordinateValues: new BigUint64Array(0),
+    requestedReplicaValues: new Uint32Array(0),
+});
+const hasNativeBackboneNumericCoordinateCommitColumns = (columns) => !!columns.hashNumberValues &&
+    !!columns.coordinateCounts &&
+    !!columns.coordinateValues &&
+    !!columns.requestedReplicaValues;
+const nativeBackboneCoordinateCommitStringColumns = (columns) => {
+    if (columns.hashNumbers && columns.coordinateBatches && columns.requestedReplicas) {
+        return {
+            hashNumbers: columns.hashNumbers,
+            coordinateBatches: columns.coordinateBatches,
+            requestedReplicas: columns.requestedReplicas,
+        };
+    }
+    if (!hasNativeBackboneNumericCoordinateCommitColumns(columns)) {
+        throw new Error("Missing native coordinate commit columns");
+    }
+    const hashNumbers = Array.from(columns.hashNumberValues, (value) => value.toString());
+    const coordinateBatches = new Array(columns.hashes.length);
+    let coordinateOffset = 0;
+    for (let i = 0; i < columns.hashes.length; i++) {
+        const count = columns.coordinateCounts[i];
+        const coordinates = new Array(count);
+        for (let j = 0; j < count; j++) {
+            coordinates[j] = columns.coordinateValues[coordinateOffset++].toString();
+        }
+        coordinateBatches[i] = coordinates;
+    }
+    return {
+        hashNumbers,
+        coordinateBatches,
+        requestedReplicas: Array.from(columns.requestedReplicaValues),
+    };
+};
+const rawReceivePreparedFactsFromRow = ([cid, hashDigestBytes, byteLength, clockId, wallTime, logical, gid, next, type, metaBytes, metaData, payloadByteLength, signatureVerified, requestedReplicas, hashNumber,]) => ({
+    cid,
+    hashDigestBytes,
+    byteLength,
+    clockId,
+    wallTime: BigInt(wallTime),
+    logical,
+    gid,
+    next,
+    type,
+    metaBytes,
+    metaData,
+    payloadByteLength,
+    signatureVerified,
+    requestedReplicas,
+    hashNumber,
+});
+const rawReceivePreparedFactsFromColumns = ([cids, hashDigestBytes, byteLengths, clockIds, wallTimes, logicals, gids, nexts, types, metaBytes, metaDatas, payloadByteLengths, signatureVerified, requestedReplicas, hashNumbers,]) => {
+    const length = cids.length;
+    if (hashDigestBytes.length !== length ||
+        byteLengths.length !== length ||
+        clockIds.length !== length ||
+        wallTimes.length !== length ||
+        logicals.length !== length ||
+        gids.length !== length ||
+        nexts.length !== length ||
+        types.length !== length ||
+        metaBytes.length !== length ||
+        metaDatas.length !== length ||
+        payloadByteLengths.length !== length ||
+        signatureVerified.length !== length ||
+        requestedReplicas.length !== length ||
+        hashNumbers.length !== length) {
+        throw new Error("Expected equal raw receive prepared column lengths");
+    }
+    const out = new Array(length);
+    for (let i = 0; i < length; i++) {
+        out[i] = {
+            cid: cids[i],
+            hashDigestBytes: hashDigestBytes[i] ?? cidifyString(cids[i]).multihash.digest,
+            byteLength: byteLengths[i],
+            clockId: clockIds[i],
+            wallTime: wallTimes[i],
+            logical: logicals[i],
+            gid: gids[i],
+            next: nexts[i],
+            type: types[i],
+            metaBytes: metaBytes[i],
+            metaData: metaDatas[i],
+            payloadByteLength: payloadByteLengths[i],
+            signatureVerified: signatureVerified[i] !== 0,
+            requestedReplicas: requestedReplicas[i] && requestedReplicas[i] > 0
+                ? requestedReplicas[i]
+                : undefined,
+            hashNumber: hashNumbers[i] == null ? undefined : String(hashNumbers[i]),
+        };
+    }
+    return out;
+};
+const rawReceiveGroupPlanFromRow = ([gid, hashes, requestedReplicas, latestHash, maxReplicasFromHead, maxReplicasFromNewEntries, maxMaxReplicas,]) => ({
+    gid,
+    hashes,
+    requestedReplicas: Array.from(requestedReplicas),
+    latestHash,
+    maxReplicasFromHead,
+    maxReplicasFromNewEntries,
+    maxMaxReplicas,
+});
+const rawReceiveGroupIndexPlanFromRow = ([gid, indexes, requestedReplicas, latestIndex, maxReplicasFromHead, maxReplicasFromNewEntries, maxMaxReplicas,]) => ({
+    gid,
+    indexes,
+    requestedReplicas: Array.from(requestedReplicas),
+    latestIndex,
+    maxReplicasFromHead,
+    maxReplicasFromNewEntries,
+    maxMaxReplicas,
+});
+const rawReceiveGroupLeaderPlanFromRow = (resolution, [gid, indexes, requestedReplicas, latestIndex, maxReplicasFromHead, maxReplicasFromNewEntries, maxMaxReplicas, coordinateRows, leaderRows,]) => {
+    let coordinates;
+    let coordinateStrings;
+    return {
+        gid,
+        indexes,
+        requestedReplicas: Array.from(requestedReplicas),
+        latestIndex,
+        maxReplicasFromHead,
+        maxReplicasFromNewEntries,
+        maxMaxReplicas,
+        get coordinates() {
+            return (coordinates ??= rowsToNumbers(resolution, coordinateRows));
+        },
+        set coordinates(value) {
+            coordinates = value;
+        },
+        get coordinateStrings() {
+            return (coordinateStrings ??= coordinateRows.map((coordinate) => String(coordinate)));
+        },
+        set coordinateStrings(value) {
+            coordinateStrings = value;
+        },
+        leaders: rowsToSamples(leaderRows) ?? new Map(),
+    };
+};
+const rawReceiveGroupAssignmentPlanFromRow = (resolution, [gid, indexes, requestedReplicas, latestIndex, maxReplicasFromHead, maxReplicasFromNewEntries, maxMaxReplicas, coordinateRows, isLeader, fromIsLeader, assignedToRangeBoundary,]) => {
+    let coordinates;
+    let coordinateStrings;
+    return {
+        gid,
+        indexes,
+        requestedReplicas: Array.from(requestedReplicas),
+        latestIndex,
+        maxReplicasFromHead,
+        maxReplicasFromNewEntries,
+        maxMaxReplicas,
+        get coordinates() {
+            return (coordinates ??= rowsToNumbers(resolution, coordinateRows));
+        },
+        set coordinates(value) {
+            coordinates = value;
+        },
+        get coordinateStrings() {
+            return (coordinateStrings ??= coordinateRows.map((coordinate) => String(coordinate)));
+        },
+        set coordinateStrings(value) {
+            coordinateStrings = value;
+        },
+        isLeader,
+        fromIsLeader,
+        assignedToRangeBoundary,
+    };
+};
+const rawReceiveSelectionFromRow = (resolution, [retainedHashes, droppedHashes, groupCount, plannedHashCount, usedNativeFastDropPlan, usedLeaderSamplePlans, retainedGroupLeaderPlanRows, retainedIndexes, droppedIndexes,]) => {
+    const plan = {
+        retainedHashes,
+        droppedHashes,
+        groupCount,
+        plannedHashCount,
+        usedNativeFastDropPlan,
+        usedLeaderSamplePlans,
+    };
+    if (retainedIndexes) {
+        plan.retainedIndexes = retainedIndexes;
+    }
+    if (droppedIndexes) {
+        plan.droppedIndexes = droppedIndexes;
+    }
+    if (retainedGroupLeaderPlanRows) {
+        plan.retainedGroupLeaderPlans = retainedGroupLeaderPlanRows.map((row) => rawReceiveGroupLeaderPlanFromRow(resolution, row));
+    }
+    return plan;
+};
+class NativeBackboneLogGraph {
+    native;
+    options;
+    constructor(native, options) {
+        this.native = native;
+        this.options = options;
+    }
+    get length() {
+        return this.native.log_len();
+    }
+    has(hash) {
+        return this.native.has_log_entry(hash);
+    }
+    hasMany(hashes) {
+        return new Set(this.native.graph_has_many([...hashes]));
+    }
+    put(entry) {
+        this.native.graph_put(entry.hash, entry.gid, entry.next, entry.type, BigInt(entry.clock.timestamp.wallTime), entry.clock.timestamp.logical ?? 0, entry.payloadSize ?? 0, entry.head ?? true, entry.data);
+    }
+    putBatch(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        const hashes = new Array(entries.length);
+        const gids = new Array(entries.length);
+        const nexts = new Array(entries.length);
+        const entryTypes = new Uint8Array(entries.length);
+        const wallTimes = new BigUint64Array(entries.length);
+        const logicals = new Uint32Array(entries.length);
+        const payloadSizes = new Uint32Array(entries.length);
+        const heads = new Uint8Array(entries.length);
+        const datas = new Array(entries.length);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            hashes[i] = entry.hash;
+            gids[i] = entry.gid;
+            nexts[i] = entry.next;
+            entryTypes[i] = entry.type;
+            wallTimes[i] = BigInt(entry.clock.timestamp.wallTime);
+            logicals[i] = entry.clock.timestamp.logical ?? 0;
+            payloadSizes[i] = entry.payloadSize ?? 0;
+            heads[i] = (entry.head ?? true) ? 1 : 0;
+            datas[i] = entry.data;
+        }
+        this.native.graph_put_batch(hashes, gids, nexts, entryTypes, wallTimes, logicals, payloadSizes, heads, datas);
+    }
+    putAppendChain(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        const first = entries[0];
+        const hashes = new Array(entries.length);
+        const wallTimes = new BigUint64Array(entries.length);
+        const logicals = new Uint32Array(entries.length);
+        const payloadSizes = new Uint32Array(entries.length);
+        const datas = new Array(entries.length);
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            hashes[i] = entry.hash;
+            wallTimes[i] = BigInt(entry.clock.timestamp.wallTime);
+            logicals[i] = entry.clock.timestamp.logical ?? 0;
+            payloadSizes[i] = entry.payloadSize ?? 0;
+            datas[i] = entry.data;
+        }
+        this.native.graph_put_append_chain(hashes, first.gid, first.next, first.type, wallTimes, logicals, payloadSizes, datas);
+    }
+    commitBlocksAndGraphBatch(entries) {
+        if (entries.length === 0) {
+            return;
+        }
+        const columns = nativeLogCommitEntryColumns(entries);
+        this.native.commit_log_blocks_and_graph_batch(columns.hashes, columns.blockBytes, columns.gids, columns.nexts, columns.entryTypes, columns.wallTimes, columns.logicals, columns.payloadSizes, columns.heads, columns.datas);
+    }
+    commitBlocksGraphAndCoordinatesBatch(entries, coordinates) {
+        if (entries.length === 0) {
+            return;
+        }
+        validateNativeBackboneCoordinateCommitColumns(coordinates);
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(coordinates);
+        const columns = nativeLogCommitEntryColumns(entries);
+        this.native.commit_log_blocks_graph_and_coordinates_batch(columns.hashes, columns.blockBytes, columns.gids, columns.nexts, columns.entryTypes, columns.wallTimes, columns.logicals, columns.payloadSizes, columns.heads, columns.datas, coordinates.hashes, coordinates.gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, coordinates.nextHashBatches, coordinates.assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    commitPreparedRawReceiveBatch(hashes, headFlags, coordinates) {
+        if (hashes.length === 0) {
+            return true;
+        }
+        if (hashes.length !== headFlags.length) {
+            throw new Error("Expected equal raw receive hash and head lengths");
+        }
+        const coordinateColumns = coordinates ?? emptyNativeBackboneCoordinateCommitColumns();
+        validateNativeBackboneCoordinateCommitColumns(coordinateColumns);
+        if (this.native.commit_prepared_raw_receive_batch_u64 &&
+            hasNativeBackboneNumericCoordinateCommitColumns(coordinateColumns)) {
+            return this.native.commit_prepared_raw_receive_batch_u64(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateColumns.hashNumberValues, coordinateColumns.coordinateCounts, coordinateColumns.coordinateValues, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateColumns.requestedReplicaValues);
+        }
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(coordinateColumns);
+        return this.native.commit_prepared_raw_receive_batch(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    commitPreparedRawReceiveJoinBatch(hashes, headFlags, coordinates) {
+        if (hashes.length === 0) {
+            return true;
+        }
+        if (hashes.length !== headFlags.length) {
+            throw new Error("Expected equal raw receive hash and head lengths");
+        }
+        if (!this.native.commit_prepared_raw_receive_join_batch) {
+            return undefined;
+        }
+        const coordinateColumns = coordinates ?? emptyNativeBackboneCoordinateCommitColumns();
+        validateNativeBackboneCoordinateCommitColumns(coordinateColumns);
+        if (this.native.commit_prepared_raw_receive_join_batch_u64 &&
+            hasNativeBackboneNumericCoordinateCommitColumns(coordinateColumns)) {
+            return this.native.commit_prepared_raw_receive_join_batch_u64(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateColumns.hashNumberValues, coordinateColumns.coordinateCounts, coordinateColumns.coordinateValues, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateColumns.requestedReplicaValues);
+        }
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(coordinateColumns);
+        return this.native.commit_prepared_raw_receive_join_batch(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    commitVerifiedPreparedRawReceiveJoinBatch(hashes, headFlags, verifyHashes, coordinates) {
+        if (hashes.length === 0) {
+            return true;
+        }
+        if (hashes.length !== headFlags.length) {
+            throw new Error("Expected equal raw receive hash and head lengths");
+        }
+        if (!this.native.commit_verified_prepared_raw_receive_join_batch) {
+            return undefined;
+        }
+        const coordinateColumns = coordinates ?? emptyNativeBackboneCoordinateCommitColumns();
+        validateNativeBackboneCoordinateCommitColumns(coordinateColumns);
+        if (this.native.commit_verified_prepared_raw_receive_join_batch_u64 &&
+            hasNativeBackboneNumericCoordinateCommitColumns(coordinateColumns)) {
+            return this.native.commit_verified_prepared_raw_receive_join_batch_u64(hashes, nativeBackboneHeadFlagsToBytes(headFlags), verifyHashes, coordinateColumns.hashes, coordinateColumns.gids, coordinateColumns.hashNumberValues, coordinateColumns.coordinateCounts, coordinateColumns.coordinateValues, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateColumns.requestedReplicaValues);
+        }
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(coordinateColumns);
+        return this.native.commit_verified_prepared_raw_receive_join_batch(hashes, nativeBackboneHeadFlagsToBytes(headFlags), verifyHashes, coordinateColumns.hashes, coordinateColumns.gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    commitVerifiedAllPreparedRawReceiveJoinBatch(hashes, headFlags, coordinates) {
+        if (hashes.length === 0) {
+            return true;
+        }
+        if (hashes.length !== headFlags.length) {
+            throw new Error("Expected equal raw receive hash and head lengths");
+        }
+        if (!this.native.commit_verified_all_prepared_raw_receive_join_batch) {
+            return undefined;
+        }
+        const coordinateColumns = coordinates ?? emptyNativeBackboneCoordinateCommitColumns();
+        validateNativeBackboneCoordinateCommitColumns(coordinateColumns);
+        if (this.native.commit_verified_all_prepared_raw_receive_join_batch_u64 &&
+            hasNativeBackboneNumericCoordinateCommitColumns(coordinateColumns)) {
+            return this.native.commit_verified_all_prepared_raw_receive_join_batch_u64(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateColumns.hashNumberValues, coordinateColumns.coordinateCounts, coordinateColumns.coordinateValues, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateColumns.requestedReplicaValues);
+        }
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(coordinateColumns);
+        return this.native.commit_verified_all_prepared_raw_receive_join_batch(hashes, nativeBackboneHeadFlagsToBytes(headFlags), coordinateColumns.hashes, coordinateColumns.gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, coordinateColumns.nextHashBatches, coordinateColumns.assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    clearPreparedRawReceiveEntries(hashes) {
+        return this.native.clear_prepared_raw_receive_entries(iterableToArray(hashes));
+    }
+    verifyPreparedRawReceiveEntries(hashes) {
+        const normalized = iterableToArray(hashes);
+        if (normalized.length === 0) {
+            return [];
+        }
+        const verified = this.native.verify_prepared_raw_receive_entries?.(normalized);
+        return verified ? Array.from(verified, (value) => value !== 0) : undefined;
+    }
+    prepareEntryV0PlainEntryCommit(input, _blockStore) {
+        if (this.options?.commitBlocks === false) {
+            return undefined;
+        }
+        if (input.includeMaterializationBytes !== false ||
+            input.includeAppendFactsBytes !== true) {
+            return undefined;
+        }
+        const wallTime = BigInt(input.wallTime);
+        const logical = input.logical ?? 0;
+        const entryType = input.type ?? 0;
+        const hasNoNext = input.next == null || input.next.length === 0;
+        const documentIndex = input.documentIndex;
+        const documentIndexArgs = nativeDocumentIndexArgs(documentIndex);
+        const projection = documentIndex?.projection;
+        if (documentIndex?.useLatestContext &&
+            documentIndexArgs &&
+            input.resolveTrimmedEntries === false) {
+            if (projection && this.options?.documentProjectionPlanId) {
+                return preparedCommitFactsWithLatestDocumentContextFromRow(this.native.prepare_plain_entry_commit_latest_facts_document_index_cached_plan_trim_hashes(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, input.trimLengthTo, documentIndex.key, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, this.options.documentProjectionPlanId(projection.plan), projection.encodedDocument, projection.signer));
+            }
+            return preparedCommitFactsWithLatestDocumentContextFromRow(this.native.prepare_plain_entry_commit_latest_facts_document_index_trim_hashes(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, input.trimLengthTo, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projection?.plan, projection?.encodedDocument, projection?.signer));
+        }
+        if (documentIndexArgs &&
+            projection &&
+            this.options?.documentProjectionPlanId &&
+            input.resolveTrimmedEntries === false &&
+            input.trimLengthTo != null &&
+            hasNoNext) {
+            const projectionPlanId = this.options.documentProjectionPlanId(projection.plan);
+            const plainPutPayloadCommit = this.native
+                .prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_hashes_plain_put_payload;
+            if (plainPutPayloadCommit) {
+                return compactPreparedCommitFactsWithTrimHashesFromRow(plainPutPayloadCommit.call(this.native, wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, input.trimLengthTo, documentIndex.key, documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.signer));
+            }
+            return compactPreparedCommitFactsWithTrimHashesFromRow(this.native.prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_trim_hashes(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, input.trimLengthTo, documentIndex.key, documentIndex.existingCreated == null
+                ? ""
+                : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.encodedDocument, projection.signer));
+        }
+        if (documentIndexArgs &&
+            projection &&
+            this.options?.documentProjectionPlanId &&
+            input.trimLengthTo == null &&
+            hasNoNext) {
+            const projectionPlanId = this.options.documentProjectionPlanId(projection.plan);
+            const plainPutPayloadCommit = this.native
+                .prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact_plain_put_payload;
+            if (plainPutPayloadCommit) {
+                return preparedCommitFactsFromRow(plainPutPayloadCommit.call(this.native, wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, documentIndex.key, documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.signer));
+            }
+            return preparedCommitFactsFromRow(this.native.prepare_plain_entry_commit_no_next_facts_document_index_cached_plan_compact(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, documentIndex.key, documentIndex.existingCreated == null
+                ? ""
+                : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.encodedDocument, projection.signer));
+        }
+        if (documentIndexArgs &&
+            projection &&
+            this.options?.documentProjectionPlanId) {
+            const baseArgs = [
+                wallTime,
+                logical,
+                input.gid,
+                input.next ?? [],
+                entryType,
+                input.metaData,
+                input.payloadData,
+                input.trimLengthTo,
+            ];
+            return preparedCommitFactsFromRow(this.native.prepare_plain_entry_commit_facts_document_index_cached_plan(...baseArgs, documentIndex.key, documentIndex.existingCreated == null
+                ? ""
+                : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, this.options.documentProjectionPlanId(projection.plan), projection.encodedDocument, projection.signer));
+        }
+        if (documentIndexArgs &&
+            input.trimLengthTo == null &&
+            hasNoNext) {
+            return preparedCommitFactsFromRow(this.native.prepare_plain_entry_commit_no_next_facts_document_index_compact(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, ...documentIndexArgs));
+        }
+        if (documentIndexArgs &&
+            input.resolveTrimmedEntries === false &&
+            input.trimLengthTo != null &&
+            hasNoNext) {
+            return compactPreparedCommitFactsWithTrimHashesFromRow(this.native.prepare_plain_entry_commit_no_next_facts_document_index_compact_trim_hashes(wallTime, logical, input.gid, entryType, input.metaData, input.payloadData, input.trimLengthTo, ...documentIndexArgs));
+        }
+        const baseArgs = [
+            wallTime,
+            logical,
+            input.gid,
+            input.next ?? [],
+            entryType,
+            input.metaData,
+            input.payloadData,
+            input.trimLengthTo,
+        ];
+        return preparedCommitFactsFromRow(documentIndexArgs
+            ? this.native.prepare_plain_entry_commit_facts_document_index(...baseArgs, ...documentIndexArgs)
+            : this.native.prepare_plain_entry_commit_facts(...baseArgs));
+    }
+    prepareEntryV0PlainEntryAndPut(input) {
+        const row = input.trimLengthTo == null
+            ? this.native.prepare_plain_entry_storage_facts_and_put(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.next ?? [], input.type ?? 0, input.metaData, input.payloadData)
+            : this.native.prepare_plain_entry_storage_facts_trim_and_put(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.next ?? [], input.type ?? 0, input.metaData, input.payloadData, input.trimLengthTo);
+        const isTrimRow = Array.isArray(row) &&
+            row.length === 2 &&
+            Array.isArray(row[0]) &&
+            Array.isArray(row[1]);
+        const entry = storageFactsEntryFromRow((isTrimRow ? row[0] : row));
+        if (!isTrimRow) {
+            return entry;
+        }
+        return {
+            ...entry,
+            trimmedEntries: row[1].map(nativeLogEntryFromTrimRow),
+        };
+    }
+    delete(hash) {
+        return this.native.graph_delete(hash);
+    }
+    deleteMany(hashes) {
+        return this.native.graph_delete_many([...hashes]);
+    }
+    oldestEntries(limit) {
+        return this.native
+            .graph_oldest_entries(limit)
+            .map(nativeLogEntryFromTrimRow);
+    }
+    clear() {
+        this.native.graph_clear();
+    }
+    heads(gid) {
+        return this.native.graph_heads(gid);
+    }
+    hasHead(gid) {
+        return this.native.graph_has_head(gid);
+    }
+    hasAnyHead(gids) {
+        return this.native.graph_has_any_head([...gids]);
+    }
+    hasAnyHeadBatch(gidSets) {
+        return this.native.graph_has_any_head_batch([...gidSets].map((gids) => [...gids]));
+    }
+    headDataEntries(gid) {
+        return this.native.graph_head_data_entries(gid).map(headDataEntryFromRow);
+    }
+    maxHeadDataU32(gid) {
+        return this.native.graph_max_head_data_u32(gid);
+    }
+    maxHeadDataU32Batch(gids) {
+        return this.native.graph_max_head_data_u32_batch([...gids]);
+    }
+    headEntries(gid) {
+        return this.native.graph_head_entries(gid).map(headEntryFromRow);
+    }
+    joinHeadEntries(gid) {
+        return this.native.graph_join_head_entries(gid).map(joinHeadEntryFromRow);
+    }
+    childJoinEntries(hash) {
+        return this.native.graph_child_join_entries(hash).map(joinHeadEntryFromRow);
+    }
+    entryMetadataBatch(hashes) {
+        return this.native
+            .graph_entry_metadata_batch([...hashes])
+            .map(metadataEntryFromRow);
+    }
+    entryMetadataHintsBatch(hashes) {
+        return (this.native.graph_entry_metadata_hints_batch ??
+            this.native.graph_entry_metadata_batch)([...hashes]).map((row) => {
+            if (row == null || !this.native.graph_entry_metadata_hints_batch) {
+                return metadataEntryFromRow(row);
+            }
+            return requestPruneEntryFromRow(row);
+        });
+    }
+    entrySignaturePublicKeysBatch(hashes) {
+        const hashList = [...hashes];
+        return (this.native.graph_entry_signature_public_key_batch?.(hashList) ??
+            hashList.map(() => undefined));
+    }
+    uniqueReferenceGids(hash) {
+        return this.native.graph_unique_reference_gids(hash);
+    }
+    uniqueReferenceGidRowsBatch(hashes) {
+        return this.native.graph_unique_reference_gid_rows_batch([...hashes]);
+    }
+    uniqueReferenceGidRowsFlatBatch(hashes) {
+        return this.native
+            .graph_unique_reference_gid_rows_flat_batch?.([...hashes])
+            ?.map((row) => {
+            const [position, hash, gid] = row;
+            return [position, hash, gid];
+        });
+    }
+    planDeleteRecursively(hashes, skipFirst = false) {
+        return this.native.graph_plan_delete_recursively([...hashes], skipFirst);
+    }
+    payloadSizeSum() {
+        return this.native.graph_payload_size_sum();
+    }
+    oldestHash() {
+        return this.native.graph_oldest_hash();
+    }
+    newestHash() {
+        return this.native.graph_newest_hash();
+    }
+    countHasNext(next, excludeHash) {
+        return this.native.graph_count_has_next(next, excludeHash);
+    }
+    shadowedGids(gid, next, excludeHash) {
+        return this.native.graph_shadowed_gids(gid, next, excludeHash);
+    }
+    planJoin(hash, next, type, reset = false, cutCheck) {
+        const [skip, missingParents, cutChecked, coveredByCut] = this.native.graph_plan_join(hash, next, type, reset, cutCheck?.gid, cutCheck?.wallTime == null ? undefined : BigInt(cutCheck.wallTime), cutCheck?.logical);
+        return { skip, missingParents, cutChecked, coveredByCut };
+    }
+    planJoinBatch(entries, reset = false) {
+        const hashes = [];
+        const nexts = [];
+        const gids = [];
+        const types = new Uint8Array(entries.length);
+        const wallTimes = new BigUint64Array(entries.length);
+        const logicals = new Uint32Array(entries.length);
+        let cutCheck = false;
+        for (let i = 0; i < entries.length; i++) {
+            const entry = entries[i];
+            hashes.push(entry.hash);
+            nexts.push(entry.next);
+            types[i] = entry.type;
+            if (entry.cutCheck) {
+                cutCheck = true;
+                gids[i] = entry.cutCheck.gid;
+                wallTimes[i] = BigInt(entry.cutCheck.wallTime);
+                logicals[i] = entry.cutCheck.logical ?? 0;
+            }
+            else {
+                gids[i] = "";
+                wallTimes[i] = 0n;
+                logicals[i] = 0;
+            }
+        }
+        return this.native
+            .graph_plan_join_batch(hashes, nexts, types, reset, gids, wallTimes, logicals, cutCheck)
+            .map(([skip, missingParents, cutChecked, coveredByCut]) => ({
+            skip,
+            missingParents,
+            cutChecked,
+            coveredByCut,
+        }));
+    }
+}
+class NativeBackboneBlockStore {
+    native;
+    constructor(native) {
+        this.native = native;
+    }
+    status() {
+        return "open";
+    }
+    open() { }
+    close() { }
+    async start() { }
+    async stop() { }
+    async put(data) {
+        const prepared = data instanceof Uint8Array ? await calculateRawCid(data) : data;
+        this.native.block_put(prepared.cid, prepared.block.bytes);
+        return prepared.cid;
+    }
+    async putMany(blocks) {
+        const prepared = await Promise.all(blocks.map((block) => block instanceof Uint8Array ? calculateRawCid(block) : block));
+        this.native.block_put_many(prepared.map((block) => block.cid), prepared.map((block) => block.block.bytes));
+        return prepared.map((block) => block.cid);
+    }
+    putKnown(cid, bytes) {
+        this.native.block_put(cid, bytes);
+        return cid;
+    }
+    putKnownMany(blocks) {
+        if (blocks.length === 0) {
+            return [];
+        }
+        const cids = new Array(blocks.length);
+        const bytes = new Array(blocks.length);
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            cids[i] = block[0];
+            bytes[i] = block[1];
+        }
+        return this.putKnownManyColumns(cids, bytes);
+    }
+    putKnownManyColumns(cids, bytes) {
+        if (cids.length !== bytes.length) {
+            throw new Error("Expected equal block column lengths");
+        }
+        if (cids.length === 0) {
+            return [];
+        }
+        this.native.block_put_many(cids, bytes);
+        return cids;
+    }
+    putImmutable(cid, bytes) {
+        this.native.block_put(cid, bytes);
+    }
+    putManyImmutable(blocks) {
+        this.putKnownMany(blocks);
+    }
+    get(cid) {
+        return this.native.block_get(cid);
+    }
+    async getMany(cids) {
+        return this.native.block_get_many(cids);
+    }
+    has(cid) {
+        return this.native.has_block(cid);
+    }
+    async hasMany(cids) {
+        return this.native.block_has_many(cids);
+    }
+    rm(cid) {
+        this.native.block_delete(cid);
+    }
+    del(cid) {
+        this.rm(cid);
+    }
+    async rmMany(cids) {
+        return this.native.block_delete_many(cids);
+    }
+    async *iterator() {
+        for (const [key, value] of this.native.block_entries()) {
+            yield [key, value];
+        }
+    }
+    size() {
+        return this.native.block_size();
+    }
+    persisted() {
+        return false;
+    }
+    waitFor() {
+        return Promise.resolve([]);
+    }
+}
+const integerString = (value) => typeof value === "string"
+    ? value
+    : typeof value === "number"
+        ? Math.trunc(value).toString()
+        : value.toString();
+const iterableToArray = (values) => {
+    if (!values) {
+        return [];
+    }
+    return Array.isArray(values) ? values : [...values];
+};
+const EMPTY_UINT8_ARRAY = new Uint8Array(0);
+const SYNC_SEND_DEFAULT_RESERVED = new Uint8Array(4);
+const nativeDocumentIndexArgs = (documentIndex) => documentIndex
+    ? [
+        documentIndex.key,
+        documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY,
+        documentIndex.existingCreated == null
+            ? ""
+            : integerString(documentIndex.existingCreated),
+        documentIndex.byteElementIndexLimit ?? 0,
+        documentIndex.deleteTrimmedHeads === true,
+        documentIndex.projection?.plan,
+        documentIndex.projection?.encodedDocument,
+        documentIndex.projection?.signer,
+    ]
+    : undefined;
+const nativeNoNextAppendArgs = (input) => [
+    BigInt(input.wallTime),
+    input.logical ?? 0,
+    input.gid,
+    input.type ?? 0,
+    input.metaData,
+    input.payloadData,
+    input.replicas,
+    input.roleAgeMs ?? 0,
+    integerString(input.now ?? Date.now()),
+    input.selfHash ?? "",
+    input.selfReplicating ?? true,
+];
+const nativeNoNextStorageAppendArgs = (input) => [
+    ...nativeNoNextAppendArgs(input),
+    input.resolveTrimmedEntries !== false,
+];
+const nativeStorageAppendArgs = (input) => [
+    BigInt(input.wallTime),
+    input.logical ?? 0,
+    input.gid,
+    iterableToArray(input.next),
+    input.type ?? 0,
+    input.metaData,
+    input.payloadData,
+    input.replicas,
+    input.roleAgeMs ?? 0,
+    integerString(input.now ?? Date.now()),
+    input.selfHash ?? "",
+    input.selfReplicating ?? true,
+    input.resolveTrimmedEntries !== false,
+];
+const optionalIterableToArray = (values) => {
+    if (!values) {
+        return undefined;
+    }
+    return Array.isArray(values) ? values : [...values];
+};
+const findLeaderArguments = (options) => [
+    options?.roleAge ?? 0,
+    integerString(options?.now ?? Date.now()),
+    optionalIterableToArray(options?.peerFilter),
+    options?.expandPeerFilter === true,
+    options?.selfHash ?? "",
+    options?.selfReplicating === true,
+    options?.fullReplicaFallback === true,
+    options?.includeStrictFullReplica !== false,
+];
+export class NativePeerbitBackbone {
+    native;
+    resolution;
+    graph;
+    storageBackedGraph;
+    blocks;
+    documentProjectionPlanIds = new WeakMap();
+    documentProjectionPlanStructuralIds = new Map();
+    constructor(native, resolution) {
+        this.native = native;
+        this.resolution = resolution;
+        this.graph = new NativeBackboneLogGraph(native, {
+            documentProjectionPlanId: this.documentProjectionPlanId.bind(this),
+        });
+        this.storageBackedGraph = new NativeBackboneLogGraph(native, {
+            commitBlocks: false,
+            documentProjectionPlanId: this.documentProjectionPlanId.bind(this),
+        });
+        this.blocks = new NativeBackboneBlockStore(native);
+    }
+    static async create(options) {
+        const wasm = await loadWasm();
+        const resolution = options.resolution ?? "u64";
+        return new NativePeerbitBackbone(new wasm.NativePeerbitBackbone(resolution, options.clockId, options.privateKey, options.publicKey), resolution);
+    }
+    get logLength() {
+        return this.native.log_len();
+    }
+    get blockLength() {
+        return this.native.block_len();
+    }
+    hasLogEntry(hash) {
+        return this.native.has_log_entry(hash);
+    }
+    hasBlock(hash) {
+        return this.native.has_block(hash);
+    }
+    /**
+     * Byte lengths of natively stored entry blocks (`undefined` marks a
+     * missing block), used by the fused send path to plan raw exchange-head
+     * message chunking without materializing block bytes in JS.
+     */
+    syncSendBlockByteLengths(hashes) {
+        if (!this.native.sync_send_block_byte_lengths) {
+            return undefined;
+        }
+        const lengths = this.native.sync_send_block_byte_lengths(hashes);
+        const out = new Array(lengths.length);
+        for (let i = 0; i < lengths.length; i++) {
+            const length = lengths[i];
+            out[i] = length === 0xffffffff ? undefined : length;
+        }
+        return out;
+    }
+    /**
+     * Serialize one outbound raw exchange sync payload (the full
+     * PubSubData → RequestV0 → DecryptedThing → RawExchangeHeadsMessage
+     * nesting) from the native block store. Returns `undefined` when the
+     * encoder is unavailable or any head's block is not natively stored.
+     */
+    encodeRawExchangeSyncPayload(properties) {
+        if (!this.native.encode_raw_exchange_sync_payload) {
+            return undefined;
+        }
+        return this.native.encode_raw_exchange_sync_payload(properties.topic, properties.strict ?? true, properties.hashes, properties.gidRefrences, properties.reserved ?? SYNC_SEND_DEFAULT_RESERVED);
+    }
+    prepareRawReceiveBatch(blocks) {
+        if (blocks.length === 0) {
+            return [];
+        }
+        const columns = this.prepareRawReceiveColumnsBatch(blocks);
+        if (columns) {
+            return rawReceivePreparedFactsFromColumns(columns);
+        }
+        return this.native
+            .prepare_raw_receive_batch(blocks)
+            .map(rawReceivePreparedFactsFromRow);
+    }
+    prepareRawReceiveColumnsBatch(blocks, hashes, options) {
+        if (hashes && blocks.length !== hashes.length) {
+            throw new Error("Expected equal raw receive block and hash lengths");
+        }
+        if (blocks.length === 0) {
+            return [
+                [],
+                [],
+                new Uint32Array(0),
+                [],
+                new BigUint64Array(0),
+                new Uint32Array(0),
+                [],
+                [],
+                new Uint8Array(0),
+                [],
+                [],
+                new Uint32Array(0),
+                new Uint8Array(0),
+                new Uint32Array(0),
+                new BigUint64Array(0),
+            ];
+        }
+        if (options?.verifySignatures === false &&
+            hashes &&
+            this.native.prepare_raw_receive_unverified_expected_columns_batch) {
+            return this.native.prepare_raw_receive_unverified_expected_columns_batch(blocks, hashes);
+        }
+        if (options?.verifySignatures === false &&
+            !hashes &&
+            this.native.prepare_raw_receive_unverified_columns_batch) {
+            return this.native.prepare_raw_receive_unverified_columns_batch(blocks);
+        }
+        if (hashes && this.native.prepare_raw_receive_expected_columns_batch) {
+            return this.native.prepare_raw_receive_expected_columns_batch(blocks, hashes);
+        }
+        return this.native.prepare_raw_receive_columns_batch?.(blocks);
+    }
+    prepareRawReceiveExpectedColumnsBatch(blocks, hashes, options) {
+        if (blocks.length !== hashes.length) {
+            throw new Error("Expected equal raw receive block and hash lengths");
+        }
+        if (blocks.length === 0) {
+            return this.prepareRawReceiveColumnsBatch(blocks, hashes, options);
+        }
+        if (options?.verifySignatures === false &&
+            this.native.prepare_raw_receive_unverified_expected_compact_columns_batch) {
+            return this.native.prepare_raw_receive_unverified_expected_compact_columns_batch(blocks, hashes);
+        }
+        if (this.native.prepare_raw_receive_expected_compact_columns_batch) {
+            return this.native.prepare_raw_receive_expected_compact_columns_batch(blocks, hashes);
+        }
+        if (options?.verifySignatures === false &&
+            this.native.prepare_raw_receive_unverified_expected_columns_batch) {
+            return this.native.prepare_raw_receive_unverified_expected_columns_batch(blocks, hashes);
+        }
+        if (this.native.prepare_raw_receive_expected_columns_batch) {
+            return this.native.prepare_raw_receive_expected_columns_batch(blocks, hashes);
+        }
+        return undefined;
+    }
+    prepareRawReceiveExpectedColumnsAndSelectionBatch(blocks, hashes, options) {
+        if (blocks.length !== hashes.length) {
+            throw new Error("Expected equal raw receive block and hash lengths");
+        }
+        if (options.verifySignatures !== false ||
+            !this.native
+                .prepare_raw_receive_unverified_expected_compact_columns_and_selection_batch) {
+            return undefined;
+        }
+        const row = this.native.prepare_raw_receive_unverified_expected_compact_columns_and_selection_batch(blocks, hashes, options.minReplicas, options.maxReplicas, ...findLeaderArguments(options.leaderOptions), options.fromHash);
+        if (!row) {
+            return undefined;
+        }
+        const [columns, selectionRow] = row;
+        return {
+            columns,
+            selection: selectionRow
+                ? rawReceiveSelectionFromRow(this.resolution, selectionRow)
+                : undefined,
+        };
+    }
+    /**
+     * Stash-backed twin of `prepareRawReceiveExpectedColumnsBatch`: the entry
+     * block bytes come from the wire-sync stash inside wasm memory instead of
+     * a JS blocks array, so no bytes cross the JS/wasm boundary. Returns
+     * undefined when the stash entry is gone (callers fall back to the
+     * blocks-based path).
+     */
+    prepareStashedRawReceiveExpectedColumnsBatch(session, id, indexes, hashes, options) {
+        if (indexes.length !== hashes.length) {
+            throw new Error("Expected equal raw receive index and hash lengths");
+        }
+        return this.native.prepare_stashed_raw_receive_expected_compact_columns_batch?.(session.handle, id, indexes, hashes, options?.verifySignatures !== false);
+    }
+    /** Stash-backed twin of `prepareRawReceiveExpectedColumnsAndSelectionBatch`. */
+    prepareStashedRawReceiveExpectedColumnsAndSelectionBatch(session, id, indexes, hashes, options) {
+        if (indexes.length !== hashes.length) {
+            throw new Error("Expected equal raw receive index and hash lengths");
+        }
+        if (options.verifySignatures !== false ||
+            !this.native
+                .prepare_stashed_raw_receive_expected_compact_columns_and_selection_batch) {
+            return undefined;
+        }
+        const row = this.native.prepare_stashed_raw_receive_expected_compact_columns_and_selection_batch(session.handle, id, indexes, hashes, options.minReplicas, options.maxReplicas, ...findLeaderArguments(options.leaderOptions), options.fromHash);
+        if (!row) {
+            return undefined;
+        }
+        const [columns, selectionRow] = row;
+        return {
+            columns,
+            selection: selectionRow
+                ? rawReceiveSelectionFromRow(this.resolution, selectionRow)
+                : undefined,
+        };
+    }
+    /**
+     * Raw entry block bytes for a hash from the pending prepared-receive
+     * entries or the committed block store — the fallback for lazily
+     * materialized stash-backed heads whose stash entry was already released.
+     */
+    rawReceiveBlockBytes(hash) {
+        return this.native.raw_receive_block_bytes?.(hash);
+    }
+    clearPreparedRawReceiveEntries(hashes) {
+        return this.native.clear_prepared_raw_receive_entries(iterableToArray(hashes));
+    }
+    verifyPreparedRawReceiveEntries(hashes) {
+        return this.graph.verifyPreparedRawReceiveEntries(hashes);
+    }
+    planPreparedRawReceiveGroups(hashes, options) {
+        if (!this.native.plan_prepared_raw_receive_groups) {
+            return undefined;
+        }
+        const rows = this.native.plan_prepared_raw_receive_groups(iterableToArray(hashes), options.minReplicas, options.maxReplicas);
+        return rows?.map(rawReceiveGroupPlanFromRow);
+    }
+    planPreparedRawReceiveGroupIndexes(hashes, options) {
+        if (!this.native.plan_prepared_raw_receive_group_indexes) {
+            return undefined;
+        }
+        const rows = this.native.plan_prepared_raw_receive_group_indexes(iterableToArray(hashes), options.minReplicas, options.maxReplicas);
+        return rows?.map(rawReceiveGroupIndexPlanFromRow);
+    }
+    planPreparedRawReceiveGroupLeaders(hashes, options, leaderOptions) {
+        if (!this.native.plan_prepared_raw_receive_group_leaders) {
+            return undefined;
+        }
+        const rows = this.native.plan_prepared_raw_receive_group_leaders(iterableToArray(hashes), options.minReplicas, options.maxReplicas, ...findLeaderArguments(leaderOptions));
+        return rows?.map((row) => rawReceiveGroupLeaderPlanFromRow(this.resolution, row));
+    }
+    planPreparedRawReceiveGroupAssignments(hashes, options, leaderOptions, fromHash) {
+        if (!this.native.plan_prepared_raw_receive_group_assignments) {
+            return undefined;
+        }
+        const rows = this.native.plan_prepared_raw_receive_group_assignments(iterableToArray(hashes), options.minReplicas, options.maxReplicas, ...findLeaderArguments(leaderOptions), fromHash);
+        return rows?.map((row) => rawReceiveGroupAssignmentPlanFromRow(this.resolution, row));
+    }
+    planPreparedRawReceiveFastDrop(hashes, options, leaderOptions, fromHash) {
+        if (!this.native.plan_prepared_raw_receive_fast_drop) {
+            return undefined;
+        }
+        const row = this.native.plan_prepared_raw_receive_fast_drop(iterableToArray(hashes), options.minReplicas, options.maxReplicas, ...findLeaderArguments(leaderOptions), fromHash);
+        if (!row) {
+            return undefined;
+        }
+        const [canDrop, groupCount, plannedHashCount] = row;
+        return { canDrop, groupCount, plannedHashCount };
+    }
+    planPreparedRawReceiveSelection(hashes, options, leaderOptions, fromHash) {
+        if (!this.native.plan_prepared_raw_receive_selection) {
+            return undefined;
+        }
+        const row = this.native.plan_prepared_raw_receive_selection(iterableToArray(hashes), options.minReplicas, options.maxReplicas, ...findLeaderArguments(leaderOptions), fromHash);
+        return row ? rawReceiveSelectionFromRow(this.resolution, row) : undefined;
+    }
+    selectPreparedRawReceiveHashes(hashes, options, leaderOptions, fromHash) {
+        if (!this.native.select_prepared_raw_receive_hashes) {
+            return undefined;
+        }
+        const row = this.native.select_prepared_raw_receive_hashes(iterableToArray(hashes), options.minReplicas, options.maxReplicas, ...findLeaderArguments(leaderOptions), fromHash);
+        return row ? rawReceiveSelectionFromRow(this.resolution, row) : undefined;
+    }
+    getEntryCoordinateHashes() {
+        return this.native.entry_coordinate_hashes();
+    }
+    getEntryCoordinates(hash) {
+        const coordinates = this.native.get_entry_coordinates(hash);
+        return coordinates
+            ? rowsToNumbers(this.resolution, coordinates)
+            : undefined;
+    }
+    getEntryHashesForHashNumbers(hashNumbers) {
+        const rows = this.native.entry_hashes_for_hash_numbers([...hashNumbers].map(integerString));
+        return rowsToHashNumberMap(rows);
+    }
+    getEntryHashesForHashNumbersU64(hashNumbers) {
+        if (typeof BigUint64Array === "undefined" ||
+            typeof this.native.entry_hashes_for_hash_numbers_u64 !== "function") {
+            return undefined;
+        }
+        return rowsToHashNumberMap(this.native.entry_hashes_for_hash_numbers_u64(hashNumbers));
+    }
+    getEntryHashListForHashNumbersU64(hashNumbers) {
+        if (typeof BigUint64Array === "undefined" ||
+            typeof this.native.entry_hashes_for_hash_numbers_flat_u64 !== "function") {
+            return undefined;
+        }
+        return this.native.entry_hashes_for_hash_numbers_flat_u64(hashNumbers);
+    }
+    getEntryHashNumbersInRange(range) {
+        return rowsToNumbers("u64", this.native.entry_hash_numbers_in_range(integerString(range.start1), integerString(range.end1), integerString(range.start2), integerString(range.end2)));
+    }
+    getEntryHashNumbersInRangeU64(range) {
+        if (typeof BigUint64Array === "undefined" ||
+            typeof this.native.entry_hash_numbers_in_range_u64 !== "function") {
+            return undefined;
+        }
+        return this.native.entry_hash_numbers_in_range_u64(integerString(range.start1), integerString(range.end1), integerString(range.start2), integerString(range.end2));
+    }
+    countEntryCoordinatesInRanges(ranges, options) {
+        const start1 = [];
+        const end1 = [];
+        const start2 = [];
+        const end2 = [];
+        for (const range of ranges) {
+            start1.push(integerString(range.start1));
+            end1.push(integerString(range.end1));
+            start2.push(integerString(range.start2));
+            end2.push(integerString(range.end2));
+        }
+        return this.native.count_entry_coordinates_in_ranges(start1, end1, start2, end2, options?.includeAssignedToRangeBoundary === true);
+    }
+    getEntryCoordinateFields() {
+        return this.native
+            .entry_coordinate_fields()
+            .map((row) => coordinateFieldsFromRow(this.resolution, row));
+    }
+    get coordinateIndexLength() {
+        return this.native.coordinate_index_len();
+    }
+    get coordinateValueLength() {
+        return this.native.coordinate_value_len();
+    }
+    hasCoordinateIndexHash(hash) {
+        return this.native.coordinate_index_has_hash(hash);
+    }
+    configureDocumentSchemaIr(schemaIr) {
+        const [rootFields, nodeCount, genericNodes] = this.native.configure_document_schema_ir(schemaIr);
+        return { rootFields, nodeCount, genericNodes };
+    }
+    setDocumentByteElementIndexLimit(limit) {
+        this.native.set_document_byte_element_index_limit?.(limit);
+    }
+    setDocumentContextHeadField(field) {
+        this.native.set_document_context_head_field(field);
+    }
+    setDocumentContextFields(fields) {
+        this.native.set_document_context_fields(fields.created, fields.modified, fields.head, fields.gid, fields.size);
+    }
+    projectDocumentIndexSimple(encodedDocument, plan, context) {
+        try {
+            return this.native.project_document_index_simple(encodedDocument, plan, integerString(context.created), integerString(context.modified), context.head ?? "", context.gid, context.size, context.signer);
+        }
+        catch {
+            return;
+        }
+    }
+    setAppendProfileEnabled(enabled) {
+        this.native.set_append_profile_enabled(enabled);
+    }
+    resetAppendProfile() {
+        this.native.reset_append_profile();
+    }
+    appendProfile() {
+        const row = this.native.append_profile();
+        return Object.fromEntries(nativeBackboneAppendProfileKeys.map((key, index) => [
+            key,
+            Number(row[index] ?? 0),
+        ]));
+    }
+    get documentIndexLength() {
+        return this.native.document_index_len();
+    }
+    get documentValueLength() {
+        return this.native.document_value_len();
+    }
+    documentExactStringFirstKey(field, value) {
+        return this.native.document_exact_string_first_key(field, value);
+    }
+    documentValueBytes(key) {
+        return this.native.document_value_bytes(key);
+    }
+    documentEntry(key) {
+        return this.native.document_entry(key);
+    }
+    documentKeysExist(keys) {
+        const batch = Array.isArray(keys) ? keys : Array.from(keys);
+        if (batch.length === 0) {
+            return new Uint8Array(0);
+        }
+        const exists = this.native.document_keys_exist;
+        if (exists) {
+            return exists.call(this.native, batch);
+        }
+        return Uint8Array.from(batch.map((key) => (this.documentEntry(key) ? 1 : 0)));
+    }
+    documentFieldValue(key, field) {
+        return this.native.document_field_value(key, field);
+    }
+    documentContext(key) {
+        return this.native.document_context(key);
+    }
+    documentContextBatch(keys) {
+        const batch = this.native.document_context_batch;
+        return batch
+            ? batch.call(this.native, keys)
+            : keys.map((key) => this.documentContext(key));
+    }
+    documentPreviousSignaturePublicKey(key) {
+        const row = this.native.document_previous_signature_public_key?.(key);
+        if (!row) {
+            return;
+        }
+        const [exists, publicKey] = row;
+        return { exists, publicKey };
+    }
+    documentContextsAndPreviousSignaturePublicKeys(keys) {
+        return this.native
+            .document_context_previous_signature_public_key_batch?.(keys)
+            .map(([contextRow, publicKey]) => ({
+            context: documentContextFactsFromRow(contextRow),
+            publicKey,
+        }));
+    }
+    documentQuery(queryBytes, sortBytes) {
+        return this.native.document_query(queryBytes, sortBytes);
+    }
+    documentQueryPage(queryBytes, sortBytes, offset, limit) {
+        return this.native.document_query_page(queryBytes, sortBytes, offset, limit);
+    }
+    documentProjectionPlanId(plan) {
+        const cached = this.documentProjectionPlanIds.get(plan);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const structuralKey = JSON.stringify(plan);
+        const structuralCached = this.documentProjectionPlanStructuralIds.get(structuralKey);
+        if (structuralCached !== undefined) {
+            this.documentProjectionPlanIds.set(plan, structuralCached);
+            return structuralCached;
+        }
+        const id = this.native.register_document_projection_plan(plan);
+        this.documentProjectionPlanIds.set(plan, id);
+        this.documentProjectionPlanStructuralIds.set(structuralKey, id);
+        return id;
+    }
+    documentCount(queryBytes) {
+        return this.native.document_count(queryBytes);
+    }
+    documentSum(queryBytes, field) {
+        return this.native.document_sum(queryBytes, field);
+    }
+    putDocumentEncodedPartsStored(key, valuePrefixBytes, valueSuffixBytes, byteElementIndexLimit = 0) {
+        this.native.put_document_encoded_parts_stored(key, valuePrefixBytes, valueSuffixBytes, byteElementIndexLimit);
+    }
+    putDocumentEncodedPartsStoredBatch(values, byteElementIndexLimit = 0) {
+        if (values.length === 0) {
+            return;
+        }
+        const keys = new Array(values.length);
+        const prefixes = new Array(values.length);
+        const suffixes = new Array(values.length);
+        for (let i = 0; i < values.length; i++) {
+            const value = values[i];
+            keys[i] = value.key;
+            prefixes[i] = value.valuePrefixBytes;
+            suffixes[i] = value.valueSuffixBytes;
+        }
+        this.native.put_document_encoded_parts_stored_batch(keys, prefixes, suffixes, byteElementIndexLimit);
+    }
+    deleteDocument(key) {
+        return this.native.delete_document(key);
+    }
+    deleteDocuments(keys) {
+        const batch = Array.isArray(keys) ? keys : Array.from(keys);
+        if (batch.length === 0) {
+            return 0;
+        }
+        return this.native.delete_documents(batch);
+    }
+    deleteDocumentsResult(keys) {
+        const batch = Array.isArray(keys) ? keys : Array.from(keys);
+        if (batch.length === 0) {
+            return new Uint8Array(0);
+        }
+        return this.native.delete_documents_result(batch);
+    }
+    clearDocumentIndex() {
+        this.native.clear_document_index();
+    }
+    get documentPendingJournalLength() {
+        return this.native.document_pending_journal_len();
+    }
+    get documentPendingJournalByteLength() {
+        return this.native.document_pending_journal_byte_len();
+    }
+    get documentJournalEnabled() {
+        return this.native.document_journal_enabled();
+    }
+    setDocumentJournalEnabled(enabled) {
+        this.native.set_document_journal_enabled(enabled);
+    }
+    documentJournalHeader() {
+        return this.native.document_journal_header();
+    }
+    documentJournal() {
+        return this.native.document_journal();
+    }
+    clearDocumentJournal() {
+        this.native.clear_document_journal();
+    }
+    clearDocumentJournalPrefix(byteLength, recordCount) {
+        this.native.clear_document_journal_prefix(byteLength, recordCount);
+    }
+    documentSnapshot() {
+        return this.native.document_snapshot();
+    }
+    loadDocumentSnapshotAndJournal(snapshot, journal) {
+        return this.native.load_document_snapshot_and_journal(snapshot ?? new Uint8Array(), journal ?? new Uint8Array());
+    }
+    get coordinatePendingJournalLength() {
+        return this.native.coordinate_pending_journal_len();
+    }
+    get coordinatePendingJournalByteLength() {
+        return this.native.coordinate_pending_journal_byte_len();
+    }
+    get coordinateJournalEnabled() {
+        return this.native.coordinate_journal_enabled();
+    }
+    setCoordinateJournalEnabled(enabled) {
+        this.native.set_coordinate_journal_enabled(enabled);
+    }
+    coordinateJournalHeader() {
+        return this.native.coordinate_journal_header();
+    }
+    coordinateJournal() {
+        return this.native.coordinate_journal();
+    }
+    clearCoordinateJournal() {
+        this.native.clear_coordinate_journal();
+    }
+    clearCoordinateJournalPrefix(byteLength, recordCount) {
+        this.native.clear_coordinate_journal_prefix(byteLength, recordCount);
+    }
+    coordinateSnapshot() {
+        return this.native.coordinate_snapshot();
+    }
+    loadCoordinateSnapshotAndJournal(snapshot, journal) {
+        return this.native.load_coordinate_snapshot_and_journal(snapshot ?? new Uint8Array(), journal ?? new Uint8Array());
+    }
+    get documentSignerPendingJournalLength() {
+        return this.native.document_signer_pending_journal_len();
+    }
+    get documentSignerPendingJournalByteLength() {
+        return this.native.document_signer_pending_journal_byte_len();
+    }
+    get documentSignerJournalEnabled() {
+        return this.native.document_signer_journal_enabled();
+    }
+    setDocumentSignerJournalEnabled(enabled) {
+        this.native.set_document_signer_journal_enabled(enabled);
+    }
+    documentSignerJournalHeader() {
+        return this.native.document_signer_journal_header();
+    }
+    documentSignerJournal() {
+        return this.native.document_signer_journal();
+    }
+    clearDocumentSignerJournal() {
+        this.native.clear_document_signer_journal();
+    }
+    clearDocumentSignerJournalPrefix(byteLength, recordCount) {
+        this.native.clear_document_signer_journal_prefix(byteLength, recordCount);
+    }
+    documentSignerSnapshot() {
+        return this.native.document_signer_snapshot();
+    }
+    loadDocumentSignerSnapshotAndJournal(snapshot, journal) {
+        return this.native.load_document_signer_snapshot_and_journal(snapshot ?? new Uint8Array(), journal ?? new Uint8Array());
+    }
+    clear() {
+        this.native.clear();
+    }
+    clearSharedLog() {
+        this.native.clear_shared_log();
+    }
+    clearEntryCoordinates() {
+        this.native.clear_entry_coordinates();
+    }
+    putRange(range) {
+        this.native.put_range(range.id, range.hash, integerString(range.timestamp), integerString(range.start1), integerString(range.end1), integerString(range.start2), integerString(range.end2), integerString(range.width), range.mode);
+    }
+    deleteRange(id) {
+        return this.native.delete_range(id);
+    }
+    putEntryCoordinates(hash, gid, coordinates, assignedToRangeBoundary, requestedReplicas, hashNumber) {
+        this.native.put_entry_coordinates(hash, gid, integerString(hashNumber), [...coordinates].map(integerString), assignedToRangeBoundary, requestedReplicas);
+    }
+    deleteEntryCoordinates(hash) {
+        return this.native.delete_entry_coordinates(hash);
+    }
+    deleteEntryCoordinatesBatch(hashes) {
+        this.native.delete_entry_coordinates_batch(iterableToArray(hashes));
+    }
+    commitEntryCoordinates(hash, gid, coordinates, nextHashes, assignedToRangeBoundary, requestedReplicas, hashNumber) {
+        this.native.commit_entry_coordinates(hash, gid, integerString(hashNumber), [...coordinates].map(integerString), iterableToArray(nextHashes), assignedToRangeBoundary, requestedReplicas);
+    }
+    commitEntryCoordinatesBatch(entries) {
+        const rows = [...entries].map((entry) => {
+            const coordinates = [...entry.coordinates].map(integerString);
+            return {
+                hash: entry.hash,
+                gid: entry.gid,
+                hashNumber: integerString(entry.hashNumber),
+                coordinates,
+                nextHashes: iterableToArray(entry.nextHashes),
+                assignedToRangeBoundary: entry.assignedToRangeBoundary ? 1 : 0,
+                requestedReplicas: entry.requestedReplicas,
+            };
+        });
+        if (rows.length === 0) {
+            return;
+        }
+        this.commitEntryCoordinatesColumnsBatch({
+            hashes: rows.map((row) => row.hash),
+            gids: rows.map((row) => row.gid),
+            hashNumbers: rows.map((row) => row.hashNumber),
+            coordinateBatches: rows.map((row) => row.coordinates),
+            nextHashBatches: rows.map((row) => row.nextHashes),
+            assignedToRangeBoundaries: new Uint8Array(rows.map((row) => row.assignedToRangeBoundary)),
+            requestedReplicas: rows.map((row) => row.requestedReplicas),
+        });
+    }
+    commitEntryCoordinatesColumnsBatch(columns) {
+        const { hashes, gids, nextHashBatches, assignedToRangeBoundaries, } = columns;
+        if (hashes.length === 0) {
+            return;
+        }
+        validateNativeBackboneCoordinateCommitColumns(columns);
+        if (this.native.commit_entry_coordinates_batch_u64 &&
+            hasNativeBackboneNumericCoordinateCommitColumns(columns)) {
+            this.native.commit_entry_coordinates_batch_u64(hashes, gids, columns.hashNumberValues, columns.coordinateCounts, columns.coordinateValues, nextHashBatches, assignedToRangeBoundaries, columns.requestedReplicaValues);
+            return;
+        }
+        const coordinateStringColumns = nativeBackboneCoordinateCommitStringColumns(columns);
+        if (!this.native.commit_entry_coordinates_batch) {
+            for (let i = 0; i < hashes.length; i++) {
+                this.native.commit_entry_coordinates(hashes[i], gids[i], coordinateStringColumns.hashNumbers[i], coordinateStringColumns.coordinateBatches[i], nextHashBatches[i], assignedToRangeBoundaries[i] === 1, coordinateStringColumns.requestedReplicas[i]);
+            }
+            return;
+        }
+        this.native.commit_entry_coordinates_batch(hashes, gids, coordinateStringColumns.hashNumbers, coordinateStringColumns.coordinateBatches, nextHashBatches, assignedToRangeBoundaries, coordinateStringColumns.requestedReplicas);
+    }
+    addGidPeers(gid, peers, reset = false) {
+        return this.native.add_gid_peers(gid, iterableToArray(peers), reset);
+    }
+    removeGidPeer(peer, gid) {
+        this.native.remove_gid_peer(peer, gid);
+    }
+    removeGidPeers(peer, gids) {
+        const gidArray = iterableToArray(gids);
+        if (this.native.remove_gid_peers) {
+            this.native.remove_gid_peers(peer, gidArray);
+            return;
+        }
+        for (const gid of gidArray) {
+            this.native.remove_gid_peer(peer, gid);
+        }
+    }
+    deleteGidPeers(gid) {
+        return this.native.delete_gid_peers(gid);
+    }
+    clearGidPeers() {
+        this.native.clear_gid_peers();
+    }
+    markEntriesKnownByPeer(hashes, peer) {
+        this.native.mark_entries_known_by_peer(iterableToArray(hashes), peer);
+    }
+    removeEntriesKnownByPeer(hashes, peer) {
+        this.native.remove_entries_known_by_peer(iterableToArray(hashes), peer);
+    }
+    removePeerFromEntryKnownPeers(peer) {
+        this.native.remove_peer_from_entry_known_peers(peer);
+    }
+    clearEntryKnownPeers() {
+        this.native.clear_entry_known_peers();
+    }
+    getGrid(from, count) {
+        return rowsToNumbers(this.resolution, this.native.get_grid(integerString(from), count));
+    }
+    getGidCoordinates(gid, count) {
+        return rowsToNumbers(this.resolution, this.native.get_gid_coordinates(gid, count));
+    }
+    findLeaders(cursors, replicas, options) {
+        const rows = this.native.find_leaders([...cursors].map(integerString), replicas, ...findLeaderArguments(options));
+        return rowsToSamples(rows) ?? new Map();
+    }
+    findLeadersBatch(items, options) {
+        const entries = [...items];
+        const rows = this.native.find_leaders_batch(entries.map((entry) => [...entry.cursors].map(integerString)), entries.map((entry) => entry.replicas), ...findLeaderArguments(options));
+        return rows.map((row) => rowsToSamples(row) ?? new Map());
+    }
+    planLeadersForGid(gid, replicas, options) {
+        const [coordinateRows, leaderRows] = this.native.plan_entry_leaders_for_gid(gid, replicas, ...findLeaderArguments(options));
+        return lazyLeaderPlanFromRows(this.resolution, coordinateRows, leaderRows);
+    }
+    planLeadersForGidsBatch(items, options) {
+        const entries = [...items];
+        const rows = this.native.plan_leaders_for_gids_batch(entries.map((entry) => entry.gid), entries.map((entry) => entry.replicas), ...findLeaderArguments(options));
+        return rows.map(([coordinateRows, leaderRows]) => lazyLeaderPlanFromRows(this.resolution, coordinateRows, leaderRows));
+    }
+    planLeaderSamplesForGidsBatch(items, options) {
+        if (!this.native.plan_leader_samples_for_gids_batch) {
+            return undefined;
+        }
+        const entries = iterableToArray(items);
+        const rows = this.native.plan_leader_samples_for_gids_batch(entries.map((entry) => entry.gid), entries.map((entry) => entry.replicas), ...findLeaderArguments(options));
+        return rows.map((leaderRows) => rowsToSamples(leaderRows) ?? new Map());
+    }
+    planRequestPruneLeaderHints(hashes, skipHashes, options) {
+        if (!this.native.plan_request_prune_leader_hints) {
+            return undefined;
+        }
+        const [entryRows, presentBlockHashes, localLeaderHashes, peerHistoryGids, peerHistoryRemovedHashes,] = this.native.plan_request_prune_leader_hints([...hashes], [...skipHashes], ...findLeaderArguments(options));
+        const entries = new Map();
+        const replicaCounts = new Map();
+        for (const row of entryRows) {
+            const entry = requestPruneEntryFromRow(row);
+            entries.set(entry.hash, entry);
+            if (entry.replicas != null) {
+                replicaCounts.set(entry.hash, entry.replicas);
+            }
+        }
+        return {
+            entries,
+            presentBlockHashes: new Set(presentBlockHashes),
+            localLeaderHashes: new Set(localLeaderHashes),
+            replicaCounts,
+            peerHistoryGids,
+            peerHistoryRemovedHashes: new Set(peerHistoryRemovedHashes),
+        };
+    }
+    planRequestPruneLeaderHintColumns(hashes, skipHashes, options) {
+        if (!this.native.plan_request_prune_leader_hint_columns) {
+            return undefined;
+        }
+        const [gids, data, presentBlockFlags, localLeaderFlags, replicaCounts, peerHistoryGids, peerHistoryRemovedFlags,] = this.native.plan_request_prune_leader_hint_columns(iterableToArray(hashes), iterableToArray(skipHashes), ...findLeaderArguments(options));
+        return {
+            gids,
+            data,
+            presentBlockFlags,
+            localLeaderFlags,
+            replicaCounts,
+            peerHistoryGids,
+            peerHistoryRemovedFlags,
+        };
+    }
+    planRequestPruneAllConfirmed(hashes, prunePeer, options) {
+        const hashArray = iterableToArray(hashes);
+        if (options?.omitPeerHistoryGids === true &&
+            this.native.plan_request_prune_all_confirmed_no_gid_return) {
+            return {
+                allConfirmed: this.native.plan_request_prune_all_confirmed_no_gid_return(hashArray, prunePeer, ...findLeaderArguments(options)),
+                peerHistoryGids: [],
+            };
+        }
+        if (!this.native.plan_request_prune_all_confirmed) {
+            return undefined;
+        }
+        const [allConfirmed, peerHistoryGids] = this.native.plan_request_prune_all_confirmed(hashArray, prunePeer, ...findLeaderArguments(options));
+        return {
+            allConfirmed,
+            peerHistoryGids,
+        };
+    }
+    planEntryAssignmentForGid(gid, replicas, options) {
+        const [coordinateRows, leaderRows, assignedToRangeBoundary] = this.native.plan_entry_assignment_for_gid(gid, replicas, ...findLeaderArguments(options));
+        return {
+            coordinates: rowsToNumbers(this.resolution, coordinateRows),
+            leaders: rowsToSamples(leaderRows) ?? new Map(),
+            assignedToRangeBoundary,
+        };
+    }
+    planRepairDispatchForEntries(input, options) {
+        const entries = [...input.entries];
+        const pendingModes = [...input.pendingModes];
+        const rows = this.native.plan_repair_dispatch_for_entries(entries.map((entry) => entry.hash), entries.map((entry) => entry.gid), entries.map((entry) => entry.requestedReplicas), entries.map((entry) => [...entry.coordinates].map(integerString)), pendingModes, pendingModes.map((mode) => [
+            ...(input.pendingPeersByMode.get(mode) ?? []),
+        ]), pendingModes.map((mode) => {
+            const optimisticByGid = input.optimisticPeersByMode?.get(mode);
+            return entries.map((entry) => [
+                ...(optimisticByGid?.get(entry.gid) ?? []),
+            ]);
+        }), input.fullReplicaRepairCandidates
+            ? [...input.fullReplicaRepairCandidates]
+            : [], input.fullReplicaRepairCandidateCount, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        return rowsToRepairDispatchPlan(rows);
+    }
+    planRepairDispatchForResidentEntries(input, options) {
+        const pendingModes = [...input.pendingModes];
+        const optimisticGidsByMode = [];
+        const optimisticPeersByGidByMode = [];
+        for (const mode of pendingModes) {
+            const optimisticByGid = input.optimisticPeersByMode?.get(mode);
+            const gids = [];
+            const peersByGid = [];
+            if (optimisticByGid) {
+                for (const [gid, peers] of optimisticByGid) {
+                    gids.push(gid);
+                    peersByGid.push([...peers]);
+                }
+            }
+            optimisticGidsByMode.push(gids);
+            optimisticPeersByGidByMode.push(peersByGid);
+        }
+        const rows = this.native.plan_repair_dispatch_for_resident_entries(pendingModes, pendingModes.map((mode) => [
+            ...(input.pendingPeersByMode.get(mode) ?? []),
+        ]), optimisticGidsByMode, optimisticPeersByGidByMode, input.fullReplicaRepairCandidates
+            ? [...input.fullReplicaRepairCandidates]
+            : [], input.fullReplicaRepairCandidateCount, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        return rowsToRepairDispatchPlan(rows);
+    }
+    planLocalAppendForGidCompact(input, options) {
+        const [leaderRows, isLeader, assignedToRangeBoundary, coordinatePlanRow] = this.native.plan_local_append_for_gid_compact(input.entryHash, input.gid, integerString(input.hashNumber ?? 0), iterableToArray(input.nextHashes), input.replicas, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        const coordinate = appendCoordinatePlanFromRow(this.resolution, coordinatePlanRow);
+        let coordinates;
+        return {
+            get coordinates() {
+                return (coordinates ??= coordinate.coordinates);
+            },
+            set coordinates(value) {
+                coordinates = value;
+            },
+            leaders: rowsToSamples(leaderRows),
+            isLeader,
+            assignedToRangeBoundary,
+            coordinate,
+        };
+    }
+    commitLocalAppendForGidCompact(input, options) {
+        const [leaderRows, isLeader, assignedToRangeBoundary, coordinatePlanRow] = this.native.commit_local_append_for_gid_compact(input.entryHash, input.gid, integerString(input.hashNumber ?? 0), iterableToArray(input.nextHashes), iterableToArray(input.deleteHashes), input.replicas, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        const coordinate = appendCoordinatePlanFromRow(this.resolution, coordinatePlanRow);
+        let coordinates;
+        return {
+            get coordinates() {
+                return (coordinates ??= coordinate.coordinates);
+            },
+            set coordinates(value) {
+                coordinates = value;
+            },
+            leaders: rowsToSamples(leaderRows),
+            isLeader,
+            assignedToRangeBoundary,
+            coordinate,
+        };
+    }
+    planAppendForGid(input, options) {
+        const [coordinateRows, leaderRows, isLeader, assignedToRangeBoundary, delivery, coordinatePlanRow,] = this.native.plan_append_for_gid(input.entryHash, input.gid, integerString(input.hashNumber ?? 0), iterableToArray(input.nextHashes), input.replicas, iterableToArray(input.fullReplicaCandidates), iterableToArray(input.fallbackRecipients), input.selfHash, input.deliveryEnabled, input.reliabilityAck, input.minAcks, input.requireRecipients, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        return {
+            coordinates: rowsToNumbers(this.resolution, coordinateRows),
+            leaders: rowsToSamples(leaderRows),
+            isLeader,
+            assignedToRangeBoundary,
+            delivery: appendDeliveryPlanFromRow(delivery),
+            coordinate: appendCoordinatePlanFromRow(this.resolution, coordinatePlanRow),
+        };
+    }
+    planAppendForGidsBatch(input, options) {
+        const entries = [...input.entries];
+        const rows = this.native.plan_append_for_gids_batch(entries.map((entry) => entry.entryHash), entries.map((entry) => entry.gid), entries.map((entry) => integerString(entry.hashNumber ?? 0)), entries.map((entry) => iterableToArray(entry.nextHashes)), entries.map((entry) => entry.replicas), iterableToArray(input.fullReplicaCandidates), iterableToArray(input.fallbackRecipients), input.selfHash, input.deliveryEnabled, input.reliabilityAck, input.minAcks, input.requireRecipients, ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        return rows.map(([coordinateRows, leaderRows, isLeader, assignedToRangeBoundary, delivery, coordinatePlanRow,]) => ({
+            coordinates: rowsToNumbers(this.resolution, coordinateRows),
+            leaders: rowsToSamples(leaderRows),
+            isLeader,
+            assignedToRangeBoundary,
+            delivery: appendDeliveryPlanFromRow(delivery),
+            coordinate: appendCoordinatePlanFromRow(this.resolution, coordinatePlanRow),
+        }));
+    }
+    planReceiveCoordinatesForGidsBatch(input, options) {
+        const entries = [...input.entries];
+        const rows = this.native.plan_receive_coordinates_for_gids_batch(entries.map((entry) => entry.entryHash), entries.map((entry) => entry.gid), entries.map((entry) => integerString(entry.hashNumber ?? 0)), entries.map((entry) => iterableToArray(entry.nextHashes)), entries.map((entry) => entry.replicas), ...findLeaderArguments({
+            ...options,
+            selfHash: input.selfHash,
+        }));
+        return rows.map(([coordinateRows, leaderRows, isLeader, assignedToRangeBoundary, coordinatePlanRow,]) => ({
+            coordinates: rowsToNumbers(this.resolution, coordinateRows),
+            leaders: rowsToSamples(leaderRows),
+            isLeader,
+            assignedToRangeBoundary,
+            coordinate: appendCoordinatePlanFromRow(this.resolution, coordinatePlanRow),
+        }));
+    }
+    appendPlainNoNextTransaction(input) {
+        return this.preparePlainCommittedNoNextStorageAppendTransaction(input);
+    }
+    preparePlainNoNextStorageAppendTransaction(input) {
+        const baseArgs = nativeNoNextStorageAppendArgs(input);
+        const documentIndexArgs = nativeDocumentIndexArgs(input.documentIndex);
+        const row = input.trimLengthTo == null
+            ? documentIndexArgs
+                ? this.native.prepare_plain_no_next_storage_append_document_index_transaction(...baseArgs, ...documentIndexArgs)
+                : this.native.prepare_plain_no_next_storage_append_transaction(...baseArgs)
+            : documentIndexArgs
+                ? this.native.prepare_plain_no_next_storage_append_document_index_transaction_trim(...baseArgs, ...documentIndexArgs, input.trimLengthTo)
+                : this.native.prepare_plain_no_next_storage_append_transaction_trim(...baseArgs, input.trimLengthTo);
+        return storageAppendResultFromRow(this.resolution, row);
+    }
+    preparePlainStorageAppendTransaction(input) {
+        const baseArgs = nativeStorageAppendArgs(input);
+        const documentIndexArgs = nativeDocumentIndexArgs(input.documentIndex);
+        const row = input.trimLengthTo == null
+            ? documentIndexArgs
+                ? this.native.prepare_plain_storage_append_document_index_transaction(...baseArgs, ...documentIndexArgs)
+                : this.native.prepare_plain_storage_append_transaction(...baseArgs)
+            : documentIndexArgs
+                ? this.native.prepare_plain_storage_append_document_index_transaction_trim(...baseArgs, ...documentIndexArgs, input.trimLengthTo)
+                : this.native.prepare_plain_storage_append_transaction_trim(...baseArgs, input.trimLengthTo);
+        return storageAppendResultFromRow(this.resolution, row);
+    }
+    preparePlainCommittedStorageAppendTransaction(input) {
+        if (input.documentDeleteKey && input.documentIndex) {
+            throw new Error("Native backbone append cannot both put and delete a document index row");
+        }
+        if (input.documentDeleteKey) {
+            const baseArgs = nativeStorageAppendArgs(input);
+            const row = input.trimLengthTo == null
+                ? this.native.prepare_plain_committed_storage_append_document_delete_transaction(...baseArgs, input.documentDeleteKey)
+                : this.native.prepare_plain_committed_storage_append_document_delete_transaction_trim(...baseArgs, input.documentDeleteKey, input.trimLengthTo);
+            return committedStorageAppendResultFromRow(this.resolution, row);
+        }
+        const documentIndex = input.documentIndex;
+        if (documentIndex?.useLatestContext) {
+            if (input.resolveTrimmedEntries === false) {
+                const requiredPreviousSignerPublicKey = documentIndex.requiredPreviousSignerPublicKey;
+                if (requiredPreviousSignerPublicKey) {
+                    const nativeCompactRequired = this.native
+                        .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_compact_transaction;
+                    if (nativeCompactRequired) {
+                        const row = nativeCompactRequired.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, documentIndex.projection?.plan, documentIndex.projection?.encodedDocument, documentIndex.projection?.signer, requiredPreviousSignerPublicKey, input.trimLengthTo);
+                        return compactCommittedLatestStorageAppendResultFromRow(this.resolution, row);
+                    }
+                }
+                const projection = documentIndex.projection;
+                if (projection) {
+                    const projectionPlanId = this.documentProjectionPlanId(projection.plan);
+                    const nativeCompactPlainPutPayload = documentIndex.usePlainPutPayload === true
+                        ? this.native
+                            .prepare_plain_committed_storage_append_document_index_latest_cached_plan_compact_plain_put_payload_transaction
+                        : undefined;
+                    if (nativeCompactPlainPutPayload) {
+                        const row = nativeCompactPlainPutPayload.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.signer, input.trimLengthTo);
+                        return compactCommittedLatestStorageAppendResultFromRow(this.resolution, row);
+                    }
+                    const nativeCompactCached = this.native
+                        .prepare_plain_committed_storage_append_document_index_latest_cached_plan_compact_transaction;
+                    if (nativeCompactCached) {
+                        const row = nativeCompactCached.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.encodedDocument, projection.signer, input.trimLengthTo);
+                        return compactCommittedLatestStorageAppendResultFromRow(this.resolution, row);
+                    }
+                }
+                if (!requiredPreviousSignerPublicKey &&
+                    documentIndex.usePlainPutPayload === true) {
+                    const nativeCompactPlainPutPayload = this.native
+                        .prepare_plain_committed_storage_append_document_index_latest_compact_plain_put_payload_transaction;
+                    if (nativeCompactPlainPutPayload) {
+                        const row = nativeCompactPlainPutPayload.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, input.trimLengthTo);
+                        return compactCommittedLatestStorageAppendResultFromRow(this.resolution, row);
+                    }
+                }
+                const nativeCompact = this.native
+                    .prepare_plain_committed_storage_append_document_index_latest_compact_transaction;
+                if (nativeCompact) {
+                    const row = nativeCompact.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, documentIndex.projection?.plan, documentIndex.projection?.encodedDocument, documentIndex.projection?.signer, input.trimLengthTo);
+                    return compactCommittedLatestStorageAppendResultFromRow(this.resolution, row);
+                }
+            }
+            const requiredPreviousSignerPublicKey = documentIndex.requiredPreviousSignerPublicKey;
+            if (requiredPreviousSignerPublicKey) {
+                const requiredPreviousSignerTransaction = this.native
+                    .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_transaction;
+                if (!requiredPreviousSignerTransaction) {
+                    throw new Error("Native backbone requires previous-signer policy transaction support");
+                }
+                const row = requiredPreviousSignerTransaction.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, input.resolveTrimmedEntries !== false, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, documentIndex.projection?.plan, documentIndex.projection?.encodedDocument, documentIndex.projection?.signer, requiredPreviousSignerPublicKey, input.trimLengthTo);
+                return committedStorageAppendResultFromRow(this.resolution, row);
+            }
+            const projection = documentIndex.projection;
+            if (projection) {
+                const row = this.native.prepare_plain_committed_storage_append_document_index_latest_cached_plan_transaction(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, input.resolveTrimmedEntries !== false, documentIndex.key, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, this.documentProjectionPlanId(projection.plan), projection.encodedDocument, projection.signer, input.trimLengthTo);
+                return committedStorageAppendResultFromRow(this.resolution, row);
+            }
+            const row = this.native.prepare_plain_committed_storage_append_document_index_latest_transaction(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, input.resolveTrimmedEntries !== false, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, documentIndex.projection?.plan, documentIndex.projection?.encodedDocument, documentIndex.projection?.signer, input.trimLengthTo);
+            return committedStorageAppendResultFromRow(this.resolution, row);
+        }
+        const baseArgs = nativeStorageAppendArgs(input);
+        const documentIndexArgs = nativeDocumentIndexArgs(documentIndex);
+        const row = input.trimLengthTo == null
+            ? documentIndexArgs
+                ? this.native.prepare_plain_committed_storage_append_document_index_transaction(...baseArgs, ...documentIndexArgs)
+                : this.native.prepare_plain_committed_storage_append_transaction(...baseArgs)
+            : documentIndexArgs
+                ? this.native.prepare_plain_committed_storage_append_document_index_transaction_trim(...baseArgs, ...documentIndexArgs, input.trimLengthTo)
+                : this.native.prepare_plain_committed_storage_append_transaction_trim(...baseArgs, input.trimLengthTo);
+        return committedStorageAppendResultFromRow(this.resolution, row);
+    }
+    preparePlainCommittedStorageAppendDocumentIndexLatestBatchTransaction(input) {
+        if (input.entries.length === 0) {
+            return [];
+        }
+        const useCompact = input.resolveTrimmedEntries === false;
+        const requiredPreviousSignerPublicKeys = input.entries
+            .map((entry) => entry.documentIndex.requiredPreviousSignerPublicKey)
+            .filter((key) => !!key);
+        const requiredPreviousSignerPublicKey = requiredPreviousSignerPublicKeys[0];
+        if (requiredPreviousSignerPublicKeys.length > 0 &&
+            requiredPreviousSignerPublicKeys.length !== input.entries.length) {
+            return undefined;
+        }
+        if (requiredPreviousSignerPublicKey &&
+            requiredPreviousSignerPublicKeys.some((key) => key.byteLength !== requiredPreviousSignerPublicKey.byteLength ||
+                key.some((byte, index) => byte !== requiredPreviousSignerPublicKey[index]))) {
+            return undefined;
+        }
+        const projected = input.entries.every((entry) => entry.documentIndex.projection);
+        if (projected) {
+            const usePlainPutPayload = input.entries.every((entry) => entry.documentIndex.usePlainPutPayload === true);
+            const baseArgs = [
+                new BigUint64Array(input.entries.map((entry) => BigInt(entry.wallTime))),
+                new Uint32Array(input.entries.map((entry) => entry.logical ?? 0)),
+                input.entries.map((entry) => entry.gid),
+                input.type ?? 0,
+                input.entries.map((entry) => entry.metaData),
+                input.entries.map((entry) => entry.payloadData),
+                input.replicas,
+                input.roleAgeMs ?? 0,
+                integerString(input.now ?? Date.now()),
+                input.selfHash ?? "",
+                input.selfReplicating ?? true,
+            ];
+            const documentPlanArgs = [
+                input.entries.map((entry) => entry.documentIndex.key),
+                input.documentByteElementIndexLimit ?? 0,
+                input.documentDeleteTrimmedHeads === true,
+                new Uint32Array(input.entries.map((entry) => this.documentProjectionPlanId(entry.documentIndex.projection.plan))),
+            ];
+            const documentEncodedDocuments = input.entries.map((entry) => entry.documentIndex.projection.encodedDocument);
+            const documentSigners = input.entries.map((entry) => entry.documentIndex.projection.signer);
+            const nativeCompactCachedBatch = this.native
+                .prepare_plain_committed_storage_append_document_index_latest_cached_plan_compact_batch_transaction;
+            const nativeCompactCachedPlainPayloadBatch = this.native
+                .prepare_plain_committed_storage_append_document_index_latest_cached_plan_compact_plain_put_payload_batch_transaction;
+            if (requiredPreviousSignerPublicKey) {
+                if (useCompact) {
+                    const nativeRequiredCompactCachedBatch = this.native
+                        .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_cached_plan_compact_batch_transaction;
+                    if (!nativeRequiredCompactCachedBatch) {
+                        return undefined;
+                    }
+                    const rows = nativeRequiredCompactCachedBatch.call(this.native, ...baseArgs, ...documentPlanArgs, documentEncodedDocuments, documentSigners, requiredPreviousSignerPublicKey, input.trimLengthTo);
+                    return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+                }
+                const nativeRequiredCachedBatch = this.native
+                    .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_cached_plan_batch_transaction;
+                if (!nativeRequiredCachedBatch) {
+                    return undefined;
+                }
+                const rows = nativeRequiredCachedBatch.call(this.native, ...baseArgs, input.resolveTrimmedEntries !== false, ...documentPlanArgs, documentEncodedDocuments, documentSigners, requiredPreviousSignerPublicKey, input.trimLengthTo);
+                return rows.map((row) => committedStorageAppendResultFromRow(this.resolution, row));
+            }
+            if (useCompact &&
+                usePlainPutPayload &&
+                nativeCompactCachedPlainPayloadBatch) {
+                const rows = nativeCompactCachedPlainPayloadBatch.call(this.native, ...baseArgs, ...documentPlanArgs, documentSigners, input.trimLengthTo);
+                return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+            }
+            if (useCompact && nativeCompactCachedBatch) {
+                const rows = nativeCompactCachedBatch.call(this.native, ...baseArgs, ...documentPlanArgs, documentEncodedDocuments, documentSigners, input.trimLengthTo);
+                return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+            }
+            const nativeCachedBatch = this.native
+                .prepare_plain_committed_storage_append_document_index_latest_cached_plan_batch_transaction;
+            if (!nativeCachedBatch) {
+                return undefined;
+            }
+            const rows = nativeCachedBatch.call(this.native, ...baseArgs, input.resolveTrimmedEntries !== false, ...documentPlanArgs, documentEncodedDocuments, documentSigners, input.trimLengthTo);
+            return rows.map((row) => committedStorageAppendResultFromRow(this.resolution, row));
+        }
+        if (input.entries.some((entry) => entry.documentIndex.projection) ||
+            input.entries.some((entry) => !entry.documentIndex.valuePrefixBytes)) {
+            return undefined;
+        }
+        const baseArgs = [
+            new BigUint64Array(input.entries.map((entry) => BigInt(entry.wallTime))),
+            new Uint32Array(input.entries.map((entry) => entry.logical ?? 0)),
+            input.entries.map((entry) => entry.gid),
+            input.type ?? 0,
+            input.entries.map((entry) => entry.metaData),
+            input.entries.map((entry) => entry.payloadData),
+            input.replicas,
+            input.roleAgeMs ?? 0,
+            integerString(input.now ?? Date.now()),
+            input.selfHash ?? "",
+            input.selfReplicating ?? true,
+        ];
+        const documentKeys = input.entries.map((entry) => entry.documentIndex.key);
+        const usePlainPutPayload = input.entries.every((entry) => entry.documentIndex.usePlainPutPayload === true);
+        if (!requiredPreviousSignerPublicKey &&
+            useCompact &&
+            usePlainPutPayload) {
+            const nativeCompactPlainPutPayloadBatch = this.native
+                .prepare_plain_committed_storage_append_document_index_latest_compact_plain_put_payload_batch_transaction;
+            if (nativeCompactPlainPutPayloadBatch) {
+                const rows = nativeCompactPlainPutPayloadBatch.call(this.native, ...baseArgs, documentKeys, input.documentByteElementIndexLimit ?? 0, input.documentDeleteTrimmedHeads === true, input.trimLengthTo);
+                return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+            }
+        }
+        const documentValuePrefixBytes = input.entries.map((entry) => entry.documentIndex.valuePrefixBytes);
+        const documentByteElementIndexLimit = input.documentByteElementIndexLimit ?? 0;
+        const documentDeleteTrimmedHeads = input.documentDeleteTrimmedHeads === true;
+        const documentArgs = [
+            documentKeys,
+            documentValuePrefixBytes,
+            documentByteElementIndexLimit,
+            documentDeleteTrimmedHeads,
+            input.trimLengthTo,
+        ];
+        if (requiredPreviousSignerPublicKey) {
+            if (useCompact) {
+                const nativeRequiredCompactBatch = this.native
+                    .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_compact_batch_transaction;
+                if (!nativeRequiredCompactBatch) {
+                    return undefined;
+                }
+                const rows = nativeRequiredCompactBatch.call(this.native, ...baseArgs, documentKeys, documentValuePrefixBytes, documentByteElementIndexLimit, documentDeleteTrimmedHeads, requiredPreviousSignerPublicKey, input.trimLengthTo);
+                return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+            }
+            const nativeRequiredBatch = this.native
+                .prepare_plain_committed_storage_append_document_index_latest_required_previous_signer_batch_transaction;
+            if (!nativeRequiredBatch) {
+                return undefined;
+            }
+            const rows = nativeRequiredBatch.call(this.native, ...baseArgs, input.resolveTrimmedEntries !== false, documentKeys, documentValuePrefixBytes, documentByteElementIndexLimit, documentDeleteTrimmedHeads, requiredPreviousSignerPublicKey, input.trimLengthTo);
+            return rows.map((row) => committedStorageAppendResultFromRow(this.resolution, row));
+        }
+        const nativeCompactBatch = this.native
+            .prepare_plain_committed_storage_append_document_index_latest_compact_batch_transaction;
+        if (useCompact && nativeCompactBatch) {
+            const rows = nativeCompactBatch.call(this.native, ...baseArgs, ...documentArgs);
+            return rows.map((row) => compactCommittedLatestStorageAppendResultFromRow(this.resolution, row));
+        }
+        const nativeBatch = this.native
+            .prepare_plain_committed_storage_append_document_index_latest_batch_transaction;
+        if (!nativeBatch) {
+            return undefined;
+        }
+        const rows = nativeBatch.call(this.native, ...baseArgs, input.resolveTrimmedEntries !== false, ...documentArgs);
+        return rows.map((row) => committedStorageAppendResultFromRow(this.resolution, row));
+    }
+    preparePlainCommittedNoNextStorageAppendTransaction(input) {
+        const baseArgs = nativeNoNextStorageAppendArgs(input);
+        const projection = input.documentIndex?.projection;
+        if (input.documentIndex && projection) {
+            const documentIndexArgs = [
+                input.documentIndex.key,
+                input.documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(input.documentIndex.existingCreated),
+                input.documentIndex.byteElementIndexLimit ?? 0,
+                input.documentIndex.deleteTrimmedHeads === true,
+                this.documentProjectionPlanId(projection.plan),
+                projection.encodedDocument,
+                projection.signer,
+            ];
+            const row = input.trimLengthTo == null
+                ? this.native.prepare_plain_committed_no_next_storage_append_document_index_cached_plan_transaction(...baseArgs, ...documentIndexArgs)
+                : this.native.prepare_plain_committed_no_next_storage_append_document_index_cached_plan_transaction_trim(...baseArgs, ...documentIndexArgs, input.trimLengthTo);
+            return committedStorageAppendResultFromRow(this.resolution, row);
+        }
+        const documentIndexArgs = nativeDocumentIndexArgs(input.documentIndex);
+        const row = input.trimLengthTo == null
+            ? documentIndexArgs
+                ? this.native.prepare_plain_committed_no_next_storage_append_document_index_transaction(...baseArgs, ...documentIndexArgs)
+                : this.native.prepare_plain_committed_no_next_storage_append_transaction(...baseArgs)
+            : documentIndexArgs
+                ? this.native.prepare_plain_committed_no_next_storage_append_document_index_transaction_trim(...baseArgs, ...documentIndexArgs, input.trimLengthTo)
+                : this.native.prepare_plain_committed_no_next_storage_append_transaction_trim(...baseArgs, input.trimLengthTo);
+        return committedStorageAppendResultFromRow(this.resolution, row);
+    }
+    preparePlainCommittedNoNextStorageAppendDocumentIndexCompactTransaction(input) {
+        const documentIndex = input.documentIndex;
+        if (!documentIndex) {
+            return this.preparePlainCommittedNoNextStorageAppendTransaction(input);
+        }
+        const projection = documentIndex.projection;
+        if (projection) {
+            const projectionPlanId = this.documentProjectionPlanId(projection.plan);
+            const plainPutPayload = documentIndex.usePlainPutPayload === true
+                ? this.native
+                    .prepare_plain_committed_no_next_storage_append_document_index_cached_plan_compact_plain_put_payload_transaction
+                : undefined;
+            const row = plainPutPayload
+                ? plainPutPayload.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.signer, input.trimLengthTo)
+                : this.native.prepare_plain_committed_no_next_storage_append_document_index_cached_plan_compact_transaction(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, projectionPlanId, projection.encodedDocument, projection.signer, input.trimLengthTo);
+            return compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row);
+        }
+        if (documentIndex.usePlainPutPayload === true) {
+            const plainPutPayload = this.native
+                .prepare_plain_committed_no_next_storage_append_document_index_compact_plain_put_payload_transaction;
+            if (plainPutPayload) {
+                const row = plainPutPayload.call(this.native, BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, input.trimLengthTo);
+                return compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row);
+            }
+        }
+        const row = this.native.prepare_plain_committed_no_next_storage_append_document_index_compact_transaction(BigInt(input.wallTime), input.logical ?? 0, input.gid, input.type ?? 0, input.metaData, input.payloadData, input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, documentIndex.key, documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY, documentIndex.existingCreated == null
+            ? ""
+            : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, input.trimLengthTo);
+        return compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row);
+    }
+    preparePlainCommittedNoNextStorageAppendDocumentIndexCompactBatchTransaction(input) {
+        if (input.entries.length === 0) {
+            return [];
+        }
+        const projected = input.entries.every((entry) => entry.documentIndex.projection);
+        if (projected) {
+            const usePlainPutPayload = input.entries.every((entry) => entry.documentIndex.usePlainPutPayload === true);
+            const baseArgs = [
+                new BigUint64Array(input.entries.map((entry) => BigInt(entry.wallTime))),
+                new Uint32Array(input.entries.map((entry) => entry.logical ?? 0)),
+                input.entries.map((entry) => entry.gid),
+                input.type ?? 0,
+                input.entries.map((entry) => entry.metaData),
+                input.entries.map((entry) => entry.payloadData),
+                input.replicas,
+                input.roleAgeMs ?? 0,
+                integerString(input.now ?? Date.now()),
+                input.selfHash ?? "",
+                input.selfReplicating ?? true,
+                input.entries.map((entry) => entry.documentIndex.key),
+                input.entries.map((entry) => entry.documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(entry.documentIndex.existingCreated)),
+                input.documentByteElementIndexLimit ?? 0,
+                input.documentDeleteTrimmedHeads === true,
+                new Uint32Array(input.entries.map((entry) => this.documentProjectionPlanId(entry.documentIndex.projection.plan))),
+            ];
+            const rows = usePlainPutPayload
+                ? this.native
+                    .prepare_plain_committed_no_next_storage_append_document_index_cached_plan_compact_plain_put_payload_batch_transaction?.call(this.native, ...baseArgs, input.entries.map((entry) => entry.documentIndex.projection.signer), input.trimLengthTo)
+                : this.native
+                    .prepare_plain_committed_no_next_storage_append_document_index_cached_plan_compact_batch_transaction?.call(this.native, ...baseArgs, input.entries.map((entry) => entry.documentIndex.projection
+                    .encodedDocument), input.entries.map((entry) => entry.documentIndex.projection.signer), input.trimLengthTo);
+            if (!rows) {
+                return undefined;
+            }
+            return rows.map((row) => compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row));
+        }
+        if (input.entries.some((entry) => entry.documentIndex.projection) ||
+            input.entries.some((entry) => !entry.documentIndex.valuePrefixBytes)) {
+            return undefined;
+        }
+        const usePlainPutPayload = input.entries.every((entry) => entry.documentIndex.usePlainPutPayload === true);
+        if (usePlainPutPayload) {
+            const nativeBatch = this.native
+                .prepare_plain_committed_no_next_storage_append_document_index_compact_plain_put_payload_batch_transaction;
+            if (nativeBatch) {
+                const rows = nativeBatch.call(this.native, new BigUint64Array(input.entries.map((entry) => BigInt(entry.wallTime))), new Uint32Array(input.entries.map((entry) => entry.logical ?? 0)), input.entries.map((entry) => entry.gid), input.type ?? 0, input.entries.map((entry) => entry.metaData), input.entries.map((entry) => entry.payloadData), input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, input.entries.map((entry) => entry.documentIndex.key), input.entries.map((entry) => entry.documentIndex.existingCreated == null
+                    ? ""
+                    : integerString(entry.documentIndex.existingCreated)), input.documentByteElementIndexLimit ?? 0, input.documentDeleteTrimmedHeads === true, input.trimLengthTo);
+                return rows.map((row) => compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row));
+            }
+        }
+        const nativeBatch = this.native
+            .prepare_plain_committed_no_next_storage_append_document_index_compact_batch_transaction;
+        if (!nativeBatch) {
+            return undefined;
+        }
+        const rows = nativeBatch.call(this.native, new BigUint64Array(input.entries.map((entry) => BigInt(entry.wallTime))), new Uint32Array(input.entries.map((entry) => entry.logical ?? 0)), input.entries.map((entry) => entry.gid), input.type ?? 0, input.entries.map((entry) => entry.metaData), input.entries.map((entry) => entry.payloadData), input.replicas, input.roleAgeMs ?? 0, integerString(input.now ?? Date.now()), input.selfHash ?? "", input.selfReplicating ?? true, input.entries.map((entry) => entry.documentIndex.key), input.entries.map((entry) => entry.documentIndex.valuePrefixBytes ?? EMPTY_UINT8_ARRAY), input.entries.map((entry) => entry.documentIndex.existingCreated == null
+            ? ""
+            : integerString(entry.documentIndex.existingCreated)), input.documentByteElementIndexLimit ?? 0, input.documentDeleteTrimmedHeads === true, input.trimLengthTo);
+        return rows.map((row) => compactCommittedNoNextStorageAppendResultFromRow(this.resolution, row));
+    }
+}
+export class NativeBackboneMemoryCoordinatePersistenceStore {
+    files = new Map();
+    async read(name) {
+        const file = this.files.get(validateCoordinatePersistenceName(name));
+        return file ? copyBytes(file) : undefined;
+    }
+    async write(name, bytes) {
+        this.files.set(validateCoordinatePersistenceName(name), copyBytes(bytes));
+    }
+    async append(name, bytes) {
+        const validName = validateCoordinatePersistenceName(name);
+        const existing = this.files.get(validName);
+        this.files.set(validName, existing ? concatBytes([existing, bytes]) : copyBytes(bytes));
+    }
+    async remove(name) {
+        this.files.delete(validateCoordinatePersistenceName(name));
+    }
+}
+export class NativeBackboneNodeCoordinatePersistenceStore {
+    directory;
+    fs;
+    appendHandles = new Map();
+    filePaths = new Map();
+    directoryEnsured = false;
+    constructor(directory, fs) {
+        this.directory = directory;
+        this.fs = fs;
+    }
+    async nodeFs() {
+        return this.fs ?? (await importNodeFs());
+    }
+    async filePath(name) {
+        const validName = validateCoordinatePersistenceName(name);
+        let path = this.filePaths.get(validName);
+        if (path === undefined) {
+            path = (await importNodePathJoin())(this.directory, validName);
+            this.filePaths.set(validName, path);
+        }
+        return path;
+    }
+    async ensureDirectory() {
+        const fs = await this.nodeFs();
+        if (!this.directoryEnsured) {
+            await fs.mkdir(this.directory, { recursive: true });
+            this.directoryEnsured = true;
+        }
+        return fs;
+    }
+    async closeAppendHandle(path) {
+        const handle = this.appendHandles.get(path);
+        if (!handle) {
+            return;
+        }
+        this.appendHandles.delete(path);
+        await (await handle).close();
+    }
+    async appendHandle(fs, path) {
+        if (!fs.open) {
+            return undefined;
+        }
+        let handle = this.appendHandles.get(path);
+        if (!handle) {
+            handle = fs.open(path, "a");
+            this.appendHandles.set(path, handle);
+        }
+        return handle;
+    }
+    async read(name) {
+        const fs = await this.nodeFs();
+        try {
+            return await fs.readFile(await this.filePath(name));
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async write(name, bytes) {
+        const fs = await this.ensureDirectory();
+        const path = await this.filePath(name);
+        await this.closeAppendHandle(path);
+        await fs.writeFile(path, bytes);
+    }
+    async append(name, bytes) {
+        const fs = await this.ensureDirectory();
+        const path = await this.filePath(name);
+        const handle = await this.appendHandle(fs, path);
+        if (handle) {
+            await handle.write(bytes);
+            return;
+        }
+        await fs.appendFile(path, bytes);
+    }
+    async remove(name) {
+        const fs = await this.nodeFs();
+        const path = await this.filePath(name);
+        await this.closeAppendHandle(path);
+        try {
+            await fs.rm(path, { force: true });
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    async close() {
+        this.directoryEnsured = false;
+        const handles = [...this.appendHandles.values()];
+        this.appendHandles.clear();
+        await Promise.all(handles.map(async (handle) => (await handle).close()));
+    }
+}
+export class NativeBackboneOPFSCoordinatePersistenceStore {
+    directory;
+    constructor(directory) {
+        this.directory = directory;
+    }
+    static async create(options) {
+        const root = options?.root ?? (await this.defaultRoot());
+        let directory = root;
+        for (const part of this.directoryParts(options?.directory)) {
+            directory = await directory.getDirectoryHandle(part, { create: true });
+        }
+        return new NativeBackboneOPFSCoordinatePersistenceStore(directory);
+    }
+    static async defaultRoot() {
+        const storage = globalThis.navigator?.storage;
+        const root = await storage?.getDirectory?.();
+        if (!root) {
+            throw new Error("OPFS getDirectory is not available in this runtime");
+        }
+        return root;
+    }
+    static directoryParts(directory) {
+        if (!directory) {
+            return [];
+        }
+        const parts = Array.isArray(directory)
+            ? directory
+            : directory.split("/").filter(Boolean);
+        return parts.map(validateCoordinatePersistenceName);
+    }
+    async read(name) {
+        try {
+            const handle = await this.directory.getFileHandle(validateCoordinatePersistenceName(name), { create: false });
+            const file = await handle.getFile();
+            return new Uint8Array(await file.arrayBuffer());
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async write(name, bytes) {
+        const handle = await this.directory.getFileHandle(validateCoordinatePersistenceName(name), { create: true });
+        const writable = await handle.createWritable();
+        try {
+            await writable.write(bytes);
+        }
+        finally {
+            await writable.close();
+        }
+    }
+    async append(name, bytes) {
+        const handle = await this.directory.getFileHandle(validateCoordinatePersistenceName(name), { create: true });
+        if (handle.createSyncAccessHandle) {
+            let access;
+            try {
+                access = await handle.createSyncAccessHandle();
+            }
+            catch {
+                // Main-thread OPFS and some browser contexts do not expose sync handles.
+            }
+            if (access) {
+                try {
+                    access.write(bytes, { at: access.getSize() });
+                    access.flush?.();
+                    return;
+                }
+                finally {
+                    access.close();
+                }
+            }
+        }
+        const file = await handle.getFile();
+        const writable = await handle.createWritable({ keepExistingData: true });
+        try {
+            await writable.seek(file.size);
+            await writable.write(bytes);
+        }
+        finally {
+            await writable.close();
+        }
+    }
+    async remove(name) {
+        try {
+            await this.directory.removeEntry(validateCoordinatePersistenceName(name));
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+}
+export class NativeBackboneBufferedCoordinatePersistenceStore {
+    inner;
+    options;
+    buffers = new Map();
+    bufferedBytes = 0;
+    constructor(inner, options = {}) {
+        this.inner = inner;
+        this.options = options;
+    }
+    buffer(name) {
+        const validName = validateCoordinatePersistenceName(name);
+        let buffer = this.buffers.get(validName);
+        if (!buffer) {
+            buffer = [];
+            this.buffers.set(validName, buffer);
+        }
+        return buffer;
+    }
+    async read(name) {
+        await this.flush(name);
+        return this.inner.read(name);
+    }
+    async write(name, bytes) {
+        await this.flush(name);
+        await this.inner.write(name, bytes);
+    }
+    async append(name, bytes) {
+        // Ownership of `bytes` is handed over by the persistence store
+        // contract, so the chunk is buffered without a defensive copy.
+        this.buffer(name).push(bytes);
+        this.bufferedBytes += bytes.byteLength;
+        if (this.options.maxBufferedBytes != null &&
+            this.bufferedBytes >= this.options.maxBufferedBytes) {
+            await this.flush();
+        }
+    }
+    async remove(name) {
+        // Chunks buffered for a file that is being removed would be deleted
+        // right after being written; discard them instead of flushing.
+        const validName = validateCoordinatePersistenceName(name);
+        const chunks = this.buffers.get(validName);
+        if (chunks) {
+            this.buffers.delete(validName);
+            for (const chunk of chunks) {
+                this.bufferedBytes -= chunk.byteLength;
+            }
+        }
+        await this.inner.remove?.(name);
+    }
+    async flush(name) {
+        const names = name
+            ? [validateCoordinatePersistenceName(name)]
+            : [...this.buffers.keys()];
+        for (const fileName of names) {
+            const chunks = this.buffers.get(fileName);
+            if (!chunks || chunks.length === 0) {
+                continue;
+            }
+            this.buffers.delete(fileName);
+            const bytes = chunks.length === 1 ? chunks[0] : concatBytes(chunks);
+            this.bufferedBytes -= bytes.byteLength;
+            await this.inner.append(fileName, bytes);
+        }
+        await this.inner.flush?.();
+    }
+    async close() {
+        await this.flush();
+        await this.inner.close?.();
+    }
+}
+export class NativeBackboneCoordinatePersistence {
+    store;
+    flushOnAppend;
+    flushMaxPendingBytes;
+    flushIntervalMs;
+    compactMaxJournalBytes;
+    compactMaxJournalRecords;
+    snapshotFile;
+    journalFile;
+    documentSnapshotFile;
+    documentJournalFile;
+    documentSignerSnapshotFile;
+    documentSignerJournalFile;
+    journalInitialized;
+    journalByteLength = 0;
+    journalRecordCount = 0;
+    documentJournalInitialized;
+    documentJournalByteLength = 0;
+    documentJournalRecordCount = 0;
+    documentSignerJournalInitialized;
+    documentSignerJournalByteLength = 0;
+    documentSignerJournalRecordCount = 0;
+    lastFlushMs = Date.now();
+    persistenceQueue;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.snapshotFile =
+            options.snapshot ?? nativeBackboneCoordinatePersistenceFiles.snapshot;
+        this.journalFile =
+            options.journal ?? nativeBackboneCoordinatePersistenceFiles.journal;
+        this.documentSnapshotFile =
+            options.documentSnapshot ??
+                nativeBackboneCoordinatePersistenceFiles.documentSnapshot;
+        this.documentJournalFile =
+            options.documentJournal ??
+                nativeBackboneCoordinatePersistenceFiles.documentJournal;
+        this.documentSignerSnapshotFile =
+            options.documentSignerSnapshot ??
+                nativeBackboneCoordinatePersistenceFiles.documentSignerSnapshot;
+        this.documentSignerJournalFile =
+            options.documentSignerJournal ??
+                nativeBackboneCoordinatePersistenceFiles.documentSignerJournal;
+        this.flushOnAppend = options.flushOnAppend ?? true;
+        this.flushMaxPendingBytes = resolveCoordinateFlushMaxPendingBytes(options);
+        if (options.flushIntervalMs != null) {
+            this.flushIntervalMs = Math.max(0, options.flushIntervalMs);
+        }
+        if (options.compactMaxJournalBytes != null) {
+            this.compactMaxJournalBytes = Math.max(0, options.compactMaxJournalBytes);
+        }
+        if (options.compactMaxJournalRecords != null) {
+            this.compactMaxJournalRecords = Math.max(0, options.compactMaxJournalRecords);
+        }
+    }
+    async hydrate(backbone) {
+        const [snapshot, journal, documentSnapshot, documentJournal, documentSignerSnapshot, documentSignerJournal,] = await Promise.all([
+            this.store.read(this.snapshotFile),
+            this.store.read(this.journalFile),
+            this.store.read(this.documentSnapshotFile),
+            this.store.read(this.documentJournalFile),
+            this.store.read(this.documentSignerSnapshotFile),
+            this.store.read(this.documentSignerJournalFile),
+        ]);
+        const operations = backbone.loadCoordinateSnapshotAndJournal(snapshot, journal);
+        const documentOperations = backbone.loadDocumentSnapshotAndJournal(documentSnapshot, documentJournal);
+        const documentSignerOperations = backbone.loadDocumentSignerSnapshotAndJournal(documentSignerSnapshot, documentSignerJournal);
+        this.journalInitialized = !!journal && journal.byteLength > 0;
+        this.journalByteLength = journal?.byteLength ?? 0;
+        this.journalRecordCount = operations;
+        this.documentJournalInitialized =
+            !!documentJournal && documentJournal.byteLength > 0;
+        this.documentJournalByteLength = documentJournal?.byteLength ?? 0;
+        this.documentJournalRecordCount = documentOperations;
+        this.documentSignerJournalInitialized =
+            !!documentSignerJournal && documentSignerJournal.byteLength > 0;
+        this.documentSignerJournalByteLength =
+            documentSignerJournal?.byteLength ?? 0;
+        this.documentSignerJournalRecordCount = documentSignerOperations;
+        backbone.setCoordinateJournalEnabled(true);
+        backbone.setDocumentJournalEnabled(true);
+        backbone.setDocumentSignerJournalEnabled(true);
+        this.lastFlushMs = Date.now();
+        return operations + documentOperations + documentSignerOperations;
+    }
+    shouldFlushJournalOnAppend(backbone, now = Date.now()) {
+        if (this.flushOnAppend !== false) {
+            return true;
+        }
+        const pendingLength = backbone.coordinatePendingJournalLength +
+            backbone.documentPendingJournalLength +
+            backbone.documentSignerPendingJournalLength;
+        if (pendingLength === 0) {
+            return false;
+        }
+        if (this.flushMaxPendingBytes != null &&
+            backbone.coordinatePendingJournalByteLength +
+                backbone.documentPendingJournalByteLength +
+                backbone.documentSignerPendingJournalByteLength >=
+                this.flushMaxPendingBytes) {
+            return true;
+        }
+        return (this.flushIntervalMs != null &&
+            now - this.lastFlushMs >= this.flushIntervalMs);
+    }
+    flushJournalOnAppend(backbone) {
+        if (!this.shouldFlushJournalOnAppend(backbone)) {
+            return 0;
+        }
+        return this.flushJournal(backbone);
+    }
+    flushJournal(backbone) {
+        // Serialized with compact() so a flush never clears records appended to
+        // the wasm journal while a previous flush was awaiting its disk write.
+        return this.enqueuePersistence(() => this.flushJournalInternal(backbone));
+    }
+    enqueuePersistence(fn) {
+        // Runs `fn` immediately when no other persistence operation is in
+        // flight so the common uncontended flush starts synchronously; queued
+        // operations still run strictly one at a time, in order.
+        const next = this.persistenceQueue
+            ? this.persistenceQueue.then(fn)
+            : fn();
+        const tail = next.then(() => undefined, () => undefined);
+        this.persistenceQueue = tail;
+        void tail.then(() => {
+            if (this.persistenceQueue === tail) {
+                this.persistenceQueue = undefined;
+            }
+        });
+        return next;
+    }
+    async flushJournalInternal(backbone) {
+        let written = 0;
+        const coordinateRecords = backbone.coordinateJournal();
+        const coordinateRecordCount = backbone.coordinatePendingJournalLength;
+        if (coordinateRecords.byteLength > 0) {
+            if (this.journalInitialized === undefined) {
+                const existing = await this.store.read(this.journalFile);
+                this.journalInitialized = !!existing && existing.byteLength > 0;
+            }
+            const bytes = this.journalInitialized
+                ? coordinateRecords
+                : concatBytes([backbone.coordinateJournalHeader(), coordinateRecords]);
+            await this.store.append(this.journalFile, bytes);
+            this.journalInitialized = true;
+            this.journalByteLength += bytes.byteLength;
+            this.journalRecordCount += coordinateRecordCount;
+            backbone.clearCoordinateJournalPrefix(coordinateRecords.byteLength, coordinateRecordCount);
+            written += coordinateRecords.byteLength;
+        }
+        const documentRecords = backbone.documentJournal();
+        const documentRecordCount = backbone.documentPendingJournalLength;
+        if (documentRecords.byteLength > 0) {
+            if (this.documentJournalInitialized === undefined) {
+                const existing = await this.store.read(this.documentJournalFile);
+                this.documentJournalInitialized = !!existing && existing.byteLength > 0;
+            }
+            const bytes = this.documentJournalInitialized
+                ? documentRecords
+                : concatBytes([backbone.documentJournalHeader(), documentRecords]);
+            await this.store.append(this.documentJournalFile, bytes);
+            this.documentJournalInitialized = true;
+            this.documentJournalByteLength += bytes.byteLength;
+            this.documentJournalRecordCount += documentRecordCount;
+            backbone.clearDocumentJournalPrefix(documentRecords.byteLength, documentRecordCount);
+            written += documentRecords.byteLength;
+        }
+        const signerRecords = backbone.documentSignerJournal();
+        const signerRecordCount = backbone.documentSignerPendingJournalLength;
+        if (signerRecords.byteLength > 0) {
+            if (this.documentSignerJournalInitialized === undefined) {
+                const existing = await this.store.read(this.documentSignerJournalFile);
+                this.documentSignerJournalInitialized =
+                    !!existing && existing.byteLength > 0;
+            }
+            const bytes = this.documentSignerJournalInitialized
+                ? signerRecords
+                : concatBytes([backbone.documentSignerJournalHeader(), signerRecords]);
+            await this.store.append(this.documentSignerJournalFile, bytes);
+            this.documentSignerJournalInitialized = true;
+            this.documentSignerJournalByteLength += bytes.byteLength;
+            this.documentSignerJournalRecordCount += signerRecordCount;
+            backbone.clearDocumentSignerJournalPrefix(signerRecords.byteLength, signerRecordCount);
+            written += signerRecords.byteLength;
+        }
+        if (written === 0) {
+            this.lastFlushMs = Date.now();
+            return 0;
+        }
+        this.lastFlushMs = Date.now();
+        if (this.shouldCompactJournal()) {
+            await this.compactInternal(backbone);
+        }
+        return written;
+    }
+    shouldCompactJournal() {
+        return ((this.compactMaxJournalBytes != null &&
+            this.journalByteLength +
+                this.documentJournalByteLength +
+                this.documentSignerJournalByteLength >=
+                this.compactMaxJournalBytes) ||
+            (this.compactMaxJournalRecords != null &&
+                this.journalRecordCount +
+                    this.documentJournalRecordCount +
+                    this.documentSignerJournalRecordCount >=
+                    this.compactMaxJournalRecords));
+    }
+    compact(backbone) {
+        return this.enqueuePersistence(() => this.compactInternal(backbone));
+    }
+    async compactInternal(backbone) {
+        // The snapshots below cover exactly the journal records pending right
+        // now; records appended during the awaited writes must survive the
+        // clears at the end, so only this prefix is dropped.
+        const coordinateJournalByteLength = backbone.coordinatePendingJournalByteLength;
+        const coordinateJournalRecordCount = backbone.coordinatePendingJournalLength;
+        const documentJournalByteLength = backbone.documentPendingJournalByteLength;
+        const documentJournalRecordCount = backbone.documentPendingJournalLength;
+        const documentSignerJournalByteLength = backbone.documentSignerPendingJournalByteLength;
+        const documentSignerJournalRecordCount = backbone.documentSignerPendingJournalLength;
+        await Promise.all([
+            this.store.write(this.snapshotFile, backbone.coordinateSnapshot()),
+            this.store.write(this.documentSnapshotFile, backbone.documentSnapshot()),
+            this.store.write(this.documentSignerSnapshotFile, backbone.documentSignerSnapshot()),
+        ]);
+        await Promise.all([
+            this.store.remove?.(this.journalFile),
+            this.store.remove?.(this.documentJournalFile),
+            this.store.remove?.(this.documentSignerJournalFile),
+        ]);
+        this.journalInitialized = false;
+        this.journalByteLength = 0;
+        this.journalRecordCount = 0;
+        this.documentJournalInitialized = false;
+        this.documentJournalByteLength = 0;
+        this.documentJournalRecordCount = 0;
+        this.documentSignerJournalInitialized = false;
+        this.documentSignerJournalByteLength = 0;
+        this.documentSignerJournalRecordCount = 0;
+        backbone.clearCoordinateJournalPrefix(coordinateJournalByteLength, coordinateJournalRecordCount);
+        backbone.clearDocumentJournalPrefix(documentJournalByteLength, documentJournalRecordCount);
+        backbone.clearDocumentSignerJournalPrefix(documentSignerJournalByteLength, documentSignerJournalRecordCount);
+        // Compact persists the full pending state, so it restarts the
+        // flushIntervalMs pacing window like a flush does.
+        this.lastFlushMs = Date.now();
+    }
+    async close() {
+        await this.store.flush?.();
+        await this.store.close?.();
+    }
+}
+const resolveNodeWriteBufferMaxBytes = (options) => options.writeBufferMaxBytes != null
+    ? Math.max(0, options.writeBufferMaxBytes)
+    : options.flushOnAppend === false
+        ? resolveCoordinateFlushMaxPendingBytes(options)
+        : undefined;
+export class NativeBackboneNodeCoordinatePersistence extends NativeBackboneCoordinatePersistence {
+    writeBuffer;
+    constructor(directory, options = {}) {
+        const writeBufferMaxBytes = resolveNodeWriteBufferMaxBytes(options);
+        const nodeStore = new NativeBackboneNodeCoordinatePersistenceStore(directory, options.fs);
+        const writeBuffer = writeBufferMaxBytes != null
+            ? new NativeBackboneBufferedCoordinatePersistenceStore(nodeStore, {
+                maxBufferedBytes: writeBufferMaxBytes,
+            })
+            : undefined;
+        super(writeBuffer ?? nodeStore, options);
+        this.writeBuffer = writeBuffer;
+    }
+    async flushJournalWriteBuffer(fileName) {
+        if (fileName) {
+            validateCoordinatePersistenceName(fileName);
+        }
+        await this.writeBuffer?.flush(fileName);
+    }
+}
+const isNativeBackboneCoordinatePersistenceAdapter = (value) => typeof value.hydrate ===
+    "function" &&
+    typeof value.flushJournal ===
+        "function";
+export const createNativeBackboneCoordinatePersistence = (config) => {
+    if (isNativeBackboneCoordinatePersistenceAdapter(config)) {
+        return config;
+    }
+    const { store, buffered, ...options } = config;
+    const isBuffered = buffered === true || !!buffered;
+    const resolvedStore = buffered === true
+        ? new NativeBackboneBufferedCoordinatePersistenceStore(store)
+        : buffered
+            ? new NativeBackboneBufferedCoordinatePersistenceStore(store, buffered)
+            : store;
+    return new NativeBackboneCoordinatePersistence(resolvedStore, {
+        ...options,
+        compactMaxJournalBytes: isBuffered && options.compactMaxJournalBytes == null
+            ? defaultNativeBackboneCoordinateCompactMaxJournalBytes
+            : options.compactMaxJournalBytes,
+    });
+};
+export const createBufferedNativeBackboneCoordinatePersistence = (store, options = {}) => {
+    const maxBufferedBytes = options.maxBufferedBytes ??
+        options.flushMaxPendingBytes ??
+        defaultNativeBackboneCoordinateFlushMaxPendingBytes;
+    const flushMaxPendingBytes = options.flushMaxPendingBytes ?? maxBufferedBytes;
+    return new NativeBackboneCoordinatePersistence(new NativeBackboneBufferedCoordinatePersistenceStore(store, {
+        maxBufferedBytes,
+    }), {
+        snapshot: options.snapshot,
+        journal: options.journal,
+        documentSnapshot: options.documentSnapshot,
+        documentJournal: options.documentJournal,
+        documentSignerSnapshot: options.documentSignerSnapshot,
+        documentSignerJournal: options.documentSignerJournal,
+        flushOnAppend: false,
+        flushMaxPendingBytes,
+        flushIntervalMs: options.flushIntervalMs,
+        compactMaxJournalBytes: options.compactMaxJournalBytes ??
+            defaultNativeBackboneCoordinateCompactMaxJournalBytes,
+        compactMaxJournalRecords: options.compactMaxJournalRecords,
+    });
+};
+export const createBufferedNativeBackboneNodeCoordinatePersistence = (directory, options = {}) => {
+    const flushMaxPendingBytes = options.flushMaxPendingBytes ??
+        defaultNativeBackboneCoordinateFlushMaxPendingBytes;
+    return new NativeBackboneNodeCoordinatePersistence(directory, {
+        ...options,
+        flushOnAppend: false,
+        flushMaxPendingBytes,
+        writeBufferMaxBytes: options.writeBufferMaxBytes ?? flushMaxPendingBytes,
+        compactMaxJournalBytes: options.compactMaxJournalBytes ??
+            defaultNativeBackboneCoordinateCompactMaxJournalBytes,
+    });
+};
+export const createNativePeerbitBackbone = NativePeerbitBackbone.create;
+//# sourceMappingURL=index.js.map