codex-overleaf-link 2.4.1 → 2.5.0

package/extension/src/page/trackedChangeCapture.js

@@ -1,8 +1,9 @@
 (function (root, factory) {
-  const api = factory();
+  const api = factory(typeof module === 'object' && module.exports
+    ? require('./trackedChangeOwnership') : root.CodexOverleafTrackedChangeOwnership);
   if (typeof module === 'object' && module.exports) module.exports = api;
   if (root) root.CodexOverleafTrackedChangeCapture = api;
-})(typeof window !== 'undefined' ? window : globalThis, function () {
+})(typeof window !== 'undefined' ? window : globalThis, function (Ownership) {
   'use strict';
 
   function create(deps = {}) {
@@ -125,11 +126,22 @@
         reason: snapshot.ready ? (snapshot.refs.length ? 'native_untracked_undo_pending_changes' : '')
           : snapshot.reason || 'native_review_unavailable' };
     }
+    const mergedPrefix = 'native-merge:';
+    const nativeKey = tuple => 'native:' + JSON.stringify(tuple);
+    const ledgerKeys = refs => refs.map(ref => ref.key).sort();
+    const { mergedInsertionScope, prepareMergedInsertionReview, nativeOwned, rangesFor, shiftedBaseline, scopeCovered } = Ownership.create({
+      fingerprint, readActiveEditorText, mergedPrefix, nativeKey, ledgerKeys
+    });
+
+
+
     function prepareTrackedChangeReview(path, refs = []) {
       const snapshot = readNativeSnapshot(path);
       const blocked = reason => ({ ...snapshot, ok: false, reason });
       if (!snapshot.ready) return blocked(snapshot.reason || 'native_review_unavailable');
       const targets = refs.filter(ref => ref.path === path), ids = new Set(targets.map(ref => ref.id));
+      if (targets.some(ref => ref.key?.startsWith(mergedPrefix)))
+        return prepareMergedInsertionReview(path, targets, snapshot);
       let expected;
       try {
         expected = targets.map(ref => {
@@ -150,19 +162,6 @@
       return { ...snapshot, ok: true, targets, ids: [...ids],
         unrelated: snapshot.refs.filter(ref => !ids.has(ref.id)) };
     }
-    function nativeOwned(ref, capture) {
-      if (ref.source !== 'native' || !Number.isSafeInteger(ref.from) || !Number.isSafeInteger(ref.to)) return false;
-      if (ref.kind === 'delete') return capture.ranges.some(range => ref.from >= range.start && ref.from <= range.end
-        && ref.textLength === range.removedLength && ref.textHash === range.removedHash && range.removedLength > 0);
-      let covered = ref.from;
-      for (const range of capture.ranges) {
-        if (range.end < covered) continue;
-        if (range.start > covered) break;
-        covered = Math.max(covered, range.end);
-        if (covered >= ref.to) return ref.to > ref.from;
-      }
-      return false;
-    }
     const identity = ref => (ref.path || '') + '\0' + ref.key;
     function diff(before, after) {
       const seen = new Set(before.map(identity));
@@ -173,34 +172,6 @@
         return true;
       });
     }
-    function rangesFor(operation, beforeContent, postContent) {
-      const patches = Array.isArray(operation.patches) && operation.patches.length
-        ? operation.patches
-        : [{ from: 0, to: beforeContent.length, insert: postContent }];
-      let delta = 0;
-      return patches.map(patch => {
-        const range = { from: patch.from, to: patch.to,
-          start: patch.from + delta, end: patch.from + delta + String(patch.insert ?? '').length,
-          removedLength: patch.to - patch.from, removedHash: fingerprint(beforeContent.slice(patch.from, patch.to)) };
-        delta += String(patch.insert ?? '').length - (patch.to - patch.from);
-        return range;
-      });
-    }
-    function shiftedBaseline(before, ranges) {
-      let overlap = false;
-      const refs = before.map(ref => {
-        const match = /^pos:(\d+):/.exec(ref.key);
-        if (!match) return ref;
-        const pos = Number(match[1]);
-        let delta = 0;
-        for (const range of ranges) {
-          if (pos >= range.from && pos < range.to) overlap = true;
-          if (pos >= range.to) delta += (range.end - range.start) - (range.to - range.from);
-        }
-        return { ...ref, key: ref.key.replace(/^pos:\d+:/, 'pos:' + (pos + delta) + ':') };
-      });
-      return { refs, overlap };
-    }
     function allowedRef(ref, capture) {
       if (ref.path !== capture.path) return false;
       if (capture.source === 'native') return nativeOwned(ref, capture);
@@ -212,16 +183,6 @@
       // insufficient to assign a new task ownership after a delayed capture.
       return Boolean(ref.id);
     }
-    function scopeCovered(refs, capture) {
-      if (capture.source === 'native') return capture.ranges.every(range => refs.some(ref =>
-        ref.from <= range.end && ref.to >= range.start));
-      const positioned = refs.filter(ref => /^pos:\d+:/.test(ref.key));
-      if (refs.some(ref => ref.id)) return true;
-      return capture.ranges.every(range => positioned.some(ref => {
-        const pos = Number(/^pos:(\d+):/.exec(ref.key)[1]);
-        return pos >= range.start && pos <= range.end;
-      }));
-    }
     async function waitForTrackedChangeDiff(before, paths, options = {}) {
       const waitMs = Math.max(0, Number(options.waitMs ?? 5000));
       const intervalMs = Math.max(1, Number(options.intervalMs ?? 180));
@@ -244,9 +205,15 @@
           if (options.capture && !allowedRef(ref, options.capture)) { filtered++; continue; }
           found.set(identity(ref), ref);
         }
+        const merged = native && lastSnapshotReady
+          ? mergedInsertionScope(options.capture, after, readActiveEditorText()) : null;
+        if (merged) { found.clear(); found.set(identity(merged.ref), merged.ref); }
         const nextSignature = after.map(ref => native ? ref.key : identity(ref)).sort().join('\n');
         if (nextSignature !== signature) { signature = nextSignature; lastChange = now(); }
         if (options.stopOnFirst && found.size) { reason = 'observed'; break; }
+        if (options.capture && now() - start >= 5000 && lastSnapshotReady && found.size
+          && now() - lastChange >= stableMs && scopeCovered(Array.from(found.values()), options.capture)
+          && afterCount < limit) { reason = 'observed'; break; }
         if (now() >= deadline) break;
         await delay(Math.min(intervalMs, deadline - now()));
       }
@@ -263,7 +230,7 @@
           source: options.capture?.source || 'dom', sourceReason }
       };
     }
