codex-overleaf-link 2.6.0 → 2.6.5

package/extension/src/content/writingStyleSettings.js

@@ -347,7 +347,20 @@
       const input = node('input'); input.type = 'search'; input.value = query; input.dataset.styleFocus = 'project-search';
       input.placeholder = tx('Search all Overleaf projects', '搜索全部 Overleaf 项目');
       input.setAttribute('aria-label', input.placeholder);
-      input.addEventListener('input', () => { query = input.value; render(); });
+      let composing = false;
+      const updateResults = () => {
+        query = input.value;
+        const results = input.closest('.ws2-picker')?.querySelector('.ws2-projects');
+        if (results) renderProjectResults(results);
+      };
+      input.addEventListener('compositionstart', () => { composing = true; });
+      input.addEventListener('compositionend', () => {
+        composing = false;
+        updateResults();
+      });
+      input.addEventListener('input', event => {
+        if (!composing && !event.isComposing) updateResults();
+      });
       search.append(input); panel.append(search);
       const filters = node('div', 'ws2-filters');
       for (const [value, label] of [['all', tx('All', '全部')], ['active', tx('Active', '常规')], ['archived', tx('Archived', '已归档')]]) {
@@ -358,6 +371,16 @@
       panel.append(filters);
       const list = node('div', 'ws2-projects');
       list.setAttribute('role', 'group'); list.setAttribute('aria-label', tx('Overleaf projects', 'Overleaf 项目'));
+      renderProjectResults(list);
+      panel.append(list);
+      const footer = node('div', 'ws2-picker-footer');
+      footer.append(node('span', '', tx(sources.length + ' of 3 references selected', '已选 ' + sources.length + ' / 3 份资料')),
+        button(tx('Done', '完成'), () => { pickerOpen = false; render(); }, 'ws2-button ws2-button-primary', 'picker-done'));
+      panel.append(footer); return panel;
+    }
+    function renderProjectResults(list) {
+      const oldScroll = list.scrollTop;
+      list.replaceChildren();
       if (projectLoading) {
         const loading = node('div', 'ws2-picker-state');
         loading.append(node('span', 'ws2-pulse'), node('span', '', tx('Loading project directory…', '正在加载项目目录…')));
@@ -395,11 +418,7 @@
         if (!matches.length) list.append(node('div', 'ws2-picker-state',
           query ? tx('No projects match this search.', '没有匹配的项目。') : tx('No projects in this group.', '此分组暂无项目。')));
       }
-      panel.append(list);
-      const footer = node('div', 'ws2-picker-footer');
-      footer.append(node('span', '', tx(sources.length + ' of 3 references selected', '已选 ' + sources.length + ' / 3 份资料')),
-        button(tx('Done', '完成'), () => { pickerOpen = false; render(); }, 'ws2-button ws2-button-primary', 'picker-done'));
-      panel.append(footer); return panel;
+      list.scrollTop = oldScroll;
     }
     function renderSources() {
       const section = node('section', 'ws2-library');
@@ -480,6 +499,38 @@
       }
       return section;
     }
