@peerbit/native-backbone 0.1.4 → 0.2.0

package/dist/src/index.js

@@ -7,6 +7,12 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     return path;
 };
 import { calculateRawCid, cidifyString } from "@peerbit/blocks-interface";
+export * from "./durability/codec.js";
+export * from "./durability/lease.js";
+export * from "./durability/memory-storage.js";
+export * from "./durability/node-lease.js";
+export * from "./durability/node-storage.js";
+export * from "./durability/storage.js";
 const nativeBackboneHeadFlagsToBytes = (headFlags) => headFlags instanceof Uint8Array
     ? headFlags
     : new Uint8Array(headFlags.map((head) => (head ? 1 : 0)));
@@ -170,8 +176,58 @@ const nativeBackboneCoordinatePersistenceFiles = {
     documentSignerSnapshot: "document-signers.bin",
     documentSignerJournal: "document-signers.wal",
 };
+export const nativeBackboneCoordinateDropTombstoneFile = "native-backbone-drop.tombstone";
 export const defaultNativeBackboneCoordinateFlushMaxPendingBytes = 1024 * 1024;
+/** @deprecated Built-in coordinate persistence compaction is currently disabled. */
 export const defaultNativeBackboneCoordinateCompactMaxJournalBytes = 64 * 1024 * 1024;
+const nativeBackboneCoordinateCompactionDisabledMessage = "Native backbone coordinate persistence compaction is disabled until snapshots use a crash-safe generation protocol";
+const nativeBackboneCoordinateJournalMagic = Uint8Array.from([
+    0x50, 0x42, 0x52, 0x49, 0x44, 0x58, 0x57, 0x31,
+]);
+const readCoordinateJournalU32 = (bytes, offset) => (bytes[offset] |
+    (bytes[offset + 1] << 8) |
+    (bytes[offset + 2] << 16) |
+    (bytes[offset + 3] << 24)) >>>
+    0;
+const coordinateJournalChecksum = (bytes) => {
+    let checksum = 0x811c9dc5;
+    for (const byte of bytes) {
+        checksum = Math.imul(checksum ^ byte, 0x01000193) >>> 0;
+    }
+    return checksum;
+};
+const hasCoordinateJournalMagic = (bytes) => bytes.byteLength >= nativeBackboneCoordinateJournalMagic.byteLength &&
+    nativeBackboneCoordinateJournalMagic.every((byte, index) => bytes[index] === byte);
+/**
+ * The Rust decoder intentionally stops at a torn/corrupt tail. Persistence
+ * must reject that tail before hydrate, otherwise a later append can land
+ * behind it and remain permanently invisible to replay.
+ */
+const validateCoordinateJournal = (bytes, name) => {
+    if (!bytes || bytes.byteLength === 0) {
+        return;
+    }
+    let offset = hasCoordinateJournalMagic(bytes)
+        ? nativeBackboneCoordinateJournalMagic.byteLength
+        : 0;
+    while (offset < bytes.byteLength) {
+        if (bytes.byteLength - offset < 8) {
+            throw new Error(`Native backbone ${name} has a torn record header`);
+        }
+        const length = readCoordinateJournalU32(bytes, offset);
+        const expectedChecksum = readCoordinateJournalU32(bytes, offset + 4);
+        const payloadOffset = offset + 8;
+        const end = payloadOffset + length;
+        if (!Number.isSafeInteger(end) || end > bytes.byteLength) {
+            throw new Error(`Native backbone ${name} has a torn record payload`);
+        }
+        const payload = bytes.subarray(payloadOffset, end);
+        if (coordinateJournalChecksum(payload) !== expectedChecksum) {
+            throw new Error(`Native backbone ${name} has a checksum mismatch`);
+        }
+        offset = end;
+    }
+};
 const resolveCoordinateFlushMaxPendingBytes = (options) => options.flushMaxPendingBytes != null
     ? Math.max(0, options.flushMaxPendingBytes)
     : options.flushOnAppend === false
@@ -181,6 +237,19 @@ const isNotFoundError = (error) => {
     const maybeError = error;
     return maybeError?.code === "ENOENT" || maybeError?.name === "NotFoundError";
 };
+const isUnsupportedDirectorySyncError = (error) => {
+    const code = error?.code;
+    return (code === "EISDIR" ||
+        code === "EINVAL" ||
+        code === "EPERM" ||
+        code === "ENOTSUP");
+};
+const validateCoordinatePersistenceWriteProgress = (written, remaining, target) => {
+    if (!Number.isSafeInteger(written) || written <= 0 || written > remaining) {
+        throw new Error(`Invalid ${target} write progress: ${String(written)} for ${remaining} remaining bytes`);
+    }
+    return written;
+};
 // Non-literal specifiers keep browser bundlers (esbuild statically resolves
 // literal dynamic imports and hard-fails on node builtins) from following
 // these node-only imports; they are only reached on node runtimes.
@@ -211,6 +280,62 @@ const validateCoordinatePersistenceName = (name) => {
     }
     return name;
 };