-    async function captureTrackedWrite({ trackedBefore, captureBaseline, operation, beforeContent, postContent, runProjectId }) {
+    async function captureTrackedWrite({ trackedBefore, captureBaseline, operation, beforeContent, postContent, runProjectId, waitMs = 5000 }) {
       if (beforeContent === postContent) return { trackedChanges: [], capture: null };
       const ranges = rangesFor(operation, beforeContent, postContent);
       const baseline = shiftedBaseline(trackedBefore, ranges);
@@ -284,7 +251,7 @@
         capture.reason = baseline.overlap ? 'preexisting_change_overlap' : 'capture_baseline_limit';
         return { trackedChanges: [], capture };
       }
-      return observe(capture, postContent, 5000);
+      return observe(capture, postContent, Math.min(35000, Math.max(5000, Number(waitMs) || 5000)));
     }
     function validCapture(capture) {
       return capture?.version === 1 && typeof capture.path === 'string'
@@ -333,7 +300,26 @@
       if (params.capture?.runProjectId !== params.runProjectId) {
         return { ok: false, code: 'capture_project_mismatch', trackedChanges: [] };
       }
-      return observe(params.capture, params.expectedContent, 1200);
+      const capture = params.capture;
+      // An expired polling window does not erase a provable, unchanged scope.
+      // Recovery is read-only and must reconstruct the complete old/new ledger.
+      if (validCapture(capture) && capture.source === 'native'
+        && (now() >= capture.expiresAt || capture.state === 'needs_review')) {
+        const active = getActiveFilePath() === capture.path
+          && readActiveEditorText() === params.expectedContent
+          && (!deps.getProjectId || deps.getProjectId() === params.runProjectId);
+        const snapshot = active ? readNativeSnapshot(capture.path, capture.nativeDocId) : null;
+        const merged = snapshot?.ready && snapshot.acceptByIdSupported
+          ? mergedInsertionScope(capture, snapshot.refs, params.expectedContent) : null;
+        if (merged) return { ok: true, trackedChanges: [merged.ref], capture: {
+          ...capture, refs: [merged.ref], state: 'observed', reason: 'observed',
+          diagnostics: { ...capture.diagnostics, capturedCount: 1,
+            sourceReason: 'native_merged_insertion_recovered' }
+        } };
+        return { ok: false, trackedChanges: [], capture: { ...capture,
+          state: 'needs_review', reason: 'capture_merged_scope_unavailable' } };
+      }
+      return observe(capture, params.expectedContent, 1200);
     }
     return { collectTrackedChangeNodes, trackedChangeRefFromNode, collectTrackedChangeRefsForPaths,
       waitForTrackedChangeDiff, prepareTrackedChangeCapture, prepareTrackedChangeReview, prepareUntrackedUndo, getTrackedChangeCaptureStatus, captureTrackedWrite, reconcileTrackedChangeCapture };