+    function replaceAround(parent, fresh, retained, replacement) {
+      for (const child of Array.from(parent.childNodes)) {
+        if (child !== retained) child.remove();
+      }
+      let before = true;
+      for (const child of Array.from(fresh.childNodes)) {
+        if (child === replacement) before = false;
+        else parent.insertBefore(child, before ? retained : null);
+      }
+    }
+    function renderKeepingProjectSearch(content) {
+      const library = host.querySelector('.ws2-library');
+      const picker = library?.querySelector('.ws2-picker');
+      const search = picker?.querySelector('.ws2-search');
+      const nextLibrary = content.querySelector('.ws2-library');
+      const nextPicker = nextLibrary?.querySelector('.ws2-picker');
+      if (!search || !nextPicker) {
+        host.replaceChildren(content);
+        return false;
+      }
+      // Keep every ancestor connected: detaching and refocusing an input
+      // cannot restore its IME composition when an async catalog read settles.
+      const input = search.querySelector('input');
+      const nextSearch = nextPicker.querySelector('.ws2-search');
+      input.placeholder = nextSearch.querySelector('input').placeholder;
+      input.setAttribute('aria-label', input.placeholder);
+      picker.setAttribute('aria-label', nextPicker.getAttribute('aria-label'));
+      replaceAround(picker, nextPicker, search, nextSearch);
+      replaceAround(library, nextLibrary, picker, nextPicker);
+      replaceAround(host, content, library, nextLibrary);
+      return document.activeElement === input;
+    }
     function render() {
       if (!host?.isConnected) return;
       alignScope();
@@ -487,7 +538,8 @@
       const oldScroll = host.querySelector('.ws2-projects')?.scrollTop || 0;
       const heading = host.closest('[data-set-group]')?.querySelector('[data-writing-style-heading]');
       if (heading) heading.textContent = tx('Writing style', '写作风格');
-      host.classList.add('ws2'); host.replaceChildren();
+      host.classList.add('ws2');
+      const content = document.createDocumentFragment();
       const top = node('div', 'ws2-heading');
       const copy = node('div', 'ws2-heading-copy');
       const title = node('label', 'ws2-title', tx('Write in My Style', '沿用写作风格'));
@@ -501,7 +553,7 @@
       toggleInput.dataset.styleFocus = 'enable-style'; toggleInput.checked = desiredEnabled;
       toggleInput.disabled = !scope || !meta || toggleBusy || (working() && !meta?.ready);
       toggleInput.addEventListener('change', () => { void toggle(toggleInput.checked); });
-      top.append(copy, toggleInput); host.append(top);
+      top.append(copy, toggleInput); content.append(top);
       if (meta?.ready) {
         const summary = node('div', 'ws2-profile');
         const mark = node('span', 'ws2-profile-icon'); mark.append(icon('check'));
@@ -518,16 +570,16 @@
         const view = button(preview ? tx('Hide preview', '收起预览') : tx('Preview style', '预览风格'),
           () => { void loadPreview(); }, 'ws2-button ws2-button-quiet', 'preview-style');
         view.disabled = previewBusy;
-        summary.append(mark, info, view); host.append(summary);
+        summary.append(mark, info, view); content.append(summary);
       }
       const editing = expanded || working();
       const manage = button(editing ? tx('Hide references', '收起参考资料')
         : meta?.ready ? tx('Manage references', '管理参考资料') : tx('Choose references', '选择参考资料'),
       () => { expanded = !expanded; pickerOpen = false; render(); }, 'ws2-manage', 'manage-references');
       manage.setAttribute('aria-expanded', String(editing));
-      manage.disabled = working(); manage.append(icon('arrow')); host.append(manage);
+      manage.disabled = working(); manage.append(icon('arrow')); content.append(manage);
       if (editing) {
-        host.append(renderSources());
+        content.append(renderSources());
         if (working()) {
           const progress = node('div', 'ws2-progress'); progress.setAttribute('role', 'status');
           const phase = activeGeneration?.phase || 'learning';
@@ -545,7 +597,7 @@
           }
           progress.append(steps);
           const stop = button(tx('Cancel', '取消'), () => { void cancel(); }, 'ws2-button', 'cancel-generation');
-          stop.disabled = cancelling; progress.append(stop); host.append(progress);
+          stop.disabled = cancelling; progress.append(stop); content.append(progress);
         } else {
           const footer = node('div', 'ws2-actions');
           const help = node('div', 'ws2-action-copy');
@@ -559,8 +611,8 @@
           const generateButton = button(meta?.ready ? tx('Update style', '更新风格') : tx('Generate style', '生成风格'),
             () => { void generate(); }, 'ws2-button ws2-button-primary', 'generate-style');
           generateButton.disabled = !scope || !meta || !sources.length || deps.isRunning();
-          footer.append(generateButton); host.append(footer);
-          if (deps.isRunning()) host.append(node('p', 'ws2-caption', tx('Available after the current task finishes.', '当前任务结束后可生成。')));
+          footer.append(generateButton); content.append(footer);
+          if (deps.isRunning()) content.append(node('p', 'ws2-caption', tx('Available after the current task finishes.', '当前任务结束后可生成。')));
         }
       }
       if (message || !meta) {
@@ -570,12 +622,13 @@
         if (!meta && message) status.append(button(tx('Retry', '重试'), () => {
           message = ''; messageTone = ''; render(); void ensureLoaded(true).catch(() => {});
         }, 'ws2-button', 'retry-settings'));
-        host.append(status);
+        content.append(status);
       }
