codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/shared/writebackSettlement.js

@@ -4,28 +4,42 @@
       require('./failureReasons'),
       require('./settlementFacts'),
       require('./writebackEvidenceProjection'),
-      require('./writebackOperationEvidence')
+      require('./writebackOperationEvidence'),
+      require('./undoOperations')
     );
   } else {
     root.CodexOverleafModuleRegistry.define('WritebackSettlement', [
       'FailureReasons',
       'SettlementFacts',
       'WritebackEvidenceProjection',
-      'WritebackOperationEvidence'
+      'WritebackOperationEvidence',
+      'UndoOperations'
     ], factory);
   }
 })(typeof window !== 'undefined' ? window : globalThis, function writebackSettlementFactory(
   DefaultFailureReasons,
   SettlementFacts,
   EvidenceProjection,
-  OperationEvidence
+  OperationEvidence,
+  UndoOperations
 ) {
   'use strict';
 
   const SETTLEMENT_FACTS_MAX_BYTES = SettlementFacts.SETTLEMENT_FACTS_MAX_BYTES;
   const RECOVERY_FIELDS = SettlementFacts.RECOVERY_FIELDS;
   const compactSettlementFacts = SettlementFacts.compactSettlementFacts;
-  const projectRunSettlement = SettlementFacts.projectRunSettlement;
+  function projectRunSettlement(run = {}) {
+    const projection = SettlementFacts.projectRunSettlement(run);
+    const undoUnavailable = UndoOperations.getUndoUnavailableFiles(run);
+    if (!undoUnavailable.length) return projection;
+    const payload = UndoOperations.withAvailableUndo(run.recoveryPayload || run);
+    // Forward receipts remain audit evidence, not fallback Undo authority for
+    // a run whose inverse checkpoint could not be safely composed.
+    const available = SettlementFacts.projectRunSettlement({ ...run,
+      recoveryPayload: { ...payload, appliedOperations: [] } });
+    return { ...projection, canUndo: available.canUndo, undoUnavailable,
+      actions: { ...projection.actions, undo: available.canUndo } };
+  }
   const deriveLegacyProjection = SettlementFacts.deriveLegacyProjection;
   const aggregateFileSettlements = EvidenceProjection.aggregateFileSettlements;
   const deriveAppliedEvidence = EvidenceProjection.deriveAppliedEvidence;
@@ -212,7 +226,7 @@
   }
 
   function deriveSettledEvidence(primaryFailure, fileSettlements = []) {
-    if (primaryFailure?.terminalState === 'needs_review'
+    if (primaryFailure?.terminalState === 'needs_review' || DefaultFailureReasons.isUnconfirmedWriteFailure?.(primaryFailure)
       || fileSettlements.some(file => file.readBack === 'mismatch')) {
       return 'needs-review';
     }
@@ -294,7 +308,8 @@
     // Both actions cover every targeted file. Partial success must retain
     // the original recovery material for unresolved siblings.
     const incomplete = collectRunResultSkipped(input.result).length > 0
-      || input.result?.ok === false;
+      || input.result?.ok === false
+      || (kind === 'reject' && UndoOperations.getUndoUnavailableFiles(input.run).length > 0);
     const needsReview = incomplete || !successful || failures.some(failure =>
       failure.terminalState === 'needs_review' || reviewCodes.has(failure.code)
     );
@@ -336,7 +351,9 @@
   }
 
   function settleLegacyUndo(input = {}) {
-    const status = input.status === 'applied' ? 'applied' : 'partial';
+    const status = input.status === 'applied'
+      && !UndoOperations.getUndoUnavailableFiles(input.run).length
+      && isUndoResultEffectivelyApplied(input.run, input.result, input.run?.undoOperations) ? 'applied' : 'partial';
     const recovery = preserveRecovery();
     return {
       statePatch: { undoStatus: status },
@@ -441,7 +458,8 @@
   }
 
   function isUndoResultEffectivelyApplied(run, result, undoOperations = []) {
-    if (!result?.skipped?.length) return true;
+    if (result?.saveVerification?.ok === false || result?.receiptUnconfirmed === true) return false;
+    if (!result?.skipped?.length) return result?.ok === true;
     const expectedByPath = new Map((run?.undoExpectedFiles || [])
       .filter(file => file?.path && typeof file.content === 'string')
       .map(file => [normalizeSettlementPath(file.path), file.content])
@@ -467,10 +485,12 @@
     if (entry?.operation?.type === 'edit' && operationPath === normalizedPath) {
       return inner.verifiedContent === expectedContent;
     }
-
     const trackedPath = normalizeSettlementPath(entry?.trackedChange?.path);
     if (trackedPath !== normalizedPath) return false;
     const key = String(entry?.trackedChange?.key || '');
+    if (['overleaf-review-reject', 'overleaf-review-reject-sweep'].includes(inner.method))
+      return /^(?:id:|pos:|sig:)/.test(key) && inner.verified === true
+        && inner.verifiedContent === expectedContent;
     if (key === `editor-undo:${normalizedPath}`) {
       return inner.method === 'overleaf-editor-undo'
         && inner.verified === true
@@ -492,14 +512,12 @@
     }
     return false;
   }
-
   function normalizeSettlementPath(value) {
     return String(value || '')
       .replace(/\\/g, '/')
       .replace(/\/+/g, '/')
       .replace(/^\/+|\/+$/g, '');
   }
-
   function attachAcceptNotVerifiedFailure(run, result, options = {}) {
     if (!result || typeof result !== 'object' || result.ok === false) return result;
     if (Array.isArray(result.skipped) && result.skipped.length > 0) return result;
@@ -580,8 +598,9 @@
       const inner = entry?.result || entry;
       if (!inner || inner.ok === true) continue;
       const operation = entry?.operation || (entry?.trackedChange ? { path: entry.trackedChange.path } : undefined);
-      failures.push(failureReasons?.normalizeFailureReason instanceof Function
-        ? failureReasons.normalizeFailureReason(inner, operation)
+      const normalize = failureReasons?.normalizeWritebackFailure || failureReasons?.normalizeFailureReason;
+      failures.push(normalize instanceof Function
+        ? normalize(inner, operation)
         : normalizeFailure(inner, operation));
     }
     return failures.filter(Boolean);
@@ -630,9 +649,27 @@
 
   function attachVerifiedContentToOperation(operation, result) {
     if (!operation || typeof operation !== 'object') return operation;
-    return operation.type === 'edit' && typeof result?.verifiedContent === 'string'
-      ? { ...operation, verifiedContent: result.verifiedContent }
-      : operation;
+    const createdDirectories = (Array.isArray(result?.createdDirectories) ? result.createdDirectories
+      : Array.isArray(result?.moveProof?.createdDirectories) ? result.moveProof.createdDirectories : [])
+      .filter(proof => proof?.v === 1 && typeof proof.projectId === 'string' && proof.projectId
+        && typeof proof.path === 'string' && proof.path && !proof.path.split('/').some(part => !part || part === '.' || part === '..')
+        && typeof proof.nativeFolderId === 'string')
+      .map(proof => ({ v: 1, projectId: proof.projectId, path: proof.path, nativeFolderId: proof.nativeFolderId,
+        ownershipConfirmed: false, observedAfterCreate: proof.observedAfterCreate === true }));
+    const rawMove = result?.moveProof;
+    const moveProof = rawMove?.v === 1 && ['text', 'binary'].includes(rawMove.kind) && /^[a-f0-9]{64}$/i.test(rawMove.sha256 || '')
+      && typeof rawMove.sourceEntityId === 'string' && rawMove.sourceEntityId
+      && typeof rawMove.targetEntityId === 'string' && rawMove.targetEntityId
+      ? { v: 1, kind: rawMove.kind, sha256: rawMove.sha256.toLowerCase(), sourceEntityId: rawMove.sourceEntityId,
+        targetEntityId: rawMove.targetEntityId, ...(['doc', 'file'].includes(rawMove.entityType) ? { entityType: rawMove.entityType } : {}), ...(createdDirectories.length ? { createdDirectories } : {}) } : null;
+    if (!(operation.type === 'edit' && typeof result?.verifiedContent === 'string') && !createdDirectories.length && !moveProof) return operation;
+    return { ...operation, ...(operation.type === 'edit' && typeof result?.verifiedContent === 'string' ? {
+      verifiedContent: result.verifiedContent,
+      ...(result.ok === true && result.verified === true && Array.isArray(result.appliedPatches)
+        ? { appliedPatches: result.appliedPatches.map(patch => ({ from: patch.from, to: patch.to,
+          expected: String(patch.expected ?? ''), insert: String(patch.insert ?? '') })) } : {})
+    } : {}),
+      ...(createdDirectories.length ? { createdDirectories } : {}), ...(moveProof ? { moveProof } : {}) };
   }
 
   function selectExpectedFilesForTrackedUndo(
@@ -641,26 +678,7 @@
     trackedChanges = [],
     previousExpectedFiles = []
   ) {
-    const paths = new Set();
-    for (const change of trackedChanges || []) {
-      if (change?.path) paths.add(change.path);
-    }
-    for (const operation of operations || []) {
-      if (operation?.path) paths.add(operation.path);
-      if (operation?.to) paths.add(operation.to);
-    }
-    const expectedByPath = new Map();
-    for (const file of previousExpectedFiles || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    for (const file of project?.files || []) {
-      if (paths.has(file?.path) && typeof file?.content === 'string' && !expectedByPath.has(file.path)) {
-        expectedByPath.set(file.path, { path: file.path, content: file.content });
-      }
-    }
-    return Array.from(expectedByPath.values());
+    return UndoOperations.selectExpectedFilesForTrackedUndo(project, operations, trackedChanges, previousExpectedFiles);
   }
 
   function acceptDiagnosticStatus(step, info) {
@@ -674,10 +692,9 @@
     return 'info';
   }
 
-  function selectPrimaryFailure(failures, failureReasons) {
-    return failureReasons?.selectPrimaryFailure instanceof Function
-      ? failureReasons.selectPrimaryFailure(failures)
-      : failures[0] || null;
+  function selectPrimaryFailure(failures, failureReasons = DefaultFailureReasons) {
+    const select = failureReasons?.selectPrimaryWritebackFailure || failureReasons?.selectPrimaryFailure;
+    return select instanceof Function ? select(failures) : failures[0] || null;
   }
 
   function appendSyntheticFailure(result, failure, path, code, type) {
@@ -749,6 +766,7 @@
     normalizeOperationEvidence,
     normalizeSaveEvidence,
     projectRunSettlement,
+    selectPrimaryFailure,
     selectExpectedFilesForTrackedUndo,
     settle,
     settleLegacyUndo,