codex-overleaf-link 2.3.0 → 2.3.2

package/extension/src/content/sessionForkController.js

@@ -0,0 +1,120 @@
+(function initCodexOverleafSessionForkController(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafSessionForkController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function sessionForkControllerFactory() {
+  'use strict';
+
+  function create(deps = {}) {
+    const {
+      SessionState, getState, setState, sendBackgroundNative, saveState,
+      applyStateToPanel, showPluginToast, tr
+    } = deps;
+
+    async function forkRunFromNode(runId) {
+      const previousState = getState();
+      const source = findSource(previousState, runId);
+      if (!source) return failFork('session_fork_source_missing', tr('forkRunUnavailable'));
+      const { session, run, runIndex } = source;
+      if (run.status === 'running' || !session.codexThreadId || !run.codexTurnId) {
+        return failFork('session_fork_unavailable', tr('forkRunUnavailable'));
+      }
+      const response = await sendBackgroundNative({
+        method: 'codex.thread.fork',
+        params: {
+          threadId: session.codexThreadId,
+          lastTurnId: run.codexTurnId,
+          speedTier: session.speedTier,
+          loadCodexLocalSkills: previousState.loadCodexLocalSkills !== false,
+          loadCodexOverleafSkills: previousState.loadCodexOverleafSkills !== false
+        }
+      });
+      if (!response?.ok || !response.result?.threadId) {
+        return failFork(response?.error?.code || 'session_fork_failed', response?.error?.message || tr('forkRunFailed'));
+      }
+      const copiedRuns = session.runs.slice(0, runIndex + 1).map(copyRunSnapshot);
+      const titleBase = String(session.title || copiedRuns[0]?.task || tr('newSessionFallback')).trim();
+      const forkTitle = buildUniqueForkTitle(previousState.sessions, titleBase);
+      const forked = SessionState.createSession({
+        title: forkTitle,
+        titleSource: 'manual',
+        runs: copiedRuns,
+        task: '',
+        mode: session.mode,
+        providerId: session.providerId,
+        model: session.model,
+        reasoningEffort: session.reasoningEffort,
+        speedTier: session.speedTier,
+        requireReviewing: session.requireReviewing,
+        focusFiles: session.focusFiles,
+        projectReferenceFiles: session.projectReferenceFiles,
+        codexThreadId: response.result.threadId,
+        pendingInputs: [],
+        forkedFromSessionId: session.id,
+        forkedFromRunId: run.id
+      });
+      setState(SessionState.normalizePanelState({
+        ...previousState,
+        sessions: [...(previousState.sessions || []), forked],
+        activeSessionId: forked.id
+      }));
+      try {
+        await saveState();
+      } catch (error) {
+        setState(previousState);
+        await sendBackgroundNative({
+          method: 'codex.history.clearPlugin',
+          params: { sessionId: forked.id, threadId: response.result.threadId }
+        }).catch(() => null);
+        showPluginToast(error.message || tr('forkRunFailed'), { status: 'failed', sticky: true });
+        throw error;
+      }
+      applyStateToPanel();
+      showPluginToast(tr('forkRunDone'), { status: 'completed' });
+      return forked;
+    }
+
+    function failFork(code, message) {
+      showPluginToast(message, { status: 'failed', sticky: true });
+      throw codedError(code, message);
+    }
+
+    return { forkRunFromNode };
+  }
+
+  function buildUniqueForkTitle(sessions = [], sourceTitle = '') {
+    const fallback = String(sourceTitle || 'New Session').trim() || 'New Session';
+    const baseTitle = fallback
+      .replace(/\s+\(fork\)$/i, '')
+      .replace(/\s+\(\d+\)$/, '')
+      .trim() || fallback;
+    const usedTitles = new Set((sessions || []).map(session => String(session?.title || '').trim()));
+    let index = 1;
+    while (usedTitles.has(`${baseTitle} (${index})`)) index += 1;
+    return `${baseTitle} (${index})`;
+  }
+
+  function findSource(state, runId) {
+    for (const session of state?.sessions || []) {
+      const runIndex = (session.runs || []).findIndex(run => run.id === runId);
+      if (runIndex >= 0) return { session, run: session.runs[runIndex], runIndex };
+    }
+    return null;
+  }
+
+  function copyRunSnapshot(run) {
+    const copy = JSON.parse(JSON.stringify(run || {}));
+    return {
+      ...copy,
+      id: `fork_${String(copy.id || 'run')}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`,
+      forkSnapshot: true,
+      forkSourceRunId: String(copy.id || ''),
+      attachments: [], appliedOperations: [], undoOperations: [], undoBaseFiles: [],
+      undoTrackedChanges: [], undoExpectedFiles: [], undoStatus: '',
+      trackedChangeStatus: '', nativeRequestId: '', queueItemId: '', interruptedDraft: undefined
+    };
+  }
+
+  function codedError(code, message) { const error = new Error(message); error.code = code; return error; }
+  return { copyRunSnapshot, create };
+});

package/extension/src/content/writebackController.js

@@ -15,6 +15,9 @@
           type: change.type,
           path: change.path,
           contentBase64: change.contentBase64 || '',
+          assetRef: change.assetRef && typeof change.assetRef === 'object' ? { ...change.assetRef } : undefined,
+          sha256: change.sha256 || change.assetRef?.sha256 || '',
+          mimeType: change.mimeType || change.assetRef?.mimeType || '',
           size: Number.isFinite(Number(change.size)) ? Number(change.size) : undefined,
           previousExists: change.previousExists === true,
           previousKind: change.previousKind || '',

package/extension/src/content/writebackOrchestrator.js

@@ -25,7 +25,6 @@
   let appendOperationsPreview;
   let appendPartialWritebackWarning;
   let appendApplyResult;
-  let renderDiffReview;
   let renderReadOnlyDiffReview;
   let showPluginConfirm;
   let callPageBridge;
@@ -62,6 +61,7 @@
   let onMirrorRefreshSettled;
   let writebackSettlement;
   let injectedWritebackSettlement;
+  let assetTransferBroker;
 
   function buildSettlement(input = {}) {
     return writebackSettlement?.settle instanceof Function
@@ -96,8 +96,8 @@
         applyResults: [],
         mode: runMode,
         nextStep: tx(
-          'Switch to Suggest or Auto only when you want Codex to edit files.',
-          '只有希望 Codex 修改文件时，才需要切换到建议修改或自动写入。'
+          'Switch to Auto only when you want Codex to edit files.',
+          '只有希望 Codex 修改文件时，才需要切换到自动写入。'
         )
       });
       return {
@@ -178,51 +178,6 @@
       };
     }
 