-      if (preview) host.append(renderPreview());
+      if (preview) content.append(renderPreview());
+      const searchKeptFocus = renderKeepingProjectSearch(content);
       const scroll = host.querySelector('.ws2-projects');
       if (scroll) scroll.scrollTop = oldScroll;
-      restoreFocus(focus);
+      if (!searchKeptFocus) restoreFocus(focus);
     }
     function mount(panel) {
       const next = panel?.querySelector('[data-writing-style-settings]');

package/extension/src/page/overleafEditor.js

@@ -68,8 +68,15 @@
       return '';
     }
 
-    function replaceActiveEditorText(text) {
+    function captureMatches(view, capture) {
+      return !capture || (view === capture.view && view?.state === capture.state && view.state.doc === capture.doc
+        && view.state.doc.toString() === capture.text);
+    }
+
+    function replaceActiveEditorText(text, options = {}) {
       const editorView = deps.getCodeMirrorEditorView?.();
+      if (!captureMatches(editorView, options.expectedCapture))
+        return { ok: false, code: 'document_identity_mismatch', changedDocument: false };
       if (editorView) {
         const from = 0;
         const to = deps.getCodeMirrorDocLength(editorView);
@@ -120,13 +127,15 @@
       };
     }
 
-    function replaceActiveEditorPatches(patches, nextContent) {
+    function replaceActiveEditorPatches(patches, nextContent, options = {}) {
       const normalized = deps.normalizeTextPatches(patches, readActiveEditorText().length);
       if (!normalized.ok) {
         return normalized;
       }
 
       const editorView = deps.getCodeMirrorEditorView?.();
+      if (!captureMatches(editorView, options.expectedCapture))
+        return { ok: false, code: 'document_identity_mismatch', changedDocument: false };
       if (editorView) {
         editorView.dispatch({
           changes: normalized.patches.map(patch => ({
@@ -159,7 +168,7 @@
         };
       }
 
-      const result = replaceActiveEditorText(nextContent);
+      const result = replaceActiveEditorText(nextContent, options);
       return result.ok
         ? {
           ...result,

package/extension/src/page/overleafProjectSnapshot.js

@@ -16,27 +16,70 @@
     const snapshotCache = createKeyedCache();
     const fileListCache = createKeyedCache();
 
+    function editorCaptureKey() {
+      const capture = deps.captureEditorDocument?.({ path: deps.getActiveFilePath?.(), projectId: deps.getProjectId?.() });
+      return capture?.ok ? capture : null;
+    }
+
+    function sameEditorCapture(left, right) {
+      return Boolean(left?.ok && right?.ok) && left.view === right.view && left.state === right.state && left.doc === right.doc
+        && left.text === right.text && ['path', 'projectId', 'documentId', 'targetDocumentId']
+          .every(key => left.documentIdentity[key] === right.documentIdentity[key]);
+    }
+
+    function hasEditorOverlay(snapshot) {
+      // Navigation reads carry the open method as their source. Only ZIP and
+      // document fetches are independent of the mounted editor.
+      return snapshot?.files?.some(file => typeof file.content === 'string'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+    }
+
+    function hasNavigationReads(snapshot) {
+      return snapshot?.files?.some(file => typeof file.content === 'string' && file.source !== 'active-editor'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+    }
+
     async function getProjectSnapshot(params = {}) {
       const cacheKey = getSnapshotCacheKey(params);
       const maxAgeMs = normalizeSnapshotMaxAge(params.maxAgeMs);
       const now = Date.now();
       const cacheEntry = snapshotCache.entries.get(cacheKey);
+      const captureKey = editorCaptureKey();
+      const projectId = deps.getProjectId?.();
 
-      if (!params.force && cacheEntry?.pending) {
-        return cacheEntry.pending;
+      function currentSnapshot(snapshot) {
+        if (deps.getProjectId?.() !== projectId) return withoutEditorFiles(snapshot, true);
+        if (!hasEditorOverlay(snapshot) || params.allowEditorNavigation === true || hasNavigationReads(snapshot)) return snapshot;
+        const captures = deps.getSnapshotEditorCaptures?.(snapshot) || [];
+        if (captures.length === 1 && deps.isCaptureCurrent?.(captures[0])) return snapshot;
+        // Fallback captures can be returned once, but never reused from cache.
+        if (!snapshot.files.some(file => file.documentIdentity !== undefined)) return snapshot;
+        return withoutEditorFiles(snapshot);
       }
 
-      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs) {
+      if (!params.force && cacheEntry?.pending && (params.allowEditorNavigation === false || params.zipOnly || params.serverOnly)
+        && (params.serverOnly === true || sameEditorCapture(cacheEntry.pendingCaptureKey, captureKey))) {
+        const snapshot = await cacheEntry.pending;
+        return currentSnapshot(snapshot);
+      }
+
+      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs
+        && (!hasEditorOverlay(cacheEntry.value) || (params.allowEditorNavigation !== true
+          && sameEditorCapture(cacheEntry.captureKey, captureKey)))) {
         return withSnapshotCacheMetadata(cacheEntry.value, 'memory', cacheEntry.capturedAt);
       }
 
       const pending = deps.buildProjectSnapshot(params)
         .then(snapshot => {
+          const captures = deps.getSnapshotEditorCaptures?.(snapshot) || [];
+          const finalCapture = captures.length === 1 ? captures[0] : null;
+          snapshot = currentSnapshot(snapshot);
           const capturedAt = Date.now();
           const currentEntry = snapshotCache.entries.get(cacheKey);
           if (currentEntry?.pending === pending) {
             snapshotCache.entries.set(cacheKey, {
               value: snapshot,
+              captureKey: params.allowEditorNavigation === true || hasNavigationReads(snapshot) ? null : finalCapture,
               capturedAt,
               pending: null
             });
@@ -52,12 +95,22 @@
 
       snapshotCache.entries.set(cacheKey, {
         value: cacheEntry?.value || null,
+        captureKey: cacheEntry?.captureKey,
+        pendingCaptureKey: captureKey,
         capturedAt: cacheEntry?.capturedAt || 0,
         pending
       });
       return pending;
     }
 
+    function withoutEditorFiles(snapshot, projectChanged = false) {
+      const files = projectChanged ? [] : (snapshot?.files || []).filter(file => /^overleaf-(?:zip|doc-fetch)/.test(file.source || ''));
+      const removed = (snapshot?.files || []).filter(file => !files.includes(file));
+      return { ...snapshot, files, capabilities: { ...snapshot?.capabilities, fullProjectSnapshot: false,
+        requestedPathsComplete: false, skipped: [...(snapshot?.capabilities?.skipped || []),
+          ...removed.map(file => ({ path: file.path, reason: 'document_identity_mismatch' }))] } };
+    }
+
     async function getProjectFileList(params = {}) {
       const cacheKey = getProjectFileListCacheKey(params);
       const maxAgeMs = normalizeFileListMaxAge(params.maxAgeMs);

package/extension/src/page/snapshotRouter.js

@@ -17,12 +17,22 @@
     const normalizeSafeProjectPath = typeof deps.normalizePath === 'function'
       ? deps.normalizePath
       : fallbackNormalizeSafeProjectPath;
-    const readActiveEditorText = typeof deps.readActiveEditorText === 'function'
-      ? deps.readActiveEditorText
-      : () => '';
     let invalidatedAt = 0;
     let preferredZipEndpoint = '';
     const writebackReads = new Set();
+    const editorCaptures = new WeakMap();
+
+    function editorFile(path, ready, source) {
+      if (ready.documentIdentity && ready.capture) editorCaptures.set(ready.documentIdentity, ready.capture);
+      return { path, content: ready.text, source, kind: 'text',
+        ...(ready.documentIdentity !== undefined ? { documentIdentity: ready.documentIdentity } : {}) };
+    }
+
+    function getSnapshotEditorCaptures(snapshot) {
+      return (snapshot?.files || []).filter(file => typeof file.content === 'string'
+        && !/^overleaf-(?:zip|doc-fetch)/.test(file.source || ''))
+        .map(file => editorCaptures.get(file.documentIdentity));
+    }
 
     function getProjectId() {
       return treeOperations.getProjectId?.() || null;
@@ -214,6 +224,18 @@
   }
 
   async function buildProjectSnapshot(params = {}) {
+    const projectId = params.projectId || getProjectId();
+    if (!projectId || projectId !== getProjectId()) return projectChangedSnapshot(projectId);
+    const snapshot = await buildProjectSnapshotForProject({ ...params, projectId });
+    return getProjectId() === projectId ? snapshot : projectChangedSnapshot(projectId);
+  }
+
+  function projectChangedSnapshot(projectId) {
+    return { ok: false, id: projectId, files: [], capabilities: { fullProjectSnapshot: false,
+      skipped: [{ path: '', reason: 'document_identity_mismatch' }] } };
+  }
+
+  async function buildProjectSnapshotForProject(params = {}) {
     if (params.zipOnly || params.serverOnly === true) {
       return buildZipOnlyProjectSnapshot(params);
     }
@@ -242,9 +264,18 @@
 
     const zipSnapshot = await fetchProjectZipSnapshot(params);
     if (zipSnapshot.ok && zipSnapshot.files.length) {
+      const skipped = [...(zipSnapshot.skipped || [])];
+      const overlays = [...(lightweightSnapshot?.files || [])];
+      for (let index = 0; index < overlays.length; index++) {
+        if (overlays[index].source !== 'active-editor') continue;
+        const captured = await readActiveEditorOverlay(overlays[index].path, zipSnapshot.files, { projectId: params.projectId });
+        skipped.push(...captured.skipped);
+        overlays.splice(index, 1, ...captured.files);
+        if (!captured.files.length) index--;
+      }
       const mergedFiles = mergeSnapshotFiles(
         zipSnapshot.files,
-        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [], zipSnapshot.skipped)
+        filterZipSnapshotOverlayFiles(zipSnapshot.files, overlays, skipped)
       );
       const files = filterRequestedSnapshotFiles(mergedFiles, params, activePath);
       const requestedPathsComplete = params.restrictToRequestedPathsOnly === true
@@ -261,7 +292,7 @@
           contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
-          skipped: zipSnapshot.skipped || [],
+          skipped,
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
             zipTiming: zipSnapshot.diagnostics,
@@ -309,15 +340,16 @@
       snapshotActivePath,
       ...(Array.isArray(params.focusFiles) ? params.focusFiles : [])
     ];
+    const enumeratedPaths = params.restrictToRequestedPathsOnly === true
+      ? []
+      : collectProjectTextPaths(snapshotActivePath);
     const projectPaths = window.CodexOverleafProjectFiles.collectUniqueTextPaths(
-      params.restrictToRequestedPathsOnly === true
-        ? requestedPaths
-        : [
-          ...requestedPaths,
-          ...collectProjectTextPaths(snapshotActivePath)
-        ],
+      [...requestedPaths, ...enumeratedPaths],
       80
     );
+    const enumerationTruncated = projectPaths.truncated === true
+      || enumeratedPaths.truncated === true
+      || internalDocRecords.truncated === true;
     const files = [];
     const skipped = [...(zipSnapshot?.skipped || [])];
     const ambiguousPaths = new Set(skipped.filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
@@ -332,7 +364,7 @@
     for (const filePath of projectPaths) {
       if (ambiguousPaths.has(filePath)) continue;
       if (filePath === snapshotActivePath) {
-        const ready = await waitForActiveEditorText(filePath, 5000);
+        const ready = await waitForActiveEditorText(filePath, 5000, { allowEmpty: true, projectId: params.projectId });
         if (!ready.ok) {
           skipped.push({
             path: filePath,
@@ -340,18 +372,14 @@
           });
           continue;
         }
-        files.push({
-          path: filePath,
-          content: ready.text,
-          source: 'active-editor'
-        });
+        files.push(editorFile(filePath, ready, 'active-editor'));
         previousSignature = contentSignature(ready.text);
         continue;
       }
 
       const docRecord = docRecordByPath.get(filePath);
       if (docRecord) {
-        const fetched = await fetchOverleafDocContent(docRecord);
+        const fetched = await fetchOverleafDocContent(docRecord, params.projectId);
         if (fetched.ok) {
           files.push({
             path: filePath,
@@ -365,6 +393,7 @@
           path: filePath,
           reason: fetched.reason
         });
+        if (fetched.reason === 'document_identity_mismatch') continue;
       }
 
       if (!canOpenInactiveFileForSnapshot(filePath, params, lightweightOnly, docRecord)) {
@@ -386,7 +415,9 @@
 
       await waitForActiveFile(filePath, 5000);
       const ready = await waitForActiveEditorText(filePath, 7000, {
-        notSignature: previousSignature
+        notSignature: previousSignature,
+        projectId: params.projectId,
+        allowEmpty: true
       });
       if (!ready.ok) {
         skipped.push({
@@ -395,11 +426,7 @@
         });
         continue;
       }
-      files.push({
-        path: filePath,
-        content: ready.text,
-        source: opened.method || 'file-tree-open'
-      });
+      files.push(editorFile(filePath, ready, opened.method || 'file-tree-open'));
       previousSignature = contentSignature(ready.text);
     }
 
@@ -409,14 +436,6 @@
       await waitForActiveEditorText(activePath, 5000);
     }
 
-    if (snapshotActivePath && !ambiguousPaths.has(snapshotActivePath) && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
-      files.push({
-        path: snapshotActivePath,
-        content: readActiveEditorText(),
-        source: 'active-editor'
-      });
-    }
-
     const requestedPathsComplete = isCompleteProjectSnapshot(files, projectPaths);
     return {
       id: getProjectId(),
@@ -424,7 +443,7 @@
       activePath: snapshotActivePath,
       files,
       capabilities: {
-        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
+        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && !enumerationTruncated && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
         pathIdentityComplete: zipSnapshot?.pathIdentityComplete,
         requestedPathsComplete,
         method: resolvePageSnapshotMethod(files, lightweightOnly),
@@ -444,11 +463,11 @@
 
   async function buildZipOnlyProjectSnapshot(params = {}) {
     const activePath = getPassiveActiveFilePath();
-    // Capture read evidence together with the path/text before awaiting ZIP.
-    // A later editor identity cannot prove that an earlier empty read succeeded.
-    const activeOverlay = params.serverOnly === true ? [] : readActiveEditorOverlay(activePath);
-
     const zipSnapshot = await fetchProjectZipSnapshot(params);
+    const captured = params.serverOnly === true ? { files: [], skipped: [] }
+      : await readActiveEditorOverlay(activePath, zipSnapshot.ok ? zipSnapshot.files : null, { passive: true, projectId: params.projectId });
+    const activeOverlay = captured.files;
+    const skipped = [...(zipSnapshot.skipped || []), ...captured.skipped];
     if (zipSnapshot.ok && zipSnapshot.files.length) {
       const files = filterRequestedSnapshotFiles(
         mergeSnapshotFiles(zipSnapshot.files, filterZipSnapshotOverlayFiles(zipSnapshot.files, activeOverlay, zipSnapshot.skipped)),
@@ -469,7 +488,7 @@
           contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
-          skipped: zipSnapshot.skipped || [],
+          skipped,
           diagnostics: {
             zipEndpoint: zipSnapshot.endpoint,
             zipTiming: zipSnapshot.diagnostics,
@@ -494,7 +513,7 @@
           ? 'active-editor-zip-only-fallback'
           : 'zip-only-fallback-empty',
         contentComplete: false,
-        skipped: [...(zipSnapshot.skipped || []), {
+        skipped: [...skipped, {
           path: 'project.zip',
           reason: zipSnapshot.reason || 'ZIP file identities were incomplete'
         }],
@@ -531,32 +550,15 @@
     return (files || []).filter(file => requestedSet.has(file?.path));
   }
 
-  function readActiveEditorOverlay(activePath) {
-    if (!activePath) return [];
-    try {
-      const content = readActiveEditorText();
-      if (typeof content !== 'string') return [];
-      if (!content.trim()) {
-        // The legacy reader also returns '' when no surface exists. A readable
-        // identity must independently confirm blank text before it can erase ZIP.
-        const identity = deps.getActiveEditorIdentity?.();
-        let observed;
-        if (identity?.type === 'codemirror-view' && typeof identity.doc?.toString === 'function') {
-          observed = identity.doc.toString();
-        } else if (identity?.type === 'textarea') {
-          observed = identity.node?.value;
-        } else if (identity?.type === 'contenteditable') {
-          const node = identity.node;
-          if (typeof node?.innerText === 'string' || typeof node?.textContent === 'string') {
-            observed = node.innerText || node.textContent || '';
-          }
-        }
-        if (typeof observed !== 'string' || observed !== content) return [];
-      } else if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(content)) return [];
-      return [{ path: activePath, content, source: 'active-editor', kind: 'text' }];
-    } catch (_error) {
-      return [];
-    }
+  async function readActiveEditorOverlay(activePath, referenceFiles, options = {}) {
+    if (!activePath) return { files: [], skipped: [] };
+    const references = referenceFiles ? new Map(referenceFiles
+      .filter(file => file.kind !== 'binary' && typeof file.content === 'string')
+      .map(file => [file.path, file.content])) : null;
+    const ready = await waitForActiveEditorText(activePath, 5000, { ...options, allowEmpty: true, references });
+    return ready.ok
+      ? { files: [editorFile(activePath, ready, 'active-editor')], skipped: [] }
+      : { files: [], skipped: [{ path: activePath, reason: ready.code || ready.reason }] };
   }
 
   function mergeSnapshotFiles(primaryFiles = [], overrideFiles = []) {
@@ -609,7 +611,7 @@
     return projectPaths.every(filePath => capturedPaths.has(filePath));
   }
 
-  async function fetchOverleafDocContent(record) {
+  async function fetchOverleafDocContent(record, expectedProjectId = getProjectId()) {
     if (!record?.id || !record.path) {
       return {
         ok: false,
@@ -625,6 +627,9 @@
       };
     }
 
+    const target = treeOperations.resolveTargetDocument?.(record.path, { projectId });
+    if (projectId !== expectedProjectId || (target && (target.status !== 'known' || target.documentId !== record.id.toLowerCase())))
+      return { ok: false, reason: 'document_identity_mismatch' };
     try {
       const response = await fetch(`${window.location.origin}/project/${encodeURIComponent(projectId)}/doc/${encodeURIComponent(record.id)}`, {
         credentials: 'include',
@@ -639,6 +644,9 @@
         };
       }
       const payload = await response.json();
+      const currentTarget = treeOperations.resolveTargetDocument?.(record.path, { projectId });
+      if (getProjectId() !== projectId || (target && (currentTarget?.status !== 'known' || currentTarget.documentId !== target.documentId)))
+        return { ok: false, reason: 'document_identity_mismatch' };
       const content = readDocPayloadContent(payload);
       if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(content)) {
         return {
@@ -1071,6 +1079,7 @@
       assembleSnapshot,
       buildProjectFileList,
       buildProjectSnapshot,
+      getSnapshotEditorCaptures,
       fetchProjectZipSnapshot,
       getInvalidatedAt,
       getRequestedSnapshotPaths,