@peerbit/shared-log 16.0.17 → 16.0.18

package/dist/src/index.js

@@ -2476,29 +2476,319 @@ let SharedLog = (() => {
             }
             return true;
         }
-        getPersistedDeliveryOptions(options) {
-            const delivery = options?.delivery;
-            if (typeof delivery !== "object" || delivery.reliability !== "persisted") {
-                return undefined;
+        snapshotDeliveryOptions(deliveryArgument, reliability) {
+            // Keep the selected AbortSignal object live: aborting it remains effective,
+            // while reassigning any caller field cannot change this invocation.
+            return Object.freeze({
+                reliability,
+                minAcks: deliveryArgument.minAcks,
+                requireRecipients: deliveryArgument.requireRecipients,
+                priority: deliveryArgument.priority,
+                timeout: deliveryArgument.timeout,
+                signal: deliveryArgument.signal,
+            });
+        }
+        snapshotAppendTrim(trim) {
+            const type = trim.type;
+            const filterArgument = trim.filter;
+            const filter = filterArgument
+                ? Object.freeze({
+                    canTrim: filterArgument.canTrim,
+                    cacheId: filterArgument.cacheId,
+                })
+                : undefined;
+            if (type === "time") {
+                return Object.freeze({ type, maxAge: trim.maxAge, filter });
+            }
+            if (type === "length" || type === "bytelength") {
+                return Object.freeze({
+                    type,
+                    to: trim.to,
+                    from: trim.from,
+                    filter,
+                });
             }
-            const parsed = this._parseDeliveryOptions(options?.delivery);
-            const target = options?.target;
+            throw new Error("Unsupported append trim type");
+        }
+        snapshotAppendEncryption(encryption) {
+            return asTrustedLowerLog(this.log).snapshotAppendEncryptionForTrustedCaller(encryption);
+        }
+        captureFullAppendNextStorageReader(next) {
+            if (next instanceof Entry) {
+                const getStorageBytes = next.getStorageBytes;
+                return () => Reflect.apply(getStorageBytes, next, []);
+            }
+            const candidate = next;
+            const init = candidate.init;
+            const getNext = candidate.getNext;
+            const getClock = candidate.getClock;
+            const getStorageBytes = candidate.getStorageBytes;
+            const verifySignatures = candidate.verifySignatures;
+            if (typeof init !== "function" ||
+                typeof getNext !== "function" ||
+                typeof getClock !== "function" ||
+                typeof getStorageBytes !== "function" ||
+                typeof verifySignatures !== "function") {
+                return;
+            }
+            return () => Reflect.apply(getStorageBytes, next, []);
+        }
+        snapshotFullAppendNext(next, getStorageBytes, canonicalHash) {
+            let entrySize;
+            try {
+                entrySize = next.size;
+            }
+            catch {
+                // A valid but not-yet-sized entry still has exact owned storage bytes below.
+            }
+            const createdLocally = next.createdLocally;
+            let sourceBytes = Entry.getPreparedStorageBytes(next);
+            if (!sourceBytes) {
+                try {
+                    sourceBytes = getStorageBytes();
+                }
+                catch {
+                    // Native commit-only entries intentionally keep payload/signature bytes
+                    // outside the JS Entry. They are valid sortable parents but cannot be
+                    // imported into another log as full blocks, so snapshot them below as
+                    // shallow canonical references instead.
+                    return;
+                }
+            }
+            const bytes = Uint8Array.from(sourceBytes);
+            const captured = deserialize(bytes, Entry);
+            const decodedHash = captured.hash;
+            if (decodedHash && decodedHash !== canonicalHash) {
+                throw new Error(`Explicit append next bytes did not match captured hash ${canonicalHash}`);
+            }
+            captured.hash = "";
+            Entry.prepareMultihashBytes(captured, bytes, canonicalHash);
+            captured.hash = canonicalHash;
+            captured.size = entrySize ?? bytes.byteLength;
+            captured.createdLocally = createdLocally;
+            captured.init({
+                encoding: this.log.encoding,
+                keychain: this.log.keychain,
+            });
+            return captured;
+        }
+        snapshotAppendNext(next) {
+            const hash = next.hash;
+            if (!hash) {
+                throw new Error("Explicit append next requires a canonical hash");
+            }
+            const getStorageBytes = this.captureFullAppendNextStorageReader(next);
+            if (getStorageBytes) {
+                const captured = this.snapshotFullAppendNext(next, getStorageBytes, hash);
+                if (captured)
+                    return captured;
+            }
+            const meta = next.meta;
+            const gid = meta.gid;
+            const nextHashes = [...meta.next];
+            const type = meta.type;
+            const sourceData = meta.data;
+            const data = sourceData && Uint8Array.from(sourceData);
+            const clock = meta.clock;
+            const clockId = Uint8Array.from(clock.id);
+            const sourceTimestamp = clock.timestamp;
+            const timestamp = new Timestamp({
+                wallTime: sourceTimestamp.wallTime,
+                logical: sourceTimestamp.logical,
+            });
+            const candidate = next;
+            let payloadSize = 0;
+            try {
+                const shallowPayloadSize = candidate.payloadSize;
+                if (typeof shallowPayloadSize === "number") {
+                    payloadSize = shallowPayloadSize;
+                }
+                else {
+                    const fullPayloadSize = candidate.payloadByteLength;
+                    if (typeof fullPayloadSize === "number")
+                        payloadSize = fullPayloadSize;
+                }
+            }
+            catch {
+                // Hollow native parents need only their canonical sorting/link facts.
+            }
+            const candidateHead = candidate.head;
+            const head = typeof candidateHead === "boolean" ? candidateHead : true;
+            const captured = new ShallowEntry({
+                hash,
+                payloadSize,
+                head,
+                meta: new ShallowMeta({
+                    gid,
+                    next: nextHashes,
+                    type,
+                    data,
+                    clock: new LamportClock({ id: clockId, timestamp }),
+                }),
+            });
+            Object.freeze(captured.meta.next);
+            Object.freeze(captured.meta.clock.timestamp);
+            Object.freeze(captured.meta.clock);
+            Object.freeze(captured.meta);
+            return Object.freeze(captured);
+        }
+        snapshotSupportedAppendOptions(options, delivery, includeDocumentShape, validateCapturedOptions) {
+            // Copy the finite public option surface, not arbitrary enumerable caller
+            // properties. This pins every value that the async append/document paths
+            // reread while avoiding surprising evaluation of unrelated custom getters.
+            const captured = Object.create(null);
+            const durability = options.durability;
+            const deferIndexWrite = options.deferIndexWrite;
+            const meta = options.meta;
+            const identity = options.identity;
+            const signers = options.signers;
+            const trim = options.trim;
+            const encryption = options.encryption;
+            const onChange = options.onChange;
+            const canAppend = options.canAppend;
+            const replicas = options.replicas;
+            const replicate = options.replicate;
+            const target = options.target;
+            const unique = includeDocumentShape ? options.unique : undefined;
+            const checkRemote = includeDocumentShape ? options.checkRemote : undefined;
+            if (durability !== undefined)
+                captured.durability = durability;
+            if (deferIndexWrite !== undefined) {
+                captured.deferIndexWrite = deferIndexWrite;
+            }
+            if (meta !== undefined) {
+                const capturedMetaInput = Object.create(null);
+                const type = meta.type;
+                const gidSeed = meta.gidSeed;
+                const hasData = "data" in meta;
+                const data = meta.data;
+                const timestamp = meta.timestamp;
+                const next = meta.next;
+                if (type !== undefined)
+                    capturedMetaInput.type = type;
+                if (gidSeed !== undefined)
+                    capturedMetaInput.gidSeed = gidSeed;
+                if (hasData)
+                    capturedMetaInput.data = data;
+                if (timestamp !== undefined)
+                    capturedMetaInput.timestamp = timestamp;
+                if (next !== undefined)
+                    capturedMetaInput.next = next;
+                captured.meta = capturedMetaInput;
+            }
+            if (identity !== undefined)
+                captured.identity = identity;
+            if (signers !== undefined)
+                captured.signers = signers;
+            if (trim !== undefined)
+                captured.trim = trim;
+            if (encryption !== undefined)
+                captured.encryption = encryption;
+            if (onChange !== undefined)
+                captured.onChange = onChange;
+            if (canAppend !== undefined)
+                captured.canAppend = canAppend;
+            if (replicas !== undefined)
+                captured.replicas = replicas;
+            if (replicate !== undefined)
+                captured.replicate = replicate;
+            if (target !== undefined)
+                captured.target = target;
+            if (delivery !== undefined)
+                captured.delivery = delivery;
+            if (includeDocumentShape) {
+                if (unique !== undefined)
+                    captured.unique = unique;
+                if (checkRemote !== undefined)
+                    captured.checkRemote = checkRemote;
+            }
+            // Strict-native Documents validates the already-captured finite surface
+            // before any accepted nested value is cloned or normalized. This keeps its
+            // mode error stable even for malformed unsupported option values, without
+            // rereading caller-owned top-level fields.
+            validateCapturedOptions?.(captured);
+            if (meta !== undefined) {
+                const capturedMetaInput = captured.meta;
+                const capturedMeta = Object.create(null);
+                if (capturedMetaInput.type !== undefined) {
+                    capturedMeta.type = capturedMetaInput.type;
+                }
+                if (capturedMetaInput.gidSeed !== undefined) {
+                    capturedMeta.gidSeed = Uint8Array.from(capturedMetaInput.gidSeed);
+                }
+                if ("data" in capturedMetaInput) {
+                    capturedMeta.data =
+                        capturedMetaInput.data && Uint8Array.from(capturedMetaInput.data);
+                }
+                if (capturedMetaInput.timestamp !== undefined) {
+                    capturedMeta.timestamp = capturedMetaInput.timestamp.clone();
+                }
+                if (capturedMetaInput.next !== undefined) {
+                    capturedMeta.next = Object.freeze(capturedMetaInput.next.map((entry) => this.snapshotAppendNext(entry)));
+                }
+                captured.meta = capturedMeta;
+            }
+            if (signers !== undefined)
+                captured.signers = [...signers];
+            if (trim !== undefined)
+                captured.trim = this.snapshotAppendTrim(trim);
+            if (encryption !== undefined) {
+                captured.encryption = this.snapshotAppendEncryption(encryption);
+            }
+            if (replicas !== undefined) {
+                captured.replicas =
+                    typeof replicas === "number"
+                        ? replicas
+                        : new AbsoluteReplicas(replicas.getValue(this));
+            }
+            return captured;
+        }
+        validatePersistedAppendInvocation(capturedOptions, delivery) {
+            this._parseDeliveryOptions(delivery);
+            const target = capturedOptions.target;
             if (target !== undefined && target !== "replicators") {
                 throw new Error('persisted delivery requires target="replicators" (or an omitted target)');
             }
-            if (parsed.delivery?.timeout != null &&
-                (!Number.isFinite(parsed.delivery.timeout) ||
-                    parsed.delivery.timeout <= 0 ||
-                    parsed.delivery.timeout > MAX_PERSISTED_DELIVERY_TIMEOUT_MS)) {
+            if (delivery.timeout != null &&
+                (!Number.isFinite(delivery.timeout) ||
+                    delivery.timeout <= 0 ||
+                    delivery.timeout > MAX_PERSISTED_DELIVERY_TIMEOUT_MS)) {
                 throw new Error(`persisted delivery timeout must be a positive number no greater than ${MAX_PERSISTED_DELIVERY_TIMEOUT_MS}`);
             }
-            if (parsed.delivery?.signal?.aborted) {
-                throw parsed.delivery.signal.reason ?? new AbortError();
+            if (delivery.signal?.aborted) {
+                throw delivery.signal.reason ?? new AbortError();
             }
-            return parsed.delivery;
         }
-        assertPersistedDeliveryOptions(options) {
-            this.getPersistedDeliveryOptions(options);
+        capturePersistedAppendInvocation(options) {
+            const deliveryArgument = options?.delivery;
+            if (typeof deliveryArgument !== "object" || deliveryArgument === null) {
+                return undefined;
+            }
+            const reliability = deliveryArgument.reliability;
+            if (reliability !== "persisted") {
+                return undefined;
+            }
+            const delivery = this.snapshotDeliveryOptions(deliveryArgument, reliability);
+            const capturedOptions = this.snapshotSupportedAppendOptions(options, delivery, false);
+            this.validatePersistedAppendInvocation(capturedOptions, delivery);
+            return { options: capturedOptions, delivery };
+        }
+        snapshotDocumentAppendOptions(options, validateCapturedOptions) {
+            if (!options)
+                return;
+            const deliveryArgument = options.delivery;
+            let delivery = deliveryArgument;
+            if (typeof deliveryArgument === "object" && deliveryArgument !== null) {
+                const reliability = deliveryArgument.reliability;
+                delivery = this.snapshotDeliveryOptions(deliveryArgument, reliability);
+            }
+            const capturedOptions = this.snapshotSupportedAppendOptions(options, delivery, true, validateCapturedOptions);
+            if (typeof delivery === "object" &&
+                delivery !== null &&
+                delivery.reliability === "persisted") {
+                this.validatePersistedAppendInvocation(capturedOptions, delivery);
+            }
+            return capturedOptions;
         }
         async _getSortedRouteHints(targetHash) {
             const pubsub = this.node.services.pubsub;
@@ -3059,16 +3349,20 @@ let SharedLog = (() => {
                 dispose: () => clearTimeout(timeout),
             };
         }
-        async planPersistedDeliveryLeaders(entries, replicas, ownershipLifecycleController) {
+        async planPersistedDeliveryLeaders(records, replicas, ownershipLifecycleController) {
             if (this.findLeadersFromEntry !== SharedLog.prototype.findLeadersFromEntry) {
                 const leaders = [];
-                for (const entry of entries) {
+                for (const record of records) {
+                    const entry = record.createFullPlanningSource?.();
+                    if (!entry) {
+                        throw new Error(`Persisted delivery requires canonical entry bytes for custom leader planning of ${record.canonicalHash}`);
+                    }
                     leaders.push(await this.findLeadersFromEntry(entry, replicas, { freshLeaderPlan: true }, ownershipLifecycleController));
                 }
                 return leaders;
             }
-            const items = entries.map((entry) => ({
-                entry,
+            const items = records.map((record) => ({
+                entry: record.createDefaultPlanningSource(),
                 replicas,
                 options: { freshLeaderPlan: true, persist: false },
             }));
@@ -3100,13 +3394,13 @@ let SharedLog = (() => {
         }
         async settlePersistedDelivery(input, replicas, delivery, ownershipLifecycleController = this.captureReplicationOwnershipLifecycle(), persistedDeadline, transferOnFirstRound = false) {
             const minAcks = Math.floor(delivery.minAcks);
-            const entries = new Map(input.map((entry) => [entry.hash, entry]));
-            if (entries.size === 0)
+            const records = new Map(input.map((record) => [record.canonicalHash, record]));
+            if (records.size === 0)
                 return;
-            const committedHashes = [...entries.keys()];
+            const committedHashes = [...records.keys()];
             const ownedDeadline = !persistedDeadline;
             const deadline = persistedDeadline ??
-                this.createPersistedDeliveryDeadline(delivery, ownershipLifecycleController, entries.size);
+                this.createPersistedDeliveryDeadline(delivery, ownershipLifecycleController, records.size);
             const signal = deadline.signal;
             let maxAttemptMs = MAX_PERSISTED_RECEIPT_ATTEMPT_MS;
             let initialTransferPending = transferOnFirstRound;
@@ -3155,7 +3449,7 @@ let SharedLog = (() => {
                     // transport epoch. A revision/session change purges them before they can
                     // survive an away-and-back leader transition or combine with a later peer.
                     const hashesByPeer = new Map();
-                    const entryArray = [...entries.values()];
+                    const entryArray = [...records.values()];
                     const leadersByEntry = await this.planPersistedDeliveryLeaders(entryArray, replicas, ownershipLifecycleController);
                     if (!isRoundOwnershipCurrent())
                         continue;
@@ -3168,7 +3462,7 @@ let SharedLog = (() => {
                         }
                     }
                     for (let index = 0; index < entryArray.length; index++) {
-                        const hash = entryArray[index].hash;
+                        const hash = entryArray[index].canonicalHash;
                         const leaders = leadersByEntry[index];
                         if (signal.aborted) {
                             throw signal.reason ?? new AbortError();
@@ -3405,7 +3699,7 @@ let SharedLog = (() => {
                                     }
                                     return false;
                                 }
-                                const hash = entryArray[index].hash;
+                                const hash = entryArray[index].canonicalHash;
                                 const leaders = validatedLeaders[index];
                                 let valid = 0;
                                 const acknowledgements = carriedAcknowledgements.get(hash);
@@ -7545,19 +7839,29 @@ let SharedLog = (() => {
         }
         async append(data, options) {
             this.throwIfNativeDurableCommitFailed();
-            const persistedDelivery = this.getPersistedDeliveryOptions(options);
+            const persistedInvocation = this.capturePersistedAppendInvocation(options);
+            options = persistedInvocation?.options ?? options;
+            const persistedDelivery = persistedInvocation?.delivery;
             const ownershipLifecycleController = this.captureReplicationOwnershipLifecycle();
             if (this._isAdaptiveReplicating) {
                 this.markLocalAppendActivity();
             }
             const { appendOptions, minReplicasValue } = this.createLogAppendOptions(options, ownershipLifecycleController);
             let committedHashes;
+            let persistedAppendCommit;
+            let persistedPlanningRecord;
             if (persistedDelivery) {
-                appendOptions.__peerbitOnLocalCommit = (hashes) => {
+                appendOptions.__peerbitOnLocalCommit = (hashes, entries) => {
                     // The lower log reports the exact hashes immediately after their
-                    // irreversible local mutation and before entry initialization, trim,
-                    // or change callbacks can reject the append.
-                    committedHashes = hashes;
+                    // irreversible local mutation and before trim/change callbacks. Own the
+                    // canonical hash first, then detach all planning facts and storage bytes
+                    // synchronously so callback mutation cannot retarget the later quorum.
+                    committedHashes = Object.freeze([...hashes]);
+                    if (hashes.length !== 1 || entries?.length !== 1) {
+                        throw new Error("Persisted delivery requires exact lower-log entry commit evidence");
+                    }
+                    persistedAppendCommit = this.capturePersistedLocalAppendCommit(hashes[0], entries[0]);
+                    persistedPlanningRecord = this.createPersistedDeliveryPlanningRecord(persistedAppendCommit);
                 };
             }
             let persistedDeadline;
@@ -7568,19 +7872,23 @@ let SharedLog = (() => {
             };
             try {
                 const result = await this.log.append(data, appendOptions);
-                committedHashes ??= [result.entry.hash];
+                if (persistedDelivery && (!committedHashes || !persistedPlanningRecord)) {
+                    throw new Error("Lower log did not provide persisted-delivery commit evidence");
+                }
                 persistedDeadline = persistedDelivery
                     ? this.createPersistedDeliveryDeadline(persistedDelivery, ownershipLifecycleController, 1)
                     : undefined;
                 this.throwIfReplicationOwnershipLifecycleInactive(ownershipLifecycleController);
                 throwIfDeliveryAborted();
-                await this.processLocalAppend(result.entry, result.removed, options, {
+                const processingEntry = persistedPlanningRecord?.createFullPlanningSource?.() ?? result.entry;
+                await this.processLocalAppend(processingEntry, result.removed, options, {
                     minReplicasValue,
+                    appendFacts: persistedAppendCommit,
                     ownershipLifecycleController,
                 });
                 throwIfDeliveryAborted();
                 if (persistedDelivery && persistedDeadline) {
-                    await this.settlePersistedDelivery([result.entry], minReplicasValue, persistedDelivery, ownershipLifecycleController, persistedDeadline);
+                    await this.settlePersistedDelivery([persistedPlanningRecord], minReplicasValue, persistedDelivery, ownershipLifecycleController, persistedDeadline);
                 }
                 this.throwIfReplicationOwnershipLifecycleInactive(ownershipLifecycleController);
                 return result;
@@ -7596,7 +7904,7 @@ let SharedLog = (() => {
             }
         }
         rejectPersistedDeliveryOnTrustedLocalAppend(options) {
-            if (this.getPersistedDeliveryOptions(options)) {
+            if (this.capturePersistedAppendInvocation(options)) {
                 throw new Error("trusted local append paths require delivery=false; call deliverPersistedEntries after the local commit");
             }
         }
@@ -9544,7 +9852,7 @@ let SharedLog = (() => {
         }
         async appendMany(data, options) {
             this.throwIfNativeDurableCommitFailed();
-            const persistedDelivery = this.getPersistedDeliveryOptions(options);
+            const persistedDelivery = this.capturePersistedAppendInvocation(options);
             if (data.length === 0) {
                 return { entries: [], removed: [] };
             }
@@ -9599,13 +9907,16 @@ let SharedLog = (() => {
          * higher-level transactional/batched writers so a receipt timeout never
          * rolls back or hides their successful local commit.
          */
-        async deliverPersistedPlanningEntries(resolveEntries, committedHashes, options) {
+        async deliverPersistedPlanningEntries(resolveRecords, committedHashesInput, options) {
+            const committedHashes = Object.freeze([...committedHashesInput]);
             let persistedDeadline;
             try {
-                const delivery = this.getPersistedDeliveryOptions(options);
-                if (!delivery) {
+                const persistedInvocation = this.capturePersistedAppendInvocation(options);
+                if (!persistedInvocation) {
                     throw new Error('deliverPersistedEntries requires reliability="persisted"');
                 }
+                options = persistedInvocation.options;
+                const delivery = persistedInvocation.delivery;
                 const ownershipLifecycleController = this.captureReplicationOwnershipLifecycle();
                 const deadline = this.createPersistedDeliveryDeadline(delivery, ownershipLifecycleController, committedHashes.length);
                 persistedDeadline = deadline;
@@ -9617,13 +9928,21 @@ let SharedLog = (() => {
                         throw new TimeoutError(`Timed out waiting for ${Math.floor(delivery.minAcks)} persisted remote replicas.`);
                     }
                 };
-                const entries = resolveEntries();
+                const records = resolveRecords();
                 throwIfDeliveryAborted();
-                if (entries.length === 0)
+                if (records.length !== committedHashes.length) {
+                    throw new Error("Persisted delivery planning evidence count mismatch");
+                }
+                for (let index = 0; index < records.length; index++) {
+                    if (records[index].canonicalHash !== committedHashes[index]) {
+                        throw new Error(`Persisted delivery planning evidence did not match committed hash ${committedHashes[index]}`);
+                    }
+                }
+                if (records.length === 0)
                     return;
                 const { minReplicasValue } = this.createLogAppendOptions(options, ownershipLifecycleController);
                 throwIfDeliveryAborted();
-                await this.settlePersistedDelivery(entries, minReplicasValue, delivery, ownershipLifecycleController, deadline, true);
+                await this.settlePersistedDelivery(records, minReplicasValue, delivery, ownershipLifecycleController, deadline, true);
             }
             catch (error) {
                 throw new PersistedDeliveryError(error, committedHashes);
@@ -9632,29 +9951,32 @@ let SharedLog = (() => {
                 persistedDeadline?.dispose();
             }
         }
-        createPersistedDeliveryPlanningEntries(appendCommits, materializeEntries) {
+        createPersistedDeliveryPlanningRecords(appendCommits, materializeEntries) {
             let materializedEntries;
             const requiresFullEntries = this.findLeadersFromEntry !== SharedLog.prototype.findLeadersFromEntry;
-            const getMaterializedEntry = (appendCommit, index) => {
+            const getCommittedEntry = (appendCommit, index) => {
                 materializedEntries ??= materializeEntries();
                 const entry = materializedEntries[index];
-                if (!entry || entry.hash !== appendCommit.hash) {
+                const materializedHash = entry?.hash;
+                if (!entry || materializedHash !== appendCommit.hash) {
                     throw new Error(`Persisted delivery materializer did not return committed entry ${appendCommit.hash}`);
                 }
                 return entry;
             };
             return appendCommits.map((appendCommit, index) => {
-                if (!requiresFullEntries && appendCommit.coordinateFields) {
-                    return this._coordinates.materializeResidentCoordinateEntry(appendCommit.coordinateFields);
+                let capturedCommit = this.snapshotPreparedLocalAppendCommit(appendCommit);
+                if (requiresFullEntries && !capturedCommit.storageBytes) {
+                    capturedCommit = this.capturePersistedLocalAppendCommit(capturedCommit.hash, getCommittedEntry(capturedCommit, index));
                 }
-                return getMaterializedEntry(appendCommit, index);
+                return this.createPersistedDeliveryPlanningRecord(capturedCommit);
             });
         }
         deliverPersistedAppendCommits(appendCommits, materializeEntries, options) {
-            return this.deliverPersistedPlanningEntries(() => this.createPersistedDeliveryPlanningEntries(appendCommits, materializeEntries), appendCommits.map((appendCommit) => appendCommit.hash), options);
+            return this.deliverPersistedPlanningEntries(() => this.createPersistedDeliveryPlanningRecords(appendCommits, materializeEntries), appendCommits.map((appendCommit) => appendCommit.hash), options);
         }
         async deliverPersistedEntries(entries, options) {
-            return this.deliverPersistedPlanningEntries(() => entries, entries.map((entry) => entry.hash), options);
+            const records = entries.map((entry) => this.snapshotPersistedDeliveryPlanningEntry(entry));
+            return this.deliverPersistedPlanningEntries(() => records, records.map((record) => record.canonicalHash), options);
         }
         canCoalesceLocalAppendMany(entries, options) {
             if (entries.length <= 1 ||
@@ -10259,7 +10581,11 @@ let SharedLog = (() => {
                 next: entry.meta.next,
                 wallTime: entry.meta.clock.timestamp.wallTime,
                 logical: entry.meta.clock.timestamp.logical,
+                clockId: entry.meta.clock.id,
+                type: entry.meta.type,
+                metaData: entry.meta.data,
                 payloadSize: entry.payload.byteLength,
+                entrySize: entry.size,
                 metaBytes: entry.getMetaBytes?.(),
                 hashNumber: nativeAppendPlan?.hashNumber,
                 coordinateFields: nativeAppendPlan?.preparedCoordinate.fields,
@@ -10272,6 +10598,9 @@ let SharedLog = (() => {
                 next: appendFacts.next,
                 wallTime: appendFacts.wallTime,
                 logical: appendFacts.logical,
+                clockId: appendFacts.clockId,
+                type: appendFacts.type,
+                metaData: appendFacts.metaData,
                 payloadSize: appendFacts.payloadSize,
                 metaBytes: appendFacts.metaBytes,
                 hashNumber: nativeAppendPlan?.hashNumber,
@@ -10279,6 +10608,109 @@ let SharedLog = (() => {
                     nativeAppendPlan?.preparedCoordinate?.fields,
             };
         }
+        snapshotPreparedLocalAppendCommit(appendCommit) {
+            const coordinateFields = appendCommit.coordinateFields;
+            return Object.freeze({
+                ...appendCommit,
+                next: [...appendCommit.next],
+                clockId: appendCommit.clockId && Uint8Array.from(appendCommit.clockId),
+                metaData: appendCommit.metaData && Uint8Array.from(appendCommit.metaData),
+                metaBytes: appendCommit.metaBytes && Uint8Array.from(appendCommit.metaBytes),
+                storageBytes: appendCommit.storageBytes && Uint8Array.from(appendCommit.storageBytes),
+                coordinateFields: coordinateFields
+                    ? {
+                        ...coordinateFields,
+                        coordinates: [...coordinateFields.coordinates],
+                        coordinateStrings: coordinateFields.coordinateStrings && [
+                            ...coordinateFields.coordinateStrings,
+                        ],
+                        metaBytes: Uint8Array.from(coordinateFields.metaBytes),
+                    }
+                    : undefined,
+                documentPreviousContext: appendCommit.documentPreviousContext
+                    ? { ...appendCommit.documentPreviousContext }
+                    : undefined,
+            });
+        }
+        capturePersistedLocalAppendCommit(canonicalHash, entry) {
+            const sourceHash = entry.hash;
+            if (sourceHash !== canonicalHash) {
+                throw new Error(`Lower-log commit evidence entry did not match committed hash ${canonicalHash}`);
+            }
+            const storageBytes = Entry.getPreparedStorageBytes(entry) ?? entry.getStorageBytes();
+            return this.snapshotPreparedLocalAppendCommit({
+                ...this.createPreparedLocalAppendCommit(entry),
+                hash: canonicalHash,
+                storageBytes,
+            });
+        }
+        createPersistedDeliveryPlanningRecord(appendCommitInput) {
+            // Callers hand this helper an invocation-owned snapshot. Do not duplicate
+            // full entry bytes here; a fresh copy is made only when a custom planner is
+            // actually invoked (and again for each replan so planner mutation cannot
+            // persist between rounds).
+            const appendCommit = appendCommitInput;
+            const canonicalHash = appendCommit.hash;
+            const coordinateFields = appendCommit.coordinateFields;
+            const createDefaultPlanningSource = coordinateFields
+                ? () => this._coordinates.materializeResidentCoordinateEntry({
+                    ...coordinateFields,
+                    coordinates: [...coordinateFields.coordinates],
+                    coordinateStrings: coordinateFields.coordinateStrings && [
+                        ...coordinateFields.coordinateStrings,
+                    ],
+                    metaBytes: Uint8Array.from(coordinateFields.metaBytes),
+                })
+                : () => new ShallowEntry({
+                    hash: canonicalHash,
+                    head: true,
+                    payloadSize: appendCommit.payloadSize,
+                    meta: new ShallowMeta({
+                        gid: appendCommit.gid,
+                        next: [...appendCommit.next],
+                        type: appendCommit.type ?? EntryType.APPEND,
+                        data: appendCommit.metaData && Uint8Array.from(appendCommit.metaData),
+                        clock: new LamportClock({
+                            id: Uint8Array.from(appendCommit.clockId ?? new Uint8Array()),
+                            timestamp: new Timestamp({
+                                wallTime: appendCommit.wallTime,
+                                logical: appendCommit.logical,
+                            }),
+                        }),
+                    }),
+                });
+            const storageBytes = appendCommit.storageBytes;
+            const createFullPlanningSource = storageBytes
+                ? () => {
+                    const bytes = Uint8Array.from(storageBytes);
+                    const entry = deserialize(bytes, Entry);
+                    const decodedHash = entry.hash;
+                    if (decodedHash && decodedHash !== canonicalHash) {
+                        throw new Error(`Persisted delivery planning bytes did not match committed hash ${canonicalHash}`);
+                    }
+                    if (!decodedHash) {
+                        Entry.prepareMultihashBytes(entry, bytes, canonicalHash);
+                        entry.hash = canonicalHash;
+                    }
+                    entry.size = appendCommit.entrySize ?? bytes.byteLength;
+                    entry.createdLocally = true;
+                    entry.init({
+                        encoding: this.log.encoding,
+                        keychain: this.log.keychain,
+                    });
+                    return entry;
+                }
+                : undefined;
+            return Object.freeze({
+                canonicalHash,
+                createDefaultPlanningSource,
+                createFullPlanningSource,
+            });
+        }
+        snapshotPersistedDeliveryPlanningEntry(value) {
+            const canonicalHash = value.hash;
+            return this.createPersistedDeliveryPlanningRecord(this.capturePersistedLocalAppendCommit(canonicalHash, value));
+        }
         createPreparedLocalAppendCommits(entries, nativeAppendPlans) {
             return entries.map((entry, index) => this.createPreparedLocalAppendCommit(entry, nativeAppendPlans?.[index]));
         }