codex-overleaf-link 2.5.0 → 2.6.0

package/extension/src/page/snapshotRouter.js

@@ -97,9 +97,10 @@
             };
           }),
           capabilities: {
-            fullProjectSnapshot: true,
+            fullProjectSnapshot: zipSnapshot.pathIdentityComplete !== false,
+            pathIdentityComplete: zipSnapshot.pathIdentityComplete,
             method: 'overleaf-zip-file-list',
-            skipped: [],
+            skipped: zipSnapshot.skipped || [],
             diagnostics: {
               zipEndpoint: zipSnapshot.endpoint,
               zipTiming: zipSnapshot.diagnostics,
@@ -243,7 +244,7 @@
     if (zipSnapshot.ok && zipSnapshot.files.length) {
       const mergedFiles = mergeSnapshotFiles(
         zipSnapshot.files,
-        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [])
+        filterZipSnapshotOverlayFiles(zipSnapshot.files, lightweightSnapshot?.files || [], zipSnapshot.skipped)
       );
       const files = filterRequestedSnapshotFiles(mergedFiles, params, activePath);
       const requestedPathsComplete = params.restrictToRequestedPathsOnly === true
@@ -255,7 +256,9 @@
         activePath,
         files,
         capabilities: {
-          fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : true,
+          fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && zipSnapshot.pathIdentityComplete !== false,
+          pathIdentityComplete: zipSnapshot.pathIdentityComplete,
+          contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
           skipped: zipSnapshot.skipped || [],
@@ -316,7 +319,8 @@
       80
     );
     const files = [];
-    const skipped = [];
+    const skipped = [...(zipSnapshot?.skipped || [])];
+    const ambiguousPaths = new Set(skipped.filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
     if (zipSnapshot && !zipSnapshot.ok) {
       skipped.push({
         path: 'project.zip',
@@ -326,6 +330,7 @@
     let previousSignature = '';
 
     for (const filePath of projectPaths) {
+      if (ambiguousPaths.has(filePath)) continue;
       if (filePath === snapshotActivePath) {
         const ready = await waitForActiveEditorText(filePath, 5000);
         if (!ready.ok) {
@@ -404,7 +409,7 @@
       await waitForActiveEditorText(activePath, 5000);
     }
 
-    if (snapshotActivePath && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
+    if (snapshotActivePath && !ambiguousPaths.has(snapshotActivePath) && !files.length && (!lightweightOnly || params.allowZipFallback === false)) {
       files.push({
         path: snapshotActivePath,
         content: readActiveEditorText(),
@@ -419,7 +424,8 @@
       activePath: snapshotActivePath,
       files,
       capabilities: {
-        fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : requestedPathsComplete,
+        fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && requestedPathsComplete && zipSnapshot?.pathIdentityComplete !== false,
+        pathIdentityComplete: zipSnapshot?.pathIdentityComplete,
         requestedPathsComplete,
         method: resolvePageSnapshotMethod(files, lightweightOnly),
         skipped,
@@ -438,15 +444,14 @@
 
   async function buildZipOnlyProjectSnapshot(params = {}) {
     const activePath = getPassiveActiveFilePath();
-    const activeText = params.serverOnly === true ? '' : activePath ? readActiveEditorText() : '';
+    // 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);
     if (zipSnapshot.ok && zipSnapshot.files.length) {
-      const activeOverlay = params.serverOnly === true ? [] : buildActiveEditorOverlay(activePath, activeText, {
-        allowedPaths: zipSnapshot.files.map(file => file.path)
-      });
       const files = filterRequestedSnapshotFiles(
-        mergeSnapshotFiles(zipSnapshot.files, activeOverlay),
+        mergeSnapshotFiles(zipSnapshot.files, filterZipSnapshotOverlayFiles(zipSnapshot.files, activeOverlay, zipSnapshot.skipped)),
         params,
         activePath
       );
@@ -459,7 +464,9 @@
         activePath,
         files,
         capabilities: {
-          fullProjectSnapshot: params.restrictToRequestedPathsOnly === true ? false : true,
+          fullProjectSnapshot: params.restrictToRequestedPathsOnly !== true && zipSnapshot.pathIdentityComplete !== false,
+          pathIdentityComplete: zipSnapshot.pathIdentityComplete,
+          contentComplete: !(zipSnapshot.skipped || []).length,
           requestedPathsComplete,
           method: 'overleaf-zip',
           skipped: zipSnapshot.skipped || [],
@@ -478,16 +485,18 @@
       id: getProjectId(),
       url: window.location.href,
       activePath,
-      files: params.serverOnly === true ? [] : buildActiveEditorOverlay(activePath, activeText),
+      files: filterZipSnapshotOverlayFiles([], activeOverlay, zipSnapshot.skipped, true),
       capabilities: {
         fullProjectSnapshot: false,
+        pathIdentityComplete: zipSnapshot.pathIdentityComplete,
         method: params.serverOnly === true ? 'overleaf-zip-unavailable'
-          : activePath && window.CodexOverleafProjectFiles.isUsableProjectFileContent(activeText)
+          : activeOverlay.length
           ? 'active-editor-zip-only-fallback'
           : 'zip-only-fallback-empty',
-        skipped: [{
+        contentComplete: false,
+        skipped: [...(zipSnapshot.skipped || []), {
           path: 'project.zip',
-          reason: zipSnapshot.reason
+          reason: zipSnapshot.reason || 'ZIP file identities were incomplete'
         }],
         diagnostics: {
           docRecordCount: 0,
@@ -500,9 +509,11 @@
     };
   }
 
-  function filterZipSnapshotOverlayFiles(zipFiles = [], overlayFiles = []) {
+  function filterZipSnapshotOverlayFiles(zipFiles = [], overlayFiles = [], skipped = [], allowMissing = false) {
     const zipPaths = new Set((zipFiles || []).map(file => file.path).filter(Boolean));
-    return (overlayFiles || []).filter(file => file?.source !== 'active-editor' || zipPaths.has(file.path));
+    const ambiguousPaths = new Set((skipped || []).filter(file => file.reason === 'zip_path_duplicate').map(file => file.path));
+    return (overlayFiles || []).filter(file => !ambiguousPaths.has(file?.path)
+      && (allowMissing || file?.source !== 'active-editor' || zipPaths.has(file.path)));
   }
 
   function getRequestedSnapshotPaths(params = {}, activePath = '') {
@@ -520,19 +531,32 @@
     return (files || []).filter(file => requestedSet.has(file?.path));
   }
 
-  function buildActiveEditorOverlay(activePath, activeText, options = {}) {
-    if (!activePath || !window.CodexOverleafProjectFiles.isUsableProjectFileContent(activeText)) {
-      return [];
-    }
-    if (Array.isArray(options.allowedPaths) && !options.allowedPaths.includes(activePath)) {
+  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 [];
     }
-    return [{
-      path: activePath,
-      content: activeText,
-      source: 'active-editor',
-      kind: 'text'
-    }];
   }
 
   function mergeSnapshotFiles(primaryFiles = [], overrideFiles = []) {
@@ -541,7 +565,7 @@
       if (!file?.path || file.kind === 'binary' || typeof file.content !== 'string') {
         continue;
       }
-      if (!window.CodexOverleafProjectFiles.isUsableProjectFileContent(file.content)) {
+      if (file.content.trim() && !window.CodexOverleafProjectFiles.isUsableProjectFileContent(file.content)) {
         continue;
       }
       filesByPath.set(file.path, {
@@ -691,7 +715,7 @@
         });
         const extractMs = Date.now() - extractStartedAt;
         const files = extracted.files || [];
-        if (!files.length) {
+        if (!files.length && extracted.pathIdentityComplete !== false) {
           attempts.push({
             endpoint,
             status: response.status,
@@ -715,6 +739,7 @@
         return {
           ok: true,
           endpoint,
+          pathIdentityComplete: extracted.pathIdentityComplete,
           skipped: extracted.skipped || [],
           files: files.map(file => ({
             ...file,
@@ -841,6 +866,9 @@
     const entryCount = view.getUint16(eocdOffset + 10, true);
     const centralDirectoryOffset = view.getUint32(eocdOffset + 16, true);
     const decoder = new TextDecoder('utf-8');
+    const nameDecoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    const seenPaths = new Set();
+    let pathIdentityComplete = true;
     const files = [];
     const skipped = [];
     let binaryBytes = 0;
@@ -859,7 +887,25 @@
       const commentLength = view.getUint16(offset + 32, true);
       const localHeaderOffset = view.getUint32(offset + 42, true);
       const rawName = bytes.slice(offset + 46, offset + 46 + fileNameLength);
-      const path = normalizeSafeProjectPath(decoder.decode(rawName));
+      let name = '';
+      try { name = nameDecoder.decode(rawName); } catch (_error) { /* unknown identity is incomplete */ }
+      const directory = name.endsWith('/');
+      const path = normalizeSafeProjectPath(directory ? name.slice(0, -1) : name);
+      if (!path || seenPaths.has(path)) {
+        if (path) {
+          const previousIndex = files.findIndex(file => file.path === path);
+          if (previousIndex >= 0) files.splice(previousIndex, 1);
+        }
+        pathIdentityComplete = false;
+        skipped.push({ path: name, reason: path ? 'zip_path_duplicate' : 'zip_path_invalid', unknownPath: !name });
+        offset += 46 + fileNameLength + extraLength + commentLength;
+        continue;
+      }
+      seenPaths.add(path);
+      if (directory) {
+        offset += 46 + fileNameLength + extraLength + commentLength;
+        continue;
+      }
       const isText = window.CodexOverleafProjectFiles.isTextProjectPath(path);
       const shouldInclude = path && !path.endsWith('/') && (isText || options.includeBinaryFiles);
 
@@ -904,7 +950,7 @@
       offset += 46 + fileNameLength + extraLength + commentLength;
     }
 
-    return { files, skipped };
+    return { files, skipped, pathIdentityComplete };
   }
 
   function uint8ArrayToBase64(bytes) {
@@ -1035,11 +1081,10 @@
   }
 
   function fallbackNormalizeSafeProjectPath(value) {
-    const text = String(value || '').replace(/\\/g, '/').replace(/\/+/g, '/').replace(/^\/+|\/+$/g, '').trim();
-    if (!text || text.split('/').some(part => !part || part === '.' || part === '..')) {
-      return '';
-    }
-    return text;
+    if (typeof value !== 'string' || !value || value.length > 2048 || value.trim() !== value
+      || /[\u0000-\u001f\u007f]/.test(value) || value.startsWith('/')
+      || value.includes('\\') || /^[A-Za-z]:/.test(value)) return '';
+    return value.split('/').some(part => !part || part === '.' || part === '..') ? '' : value;
   }
 
   return { create };

package/extension/src/page/textCoordinates.js

@@ -6,7 +6,7 @@
   'use strict';
 
   function resolveJumpToPositionRange(params, text, filePath) {
-    if (params.line === undefined && params.column === undefined) {
+    if (params.line === undefined && params.column === undefined && params.endLine === undefined) {
       return {
         ok: true,
         from: params.from,
@@ -33,6 +33,22 @@
       });
     }
 
+    if (params.endLine !== undefined) {
+      const endLineNumber = Number(params.endLine);
+      if (!Number.isInteger(endLineNumber) || endLineNumber < lineNumber) {
+        return jumpPositionOutOfRange('line_out_of_range', filePath, {
+          line: lineNumber,
+          endLine: Number.isInteger(endLineNumber) ? endLineNumber : params.endLine,
+          lineCount
+        });
+      }
+      return {
+        ok: true,
+        from: line.start,
+        to: lines[Math.min(endLineNumber, lineCount) - 1].end
+      };
+    }
+
     const lineLength = line.end - line.start;
     if (params.selectLine === true) {
       return {

package/extension/src/page/textFileCreator.js

@@ -1,7 +1,7 @@
 (function (root, factory) {
-  if (typeof module === 'object' && module.exports) module.exports = factory();
-  else root.CodexOverleafTextFileCreator = factory();
-})(typeof window !== 'undefined' ? window : globalThis, function () {
+  if (typeof module === 'object' && module.exports) module.exports = factory(require('./ownedDirectoryCleanup'));
+  else root.CodexOverleafTextFileCreator = factory(root.CodexOverleafOwnedDirectoryCleanup);
+})(typeof window !== 'undefined' ? window : globalThis, function (OwnedDirectoryCleanup) {
   'use strict';
 
   const MAX_CONFIRMATION_OBSERVATIONS = 8;
@@ -18,6 +18,7 @@
     const delay = ms => new Promise(resolve => window.setTimeout(resolve, ms));
     const now = typeof deps.now === 'function' ? deps.now : Date.now;
     const verificationReads = new Set();
+    const uploadParentProofs = new WeakMap();
     const verificationBudget = () => ({ remainingMs: 90000 });
     async function pauseVerification(budget, durationMs) {
       const started = now();
@@ -81,7 +82,18 @@
             } : {}) };
           } finally { if (controller) verificationReads.delete(controller); }
           assertVerificationOwner(projectId, isCurrent);
-          if (result?.ok === true && Array.isArray(result.files)) return result;
+          if (result?.ok === true && Array.isArray(result.files)) {
+            const skipped = [...(Array.isArray(result.skipped) ? result.skipped : []),
+              ...(Array.isArray(result.capabilities?.skipped) ? result.capabilities.skipped : [])];
+            if (result.pathIdentityComplete === false || result.capabilities?.pathIdentityComplete === false
+              || skipped.some(file => file?.unknownPath || ['zip_path_invalid', 'zip_path_duplicate'].includes(file?.reason))) {
+              throw Object.assign(new Error('The server snapshot contains unresolved file identities; absence cannot be confirmed.'), {
+                code: 'source_zip_unavailable', originalCode: 'zip_path_identity_incomplete', retryable: false,
+                diagnostics: { ...(result.diagnostics || {}), pathIdentityComplete: false }
+              });
+            }
+            return result;
+          }
           last = Object.assign(new Error('The server project snapshot could not be read.'), {
             code: 'source_zip_unavailable', diagnostics: result?.diagnostics || null,
             technicalMessage: result?.reason || 'No complete server snapshot was returned.',
@@ -96,9 +108,14 @@
     }
     function verificationFailure(error, changedDocument, phase) {
       const interrupted = ['codex_cancelled', 'aborted_project_changed'].includes(error?.code);
-      const code = interrupted ? error.code : changedDocument ? 'file_upload_unconfirmed' : 'source_zip_unavailable';
+      // Only a failed server read means the project could not be checked; any
+      // other error before the upload came from the Overleaf file-tree controls.
+      const treeControls = !interrupted && !changedDocument && error?.code !== 'source_zip_unavailable';
+      const code = interrupted ? error.code : changedDocument ? 'file_upload_unconfirmed'
+        : treeControls ? 'file_tree_controls_unavailable' : 'source_zip_unavailable';
       const reason = interrupted ? error.message : changedDocument
         ? 'The file was submitted, but its saved content could not be confirmed.'
+        : treeControls ? 'Codex could not safely perform this file operation with the available Overleaf controls.'
         : 'The project could not be checked before uploading this file.';
       return { ok: false, code, reason, changedDocument, diagnostics: {
         verificationPhase: phase, ...(error?.diagnostics || {}), reason: error?.technicalMessage || error?.message || ''
@@ -142,11 +159,13 @@
         if (!lastError && observed.get(operation.path)?.content === operation.content) {
           results.push({ operation, result: { ok: true, verified: true, changedDocument: true,
             method: 'overleaf.native-text-upload', verification: 'overleaf-zip',
+            createdDirectories: entry.result?.createdDirectories || [], fileUploadAttempted: entry.result?.fileUploadAttempted === true,
             saveReceipt: await makeSaveReceipt(batch.projectId, operation.path, operation.content) } });
         } else {
-          results.push({ operation, result: verificationFailure(lastError || new Error(
+          results.push({ operation, result: { ...verificationFailure(lastError || new Error(
             observed.has(operation.path) ? 'Server content differs from the submitted file.' : 'The file is not yet present in the server snapshot.'
-          ), true, 'post-upload') });
+          ), true, 'post-upload'), createdDirectories: entry.result?.createdDirectories || [],
+            fileUploadAttempted: entry.result?.fileUploadAttempted === true } });
         }
       }
       // The final fresh snapshot can also prove unrelated edits in this batch.
@@ -191,6 +210,10 @@
       return folder;
     };
 
+    const directoryCleanup = OwnedDirectoryCleanup.create({ document, treeOperations, delay, now,
+      readServerSnapshot, assertVerificationOwner, normalizeDomText, normalizeSafeProjectPath });
+    const { folderIdentity, cleanupCreatedDirectories } = directoryCleanup;
+
     async function createFolderWithDom(entryPath, options = {}) {
       const target = normalizeSafeProjectPath(entryPath);
       const projectId = getProjectId();
@@ -230,7 +253,15 @@
         toggle.click();
         await waitFor(() => findFolder(parentPath)?.getAttribute('aria-expanded') === 'true');
       };
-      let ownedDialog = null;
+      let ownedDialog = null, createdProof = null;
+      const publishProof = () => {
+        if (!createdProof) return;
+        if (getProjectId() === projectId) {
+          const row = findFolder(target);
+          if (row) { createdProof.nativeFolderId = folderIdentity(row); createdProof.observedAfterCreate = true; }
+        }
+        options.onCreatedDirectory?.({ ...createdProof });
+      };
       try {
         assertCurrent();
         if (findFolder(target)) return;
@@ -259,12 +290,18 @@
         await delay(0);
         assertCurrent();
         if (findFolder(target) || projectPathExists(target)) throw new Error('The target path appeared during creation; no replacement was attempted.');
+        const confirm = choose(ownedDialog, /^(?:Create|创建)$/i);
+        createdProof = { v: 1, projectId, path: target, nativeFolderId: '', ownershipConfirmed: false, observedAfterCreate: false };
+        options.onCreatedDirectory?.({ ...createdProof });
         options.onMutation?.();
-        choose(ownedDialog, /^(?:Create|创建)$/i).click();
+        confirm.click();
+        publishProof();
         await waitFor(() => !dialogs().length);
         await expandParent();
         await waitFor(() => findFolder(target));
+        publishProof();
       } finally {
+        publishProof();
         if (ownedDialog && getProjectId() === projectId && dialogs().includes(ownedDialog)) {
           const cancel = Array.from(ownedDialog.querySelectorAll('button')).filter(node => visible(node) && /^(?:Cancel|取消)$/i.test(controlName(node)));
           if (cancel.length === 1) cancel[0].click();
@@ -281,7 +318,12 @@
       if (!target || !projectId || typeof operation.content !== 'string' || !window.CodexOverleafProjectFiles?.isTextProjectPath(target)) {
         return { ok: false, code: 'invalid_project_path', reason: 'A valid text-file path and project are required.' };
       }
-      let mutationAttempted = false;
+      let mutationAttempted = false, fileUploadAttempted = false;
+      const createdDirectories = [];
+      const recordDirectory = proof => {
+        const index = createdDirectories.findIndex(item => item.path === proof.path);
+        if (index < 0) createdDirectories.push(proof); else createdDirectories[index] = proof;
+      };
       let verificationPhase = 'preflight', zipReadCount = 0, lastZipFailure = null;
       const readBudget = options.batch?.budget || verificationBudget();
       let uploadDialog = null;
@@ -346,7 +388,7 @@
         data.items.add(file);
         assertCurrent();
         uploadHelpers.assignFilesToInput(input, data.files, window);
-        mutationAttempted = true;
+        mutationAttempted = true; fileUploadAttempted = true;
         options.batch?.pending.set(target, operation);
         input.dispatchEvent(new window.Event('change', { bubbles: true }));
         // Never click Replace/Overwrite. A concurrent name conflict must stop.
@@ -402,20 +444,28 @@
           const folderPath = parts.slice(0, depth).join('/');
           if (!findFolder(folderPath)) await createFolderWithDom(folderPath, {
             isCurrent: () => { assertCurrent(); return true; },
-            onMutation: () => { mutationAttempted = true; }
+            onMutation: () => { mutationAttempted = true; }, onCreatedDirectory: recordDirectory
           });
           await ensureFolderExpanded(folderPath);
         }
         await uploadText();
-        if (options.batch) return { ok: false, pendingVerification: true, changedDocument: true };
-        return { ok: true, method: 'overleaf.native-text-upload', changedDocument: true,
+        if (options.batch) return { ok: false, pendingVerification: true, changedDocument: true, createdDirectories, fileUploadAttempted };
+        return { ok: true, method: 'overleaf.native-text-upload', changedDocument: true, createdDirectories, fileUploadAttempted,
           verified: true, verification: 'overleaf-zip',
           saveReceipt: await makeSaveReceipt(projectId, target, operation.content) };
       } catch (error) {
-        return {
-          ...verificationFailure(error, mutationAttempted, verificationPhase),
-          diagnostics: { verificationPhase, zipReadCount, lastZipFailure }
-        };
+        const directoryCleanup = createdDirectories.length
+          ? await cleanupCreatedDirectories(createdDirectories, { projectId, isCurrent: options.isCurrent }) : undefined;
+        const result = verificationFailure(error, mutationAttempted, verificationPhase);
+        if (!fileUploadAttempted && mutationAttempted) {
+          const reason = directoryCleanup?.ok ? 'File upload did not start. The new empty folders were removed.'
+            : 'File upload did not start. Some new folders remain and need review.';
+          result.reason = reason; result.code = 'file_tree_operation_unverified';
+          result.failure = { ...result.failure, code: result.code, stage: 'directory-preparation', userMessage: reason,
+            nextAction: directoryCleanup?.ok ? 'Retry sync to create the file.' : 'Review the remaining folders before retrying.' };
+        }
+        return { ...result, createdDirectories: directoryCleanup?.remaining || createdDirectories,
+          fileUploadAttempted, directoryCleanup, diagnostics: { verificationPhase, zipReadCount, lastZipFailure } };
       } finally {
         if (uploadDialog && getProjectId() === projectId && dialogs().includes(uploadDialog)) {
           const close = Array.from(uploadDialog.querySelectorAll('button')).find(node => visible(node)
@@ -424,6 +474,31 @@
         }
       }
     }
+    const rootUploadIdentity = row => row?.querySelector?.('[data-file-type="doc"][data-file-id], [data-file-type="file"][data-file-id]')
+      ?.getAttribute?.('data-file-id') || '';
+    function rememberUploadParent(path, node, projectId) {
+      if (node && typeof node === 'object') uploadParentProofs.set(node, Object.freeze({
+        path, projectId, nativeId: path ? folderIdentity(node) : rootUploadIdentity(node)
+      }));
+      return node;
+    }
+    // Synchronous last-moment guard after any uploader await. Snapshot the
+    // identity at preparation, since React can reuse a DOM row for a new ID.
+    function isUploadParentCurrent(folderPath, parentNode) {
+      const target = normalizeSafeProjectPath(folderPath);
+      const proof = parentNode && uploadParentProofs.get(parentNode);
+      if ((!target && folderPath !== '') || !proof?.projectId || !proof.nativeId
+        || proof.path !== target || getProjectId() !== proof.projectId) return false;
+      const root = document.querySelector('[data-testid="file-tree-list-root"], .file-tree-list[role="tree"]');
+      if (!root?.children) return false;
+      const selected = Array.from(root.querySelectorAll?.('[role="treeitem"]') || [])
+        .filter(row => row.getAttribute('aria-selected') === 'true');
+      if (selected.length !== 1 || selected[0] !== parentNode) return false;
+      if (!target) return parentNode.closest?.('[role="tree"]') === root
+        && !parentNode.querySelector('[data-file-type="folder"]') && rootUploadIdentity(parentNode) === proof.nativeId;
+      return findFolder(target) === parentNode && folderIdentity(parentNode) === proof.nativeId;
+    }
+
     // Binary uploads use the same folder hierarchy as verified text uploads.
     // A folder is not a text document and must never use basename fallback.
     async function prepareUploadParent(folderPath, options = {}) {
@@ -454,7 +529,7 @@
         if (selected.length !== 1 || selected[0] !== anchor || anchor.closest('[role="tree"]') !== currentRoot) {
           throw new Error('Overleaf did not confirm the selected root upload parent.');
         }
-        return anchor;
+        return rememberUploadParent('', anchor, projectId);
       }
       const expand = async path => {
         assertCurrent();
@@ -479,7 +554,8 @@
         const path = parts.slice(0, depth).join('/');
         assertCurrent();
         if (!findFolder(path) && options.createMissing === true) await createFolderWithDom(path, {
-          isCurrent: () => { assertCurrent(); return true; }, onMutation: options.onMutation
+          isCurrent: () => { assertCurrent(); return true; }, onMutation: options.onMutation,
+          onCreatedDirectory: options.onCreatedDirectory
         });
         await expand(path);
       }
@@ -493,7 +569,7 @@
       if (selected.getAttribute('aria-selected') !== 'true') {
         throw new Error('Overleaf did not confirm the selected upload parent.');
       }
-      return selected;
+      return rememberUploadParent(target, selected, projectId);
     }
 
     async function prepareEditor(params = {}) {
@@ -539,6 +615,9 @@
     async function ensureWriteMode(reviewing, params = {}) {
       const ensureMode = reviewing ? deps.ensureReviewing : deps.ensureEditing;
       if (typeof ensureMode !== 'function') return { ok: false, reason: 'Editor mode controls are unavailable.' };
+      // An open paywall can make the underlying editor inert. Detect it before
+      // preparation attempts any file navigation behind that modal.
+      if (reviewing && deps.findUpgradeModal?.()) return ensureMode(params);
       const prepared = await prepareEditor(params);
       return prepared.ok ? ensureMode(params) : prepared;
     }
@@ -552,6 +631,15 @@
       const deadlineAt = Math.min(now() + 90000, Number.isFinite(options.deadlineAt) ? options.deadlineAt : Infinity);
       const preflightDeadlineAt = deadlineAt - 15000;
       const expected = options.expectedContent;
+      const finishCreatedDeletion = result => {
+        const proofs = operation.undoCreatedFile?.createdDirectories;
+        if (options.undoCreatedFile !== true || !Array.isArray(proofs) || !proofs.length) return result;
+        // The ZIP-confirmed file deletion completes its Undo checkpoint.
+        // Directory observations are retained separately and grant no deletion authority.
+        return { ...result, fileDeleted: true, directoryCleanup: {
+          ok: false, removed: [], remaining: proofs, changedDocument: false
+        } };
+      };
       const binary = operation.undoCreatedFile?.v === 1 && operation.undoCreatedFile.kind === 'binary'
         && options.undoCreatedFile === true && /^[a-f0-9]{64}$/i.test(options.expectedSha256 || '');
       const matchesExpected = async file => {
@@ -658,8 +746,8 @@
         if (!snapshotRouter?.fetchProjectZipSnapshot) throw new Error('Verified deletion support is unavailable.');
         const original = (await readServerFiles()).find(file => file.path === target);
         if (!original && options.undoCreatedFile === true && !resolveRow()) {
-          return { ok: true, method: 'overleaf.native-created-file-delete', changedDocument: false,
-            idempotent: true, verified: true, verification: 'overleaf-zip' };
+          return finishCreatedDeletion({ ok: true, method: 'overleaf.native-created-file-delete', changedDocument: false,
+            idempotent: true, verified: true, verification: 'overleaf-zip' });
         }
         const originalMatches = await matchesExpected(original);
         assertCurrent();
@@ -741,8 +829,8 @@
         for (let observation = 0; ; observation++) {
           const files = await readServerFiles();
           if (!files.some(file => file.path === target)) {
-            return { ok: true, method: binary ? 'overleaf.native-created-file-delete' : 'overleaf.native-text-delete', changedDocument: true,
-              verified: true, verification: 'overleaf-zip' };
+            return finishCreatedDeletion({ ok: true, method: binary ? 'overleaf.native-created-file-delete' : 'overleaf.native-text-delete', changedDocument: true,
+              verified: true, verification: 'overleaf-zip' });
           }
           await delay(Math.min(250 * (2 ** Math.min(observation, 3)), remainingMs()));
         }
@@ -776,7 +864,7 @@
     async function createFile(operation, options = {}) {
       return createTextFileWithDom(operation, options);
     }
-    return { createFile, deleteFile, prepareEditor, ensureWriteMode, prepareUploadParent, findFolderNode: findFolder,
+    return { createFile, deleteFile, prepareEditor, ensureWriteMode, prepareUploadParent, isUploadParentCurrent, cleanupCreatedDirectories, findFolderNode: findFolder,
       beginCreateBatch, finishCreateBatch,
       cancelVerifications() { for (const controller of verificationReads) controller.abort(); } };
   }

package/extension/src/page/trackedChangeCapture.js

@@ -129,12 +129,22 @@
     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({
+    const { mergedInsertionScope, prepareMergedInsertionReview, nativeOwned, rangesFor, shiftedBaseline, scopeCovered, reviewNodeMatches } = Ownership.create({
       fingerprint, readActiveEditorText, mergedPrefix, nativeKey, ledgerKeys
     });
 
 
 
+    function isTrackedChangeNodeInNativeScope(node, path) {
+      if (typeof deps.getCodeMirrorEditorView !== 'function') return true;
+      return reviewNodeMatches(node, path, readNativeSnapshot(path), explicitId(node));
+    }
+    function rememberTrackedChangeNodeContext(path) {
+      if (typeof deps.getCodeMirrorEditorView !== 'function') return;
+      const snapshot = readNativeSnapshot(path);
+      if (snapshot.ready) for (const node of collectTrackedChangeNodes()) reviewNodeMatches(node, path, snapshot, explicitId(node));
+    }
+
     function prepareTrackedChangeReview(path, refs = []) {
       const snapshot = readNativeSnapshot(path);
       const blocked = reason => ({ ...snapshot, ok: false, reason });
@@ -321,7 +331,7 @@
       }
       return observe(capture, params.expectedContent, 1200);
     }
-    return { collectTrackedChangeNodes, trackedChangeRefFromNode, collectTrackedChangeRefsForPaths,
+    return { collectTrackedChangeNodes, trackedChangeRefFromNode, collectTrackedChangeRefsForPaths, isTrackedChangeNodeInNativeScope, rememberTrackedChangeNodeContext,
       waitForTrackedChangeDiff, prepareTrackedChangeCapture, prepareTrackedChangeReview, prepareUntrackedUndo, getTrackedChangeCaptureStatus, captureTrackedWrite, reconcileTrackedChangeCapture };
   }
   return { create };

package/extension/src/page/trackedChangeOwnership.js

@@ -191,7 +191,25 @@
       }));
     }
 
-    return { mergedInsertionScope, prepareMergedInsertionReview, nativeOwned, rangesFor, shiftedBaseline, scopeCovered };
+    const reviewNodeOwners = new WeakMap();
+    function reviewNodeMatches(node, path, snapshot, id = '') {
+      if (!node || snapshot?.ready !== true || !snapshot.nativeDocId) return false;
+      const explicitPath = node.getAttribute?.('data-path') || node.getAttribute?.('data-file-path') || node.getAttribute?.('data-doc-path');
+      if (explicitPath && explicitPath !== path) return false;
+      const rawPosition = node.getAttribute?.('data-pos'), from = Number(rawPosition);
+      const parts = Array.from(node.querySelectorAll?.('.review-panel-expandable-content') || []);
+      if (parts.length !== 1 || (!id && (rawPosition == null || rawPosition === '' || !Number.isSafeInteger(from) || from < 0))) return false;
+      const kind = /(?:delete|change-d)(?:\s|$)/.test(node.className || '') ? 'delete' : 'insert';
+      const textHash = fingerprint(parts[0].textContent || '');
+      if (!snapshot.refs.some(ref => (id ? ref.id === id : ref.from === from) && ref.kind === kind && ref.textHash === textHash)) return false;
+      const signature = JSON.stringify([id, from, kind, textHash]);
+      const prior = reviewNodeOwners.get(node);
+      if (prior && prior.docId !== snapshot.nativeDocId && prior.signature === signature) return false;
+      reviewNodeOwners.set(node, { docId: snapshot.nativeDocId, signature });
+      return true;
+    }
+
+    return { mergedInsertionScope, prepareMergedInsertionReview, nativeOwned, rangesFor, shiftedBaseline, scopeCovered, reviewNodeMatches };
   }
 
   return { create };