package/extension/src/page/trackedChangeOwnership.js

@@ -0,0 +1,198 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafTrackedChangeOwnership = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  function create({ fingerprint, readActiveEditorText, mergedPrefix, nativeKey, ledgerKeys }) {
+    function parseNativeRef(ref) {
+      try {
+        if (!ref?.key?.startsWith('native:') || ref.key.length > 1024) return null;
+        const tuple = JSON.parse(ref.key.slice(7));
+        if (!Array.isArray(tuple) || tuple.length !== 5 || tuple[0] !== ref.id
+          || typeof tuple[0] !== 'string' || !tuple[0] || tuple[0].length > 256
+          || !['insert', 'delete'].includes(tuple[1])
+          || !Number.isSafeInteger(tuple[2]) || !Number.isSafeInteger(tuple[3])
+          || tuple[2] < 0 || tuple[3] < tuple[2]
+          || (tuple[1] === 'delete' && tuple[2] !== tuple[3])
+          || (tuple[1] === 'insert' && tuple[2] === tuple[3])
+          || typeof tuple[4] !== 'string' || !/^\d+:[0-9a-f]+:[0-9a-f]+$/.test(tuple[4])) return null;
+        return tuple;
+      } catch (_error) { return null; }
+    }
+
+    // An existing ID can grow when a later insertion touches an older change.
+    // Prove the entire ledger as old fragments + this run's inserted slices.
+    // Never assign ownership of the whole merged ID.
+    function mergedInsertionScope(capture, after, postContent) {
+      if (capture?.source !== 'native' || !capture.nativeDocId || !capture.runProjectId
+        || typeof postContent !== 'string' || fingerprint(postContent) !== capture.expected
+        || !Array.isArray(capture.before) || !capture.before.length || capture.before.length > 128
+        || !Array.isArray(after) || !after.length || after.length > 128
+        || !Array.isArray(capture.ranges) || !capture.ranges.length || capture.ranges.length > 64) return null;
+      const ranges = capture.ranges;
+      let delta = 0, previousFrom = -1;
+      for (const range of ranges) {
+        if (!Number.isSafeInteger(range.from) || range.from <= previousFrom || range.to !== range.from
+          || range.removedLength !== 0 || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end)
+          || range.start !== range.from + delta || range.end <= range.start || range.end > postContent.length) return null;
+        delta += range.end - range.start;
+        previousFrom = range.from;
+      }
+      let preContent = postContent;
+      for (const range of ranges.slice().reverse()) {
+        preContent = preContent.slice(0, range.start) + preContent.slice(range.end);
+      }
+      const before = capture.before.map(parseNativeRef);
+      if (before.some(tuple => !tuple)) return null;
+      const beforeKeys = before.map(nativeKey).sort();
+      if (new Set(beforeKeys).size !== beforeKeys.length) return null;
+      const preservedKeys = [];
+      for (const tuple of before) {
+        const [id, kind, from, to, hash] = tuple;
+        if (to > preContent.length
+          || (kind === 'insert' && fingerprint(preContent.slice(from, to)) !== hash)) return null;
+        // Interior edits and deletion-boundary ambiguity need a different proof.
+        if (ranges.some(range => kind === 'insert'
+          ? range.from > from && range.from < to : range.from === from)) return null;
+        const startShift = ranges.filter(range => range.from <= from)
+          .reduce((sum, range) => sum + range.end - range.start, 0);
+        const endShift = kind === 'delete' ? startShift : ranges.filter(range => range.from < to)
+          .reduce((sum, range) => sum + range.end - range.start, 0);
+        preservedKeys.push(nativeKey([id, kind, from + startShift, to + endShift, hash]));
+      }
+      preservedKeys.sort();
+      const oldIds = new Set(before.map(tuple => tuple[0]));
+      const mergedIds = new Set(), residue = [], claims = ranges.map(() => []);
+      for (const ref of after) {
+        const tuple = parseNativeRef(ref);
+        if (!tuple || ref.path !== capture.path) return null;
+        const [id, kind, from, to, hash] = tuple;
+        if (kind === 'delete') { residue.push(nativeKey(tuple)); continue; }
+        if (to > postContent.length || fingerprint(postContent.slice(from, to)) !== hash) return null;
+        let pieces = [[from, to]];
+        ranges.forEach((range, index) => {
+          const start = Math.max(from, range.start), end = Math.min(to, range.end);
+          if (start >= end) return;
+          claims[index].push([start, end]);
+          if (oldIds.has(id)) mergedIds.add(id);
+          pieces = pieces.flatMap(([left, right]) => {
+            if (range.end <= left || range.start >= right) return [[left, right]];
+            const remaining = [];
+            if (left < range.start) remaining.push([left, range.start]);
+            if (range.end < right) remaining.push([range.end, right]);
+            return remaining;
+          });
+        });
+        for (const [left, right] of pieces) {
+          residue.push(nativeKey([id, kind, left, right, fingerprint(postContent.slice(left, right))]));
+        }
+      }
+      if (!mergedIds.size || JSON.stringify(residue.sort()) !== JSON.stringify(preservedKeys)) return null;
+      for (let index = 0; index < ranges.length; index++) {
+        let cursor = ranges[index].start;
+        for (const [start, end] of claims[index].sort((a, b) => a[0] - b[0])) {
+          if (start !== cursor) return null;
+          cursor = end;
+        }
+        if (cursor !== ranges[index].end) return null;
+      }
+      const proof = [1, capture.runProjectId, capture.nativeDocId, fingerprint(preContent),
+        capture.expected, beforeKeys, ranges.map(range => [range.from, range.start, range.end]),
+        fingerprint(JSON.stringify(ledgerKeys(after)))];
+      const key = mergedPrefix + JSON.stringify(proof);
+      if (key.length > 32768) return null;
+      return {
+        ref: { key, id: [...mergedIds].sort()[0], path: capture.path,
+          label: 'This run: insertion merged with an earlier tracked change' },
+        runProjectId: capture.runProjectId, beforeKeys, preservedKeys, ranges, preContent, postContent
+      };
+    }
+
+    function prepareMergedInsertionReview(path, targets, snapshot) {
+      const blocked = reason => ({ ...snapshot, ok: false, reason });
+      if (targets.length !== 1 || !snapshot.acceptByIdSupported) return blocked('native_merged_review_unsupported');
+      const target = targets[0];
+      try {
+        if (target.key.length > 32768) return blocked('native_merged_review_invalid');
+        const proof = JSON.parse(target.key.slice(mergedPrefix.length));
+        if (!Array.isArray(proof) || proof.length !== 8 || proof[0] !== 1
+          || proof[2] !== snapshot.nativeDocId || !Array.isArray(proof[5]) || proof[5].length > 128
+          || !Array.isArray(proof[6]) || proof[6].length > 64) return blocked('native_merged_review_invalid');
+        const before = proof[5].map(key => {
+          const tuple = JSON.parse(key.slice(7));
+          return { key, id: tuple[0], path };
+        });
+        const ranges = proof[6].map(([from, start, end]) => ({
+          from, to: from, start, end, removedLength: 0
+        }));
+        const merged = mergedInsertionScope({ source: 'native', path, runProjectId: proof[1],
+          nativeDocId: proof[2], expected: proof[4], before, ranges }, snapshot.refs, readActiveEditorText());
+        if (!merged || merged.ref.key !== target.key || merged.ref.id !== target.id)
+          return blocked('native_merged_review_scope_changed');
+        return { ...snapshot, ok: true, targets, ids: [], unrelated: snapshot.refs, merged };
+      } catch (_error) { return blocked('native_merged_review_invalid'); }
+    }
+
+    function nativeOwned(ref, capture) {
+      if (ref.source !== 'native' || !Number.isSafeInteger(ref.from) || !Number.isSafeInteger(ref.to)) return false;
+      if (ref.kind === 'delete') return capture.ranges.some(range => ref.from >= range.start && ref.from <= range.end
+        && ref.textLength === range.removedLength && ref.textHash === range.removedHash && range.removedLength > 0);
+      let covered = ref.from;
+      for (const range of capture.ranges) {
+        if (range.end < covered) continue;
+        if (range.start > covered) break;
+        covered = Math.max(covered, range.end);
+        if (covered >= ref.to) return ref.to > ref.from;
+      }
+      return false;
+    }
+
+    function rangesFor(operation, beforeContent, postContent) {
+      const patches = Array.isArray(operation.patches) && operation.patches.length
+        ? operation.patches
+        : [{ from: 0, to: beforeContent.length, insert: postContent }];
+      let delta = 0;
+      return patches.map(patch => {
+        const range = { from: patch.from, to: patch.to,
+          start: patch.from + delta, end: patch.from + delta + String(patch.insert ?? '').length,
+          removedLength: patch.to - patch.from, removedHash: fingerprint(beforeContent.slice(patch.from, patch.to)) };
+        delta += String(patch.insert ?? '').length - (patch.to - patch.from);
+        return range;
+      });
+    }
+
+    function shiftedBaseline(before, ranges) {
+      let overlap = false;
+      const refs = before.map(ref => {
+        const match = /^pos:(\d+):/.exec(ref.key);
+        if (!match) return ref;
+        const pos = Number(match[1]);
+        let delta = 0;
+        for (const range of ranges) {
+          if (pos >= range.from && pos < range.to) overlap = true;
+          if (pos >= range.to) delta += (range.end - range.start) - (range.to - range.from);
+        }
+        return { ...ref, key: ref.key.replace(/^pos:\d+:/, 'pos:' + (pos + delta) + ':') };
+      });
+      return { refs, overlap };
+    }
+
+    function scopeCovered(refs, capture) {
+      if (refs.length === 1 && refs[0].key?.startsWith(mergedPrefix)) return true;
+      if (capture.source === 'native') return capture.ranges.every(range => refs.some(ref =>
+        ref.from <= range.end && ref.to >= range.start));
+      const positioned = refs.filter(ref => /^pos:\d+:/.test(ref.key));
+      if (refs.some(ref => ref.id)) return true;
+      return capture.ranges.every(range => positioned.some(ref => {
+        const pos = Number(/^pos:(\d+):/.exec(ref.key)[1]);
+        return pos >= range.start && pos <= range.end;
+      }));
+    }
+
+    return { mergedInsertionScope, prepareMergedInsertionReview, nativeOwned, rangesFor, shiftedBaseline, scopeCovered };
+  }
+
+  return { create };
+});

