@peerbit/document 15.0.14 → 15.0.16

package/dist/src/program.js

@@ -35,16 +35,16 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 import { BorshError, deserialize, field, serialize, variant, } from "@dao-xyz/borsh";
 import { AccessError } from "@peerbit/crypto";
 import { Context, NotFoundError, } from "@peerbit/document-interface";
-import { extractDocumentFieldSimple, initializeDocumentRust, planDocumentContext, planDocumentContextBatch, tryPlanDocumentContext, tryPlanDocumentContextBatch, } from "./native-rust.js";
 import * as indexerTypes from "@peerbit/indexer-interface";
 import { Entry, EntryType, LamportClock, ShallowEntry, ShallowMeta, Timestamp, entryV0PlainPayloadDataFromStorage, } from "@peerbit/log";
 import { logger as loggerFn } from "@peerbit/logger";
 import { Program } from "@peerbit/program";
-import { SharedLog, } from "@peerbit/shared-log";
-import { detachCanPerformCallbackProperties, detachEntryPayloadForCallback, } from "./callback-detachment.js";
+import { PersistedDeliveryError, SharedLog, } from "@peerbit/shared-log";
+import { detachCanPerformCallbackProperties, detachEntryForCallback, detachEntryPayloadForCallback, } from "./callback-detachment.js";
 import { MAX_BATCH_SIZE } from "./constants.js";
+import { extractDocumentFieldSimple, initializeDocumentRust, planDocumentContext, planDocumentContextBatch, tryPlanDocumentContext, tryPlanDocumentContextBatch, } from "./native-rust.js";
 import { BORSH_ENCODING_OPERATION, DeleteOperation, PutOperation, PutWithKeyOperation, coerceDeleteOperation, isDeleteOperation, isPutOperation, } from "./operation.js";
-import { createCanPerformPolicyEvaluator, createCanPerformDeletePolicyEvaluator, getCanPerformPolicyDescriptor, canPerformPolicyDeleteFieldPaths, canPerformPolicyNeedsDeleteValue, canPerformPolicyNeedsPreviousEntries, canPerformPolicyPutNeedsEntryPublicKeys, canPerformPolicySignedByFieldPaths, } from "./policy.js";
+import { canPerformPolicyDeleteFieldPaths, canPerformPolicyNeedsDeleteValue, canPerformPolicyNeedsPreviousEntries, canPerformPolicyPutNeedsEntryPublicKeys, canPerformPolicySignedByFieldPaths, createCanPerformDeletePolicyEvaluator, createCanPerformPolicyEvaluator, getCanPerformPolicyDescriptor, } from "./policy.js";
 import { isResultIndexedValue } from "./result-shape.js";
 import { DocumentIndex, INDEX_CONTEXT_SHAPE, coerceWithContext, coerceWithIndexed, coerceWithLazyIndexed, encodeContextSuffix as encodeDocumentContextSuffix, } from "./search.js";
 import { getDocumentTransformDescriptor, } from "./transform.js";
@@ -111,6 +111,54 @@ const encodePutOperationPayload = (data) => {
     return encoded;
 };
 const toContextBigInt = (value) => typeof value === "bigint" ? value : BigInt(value);