-    if (runMode === 'confirm') {
-      appendRunEvent({
-        title: tx(
-          `Local Codex produced ${operations.length} change(s). Review the diff before applying.`,
-          `本地 Codex 产生了 ${operations.length} 项改动，请查看差异后确认。`
-        ),
-        status: 'running'
-      });
-      const accepted = await renderDiffReview(visibleSyncChanges);
-      if (!accepted.length) {
-        appendRunEvent({
-          title: tx('Sync cancelled: Overleaf was not modified.', '已取消同步：Overleaf 没有被修改。'),
-          status: 'completed'
-        });
-        appendCompletionReport({
-          conclusion: tx('You cancelled syncing. Local Codex changes were not written back to Overleaf.', '你取消了同步，本地 Codex 改动没有写回 Overleaf。'),
-          status: 'rejected',
-          operations: [],
-          applyResults: [],
-          mode: runMode,
-          nextStep: tx('Run the task again, or switch to Auto if you want changes synced directly.', '可以重新运行任务，或切换到自动写入后再同步。')
-        });
-        return {
-          summaryLine: tx('Sync cancelled', '已取消同步'),
-          hasSkippedOperations: additionalSkippedEntries.length > 0,
-          settlement: buildSettlement({
-            operations,
-            applyResult: { ok: false, applied: [], skipped: additionalSkippedEntries }
-          }),
-          audit: buildAuditSummaryFromApply({
-            operations,
-            applyResults: additionalSkippedEntries.length ? [{ ok: false, applied: [], skipped: additionalSkippedEntries }] : [],
-            blockedFiles: additionalSkippedEntries.map(item => summarizeOperationForAudit(item.operation, item.result, 'blocked')),
-            resultStatus: 'rejected'
-          })
-        };
-      }
-      operations = buildSyncApplyOperations(accepted, project);
-      const acceptedPathSafety = partitionUnsafeProjectPathOperations(operations);
-      if (acceptedPathSafety.skipped.length) {
-        additionalSkippedEntries.push(...acceptedPathSafety.skipped);
-        operations = acceptedPathSafety.safe;
-      }
-    }
-
     const deleteOperations = operations.filter(operation => operation.type === 'delete');
     if (deleteOperations.length) {
       const approved = await showPluginConfirm({
@@ -329,7 +284,7 @@
       };
     }
     const applied = operations.length
-      ? mergeApplyResultSkipped(await callPageBridge('applyOperations', {
+      ? mergeApplyResultSkipped(await assetTransferBroker.applyOperations({
         operations,
         baseFiles: project?.files || [],
         requireReviewing: runRequireReviewing,
@@ -872,7 +827,6 @@
       appendOperationsPreview,
       appendPartialWritebackWarning,
       appendApplyResult,
-      renderDiffReview,
       renderReadOnlyDiffReview,
       showPluginConfirm,
       callPageBridge,
@@ -906,6 +860,7 @@
       getState,
       getCurrentRunView,
     } = deps);
+    assetTransferBroker = deps.assetTransferBroker;
     onMirrorRefreshSettled = deps.onMirrorRefreshSettled;
     writebackSettlement = deps.writebackSettlement;
     compileAdapter = deps.compileAdapter;

package/extension/src/page/binaryAssetUploader.js

@@ -0,0 +1,343 @@
+(function initCodexOverleafBinaryAssetUploader(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafBinaryAssetUploader = api;
+})(typeof window !== 'undefined' ? window : globalThis, function binaryAssetUploaderFactory() {
+  'use strict';
+
+  const MAX_ASSET_BYTES = 10 * 1024 * 1024;
+
+  function create(deps = {}) {
+    const windowRef = deps.window || globalThis.window;
+    const documentRef = deps.document || windowRef?.document;
+    const treeOperations = deps.treeOperations;
+    const snapshotRouter = deps.snapshotRouter;
+    const transfers = new Map();
+
+    function begin(params = {}) {
+      let transferId;
+      let projectPath;
+      try {
+        transferId = cleanTransferId(params.transferId);
+        projectPath = normalizePath(params.path);
+      } catch (error) {
+        return failure('binary_asset_path_invalid', error.message);
+      }
+      const size = Number(params.size);
+      if (!Number.isSafeInteger(size) || size < 0 || size > MAX_ASSET_BYTES) {
+        return failure('binary_asset_size_invalid', 'Asset size is invalid or exceeds 10 MiB.');
+      }
+      if (!/^[a-f0-9]{64}$/i.test(String(params.sha256 || ''))) {
+        return failure('binary_asset_hash_invalid', 'Asset SHA-256 is missing or invalid.');
+      }
+      transfers.set(transferId, {
+        id: transferId,
+        path: projectPath,
+        size,
+        sha256: String(params.sha256).toLowerCase(),
+        mimeType: String(params.mimeType || 'application/octet-stream'),
+        overwrite: params.overwrite === true,
+        chunks: [],
+        received: 0
+      });
+      return { ok: true, transferId };
+    }
+
+    function append(params = {}) {
+      const transfer = transfers.get(String(params.transferId || ''));
+      if (!transfer) return failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.');
+      if (Number(params.offset) !== transfer.received) {
+        return failure('binary_upload_chunk_order_invalid', 'Asset chunks arrived out of order.');
+      }
+      let bytes;
+      try { bytes = decodeBase64(params.contentBase64, windowRef); } catch (_error) {
+        return failure('binary_upload_chunk_invalid', 'Asset chunk is not valid Base64.');
+      }
+      if (transfer.received + bytes.length > transfer.size) {
+        return failure('binary_upload_size_mismatch', 'Asset chunks exceed the declared size.');
+      }
+      transfer.chunks.push(bytes);
+      transfer.received += bytes.length;
+      return { ok: true, transferId: transfer.id, received: transfer.received };
+    }
+
+    async function commit(params = {}) {
+      const transferId = String(params.transferId || '');
+      const transfer = transfers.get(transferId);
+      if (!transfer) return failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.');
+      try {
+        if (transfer.received !== transfer.size) return failure('binary_upload_incomplete', 'Asset upload is incomplete.');
+        const bytes = joinChunks(transfer.chunks, transfer.size);
+        const digest = await sha256Hex(bytes, windowRef.crypto);
+        if (digest !== transfer.sha256) {
+          return failure('binary_upload_checksum_mismatch', 'Asset checksum did not match the Native Host descriptor.');
+        }
+        const fileName = transfer.path.split('/').pop();
+        const file = new windowRef.File([bytes], fileName, { type: transfer.mimeType });
+        const attempts = [
+          // Prefer Overleaf's visible uploader. Its UI contract is more
+          // stable than the private multipart endpoint across deployments.
+          () => uploadWithDom(file, transfer),
+          () => uploadWithMultipart(file, transfer),
+          () => uploadWithLegacyManager(file, transfer)
+        ];
+        const errors = [];
+        for (const attempt of attempts) {
+          try {
+            const result = await attempt();
+            const observed = result?.ok ? await waitForPath(transfer.path, 12000) : null;
+            const hashVerified = observed ? await verifyRemoteHash(observed, transfer).catch(() => false) : false;
+            const overwriteVerified = !transfer.overwrite || hashVerified || result?.confirmedByTransport === true;
+            if (result?.ok && observed && overwriteVerified) {
+              return { ok: true, written: true, path: transfer.path, method: result.method, changedDocument: true };
+            }
+            if (result?.ok && observed && !overwriteVerified) errors.push('Overleaf did not expose enough evidence to verify the binary replacement.');
+            if (result?.reason) errors.push(result.reason);
+          } catch (error) {
+            errors.push(error.message);
+          }
+        }
+        return failure('binary_upload_unavailable', errors.filter(Boolean).join('; ') || 'No supported Overleaf asset upload path succeeded.');
+      } finally {
+        transfers.delete(transferId);
+      }
+    }
+
+    function abort(params = {}) {
+      return { ok: true, aborted: transfers.delete(String(params.transferId || '')) };
+    }
+
+    async function uploadWithMultipart(file, transfer) {
+      const projectId = treeOperations.getProjectId();
+      if (!projectId || typeof windowRef.fetch !== 'function') return { ok: false, reason: 'Project upload endpoint is unavailable.' };
+      const parentPath = transfer.path.split('/').slice(0, -1).join('/');
+      const folderId = await findFolderId(parentPath);
+      if (parentPath && !folderId) return { ok: false, reason: 'Target folder id is unavailable for direct upload.' };
+      const form = new windowRef.FormData();
+      form.append('qqfile', file, file.name);
+      form.append('name', file.name);
+      if (folderId) form.append('folder_id', folderId);
+      const csrf = findCsrfToken();
+      const headers = csrf ? { 'X-CSRF-Token': csrf } : {};
+      const query = folderId ? `?folder_id=${encodeURIComponent(folderId)}` : '';
+      const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/upload${query}`, {
+        method: 'POST', body: form, credentials: 'same-origin', headers
+      });
+      const responseText = await response.text();
+      if (!response.ok) throw new Error(formatUploadHttpError(response.status, responseText));
+      try {
+        const payload = responseText ? JSON.parse(responseText) : null;
+        if (payload && (payload.success === false || payload.ok === false || payload.error)) {
+          throw new Error(payload.error?.message || payload.error || payload.message || 'Overleaf rejected the asset upload.');
+        }
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          // Some Overleaf deployments return an empty or HTML success body.
+        } else {
+          throw error;
+        }
+      }
+      return { ok: true, method: 'overleaf.multipart', confirmedByTransport: true };
+    }
+
+    async function uploadWithDom(file, transfer) {
+      const parentPath = transfer.path.split('/').slice(0, -1).join('/');
+      if (parentPath) {
+        const folderNode = treeOperations.findFileTreeNode(parentPath);
+        if (!folderNode) return { ok: false, reason: `Target folder ${parentPath} is unavailable in the Overleaf file tree.` };
+        folderNode?.dispatchEvent(new windowRef.MouseEvent('click', { bubbles: true }));
+        await delay(120);
+      }
+      let input = findFileInput();
+      if (!input) {
+        const button = findUploadButton();
+        if (!button) return { ok: false, reason: 'Overleaf upload button was not found.' };
+        button.click();
+        input = await waitForFileInput(4000);
+      }
+      if (!input) return { ok: false, reason: 'Overleaf upload file input was not found.' };
+      const data = new windowRef.DataTransfer();
+      data.items.add(file);
+      assignFilesToInput(input, data.files, windowRef);
+      input.dispatchEvent(new windowRef.Event('input', { bubbles: true }));
+      input.dispatchEvent(new windowRef.Event('change', { bubbles: true }));
+      await clickReplaceIfShown();
+      return { ok: true, method: 'overleaf.file-input' };
+    }
+
+    async function uploadWithLegacyManager(file, transfer) {
+      const manager = treeOperations.findFileTreeManager();
+      if (!manager) return { ok: false, reason: 'Legacy file-tree manager is unavailable.' };
+      for (const name of ['uploadFile', 'uploadAsset', 'createBinaryFile', 'createFile', 'addFile']) {
+        if (typeof manager[name] !== 'function') continue;
+        try {
+          await manager[name](transfer.path, file);
+          return { ok: true, method: `fileTreeManager.${name}`, confirmedByTransport: true };
+        } catch (_error) { /* try the next adapter */ }
+      }
+      return { ok: false, reason: 'Legacy file-tree manager has no compatible asset method.' };
+    }
+
+    async function findFolderId(parentPath) {
+      const node = parentPath ? treeOperations.findFileTreeNode(parentPath) : null;
+      const element = node?.closest?.('[data-entity-id], [data-folder-id], [data-id]') || node;
+      const domId = element?.dataset?.entityId || element?.dataset?.folderId || element?.dataset?.id;
+      if (domId) return domId;
+      for (const root of [windowRef._ide, windowRef.Overleaf, windowRef.overleaf, windowRef.OL]) {
+        const folder = root?.project?.rootFolder?.[0] || root?.project?.rootFolder || root?.rootFolder?.[0] || root?.rootFolder;
+        if (!parentPath && (folder?._id || folder?.id)) return folder._id || folder.id;
+      }
+      try {
+        const list = await snapshotRouter?.buildProjectFileList({
+          force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
+        });
+        const folder = (list?.files || []).find(item => item.path === parentPath && /folder/i.test(item.kind || item.type || ''));
+        if (folder) return folder.id || folder._id || folder.entityId || '';
+      } catch (_error) { /* DOM and legacy adapters remain available */ }
+      return '';
+    }
+
+    function findCsrfToken() {
+      return documentRef.querySelector('meta[name="ol-csrfToken"], meta[name="csrf-token"], meta[name="_csrf"]')?.content
+        || windowRef.csrfToken || windowRef._csrf || '';
+    }
+    function findFileInput() {
+      return chooseOverleafFileInput(Array.from(documentRef.querySelectorAll('input[type="file"]')));
+    }
+    function findUploadButton() {
+      return chooseOverleafUploadButton(Array.from(documentRef.querySelectorAll('button, [role="button"]')));
+    }
+    function chooseOverleafUploadButton(nodes) {
+      return nodes.filter(node => {
+        if (!node || node.disabled || isCodexOwnedNode(node)) return false;
+        const label = `${node.getAttribute('aria-label') || ''} ${node.getAttribute('title') || ''} ${node.textContent || ''}`;
+        return /upload|上传/i.test(label);
+      }).sort((left, right) => uploadButtonScore(right) - uploadButtonScore(left))[0] || null;
+    }
+    async function waitForFileInput(timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const input = findFileInput();
+        if (input) return input;
+        await delay(50);
+      }
+      return null;
+    }
+    async function clickReplaceIfShown() {
+      await delay(180);
+      const button = Array.from(documentRef.querySelectorAll('button')).find(node => /replace|overwrite|替换|覆盖/i.test(node.textContent || ''));
+      if (button) button.click();
+    }
+    async function waitForPath(projectPath, timeoutMs) {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        if (treeOperations.projectPathExists(projectPath)) {
+          const node = treeOperations.findFileTreeNode(projectPath);
+          return {
+            path: projectPath,
+            id: node?.dataset?.entityId || node?.dataset?.fileId || node?.dataset?.id || ''
+          };
+        }
+        await delay(250);
+        try {
+          const list = await snapshotRouter?.buildProjectFileList({
+            force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
+          });
+          const file = (list?.files || []).find(item => item.path === projectPath);
+          if (file) return file;
+        } catch (_error) { /* continue until the deadline */ }
+      }
+      return null;
+    }
+    async function verifyRemoteHash(observed, transfer) {
+      const fileId = observed?.id || observed?._id || observed?.entityId || observed?.fileId || '';
+      const projectId = treeOperations.getProjectId();
+      if (!fileId || !projectId || typeof windowRef.fetch !== 'function') return false;
+      const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/file/${encodeURIComponent(fileId)}`, {
+        credentials: 'same-origin', cache: 'no-store'
+      });
+      if (!response.ok) return false;
+      const digest = await sha256Hex(new Uint8Array(await response.arrayBuffer()), windowRef.crypto);
+      return digest === transfer.sha256;
+    }
+    function delay(ms) { return new Promise(resolve => windowRef.setTimeout(resolve, ms)); }
+    return { abort, append, begin, commit };
+  }
+
+  function normalizePath(value) {
+    const path = String(value || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+    if (!path || path.split('/').some(part => !part || part === '.' || part === '..')) throw new Error('Asset path is invalid.');
+    return path;
+  }
+  function cleanTransferId(value) {
+    const id = String(value || '');
+    if (!/^[a-zA-Z0-9_-]{8,120}$/.test(id)) throw new Error('Asset transfer id is invalid.');
+    return id;
+  }
+  function chooseOverleafFileInput(inputs) {
+    return Array.from(inputs || [])
+      .filter(input => input && !input.disabled && !isCodexOwnedNode(input))
+      .sort((left, right) => uploadInputScore(right) - uploadInputScore(left))[0] || null;
+  }
+  function isCodexOwnedNode(node) {
+    return Boolean(node?.closest?.('#codex-overleaf-panel, [data-codex-overleaf-root], .codex-overleaf-panel'));
+  }
+  function uploadInputScore(input) {
+    let score = 0;
+    if (input?.closest?.('.uppy-Dashboard, [data-uppy-drag-drop-supported]')) score += 100;
+    if (input?.closest?.('[role="dialog"], .modal')) score += 40;
+    if (/uppy|upload/i.test(`${input?.className || ''} ${input?.getAttribute?.('data-testid') || ''}`)) score += 30;
+    if (input?.multiple) score += 10;
+    if (input?.isConnected !== false) score += 1;
+    return score;
+  }
+  function uploadButtonScore(node) {
+    let score = 0;
+    const label = `${node?.getAttribute?.('aria-label') || ''} ${node?.getAttribute?.('title') || ''} ${node?.textContent || ''}`.trim();
+    if (/^(upload|上传)$/i.test(label)) score += 50;
+    if (node?.closest?.('[data-testid*="file-tree"], .file-tree, .ide-react-file-tree')) score += 30;
+    if (node?.isConnected !== false) score += 1;
+    return score;
+  }
+  function assignFilesToInput(input, files, windowRef) {
+    const prototype = windowRef?.HTMLInputElement?.prototype;
+    const setter = prototype && Object.getOwnPropertyDescriptor(prototype, 'files')?.set;
+    if (setter) {
+      setter.call(input, files);
+      return;
+    }
+    Object.defineProperty(input, 'files', { configurable: true, value: files });
+  }
+  function formatUploadHttpError(status, responseText) {
+    const detail = summarizeUploadResponse(responseText);
+    return `Overleaf upload endpoint returned HTTP ${status}${detail ? ` (${detail})` : ''}.`;
+  }
+  function summarizeUploadResponse(value) {
+    const text = String(value || '').trim();
+    if (!text || /^\s*</.test(text)) return '';
+    let message = text;
+    try {
+      const payload = JSON.parse(text);
+      message = payload?.error?.message || payload?.error || payload?.message || text;
+    } catch (_error) { /* use the bounded plain-text response */ }
+    return String(message || '').replace(/\s+/g, ' ').slice(0, 240);
+  }
+  function decodeBase64(value, windowRef) {
+    const binary = windowRef.atob(String(value || ''));
+    const bytes = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+    return bytes;
+  }
+  function joinChunks(chunks, size) {
+    const output = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) { output.set(chunk, offset); offset += chunk.length; }
+    return output;
+  }
+  async function sha256Hex(bytes, cryptoImpl) {
+    const digest = await cryptoImpl.subtle.digest('SHA-256', bytes);
+    return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+  }
+  function failure(code, reason) { return { ok: false, code, reason, changedDocument: false }; }
+  return { chooseOverleafFileInput, create, formatUploadHttpError, joinChunks, normalizePath };
+});

package/extension/src/page/trackedChangesLifecycle.js

@@ -971,8 +971,15 @@
     }
 
     for (const path of paths) {
-      if (path && getActiveFilePath() !== path) {
-        const opened = await openFileByPath(path);
+      const postContent = postByPath.get(path);
+      const activePathMatches = getActiveFilePath() === path;
+      const activeContentMatches = readActiveEditorText() === postContent;
+      // Overleaf can update the selected tree path before CodeMirror swaps its
+      // document. In that state getActiveFilePath() already names `path`, while
+      // readActiveEditorText() still belongs to the previously viewed file.
+      // Force-reopen the target whenever either identity signal disagrees.
+      if (path && (!activePathMatches || !activeContentMatches)) {
+        const opened = await openFileByPath(path, { force: true });
         if (!opened.ok) {
           return {
             ok: false,
@@ -983,8 +990,7 @@
         }
       }
 
-      const postContent = postByPath.get(path);
-      const postReady = await waitForActiveEditorExpectedText(path, postContent, 2500);
+      const postReady = await waitForActiveEditorExpectedText(path, postContent, 9000);
       if (!postReady.ok) {
         return {
           ok: false,
@@ -1492,6 +1498,8 @@
       '[data-track-change-id]',
       '[data-ol-change-id]',
       '[data-path][class*="change" i]',
+      '.ol-cm-change',
+      '.review-panel-entry-change',
       '[class*="track-change" i]',
       '[class*="review-change" i]',
       '[class*="suggest" i]',

package/extension/src/page/writebackRouter.js

@@ -1667,13 +1667,17 @@
         continue;
       }
       const key = typeof ref.key === 'string' ? ref.key : '';
-      if (!key || seen.has(key)) {
+      if (!key) {
         continue;
       }
-      seen.add(key);
       const hasPath = typeof ref.path === 'string';
       const hasExplicitPath = hasPath && ref.path.trim() !== '';
       const path = hasPath ? normalizeSafeProjectPath(ref.path) : '';
+      const identity = `${path}\u0000${key}`;
+      if (seen.has(identity)) {
+        continue;
+      }
+      seen.add(identity);
       normalized.push({
         key,
         id: typeof ref.id === 'string' ? ref.id : '',