package/extension/src/page/trackedChangeReplay.js

@@ -0,0 +1,164 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafTrackedChangeReplay = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+
+  function create({ normalizeSafeProjectPath, applyTextPatches }) {
+  // Builds the minimal replay operations for Accept All. The replay must write
+  // only the changed fragments, never a whole-file replaceAll.
+  //
+  // Preferred source: the run's own original forward writeback operations
+  // (carrying their `patches`). After the editor-undo the document is back at
+  // the pre-write content, so those patches' `expected` slices match and
+  // re-apply cleanly.
+  //
+  // Fallback: when a path has no usable original patch operation, compute a
+  // minimal pre->post diff (trim the common prefix/suffix to a single targeted
+  // {from,to,insert} patch).
+  function buildAcceptReplayOperations(paths, expectedByPath, postByPath, appliedOperations) {
+    const patchesByPath = collectAppliedEditPatchesByPath(appliedOperations);
+    const operations = [];
+    for (const path of paths) {
+      const preContent = expectedByPath.get(path);
+      const postContent = postByPath.get(path);
+      if (typeof preContent !== 'string' || typeof postContent !== 'string') {
+        return {
+          ok: false,
+          code: 'accept_missing_run_content',
+          reason: `${path} 缺少写入前/写入后内容；Codex 没有重放本轮改动。`
+        };
+      }
+
+      // Preferred: re-apply the run's original forward patches verbatim.
+      const originalPatches = patchesByPath.get(path);
+      if (originalPatches && originalPatches.length && patchesApplyCleanly(preContent, originalPatches)) {
+        operations.push({
+          type: 'edit',
+          path,
+          patches: originalPatches,
+          reason: 'Accept tracked edit (replay untracked)'
+        });
+        continue;
+      }
+
+      // Fallback: minimal pre->post diff trimmed to a single targeted patch.
+      const diffPatch = buildMinimalDiffPatch(preContent, postContent);
+      if (!diffPatch) {
+        // pre === post: nothing to replay for this file.
+        continue;
+      }
+      operations.push({
+        type: 'edit',
+        path,
+        patches: [diffPatch],
+        reason: 'Accept tracked edit (replay untracked)'
+      });
+    }
+    return { ok: true, operations };
+  }
+
+  // Collects the per-path `patches` arrays from the run's applied edit
+  // operations. Only edit operations that actually carried `patches` are
+  // usable; whole-file replaceAll / verifiedContent operations are skipped so
+  // the replay never falls back to a whole-file write.
+  function collectAppliedEditPatchesByPath(appliedOperations) {
+    const patchesByPath = new Map();
+    for (const rawOperation of Array.isArray(appliedOperations) ? appliedOperations : []) {
+      if (!rawOperation || rawOperation.type !== 'edit') {
+        continue;
+      }
+      const path = typeof rawOperation.path === 'string'
+        ? normalizeSafeProjectPath(rawOperation.path)
+        : '';
+      if (!path || !Array.isArray(rawOperation.patches) || !rawOperation.patches.length) {
+        continue;
+      }
+      const normalized = rawOperation.patches.map(patch => ({
+        from: Number(patch?.from),
+        to: Number(patch?.to),
+        expected: String(patch?.expected ?? ''),
+        insert: String(patch?.insert ?? '')
+      }));
+      const existing = patchesByPath.get(path) || [];
+      patchesByPath.set(path, existing.concat(normalized));
+    }
+    return patchesByPath;
+  }
+
+  // Confirms a patch set re-applies cleanly against the given (pre-write) text:
+  // every patch range is valid and its `expected` slice matches.
+  function patchesApplyCleanly(text, patches) {
+    const applied = applyTextPatches(text, patches);
+    return applied.ok === true;
+  }
+
+  // Computes a single targeted {from,to,insert} patch describing the pre->post
+  // change by trimming the common prefix and suffix. Returns null when the two
+  // strings are identical.
+  function buildMinimalDiffPatch(preContent, postContent) {
+    if (preContent === postContent) {
+      return null;
+    }
+    const preLen = preContent.length;
+    const postLen = postContent.length;
+    let prefix = 0;
+    const maxPrefix = Math.min(preLen, postLen);
+    while (prefix < maxPrefix && preContent[prefix] === postContent[prefix]) {
+      prefix += 1;
+    }
+    let suffix = 0;
+    const maxSuffix = Math.min(preLen, postLen) - prefix;
+    while (
+      suffix < maxSuffix
+      && preContent[preLen - 1 - suffix] === postContent[postLen - 1 - suffix]
+    ) {
+      suffix += 1;
+    }
+    const from = prefix;
+    const to = preLen - suffix;
+    return {
+      from,
+      to,
+      expected: preContent.slice(from, to),
+      insert: postContent.slice(from, postLen - suffix)
+    };
+  }
+
+  function rebaseCheckpointPair(actualContent, expectedContent, postContent) {
+    const actual = String(actualContent ?? '');
+    const expected = String(expectedContent ?? '');
+    const post = String(postContent ?? '');
+    if (actual === post) {
+      return {
+        ok: true,
+        expectedContent: expected,
+        postContent: post,
+        prefixLength: 0,
+        suffixLength: 0
+      };
+    }
+    if (!post) {
+      return { ok: false };
+    }
+    const matchIndex = actual.indexOf(post);
+    if (matchIndex < 0 || actual.indexOf(post, matchIndex + 1) >= 0) {
+      return { ok: false };
+    }
+    const prefix = actual.slice(0, matchIndex);
+    const suffix = actual.slice(matchIndex + post.length);
+    return {
+      ok: true,
+      expectedContent: prefix + expected + suffix,
+      postContent: actual,
+      prefixLength: prefix.length,
+      suffixLength: suffix.length
+    };
+  }
+
+    return { buildAcceptReplayOperations, rebaseCheckpointPair };
+  }
+
+  return { create };
+});