+const hasPersistedDelivery = (options) => typeof options?.delivery === "object" &&
+    options.delivery.reliability === "persisted";
+const withoutPersistedDelivery = (options) => {
+    if (!hasPersistedDelivery(options)) {
+        return options;
+    }
+    return {
+        ...options,
+        target: "none",
+        delivery: false,
+        replicate: false,
+    };
+};
+const runAfterDocumentCommit = (options, committedHashes, fn) => {
+    if (!hasPersistedDelivery(options))
+        return fn();
+    const resolvedHashes = typeof committedHashes === "function" ? committedHashes() : committedHashes;
+    const hashes = typeof resolvedHashes === "string" ? [resolvedHashes] : resolvedHashes;
+    try {
+        const result = fn();
+        if (isPromiseLike(result)) {
+            return result.catch((error) => {
+                throw new PersistedDeliveryError(error, hashes);
+            });
+        }
+        return result;
+    }
+    catch (error) {
+        throw new PersistedDeliveryError(error, hashes);
+    }
+};
+const runWithTrustedLocalCommitEvidence = (options, evidence, fn) => {
+    if (!evidence || !hasPersistedDelivery(options))
+        return fn();
+    const classify = (error) => {
+        if (evidence.committedHashes.size > 0) {
+            throw new PersistedDeliveryError(error, evidence.committedHashes);
+        }
+        throw error;
+    };
+    try {
+        const result = fn();
+        return isPromiseLike(result) ? result.catch(classify) : result;
+    }
+    catch (error) {
+        return classify(error);
+    }
+};
 const NATIVE_LOCAL_PUT_OPTIONS = Object.freeze({
     replicate: false,
     target: "none",
@@ -136,6 +184,7 @@ const cachedNativeLocalPutOptions = (options) => {
     }
     return options.unique === true ? NATIVE_LOCAL_UNIQUE_PUT_OPTIONS : undefined;
 };
+const persistedDeliveryAlreadySettled = new WeakSet();
 class CompatDocumentBackend {
     putImpl;
     putManyImpl;
@@ -186,15 +235,7 @@ class NativeDocumentBackend {
                 useNativeExistingDocumentContext,
                 requiredPreviousSignerPublicKey,
                 existing,
-            }), (documentAppendCommit) => mapMaybePromise(this.context.handlePreparedPlainPutCommit(documentAppendCommit), () => {
-                this.context.keepEntry(documentAppendCommit.append.hash);
-                return {
-                    get entry() {
-                        return documentAppendCommit.entry;
-                    },
-                    removed: documentAppendCommit.removed,
-                };
-            }));
+            }), (documentAppendCommit) => this.context.finishPreparedPlainPutCommit(documentAppendCommit, options));
         };
         const assertPolicyAndCommit = (existingContext, previousSignerPublicKey) => {
             const existingHead = this.context.getIndexedContextHead(existingContext);
@@ -239,6 +280,9 @@ class NativeDocumentBackend {
         }
         const prepared = docs.map((doc) => this.context.preparePlainPut(doc));
         if (this.context.hasDuplicatePreparedPutKeys(prepared)) {
+            if (hasPersistedDelivery(options)) {
+                throw this.context.nativeModeError("requires distinct document keys for persisted putMany");
+            }
             const results = [];
             for (const doc of docs) {
                 results.push(await this.put(doc, putOptions));
@@ -318,17 +362,7 @@ class NativeDocumentBackend {
             if (!documentAppendCommit) {
                 throw this.context.nativeModeError("requires native batched payload append support");
             }
-            return mapMaybePromise(this.context.handlePreparedPlainPutManyCommit(documentAppendCommit), () => {
-                for (const commit of documentAppendCommit.commits) {
-                    this.context.keepEntry(commit.append.hash);
-                }
-                return {
-                    get entries() {
-                        return documentAppendCommit.entries;
-                    },
-                    removed: documentAppendCommit.removed,
-                };
-            });
+            return this.context.finishPreparedPlainPutManyCommit(documentAppendCommit, options);
         });
     }
     del(id, options) {
@@ -337,6 +371,10 @@ class NativeDocumentBackend {
     }
 }
 const nativeDocumentContextFactsAsContext = (facts) => facts;
+// Keep the public putMany result shape unchanged while carrying the native
+// commit/coordinate facts to the internal persisted-delivery seam. The result
+// remains the lifetime owner of the lazy full-entry materializer.
+const persistedDocumentAppendDelivery = new WeakMap();
 const asTrustedDocumentSharedLog = (log) => log;
 const documentIndexStoreKey = (id) => {
     const key = indexerTypes.toIdeable(id);
@@ -430,11 +468,7 @@ let Documents = (() => {
             const boundMethods = new Map();
             const detachedFromEntry = (entry) => {
                 const fromEntry = Reflect.get(domain, "fromEntry", domain);
-                return Reflect.apply(fromEntry, domain, [
-                    entry instanceof Entry
-                        ? detachEntryPayloadForCallback(entry)
-                        : entry,
-                ]);
+                return Reflect.apply(fromEntry, domain, [detachEntryForCallback(entry)]);
             };
             const facade = Object.create(Object.getPrototypeOf(domain));
             let callbackDomain;
@@ -490,6 +524,22 @@ let Documents = (() => {
             });
             return callbackDomain;
         }
+        detachTrimEntryCallback(option) {
+            const filter = option?.filter;
+            if (!option || !filter?.canTrim) {
+                return option;
+            }
+            const canTrim = filter.canTrim;
+            return {
+                ...option,
+                filter: {
+                    ...filter,
+                    canTrim: function (entry) {
+                        return Reflect.apply(canTrim, this, [detachEntryForCallback(entry)]);
+                    },
+                },
+            };
+        }
         createNativeDocumentBackendContext() {
             return {
                 assertPlainPutSupported: (doc, options) => {
@@ -519,12 +569,9 @@ let Documents = (() => {
                 },
                 commitNativeDocumentAppend: (input) => this.commitNativeDocumentAppend(input),
                 commitNativeDocumentAppendMany: (input) => this.commitNativeDocumentAppendMany(input),
-                handlePreparedPlainPutCommit: (commit) => this.handlePreparedPlainPutCommit(commit),
-                handlePreparedPlainPutManyCommit: (commit) => this.handlePreparedPlainPutManyCommit(commit),
+                finishPreparedPlainPutCommit: (commit, options) => this.finishPreparedPlainPutCommit(commit, options),
+                finishPreparedPlainPutManyCommit: (commit, options) => this.finishPreparedPlainPutManyCommit(commit, options),
                 deleteDocument: (id, options) => this.delNativeDocumentBackend(id, options),
-                keepEntry: (hash) => {
-                    this.keepCache?.add(hash);
-                },
                 nativeModeError: (message) => this.nativeModeError(message),
             };
         }
@@ -715,10 +762,14 @@ let Documents = (() => {
             if (options?.replicate === true) {
                 unsupported.push("replicated put");
             }
-            if (options?.target && options.target !== "none") {
+            if (options?.target &&
+                options.target !== "none" &&
+                !(hasPersistedDelivery(options) && options.target === "replicators")) {
                 unsupported.push("non-local target");
             }
-            if (options?.delivery !== undefined && options.delivery !== false) {
+            if (options?.delivery !== undefined &&
+                options.delivery !== false &&
+                !hasPersistedDelivery(options)) {
                 unsupported.push("delivery");
             }
             if (options?.checkRemote) {
@@ -793,7 +844,8 @@ let Documents = (() => {
             return this.nativeFieldValueMatchesPublicKey(value, localPublicKey);
         }
         nativeFieldValueMatchesPublicKey(value, publicKey) {
-            const localRawPublicKey = publicKey.publicKey;
+            const localRawPublicKey = publicKey
+                .publicKey;
             return (value instanceof Uint8Array &&
                 (bytesEqual(value, publicKey.bytes) ||
                     (localRawPublicKey ? bytesEqual(value, localRawPublicKey) : false)));
@@ -949,6 +1001,9 @@ let Documents = (() => {
                 return;
             }
             const unsupported = this.unsupportedNativePutOptions(options);
+            if (options && hasPersistedDelivery(options)) {
+                unsupported.push("delivery");
+            }
             if (options?.unique !== undefined) {
                 unsupported.push("unique delete");
             }
@@ -992,6 +1047,9 @@ let Documents = (() => {
             if (!this.isNativeMode()) {
                 return options;
             }
+            if (hasPersistedDelivery(options)) {
+                return options;
+            }
             if (options?.replicate === false && options.target === "none") {
                 return options;
             }
@@ -1320,8 +1378,7 @@ let Documents = (() => {
             this._documentInternalChangeListenerCount = Math.max(0, this._documentChangeListenerCount - changeListenersBeforeIndexOpen);
             this._nativeDocumentFieldExtractionPlans ??= new Map();
             this._nativeDocumentFieldExtractionPlans.clear();
-            this._nativeDocumentIdExtractionPlan =
-                asTrustedDocumentIndex(this._index).getNativeDocumentFieldExtractionPlan(idProperty);
+            this._nativeDocumentIdExtractionPlan = asTrustedDocumentIndex(this._index).getNativeDocumentFieldExtractionPlan(idProperty);
             // B12: the historical document->log compatibility mapping (6 -> log v8,
             // 7 -> log v9) is retired; the rejection at the top of open() fires for
             // any defined value before this point.
@@ -1371,11 +1428,7 @@ let Documents = (() => {
                 const keep = options?.keep;
                 keepFunction = keep
                     ? function (entry) {
-                        return Reflect.apply(keep, this, [
-                            entry instanceof Entry
-                                ? detachEntryPayloadForCallback(entry)
-                                : entry,
-                        ]);
+                        return Reflect.apply(keep, this, [detachEntryForCallback(entry)]);
                     }
                     : undefined;
             }
@@ -1384,7 +1437,7 @@ let Documents = (() => {
                 canReplicate: options?.canReplicate,
                 canAppend: this.canAppend.bind(this),
                 onChange: this.handleChanges.bind(this),
-                trim: options?.log?.trim,
+                trim: this.detachTrimEntryCallback(options?.log?.trim),
                 appendDurability: options?.appendDurability,
                 nativeBackbone: options?.nativeBackbone,
                 nativeGraph: options?.nativeGraph,
@@ -1650,7 +1703,8 @@ let Documents = (() => {
                             : reference.document);
                     }
                     else {
-                        keyValue = await this.getNativeDocumentIdFromPutOperation(putOperation);
+                        keyValue =
+                            await this.getNativeDocumentIdFromPutOperation(putOperation);
                         if (keyValue == null) {
                             if (this.isNativeMode()) {
                                 return false;
@@ -1941,7 +1995,28 @@ let Documents = (() => {
             };
         }
         async put(doc, options) {
-            return this._documentBackend.put(doc, options);
+            if (hasPersistedDelivery(options)) {
+                asTrustedDocumentSharedLog(this.log).assertPersistedDeliveryOptions(options);
+            }
+            const result = await this._documentBackend.put(doc, options);
+            if (!hasPersistedDelivery(options) ||
+                persistedDeliveryAlreadySettled.has(result)) {
+                return result;
+            }
+            const entry = result.entry;
+            await this.deliverPersistedDocumentEntries([entry], options);
+            return {
+                get entry() {
+                    return entry;
+                },
+                removed: result.removed,
+            };
+        }
+        deliverPersistedDocumentEntries(entries, options) {
+            return asTrustedDocumentSharedLog(this.log).deliverPersistedEntries(entries, options);
+        }
+        deliverPersistedDocumentAppendCommits(delivery, options) {
+            return asTrustedDocumentSharedLog(this.log).deliverPersistedAppendCommits(delivery.appendCommits, delivery.materializeEntries, options);
         }
         async putCompatDocumentBackend(doc, options) {
             const putOptions = this.normalizeNativeModePutOptions(options);
@@ -1971,6 +2046,7 @@ let Documents = (() => {
             const operation = "operation" in prepared
                 ? prepared.operation
                 : new PutOperation({ data: prepared.encodedDocument });
+            const persistedDelivery = hasPersistedDelivery(putOptions);
             const appended = await this.log.append(operation, {
                 ...putOptions,
                 meta: {
@@ -1983,32 +2059,73 @@ let Documents = (() => {
                         operation,
                     });
                 },
-                onChange: (change) => {
-                    return this.handleChanges(change, {
+                onChange: persistedDelivery
+                    ? (change) => runAfterDocumentCommit(putOptions, () => change.added.map(({ entry }) => entry.hash), () => mapMaybePromise(this.handleChanges(change, {
                         document: prepared.document,
                         operation,
                         key: prepared.key,
                         unique: putOptions?.unique,
                         existing: existingLocalContext,
-                    });
-                },
+                    }), () => {
+                        this.keepCache?.add(change.added[0].entry.hash);
+                    }))
+                    : (change) => this.handleChanges(change, {
+                        document: prepared.document,
+                        operation,
+                        key: prepared.key,
+                        unique: putOptions?.unique,
+                        existing: existingLocalContext,
+                    }),
                 replicate: putOptions?.replicate,
             });
             this.keepCache?.add(appended.entry.hash);
+            if (persistedDelivery) {
+                persistedDeliveryAlreadySettled.add(appended);
+            }
             return appended;
         }
         async putMany(docs, options) {
-            return this._documentBackend.putMany(docs, options);
+            if (hasPersistedDelivery(options)) {
+                asTrustedDocumentSharedLog(this.log).assertPersistedDeliveryOptions(options);
+            }
+            const result = await this._documentBackend.putMany(docs, options);
+            if (!hasPersistedDelivery(options)) {
+                return result;
+            }
+            const appendDelivery = persistedDocumentAppendDelivery.get(result);
+            if (appendDelivery) {
+                persistedDocumentAppendDelivery.delete(result);
+                await this.deliverPersistedDocumentAppendCommits(appendDelivery, options);
+                let entries;
+                return {
+                    get entries() {
+                        return (entries ??= result.entries);
+                    },
+                    removed: result.removed,
+                };
+            }
+            const entries = result.entries;
+            if (entries.length === 0) {
+                return result;
+            }
+            await this.deliverPersistedDocumentEntries(entries, options);
+            return { entries, removed: result.removed };
         }
         async putManyCompatDocumentBackend(docs, options) {
             if (docs.length === 0) {
                 return { entries: [], removed: [] };
             }
             if (!this.canUsePlainPutManyFastPath(docs, options)) {
+                if (hasPersistedDelivery(options)) {
+                    throw new Error("persisted putMany requires the independent batched document path");
+                }
                 return this.putManySequential(docs, options);
             }
             const prepared = docs.map((doc) => this.preparePlainPut(doc));
             if (this.hasDuplicatePreparedPutKeys(prepared)) {
+                if (hasPersistedDelivery(options)) {
+                    throw new Error("persisted putMany requires distinct document keys");
+                }
                 return this.putManySequential(docs, options);
             }
             const documentAppendCommit = await this.commitNativeDocumentAppendMany({
@@ -2024,18 +2141,12 @@ let Documents = (() => {
                 options,
             });
             if (!documentAppendCommit) {
+                if (hasPersistedDelivery(options)) {
+                    throw new Error("persisted putMany requires native batched payload append support");
+                }
                 return this.putManySequential(docs, options);
             }
-            await this.handlePreparedPlainPutManyCommit(documentAppendCommit);
-            for (const commit of documentAppendCommit.commits) {
-                this.keepCache?.add(commit.append.hash);
-            }
-            return {
-                get entries() {
-                    return documentAppendCommit.entries;
-                },
-                removed: documentAppendCommit.removed,
-            };
+            return await this.finishPreparedPlainPutManyCommit(documentAppendCommit, options);
         }
         async putManySequential(docs, options) {
             const entries = [];
@@ -2058,6 +2169,7 @@ let Documents = (() => {
             return false;
         }
         canUsePlainPutFastPath(doc, options) {
+            const persistedDelivery = hasPersistedDelivery(options);
             return (this._mode !== "compat" &&
                 this.canPerformAllowsPlainPutFastPath(doc) &&
                 !this.immutable &&
@@ -2077,16 +2189,26 @@ let Documents = (() => {
                 !options?.meta?.timestamp &&
                 !options?.meta?.gidSeed &&
                 options?.replicate !== true &&
-                (!options?.target || options.target === "none") &&
-                (options?.delivery === undefined || options.delivery === false) &&
+                (!options?.target ||
+                    options.target === "none" ||
+                    (persistedDelivery && options.target === "replicators")) &&
+                (options?.delivery === undefined ||
+                    options.delivery === false ||
+                    persistedDelivery) &&
                 !options?.checkRemote &&
                 options?.replicas === undefined);
         }
         canUsePlainPutManyFastPath(docs, options) {
+            const persistedDelivery = hasPersistedDelivery(options);
             return (options?.unique === true &&
                 options?.replicate !== true &&
-                options?.target === "none" &&
-                (options?.delivery === undefined || options.delivery === false) &&
+                (options?.target === "none" ||
+                    (persistedDelivery &&
+                        (options.target === undefined ||
+                            options.target === "replicators"))) &&
+                (options?.delivery === undefined ||
+                    options.delivery === false ||
+                    persistedDelivery) &&
                 docs.every((doc) => this.canUsePlainPutFastPath(doc, options)));
         }
         async createPlainPutCommitPlan(prepared, existingHead, existingLocalContext, options, assumePlainPutFastPath = false) {
@@ -2135,41 +2257,43 @@ let Documents = (() => {
                 options,
                 unique: plan.unique,
                 existing: plan.existing,
-            }), (documentAppendCommit) => {
-                const handled = plan.useGenericChangeHandler
-                    ? this.handleChanges({
-                        added: [{ head: true, entry: documentAppendCommit.entry }],
-                        removed: documentAppendCommit.removed,
-                    }, {
-                        document: plan.document,
-                        operation: documentAppendCommit.operation ??
-                            plan.operation ??
-                            new PutOperation({ data: plan.encodedDocument }),
-                        key: plan.key,
-                        unique: plan.unique,
-                        existing: plan.existing,
-                    })
-                    : this.handlePreparedPlainPutCommit(documentAppendCommit);
-                return mapMaybePromise(handled, () => {
-                    this.keepCache?.add(documentAppendCommit.append.hash);
-                    return {
-                        get entry() {
-                            return documentAppendCommit.entry;
+            }), (documentAppendCommit) => this.finishPreparedPlainPutCommit(documentAppendCommit, options, () => plan.useGenericChangeHandler
+                ? this.handleChanges({
+                    added: [
+                        {
+                            head: true,
+                            entry: documentAppendCommit.entry,
                         },
-                        removed: documentAppendCommit.removed,
-                    };
-                });
-            });
+                    ],
+                    removed: documentAppendCommit.removed,
+                }, {
+                    document: plan.document,
+                    operation: documentAppendCommit.operation ??
+                        plan.operation ??
+                        new PutOperation({ data: plan.encodedDocument }),
+                    key: plan.key,
+                    unique: plan.unique,
+                    existing: plan.existing,
+                })
+                : this.handlePreparedPlainPutCommit(documentAppendCommit)));
         }
         commitNativeDocumentAppend(input) {
+            if (!hasPersistedDelivery(input.options)) {
+                return this.commitNativeDocumentAppendWithEvidence(input, undefined);
+            }
+            const localCommitEvidence = { committedHashes: new Set() };
+            return runWithTrustedLocalCommitEvidence(input.options, localCommitEvidence, () => this.commitNativeDocumentAppendWithEvidence(input, localCommitEvidence));
+        }
+        commitNativeDocumentAppendWithEvidence(input, localCommitEvidence) {
             const trustedLog = asTrustedDocumentSharedLog(this.log);
+            const localAppendOptions = withoutPersistedDelivery(input.options);
             const appendOptions = {
-                ...input.options,
+                ...localAppendOptions,
                 meta: {
                     next: input.next,
-                    ...input.options?.meta,
+                    ...localAppendOptions?.meta,
                 },
-                replicate: input.options?.replicate,
+                replicate: localAppendOptions?.replicate,
             };
             const prepareNativeDocumentIndexWithAppendFacts = this.createNativeBackboneDocumentIndexAppendFactsPreparer(input);
             const preferAppendFactsDocumentIndex = this.isNativeMode() && !!prepareNativeDocumentIndexWithAppendFacts;
@@ -2190,6 +2314,7 @@ let Documents = (() => {
                     resolveTrimmedEntries: input.resolveTrimmedEntries,
                     payloadData: input.operationPayloadBytes,
                     useNativeExistingDocumentContext: input.useNativeExistingDocumentContext,
+                    ...(localCommitEvidence ? { localCommitEvidence } : undefined),
                     ...(nativeDocumentIndexCommit
                         ? {
                             nativeBackboneDocumentIndex: this.toNativeBackboneDocumentIndexCommitInput(input, nativeDocumentIndexCommit),
@@ -2211,14 +2336,14 @@ let Documents = (() => {
                     if (this.isNativeMode()) {
                         throw this.nativeModeError("requires payload-backed put operations");
                     }
-                    return mapMaybePromise(trustedLog.appendLocallyPrepared(input.operation, appendOptions, appendProperties), (appended) => this.createNativeCheckedDocumentAppendCommitFacts(input, appended, committedNativeDocumentIndex));
+                    return mapMaybePromise(trustedLog.appendLocallyPrepared(input.operation, appendOptions, appendProperties), (appended) => runAfterDocumentCommit(input.options, appended.appendCommit.hash, () => this.createNativeCheckedDocumentAppendCommitFacts(input, appended, committedNativeDocumentIndex)));
                 }
                 const commitOnlyAppend = this.isNativeMode()
                     ? trustedLog.appendStrictNativeDocumentPayloadCommitOnly(input.operationPayloadBytes, appendOptions, appendProperties)
                     : trustedLog.appendLocallyPreparedPayloadCommitOnly(input.operationPayloadBytes, appendOptions, appendProperties);
                 return mapMaybePromise(commitOnlyAppend, (commitOnly) => {
                     if (commitOnly) {
-                        return this.createNativeCheckedDocumentAppendCommitFacts(input, commitOnly, committedNativeDocumentIndex);
+                        return runAfterDocumentCommit(input.options, commitOnly.appendCommit.hash, () => this.createNativeCheckedDocumentAppendCommitFacts(input, commitOnly, committedNativeDocumentIndex));
                     }
                     if (this.isNativeMode()) {
                         throw this.nativeModeError("requires native payload commit-only append");
@@ -2296,16 +2421,24 @@ let Documents = (() => {
                 appended = await trustedLog.appendLocallyPreparedPayload(input.operationPayloadBytes, appendOptions, appendProperties);
             }
             catch (error) {
-                if (!(error instanceof Error) ||
+                if (appendProperties.localCommitEvidence?.committedHashes.size ||
+                    !(error instanceof Error) ||
                     error.message !==
                         "appendLocallyPrepared payload-only path requires native append support") {
                     throw error;
                 }
                 appended = await trustedLog.appendLocallyPrepared(new PutOperation({ data: input.documentBytes }), appendOptions, appendProperties);
             }
-            return this.createDocumentAppendCommitFacts(input, appended, nativeBackboneDocumentIndex);
+            return await runAfterDocumentCommit(input.options, appended.appendCommit.hash, () => this.createDocumentAppendCommitFacts(input, appended, nativeBackboneDocumentIndex));
         }
         async commitNativeDocumentAppendMany(input) {
+            if (!hasPersistedDelivery(input.options)) {
+                return this.commitNativeDocumentAppendManyWithEvidence(input, undefined);
+            }
+            const localCommitEvidence = { committedHashes: new Set() };
+            return await runWithTrustedLocalCommitEvidence(input.options, localCommitEvidence, () => this.commitNativeDocumentAppendManyWithEvidence(input, localCommitEvidence));
+        }
+        async commitNativeDocumentAppendManyWithEvidence(input, localCommitEvidence) {
             const trustedLog = asTrustedDocumentSharedLog(this.log);
             const nativeBackboneDocumentIndexes = await this.prepareNativeBackboneDocumentIndexCommitBatch(input.puts);
             const nativeBackboneDocumentIndexInputs = nativeBackboneDocumentIndexes?.map((commit, index) => this.toNativeBackboneDocumentIndexCommitInput(input.puts[index], commit, input.useNativeExistingDocumentContext === true));
@@ -2324,14 +2457,12 @@ let Documents = (() => {
                 }
                 return [next];
             });
-            const appended = await trustedLog.appendLocallyPreparedPayloadsManyIndependent(input.puts.map((put) => put.operationPayloadBytes), {
-                ...input.options,
-                replicate: input.options?.replicate,
-            }, {
+            const appended = await trustedLog.appendLocallyPreparedPayloadsManyIndependent(input.puts.map((put) => put.operationPayloadBytes), withoutPersistedDelivery(input.options), {
                 resolveTrimmedEntries: input.resolveTrimmedEntries,
                 nexts,
                 nativeBackboneDocumentIndexes: nativeBackboneDocumentIndexInputs,
                 retainMaterializationBytes: this._hasLogTrim,
+                ...(localCommitEvidence ? { localCommitEvidence } : undefined),
             });
             if (!appended) {
                 if (this.isNativeMode()) {
@@ -2339,36 +2470,38 @@ let Documents = (() => {
                 }
                 return undefined;
             }
-            const appendInputs = input.puts.map((put, index) => ({
-                input: nativeBackboneDocumentIndexes?.[index]
-                    ? {
-                        ...put,
-                        nativeBackboneDocumentIndex: nativeBackboneDocumentIndexes[index],
-                    }
-                    : put,
-                appended: (() => {
-                    const materializeEntry = appended.materializeEntries?.[index];
-                    let entry;
-                    return {
-                        get entry() {
-                            return (entry ??= materializeEntry
-                                ? materializeEntry()
-                                : appended.entries[index]);
-                        },
-                        removed: [],
-                        appendCommit: appended.appendCommits[index],
-                    };
-                })(),
-            }));
-            const commits = await this.createDocumentAppendCommitFactsBatch(appendInputs);
-            let entries;
-            return {
-                get entries() {
-                    return (entries ??= commits.map((commit) => commit.entry));
-                },
-                removed: appended.removed,
-                commits,
-            };
+            return await runAfterDocumentCommit(input.options, () => appended.appendCommits.map((commit) => commit.hash), async () => {
+                const appendInputs = input.puts.map((put, index) => ({
+                    input: nativeBackboneDocumentIndexes?.[index]
+                        ? {
+                            ...put,
+                            nativeBackboneDocumentIndex: nativeBackboneDocumentIndexes[index],
+                        }
+                        : put,
+                    appended: (() => {
+                        const materializeEntry = appended.materializeEntries?.[index];
+                        let entry;
+                        return {
+                            get entry() {
+                                return (entry ??= materializeEntry
+                                    ? materializeEntry()
+                                    : appended.entries[index]);
+                            },
+                            removed: [],
+                            appendCommit: appended.appendCommits[index],
+                        };
+                    })(),
+                }));
+                const commits = await this.createDocumentAppendCommitFactsBatch(appendInputs);
+                let entries;
+                return {
+                    get entries() {
+                        return (entries ??= commits.map((commit) => commit.entry));
+                    },
+                    removed: appended.removed,
+                    commits,
+                };
+            });
         }
         prepareNativeBackboneDocumentIndexCommitBatch(inputs) {
             if (!this._nativeBackboneDocumentIndexEnabled || inputs.length === 0) {
@@ -2659,6 +2792,40 @@ let Documents = (() => {
                 }),
             });
         }
+        finishPreparedPlainPutCommit(commit, options, handle = () => this.handlePreparedPlainPutCommit(commit)) {
+            return runAfterDocumentCommit(options, commit.append.hash, () => mapMaybePromise(handle(), () => {
+                this.keepCache?.add(commit.append.hash);
+                const persistedEntry = hasPersistedDelivery(options)
+                    ? commit.entry
+                    : undefined;
+                return {
+                    get entry() {
+                        return persistedEntry ?? commit.entry;
+                    },
+                    removed: commit.removed,
+                };
+            }));
+        }
+        finishPreparedPlainPutManyCommit(commit, options) {
+            return runAfterDocumentCommit(options, () => commit.commits.map((item) => item.append.hash), () => mapMaybePromise(this.handlePreparedPlainPutManyCommit(commit), () => {
+                for (const item of commit.commits) {
+                    this.keepCache?.add(item.append.hash);
+                }
+                const result = {
+                    get entries() {
+                        return commit.entries;
+                    },
+                    removed: commit.removed,
+                };
+                if (hasPersistedDelivery(options)) {
+                    persistedDocumentAppendDelivery.set(result, {
+                        appendCommits: commit.commits.map((item) => item.append),
+                        materializeEntries: () => commit.entries,
+                    });
+                }
+                return result;
+            }));
+        }
         handlePreparedPlainPutCommit(commit) {
             const shouldPrepareChange = this.hasDocumentChangeConsumers();
             const removedAlreadyHandled = commit.nativeBackboneDocumentIndexTrimmedHeadsProcessed === true;
@@ -2935,8 +3102,7 @@ let Documents = (() => {
             }
         }
         async handlePreparedPlainPutManyCommit(commit) {
-            if (!this.hasDocumentChangeConsumers() &&
-                commit.removed.length === 0) {
+            if (!this.hasDocumentChangeConsumers() && commit.removed.length === 0) {
                 const stored = await asTrustedDocumentIndex(this._index)._putManyPreparedNativeBackboneDocumentIndexStored(commit.commits.map((put) => {
                     const existing = put.unique || put.existing === null ? null : put.existing;
                     return {
@@ -2985,16 +3151,15 @@ let Documents = (() => {
                     encodedValueParts: put.contextualEncodedValueParts,
                 },
             })));
-            indexedDocuments ??=
-                await asTrustedDocumentIndex(this._index)._putManyPreparedNativeBackboneDocumentIndexWithContext(putsToIndex.map((put) => ({
-                    value: put.document,
-                    id: put.key,
-                    context: put.context,
-                    nativeDocumentIndex: put.nativeBackboneDocumentIndex,
-                    options: {
-                        replace: put.replace,
-                    },
-                })));
+            indexedDocuments ??= await asTrustedDocumentIndex(this._index)._putManyPreparedNativeBackboneDocumentIndexWithContext(putsToIndex.map((put) => ({
+                value: put.document,
+                id: put.key,
+                context: put.context,
+                nativeDocumentIndex: put.nativeBackboneDocumentIndex,
+                options: {
+                    replace: put.replace,
+                },
+            })));
             if (indexedDocuments) {
                 documentsChanged.added.push(...indexedDocuments);
             }
@@ -3297,6 +3462,9 @@ let Documents = (() => {
             return resolved ? resolved : undefined;
         }
         async del(id, options) {
+            if (hasPersistedDelivery(options)) {
+                throw new Error("persisted delivery is not supported for document deletes");
+            }
             return this._documentBackend.del(id, options);
         }
         async delCompatDocumentBackend(id, options) {
@@ -3481,8 +3649,7 @@ let Documents = (() => {
                                 }
                                 const existing = reference?.unique || reference?.existing === null
                                     ? null
-                                    : isReferencedAppendEntry &&
-                                        reference?.existing !== undefined
+                                    : isReferencedAppendEntry && reference?.existing !== undefined
                                         ? reference.existing
                                         : this.getNativeModeIndexedContext(key) || null;
                                 if (!this.strictHistory && existing) {