+const nativeBackboneCoordinateDropTombstoneBodyBytes = (body) => new TextEncoder().encode(JSON.stringify(body));
+const nativeBackboneCoordinateDropChecksum = (bytes) => {
+    let checksum = 0xffffffff;
+    for (const byte of bytes) {
+        checksum ^= byte;
+        for (let bit = 0; bit < 8; bit++) {
+            checksum = (checksum >>> 1) ^ (checksum & 1 ? 0xedb88320 : 0);
+        }
+    }
+    return ((checksum ^ 0xffffffff) >>> 0).toString(16).padStart(8, "0");
+};
+const nativeBackboneCoordinateDropTombstoneBytes = (files) => {
+    const body = {
+        format: "peerbit-native-backbone-coordinate-drop",
+        version: 1,
+        files: [...files],
+    };
+    return new TextEncoder().encode(JSON.stringify({
+        ...body,
+        checksum: nativeBackboneCoordinateDropChecksum(nativeBackboneCoordinateDropTombstoneBodyBytes(body)),
+    }));
+};
+const parseNativeBackboneCoordinateDropTombstone = (bytes) => {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(bytes));
+    }
+    catch (error) {
+        throw new Error("Invalid native backbone drop tombstone JSON", {
+            cause: error,
+        });
+    }
+    const candidate = parsed;
+    if (!candidate ||
+        candidate.format !== "peerbit-native-backbone-coordinate-drop" ||
+        candidate.version !== 1 ||
+        !Array.isArray(candidate.files) ||
+        candidate.files.some((name) => typeof name !== "string") ||
+        typeof candidate.checksum !== "string") {
+        throw new Error("Invalid native backbone drop tombstone");
+    }
+    const files = candidate.files.map(validateCoordinatePersistenceName);
+    if (new Set(files).size !== files.length ||
+        files.includes(nativeBackboneCoordinateDropTombstoneFile)) {
+        throw new Error("Invalid native backbone drop tombstone file set");
+    }
+    const body = {
+        format: "peerbit-native-backbone-coordinate-drop",
+        version: 1,
+        files,
+    };
+    if (nativeBackboneCoordinateDropChecksum(nativeBackboneCoordinateDropTombstoneBodyBytes(body)) !== candidate.checksum) {
+        throw new Error("Native backbone drop tombstone checksum mismatch");
+    }
+    return body;
+};
 const concatBytes = (chunks) => {
     const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
     const out = new Uint8Array(total);
@@ -706,7 +831,9 @@ const validateNativeBackboneCoordinateCommitColumns = (columns) => {
         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) {
         if (!columns.hashNumberValues ||
             !columns.coordinateCounts ||
             !columns.coordinateValues ||
@@ -726,7 +853,9 @@ const validateNativeBackboneCoordinateCommitColumns = (columns) => {
         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) {
         if (!columns.hashNumbers ||
             !columns.coordinateBatches ||
             !columns.requestedReplicas ||
@@ -752,7 +881,9 @@ const hasNativeBackboneNumericCoordinateCommitColumns = (columns) => !!columns.h
     !!columns.coordinateValues &&
     !!columns.requestedReplicaValues;
 const nativeBackboneCoordinateCommitStringColumns = (columns) => {
-    if (columns.hashNumbers && columns.coordinateBatches && columns.requestedReplicas) {
+    if (columns.hashNumbers &&
+        columns.coordinateBatches &&
+        columns.requestedReplicas) {
         return {
             hashNumbers: columns.hashNumbers,
             coordinateBatches: columns.coordinateBatches,
@@ -1171,9 +1302,7 @@ class NativeBackboneLogGraph {
                 ? ""
                 : integerString(documentIndex.existingCreated), documentIndex.byteElementIndexLimit ?? 0, documentIndex.deleteTrimmedHeads === true, this.options.documentProjectionPlanId(projection.plan), projection.encodedDocument, projection.signer));
         }
-        if (documentIndexArgs &&
-            input.trimLengthTo == null &&
-            hasNoNext) {
+        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 &&
@@ -2137,7 +2266,7 @@ export class NativePeerbitBackbone {
         });
     }
     commitEntryCoordinatesColumnsBatch(columns) {
-        const { hashes, gids, nextHashBatches, assignedToRangeBoundaries, } = columns;
+        const { hashes, gids, nextHashBatches, assignedToRangeBoundaries } = columns;
         if (hashes.length === 0) {
             return;
         }
@@ -2628,9 +2757,7 @@ export class NativePeerbitBackbone {
         ];
         const documentKeys = input.entries.map((entry) => entry.documentIndex.key);
         const usePlainPutPayload = input.entries.every((entry) => entry.documentIndex.usePlainPutPayload === true);
-        if (!requiredPreviousSignerPublicKey &&
-            useCompact &&
-            usePlainPutPayload) {
+        if (!requiredPreviousSignerPublicKey && useCompact && usePlainPutPayload) {
             const nativeCompactPlainPutPayloadBatch = this.native
                 .prepare_plain_committed_storage_append_document_index_latest_compact_plain_put_payload_batch_transaction;
             if (nativeCompactPlainPutPayloadBatch) {
@@ -2774,11 +2901,8 @@ export class NativePeerbitBackbone {
                 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);
+                ? 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;
             }
@@ -2827,6 +2951,7 @@ export class NativeBackboneMemoryCoordinatePersistenceStore {
     async remove(name) {
         this.files.delete(validateCoordinatePersistenceName(name));
     }
+    async flush(_name) { }
 }
 export class NativeBackboneNodeCoordinatePersistenceStore {
     directory;
@@ -2834,9 +2959,17 @@ export class NativeBackboneNodeCoordinatePersistenceStore {
     appendHandles = new Map();
     filePaths = new Map();
     directoryEnsured = false;
+    appendFailure;
+    durableBarrier;
     constructor(directory, fs) {
         this.directory = directory;
         this.fs = fs;
+        // The default Node backend has FileHandle.sync. Injected test/custom
+        // backends only advertise durability when they at least expose open(); the
+        // barrier itself verifies sync on every opened handle before ACK.
+        if (!fs || typeof fs.open === "function") {
+            this.durableBarrier = (name) => this.syncDurably(name);
+        }
     }
     async nodeFs() {
         return this.fs ?? (await importNodeFs());
@@ -2896,14 +3029,44 @@ export class NativeBackboneNodeCoordinatePersistenceStore {
         await fs.writeFile(path, bytes);
     }
     async append(name, bytes) {
+        if (this.appendFailure !== undefined) {
+            throw this.appendFailure;
+        }
         const fs = await this.ensureDirectory();
         const path = await this.filePath(name);
         const handle = await this.appendHandle(fs, path);
         if (handle) {
-            await handle.write(bytes);
+            let offset = 0;
+            while (offset < bytes.byteLength) {
+                let result;
+                try {
+                    result = await handle.write(bytes.subarray(offset));
+                }
+                catch (error) {
+                    // FileHandle.write does not expose progress on rejection, even for the
+                    // first call, so a partial tail can not be ruled out.
+                    this.appendFailure ??= error;
+                    throw this.appendFailure;
+                }
+                try {
+                    offset += validateCoordinatePersistenceWriteProgress(result.bytesWritten, bytes.byteLength - offset, "Node coordinate WAL");
+                }
+                catch (error) {
+                    this.appendFailure ??= error;
+                    throw this.appendFailure;
+                }
+            }
             return;
         }
-        await fs.appendFile(path, bytes);
+        try {
+            await fs.appendFile(path, bytes);
+        }
+        catch (error) {
+            // appendFile does not report partial progress. Conservatively prevent a
+            // later append from landing behind a possibly torn tail.
+            this.appendFailure ??= error;
+            throw this.appendFailure;
+        }
     }
     async remove(name) {
         const fs = await this.nodeFs();
@@ -2918,6 +3081,67 @@ export class NativeBackboneNodeCoordinatePersistenceStore {
             }
         }
     }
+    async flush(name) {
+        if (!this.durableBarrier) {
+            return;
+        }
+        try {
+            await this.durableBarrier(name);
+        }
+        catch (error) {
+            // Ordinary buffering reads flush a named queue before discovering whether
+            // the backing file exists. Missing files are expected there; strict ACK
+            // paths call durableBarrier directly and therefore remain fail-closed.
+            if (!name || !isNotFoundError(error)) {
+                throw error;
+            }
+        }
+    }
+    async syncDurably(name) {
+        const fs = await this.nodeFs();
+        if (!fs.open) {
+            throw new Error("Node coordinate persistence does not expose a durable FileHandle.sync barrier");
+        }
+        const syncHandle = async (handle, target) => {
+            if (typeof handle.sync !== "function") {
+                throw new Error(`Node coordinate persistence ${target} does not expose FileHandle.sync`);
+            }
+            await handle.sync();
+        };
+        if (name) {
+            const path = await this.filePath(name);
+            const appendHandle = this.appendHandles.get(path);
+            if (appendHandle) {
+                await syncHandle(await appendHandle, `file ${name}`);
+            }
+            else {
+                let handle;
+                try {
+                    handle = await fs.open(path, "r");
+                    await syncHandle(handle, `file ${name}`);
+                }
+                finally {
+                    await handle?.close();
+                }
+            }
+        }
+        else {
+            await Promise.all([...this.appendHandles.entries()].map(async ([path, handle]) => syncHandle(await handle, `file ${path}`)));
+        }
+        let directoryHandle;
+        try {
+            directoryHandle = await fs.open(this.directory, "r");
+            await syncHandle(directoryHandle, "directory");
+        }
+        catch (error) {
+            if (!isNotFoundError(error) && !isUnsupportedDirectorySyncError(error)) {
+                throw error;
+            }
+        }
+        finally {
+            await directoryHandle?.close();
+        }
+    }
     async close() {
         this.directoryEnsured = false;
         const handles = [...this.appendHandles.values()];
@@ -2927,6 +3151,7 @@ export class NativeBackboneNodeCoordinatePersistenceStore {
 }
 export class NativeBackboneOPFSCoordinatePersistenceStore {
     directory;
+    appendFailure;
     constructor(directory) {
         this.directory = directory;
     }
@@ -2979,6 +3204,9 @@ export class NativeBackboneOPFSCoordinatePersistenceStore {
         }
     }
     async append(name, bytes) {
+        if (this.appendFailure !== undefined) {
+            throw this.appendFailure;
+        }
         const handle = await this.directory.getFileHandle(validateCoordinatePersistenceName(name), { create: true });
         if (handle.createSyncAccessHandle) {
             let access;
@@ -2989,11 +3217,28 @@ export class NativeBackboneOPFSCoordinatePersistenceStore {
                 // Main-thread OPFS and some browser contexts do not expose sync handles.
             }
             if (access) {
+                const originalSize = access.getSize();
+                let offset = 0;
                 try {
-                    access.write(bytes, { at: access.getSize() });
+                    while (offset < bytes.byteLength) {
+                        offset += validateCoordinatePersistenceWriteProgress(access.write(bytes.subarray(offset), {
+                            at: originalSize + offset,
+                        }), bytes.byteLength - offset, "OPFS coordinate WAL");
+                    }
                     access.flush?.();
                     return;
                 }
+                catch (error) {
+                    try {
+                        access.truncate?.(originalSize);
+                        access.flush?.();
+                    }
+                    catch {
+                        // The sticky error below prevents appending behind a torn tail.
+                    }
+                    this.appendFailure ??= error;
+                    throw this.appendFailure;
+                }
                 finally {
                     access.close();
                 }
@@ -3004,10 +3249,19 @@ export class NativeBackboneOPFSCoordinatePersistenceStore {
         try {
             await writable.seek(file.size);
             await writable.write(bytes);
-        }
-        finally {
             await writable.close();
         }
+        catch (error) {
+            try {
+                await writable.close();
+            }
+            catch {
+                // Preserve the first error; the adapter is terminal either way.
+            }
+            // Async OPFS reports no write progress, so failure may leave a torn tail.
+            this.appendFailure ??= error;
+            throw this.appendFailure;
+        }
     }
     async remove(name) {
         try {
@@ -3019,15 +3273,45 @@ export class NativeBackboneOPFSCoordinatePersistenceStore {
             }
         }
     }
+    async flush(_name) { }
+    async durableBarrier(name) {
+        if (!name) {
+            throw new Error("OPFS coordinate persistence requires a named durable barrier");
+        }
+        const handle = await this.directory.getFileHandle(validateCoordinatePersistenceName(name), { create: false });
+        if (!handle.createSyncAccessHandle) {
+            throw new Error("OPFS coordinate persistence durable barriers require createSyncAccessHandle");
+        }
+        const access = await handle.createSyncAccessHandle();
+        try {
+            if (typeof access.flush !== "function") {
+                throw new Error("OPFS coordinate persistence sync handle does not expose flush");
+            }
+            access.flush();
+        }
+        finally {
+            access.close();
+        }
+    }
 }
 export class NativeBackboneBufferedCoordinatePersistenceStore {
     inner;
     options;
     buffers = new Map();
     bufferedBytes = 0;
+    supportsRemoval;
+    durableBarrier;
     constructor(inner, options = {}) {
         this.inner = inner;
         this.options = options;
+        this.supportsRemoval =
+            inner.supportsRemoval ?? typeof inner.remove === "function";
+        if (typeof inner.durableBarrier === "function") {
+            this.durableBarrier = async (name) => {
+                await this.flush(name);
+                await inner.durableBarrier(name);
+            };
+        }
     }
     buffer(name) {
         const validName = validateCoordinatePersistenceName(name);
@@ -3067,7 +3351,10 @@ export class NativeBackboneBufferedCoordinatePersistenceStore {
                 this.bufferedBytes -= chunk.byteLength;
             }
         }
-        await this.inner.remove?.(name);
+        if (!this.inner.remove) {
+            throw new Error("Native backbone coordinate persistence store does not support removal");
+        }
+        await this.inner.remove(name);
     }
     async flush(name) {
         const names = name
@@ -3083,11 +3370,17 @@ export class NativeBackboneBufferedCoordinatePersistenceStore {
             this.bufferedBytes -= bytes.byteLength;
             await this.inner.append(fileName, bytes);
         }
-        await this.inner.flush?.();
+        await this.inner.flush?.(name);
     }
-    async close() {
-        await this.flush();
-        await this.inner.close?.();
+    async close(options) {
+        if (options?.flush === false) {
+            this.buffers.clear();
+            this.bufferedBytes = 0;
+        }
+        else {
+            await this.flush();
+        }
+        await this.inner.close?.(options);
     }
 }
 export class NativeBackboneCoordinatePersistence {
@@ -3097,6 +3390,10 @@ export class NativeBackboneCoordinatePersistence {
     flushIntervalMs;
     compactMaxJournalBytes;
     compactMaxJournalRecords;
+    crashSafeCompaction = false;
+    durableBarrier;
+    supportsDrop;
+    dropIsTerminal = true;
     snapshotFile;
     journalFile;
     documentSnapshotFile;
@@ -3104,75 +3401,270 @@ export class NativeBackboneCoordinatePersistence {
     documentSignerSnapshotFile;
     documentSignerJournalFile;
     journalInitialized;
-    journalByteLength = 0;
-    journalRecordCount = 0;
     documentJournalInitialized;
-    documentJournalByteLength = 0;
-    documentJournalRecordCount = 0;
     documentSignerJournalInitialized;
-    documentSignerJournalByteLength = 0;
-    documentSignerJournalRecordCount = 0;
     lastFlushMs = Date.now();
     persistenceQueue;
+    persistenceLifecycle = "active";
+    dropInitiatedOnGeneration = false;
+    persistenceFailure;
+    closeMode;
+    closeFlushCompleted = false;
+    closeStoreCompleted = false;
+    closePromise;
     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.durableBarrier = typeof store.durableBarrier === "function";
+        this.supportsDrop =
+            (store.supportsRemoval ?? typeof store.remove === "function") &&
+                typeof store.remove === "function";
+        this.snapshotFile = validateCoordinatePersistenceName(options.snapshot ?? nativeBackboneCoordinatePersistenceFiles.snapshot);
+        this.journalFile = validateCoordinatePersistenceName(options.journal ?? nativeBackboneCoordinatePersistenceFiles.journal);
+        this.documentSnapshotFile = validateCoordinatePersistenceName(options.documentSnapshot ??
+            nativeBackboneCoordinatePersistenceFiles.documentSnapshot);
+        this.documentJournalFile = validateCoordinatePersistenceName(options.documentJournal ??
+            nativeBackboneCoordinatePersistenceFiles.documentJournal);
+        this.documentSignerSnapshotFile = validateCoordinatePersistenceName(options.documentSignerSnapshot ??
+            nativeBackboneCoordinatePersistenceFiles.documentSignerSnapshot);
+        this.documentSignerJournalFile = validateCoordinatePersistenceName(options.documentSignerJournal ??
+            nativeBackboneCoordinatePersistenceFiles.documentSignerJournal);
+        if (this.configuredFiles().includes(nativeBackboneCoordinateDropTombstoneFile)) {
+            throw new Error("Native backbone coordinate persistence file conflicts with its drop tombstone");
+        }
         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.compactMaxJournalBytes != null ||
+            options.compactMaxJournalRecords != null) {
+            throw new Error(nativeBackboneCoordinateCompactionDisabledMessage);
         }
-        if (options.compactMaxJournalRecords != null) {
-            this.compactMaxJournalRecords = Math.max(0, options.compactMaxJournalRecords);
+    }
+    /** Durable operation-intent capability for strict shared-log transactions. */
+    get intentStore() {
+        return this.store;
+    }
+    configuredFiles() {
+        return [
+            this.snapshotFile,
+            this.journalFile,
+            this.documentSnapshotFile,
+            this.documentJournalFile,
+            this.documentSignerSnapshotFile,
+            this.documentSignerJournalFile,
+        ];
+    }
+    assertLifecycleActive(operation) {
+        if (this.persistenceLifecycle !== "active") {
+            throw new Error(`Native backbone coordinate persistence can not ${operation} while ${this.persistenceLifecycle}`);
         }
     }
-    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);
+    assertActive(operation) {
+        if (this.persistenceFailure !== undefined) {
+            throw this.persistenceFailure;
+        }
+        this.assertLifecycleActive(operation);
+        if (this.dropInitiatedOnGeneration) {
+            throw new Error(`Native backbone coordinate persistence can not ${operation} after drop was initiated; retry drop or resume drop first`);
+        }
+    }
+    resetJournalTracking() {
+        this.journalInitialized = undefined;
+        this.documentJournalInitialized = undefined;
+        this.documentSignerJournalInitialized = undefined;
         this.lastFlushMs = Date.now();
-        return operations + documentOperations + documentSignerOperations;
+    }
+    async eraseDropFiles(files) {
+        if (!this.supportsDrop || !this.store.remove) {
+            throw new Error("Native backbone coordinate persistence store does not support removal");
+        }
+        const removals = await Promise.allSettled(files.map((name) => this.store.remove(name)));
+        const failures = removals.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+        if (failures.length > 0) {
+            throw new AggregateError(failures, "Failed to erase native backbone coordinate persistence namespace");
+        }
+        await this.store.flush?.();
+        await this.store.remove(nativeBackboneCoordinateDropTombstoneFile);
+        await this.store.flush?.();
+    }
+    async drop(additionalFiles = []) {
+        // Drop is the recovery escape hatch for a persistence generation that has
+        // already failed closed, so only the lifecycle (not persistenceFailure)
+        // gates this destructive operation.
+        this.assertLifecycleActive("drop");
+        const files = [
+            ...new Set([
+                ...this.configuredFiles(),
+                ...additionalFiles.map(validateCoordinatePersistenceName),
+            ]),
+        ];
+        if (files.includes(nativeBackboneCoordinateDropTombstoneFile)) {
+            throw new Error("Native backbone drop targets can not include the drop tombstone");
+        }
+        if (!this.supportsDrop || !this.store.remove) {
+            throw new Error("Native backbone coordinate persistence store does not support removal");
+        }
+        // Flip synchronously so no later append/compact can enqueue behind this
+        // erase and recreate a file after its removal.
+        this.dropInitiatedOnGeneration = true;
+        this.persistenceLifecycle = "dropping";
+        await this.enqueuePersistence(async () => {
+            await this.store.write(nativeBackboneCoordinateDropTombstoneFile, nativeBackboneCoordinateDropTombstoneBytes(files));
+            if (this.store.durableBarrier) {
+                await this.store.durableBarrier(nativeBackboneCoordinateDropTombstoneFile);
+            }
+            else {
+                await this.store.flush?.(nativeBackboneCoordinateDropTombstoneFile);
+            }
+            await this.eraseDropFiles(files);
+            this.resetJournalTracking();
+            this.persistenceLifecycle = "dropped";
+        });
+    }
+    async resumeDrop() {
+        if (this.persistenceLifecycle === "dropped") {
+            return true;
+        }
+        if (this.closeMode !== undefined) {
+            throw new Error("Native backbone coordinate persistence can not resume drop after close was initiated");
+        }
+        const resumesInProgress = this.persistenceLifecycle === "dropping";
+        const completesInitiatedDrop = this.dropInitiatedOnGeneration;
+        if (!resumesInProgress) {
+            if (completesInitiatedDrop) {
+                this.assertLifecycleActive("resume drop");
+            }
+            else {
+                this.assertActive("resume drop");
+            }
+        }
+        this.persistenceLifecycle = "dropping";
+        return this.enqueuePersistence(async () => {
+            // A concurrent drop may have completed before this queued recovery runs.
+            // Preserve its terminal lifecycle instead of reactivating the generation.
+            if (this.persistenceLifecycle === "dropped") {
+                return true;
+            }
+            return this.resumeDropInternal(completesInitiatedDrop ? "dropped" : "active");
+        });
+    }
+    async hydrate(backbone) {
+        this.assertActive("hydrate");
+        // Claim the lifecycle synchronously. close() queues after this complete
+        // read/validate/load operation; drop() rejects before erasing anything.
+        this.persistenceLifecycle = "hydrating";
+        return this.enqueuePersistence(async () => {
+            try {
+                this.assertHydrating();
+                await this.resumeDropInternal("hydrating");
+                this.assertHydrating();
+                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),
+                ]);
+                this.assertHydrating();
+                try {
+                    validateCoordinateJournal(journal, this.journalFile);
+                    validateCoordinateJournal(documentJournal, this.documentJournalFile);
+                    validateCoordinateJournal(documentSignerJournal, this.documentSignerJournalFile);
+                }
+                catch (error) {
+                    this.persistenceFailure ??= error;
+                    throw this.persistenceFailure;
+                }
+                let operations;
+                let documentOperations;
+                let documentSignerOperations;
+                try {
+                    this.assertHydrating();
+                    operations = backbone.loadCoordinateSnapshotAndJournal(snapshot, journal);
+                    this.assertHydrating();
+                    documentOperations = backbone.loadDocumentSnapshotAndJournal(documentSnapshot, documentJournal);
+                    this.assertHydrating();
+                    documentSignerOperations =
+                        backbone.loadDocumentSignerSnapshotAndJournal(documentSignerSnapshot, documentSignerJournal);
+                }
+                catch (error) {
+                    if (journal?.byteLength ||
+                        documentJournal?.byteLength ||
+                        documentSignerJournal?.byteLength) {
+                        this.persistenceFailure ??= error;
+                        throw this.persistenceFailure;
+                    }
+                    throw error;
+                }
+                this.assertHydrating();
+                this.journalInitialized = !!journal && journal.byteLength > 0;
+                this.documentJournalInitialized =
+                    !!documentJournal && documentJournal.byteLength > 0;
+                this.documentSignerJournalInitialized =
+                    !!documentSignerJournal && documentSignerJournal.byteLength > 0;
+                backbone.setCoordinateJournalEnabled(true);
+                backbone.setDocumentJournalEnabled(true);
+                backbone.setDocumentSignerJournalEnabled(true);
+                this.lastFlushMs = Date.now();
+                this.persistenceLifecycle = this.closePromise ? "closing" : "active";
+                return operations + documentOperations + documentSignerOperations;
+            }
+            catch (error) {
+                if (this.persistenceLifecycle === "hydrating") {
+                    this.persistenceLifecycle = this.closePromise ? "closing" : "active";
+                }
+                throw error;
+            }
+        });
+    }
+    assertHydrating() {
+        if (this.persistenceLifecycle !== "hydrating") {
+            throw new Error(`Native backbone coordinate persistence hydrate was interrupted while ${this.persistenceLifecycle}`);
+        }
+    }
+    async resumeDropInternal(finalLifecycle) {
+        const bytes = await this.store.read(nativeBackboneCoordinateDropTombstoneFile);
+        if (!bytes) {
+            // A failed drop can stop before its tombstone is durable. Restore the
+            // generation to active so the caller can start a complete drop; only a
+            // tombstone-backed erase may finish it as dropped.
+            this.persistenceLifecycle =
+                finalLifecycle === "hydrating"
+                    ? "hydrating"
+                    : this.closePromise
+                        ? "closing"
+                        : "active";
+            return false;
+        }
+        let tombstone;
+        try {
+            tombstone = parseNativeBackboneCoordinateDropTombstone(bytes);
+            for (const file of this.configuredFiles()) {
+                if (!tombstone.files.includes(file)) {
+                    throw new Error("Native backbone drop tombstone does not cover the configured namespace");
+                }
+            }
+        }
+        catch (error) {
+            // Corruption must never hydrate stale files, but an explicit drop must
+            // remain available to overwrite the bad marker and erase the namespace.
+            this.persistenceFailure ??= error;
+            this.persistenceLifecycle = this.closePromise ? "closing" : "active";
+            throw this.persistenceFailure;
+        }
+        await this.eraseDropFiles(tombstone.files);
+        this.resetJournalTracking();
+        this.persistenceLifecycle =
+            finalLifecycle === "dropped"
+                ? "dropped"
+                : finalLifecycle === "hydrating"
+                    ? "hydrating"
+                    : this.closePromise
+                        ? "closing"
+                        : "active";
+        return true;
     }
     shouldFlushJournalOnAppend(backbone, now = Date.now()) {
         if (this.flushOnAppend !== false) {
@@ -3195,12 +3687,14 @@ export class NativeBackboneCoordinatePersistence {
             now - this.lastFlushMs >= this.flushIntervalMs);
     }
     flushJournalOnAppend(backbone) {
+        this.assertActive("flush on append");
         if (!this.shouldFlushJournalOnAppend(backbone)) {
             return 0;
         }
         return this.flushJournal(backbone);
     }
     flushJournal(backbone) {
+        this.assertActive("flush");
         // 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));
@@ -3209,9 +3703,7 @@ export class NativeBackboneCoordinatePersistence {
         // 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 next = this.persistenceQueue ? this.persistenceQueue.then(fn) : fn();
         const tail = next.then(() => undefined, () => undefined);
         this.persistenceQueue = tail;
         void tail.then(() => {
@@ -3223,122 +3715,157 @@ export class NativeBackboneCoordinatePersistence {
     }
     async flushJournalInternal(backbone) {
         let written = 0;
+        let persistenceMutationStarted = false;
+        let coordinateBytes;
+        let documentBytes;
+        let signerBytes;
         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;
+        try {
+            if (coordinateRecords.byteLength > 0) {
+                if (this.journalInitialized === undefined) {
+                    const existing = await this.store.read(this.journalFile);
+                    this.journalInitialized = !!existing && existing.byteLength > 0;
+                }
+                coordinateBytes = this.journalInitialized
+                    ? coordinateRecords
+                    : concatBytes([
+                        backbone.coordinateJournalHeader(),
+                        coordinateRecords,
+                    ]);
+                await this.store.append(this.journalFile, coordinateBytes);
+                persistenceMutationStarted = true;
+                written += coordinateRecords.byteLength;
+            }
+            if (documentRecords.byteLength > 0) {
+                if (this.documentJournalInitialized === undefined) {
+                    const existing = await this.store.read(this.documentJournalFile);
+                    this.documentJournalInitialized =
+                        !!existing && existing.byteLength > 0;
+                }
+                documentBytes = this.documentJournalInitialized
+                    ? documentRecords
+                    : concatBytes([backbone.documentJournalHeader(), documentRecords]);
+                await this.store.append(this.documentJournalFile, documentBytes);
+                persistenceMutationStarted = true;
+                written += documentRecords.byteLength;
+            }
+            if (signerRecords.byteLength > 0) {
+                if (this.documentSignerJournalInitialized === undefined) {
+                    const existing = await this.store.read(this.documentSignerJournalFile);
+                    this.documentSignerJournalInitialized =
+                        !!existing && existing.byteLength > 0;
+                }
+                signerBytes = this.documentSignerJournalInitialized
+                    ? signerRecords
+                    : concatBytes([
+                        backbone.documentSignerJournalHeader(),
+                        signerRecords,
+                    ]);
+                await this.store.append(this.documentSignerJournalFile, signerBytes);
+                persistenceMutationStarted = true;
+                written += signerRecords.byteLength;
+            }
+            if (written === 0) {
+                this.lastFlushMs = Date.now();
+                return 0;
+            }
+            // `append` may only enqueue bytes in a buffered store. Drain and fsync
+            // every affected WAL before clearing its wasm prefix or returning an ACK.
+            for (const file of [
+                coordinateBytes ? this.journalFile : undefined,
+                documentBytes ? this.documentJournalFile : undefined,
+                signerBytes ? this.documentSignerJournalFile : undefined,
+            ]) {
+                if (file) {
+                    if (this.store.durableBarrier) {
+                        await this.store.durableBarrier(file);
+                    }
+                    else {
+                        await this.store.flush?.(file);
+                    }
+                }
+            }
+            if (coordinateBytes) {
+                this.journalInitialized = true;
+            }
+            if (documentBytes) {
+                this.documentJournalInitialized = true;
+            }
+            if (signerBytes) {
+                this.documentSignerJournalInitialized = true;
+            }
+            backbone.clearCoordinateJournalPrefix(coordinateRecords.byteLength, coordinateRecordCount);
+            backbone.clearDocumentJournalPrefix(documentRecords.byteLength, documentRecordCount);
             backbone.clearDocumentSignerJournalPrefix(signerRecords.byteLength, signerRecordCount);
-            written += signerRecords.byteLength;
-        }
-        if (written === 0) {
             this.lastFlushMs = Date.now();
-            return 0;
+            return written;
+        }
+        catch (error) {
+            if (persistenceMutationStarted) {
+                this.persistenceFailure ??= error;
+                throw this.persistenceFailure;
+            }
+            throw error;
         }
-        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?.();
+    async compact(_backbone) {
+        this.assertActive("compact");
+        throw new Error(nativeBackboneCoordinateCompactionDisabledMessage);
+    }
+    close() {
+        if (this.closePromise) {
+            return this.closePromise;
+        }
+        const closeMode = this.closeMode ??
+            (this.persistenceLifecycle === "active" && !this.dropInitiatedOnGeneration
+                ? "flush"
+                : "withoutFlush");
+        this.closeMode = closeMode;
+        // Close wins once invoked from an active generation. The synchronous
+        // transition rejects any later drop/hydrate/flush before the terminal
+        // store close starts, including for stores that forbid all post-close I/O.
+        if (this.persistenceLifecycle === "active") {
+            this.persistenceLifecycle = "closing";
+        }
+        const closeAttempt = this.enqueuePersistence(async () => {
+            if (closeMode === "flush") {
+                this.persistenceLifecycle = "closing";
+                if (!this.closeFlushCompleted) {
+                    await this.store.flush?.();
+                    this.closeFlushCompleted = true;
+                }
+                if (!this.closeStoreCompleted) {
+                    await this.store.close?.();
+                    this.closeStoreCompleted = true;
+                }
+                this.persistenceLifecycle = "closed";
+                return;
+            }
+            // A drop already in flight wins. Drain no buffered bytes after its
+            // tombstone erase and preserve the dropped terminal lifecycle.
+            if (!this.closeStoreCompleted) {
+                await this.store.close?.({ flush: false });
+                this.closeStoreCompleted = true;
+            }
+            if (this.persistenceLifecycle !== "dropped") {
+                this.persistenceLifecycle = "closed";
+            }
+        });
+        this.closePromise = closeAttempt;
+        void closeAttempt.catch(() => {
+            // A rejected close is only the failed attempt, not terminal progress.
+            // Retain completed stages above, but let the exact owner retry the first
+            // incomplete store operation.
+            if (this.closePromise === closeAttempt) {
+                this.closePromise = undefined;
+            }
+        });
+        return closeAttempt;
     }
 }
 const resolveNodeWriteBufferMaxBytes = (options) => options.writeBufferMaxBytes != null
@@ -3375,18 +3902,12 @@ export const createNativeBackboneCoordinatePersistence = (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,
-    });
+    return new NativeBackboneCoordinatePersistence(resolvedStore, options);
 };
 export const createBufferedNativeBackboneCoordinatePersistence = (store, options = {}) => {
     const maxBufferedBytes = options.maxBufferedBytes ??
@@ -3405,8 +3926,7 @@ export const createBufferedNativeBackboneCoordinatePersistence = (store, options
         flushOnAppend: false,
         flushMaxPendingBytes,
         flushIntervalMs: options.flushIntervalMs,
-        compactMaxJournalBytes: options.compactMaxJournalBytes ??
-            defaultNativeBackboneCoordinateCompactMaxJournalBytes,
+        compactMaxJournalBytes: options.compactMaxJournalBytes,
         compactMaxJournalRecords: options.compactMaxJournalRecords,
     });
 };
@@ -3418,8 +3938,6 @@ export const createBufferedNativeBackboneNodeCoordinatePersistence = (directory,
         flushOnAppend: false,
         flushMaxPendingBytes,
         writeBufferMaxBytes: options.writeBufferMaxBytes ?? flushMaxPendingBytes,
-        compactMaxJournalBytes: options.compactMaxJournalBytes ??
-            defaultNativeBackboneCoordinateCompactMaxJournalBytes,
     });
 };
 export const createNativePeerbitBackbone = NativePeerbitBackbone.create;