codex-overleaf-link 2.4.1 → 2.5.1

package/extension/src/content/writtenChangesView.js

@@ -0,0 +1,152 @@
+(function initCodexOverleafWrittenChangesView(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafModuleRegistry.define('WrittenChangesView', [], factory);
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function writtenChangesViewFactory() {
+  'use strict';
+
+  // Read-only receipt for changes already written to Overleaf: one folded row
+  // per file, and inside it only the changed lines with word-level marks.
+  // Reviewing-mode hunks with Accept/Reject stay in DiffReviewPanel.
+  const CONTEXT_LINES = 1;
+  const MAX_WORD_DIFF_TOKENS = 600;
+  // CJK characters diff one by one; Latin words, spaces and punctuation as runs.
+  const TOKEN = /[\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]|[A-Za-z0-9_]+|\s+|\\[A-Za-z]+|[^\sA-Za-z0-9_\u3000-\u9fff\uac00-\ud7af\uff00-\uffef]/g;
+
+  function tokenize(text) {
+    return String(text || '').match(TOKEN) || [];
+  }
+
+  // Classic LCS over tokens; returns [{ type: 'same'|'del'|'ins', text }].
+  function diffWords(before, after) {
+    const a = tokenize(before), b = tokenize(after);
+    if (a.length > MAX_WORD_DIFF_TOKENS || b.length > MAX_WORD_DIFF_TOKENS) {
+      return [{ type: 'del', text: String(before) }, { type: 'ins', text: String(after) }];
+    }
+    const table = Array.from({ length: a.length + 1 }, () => new Uint16Array(b.length + 1));
+    for (let i = a.length - 1; i >= 0; i -= 1) {
+      for (let j = b.length - 1; j >= 0; j -= 1) {
+        table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
+      }
+    }
+    const parts = [];
+    const push = (type, text) => {
+      const last = parts[parts.length - 1];
+      if (last?.type === type) last.text += text; else parts.push({ type, text });
+    };
+    let i = 0, j = 0;
+    while (i < a.length && j < b.length) {
+      if (a[i] === b[j]) { push('same', a[i]); i += 1; j += 1; }
+      else if (table[i + 1][j] >= table[i][j + 1]) { push('del', a[i]); i += 1; }
+      else { push('ins', b[j]); j += 1; }
+    }
+    while (i < a.length) push('del', a[i++]);
+    while (j < b.length) push('ins', b[j++]);
+    return parts;
+  }
+
+  // Turns diff hunk lines into display rows: paired remove/add runs become one
+  // merged row; long unchanged stretches fold into a gap row.
+  function buildRows(lines) {
+    const rows = [];
+    for (let index = 0; index < lines.length;) {
+      const line = lines[index];
+      if (line?.type !== 'remove' && line?.type !== 'add') {
+        rows.push({ kind: 'context', text: String(line?.text ?? '') });
+        index += 1;
+        continue;
+      }
+      const removed = [], added = [];
+      while (lines[index]?.type === 'remove') removed.push(String(lines[index++].text ?? ''));
+      while (lines[index]?.type === 'add') added.push(String(lines[index++].text ?? ''));
+      const paired = Math.min(removed.length, added.length);
+      for (let k = 0; k < paired; k += 1) rows.push({ kind: 'change', parts: diffWords(removed[k], added[k]) });
+      for (const text of removed.slice(paired)) rows.push({ kind: 'change', parts: [{ type: 'del', text }] });
+      for (const text of added.slice(paired)) rows.push({ kind: 'change', parts: [{ type: 'ins', text }] });
+    }
+    const near = rows.map((row, index) => row.kind === 'change'
+      || rows.slice(Math.max(0, index - CONTEXT_LINES), index + CONTEXT_LINES + 1).some(other => other.kind === 'change'));
+    const out = [];
+    for (let index = 0; index < rows.length;) {
+      if (near[index]) { out.push(rows[index]); index += 1; continue; }
+      let end = index;
+      while (end < rows.length && !near[end]) end += 1;
+      out.push({ kind: 'gap', count: end - index });
+      index = end;
+    }
+    return out;
+  }
+
+  function countLines(diff) {
+    let added = 0, removed = 0;
+    for (const hunk of diff || []) {
+      for (const line of hunk?.lines || []) {
+        if (line?.type === 'add') added += 1;
+        else if (line?.type === 'remove') removed += 1;
+      }
+    }
+    return { added, removed };
+  }
+
+  function render(changes, { document: doc = globalThis.document, tx = en => en } = {}) {
+    const make = (tag, className, text) => {
+      const el = doc.createElement(tag);
+      if (className) el.className = className;
+      if (text !== undefined) el.textContent = text;
+      return el;
+    };
+    const list = make('div', 'run-written-changes');
+    list.setAttribute('role', 'list');
+    for (const change of changes || []) {
+      if (!change?.path || !Array.isArray(change.diff) || !change.diff.length) continue;
+      const file = make('details', 'run-written-file');
+      file.setAttribute('role', 'listitem');
+      const summary = make('summary', 'run-written-file-sum');
+      const name = make('span', 'run-written-file-name', change.path.split('/').pop());
+      name.title = change.path;
+      const { added, removed } = countLines(change.diff);
+      summary.append(name);
+      if (change.path.includes('/')) summary.append(make('span', 'run-written-file-dir', change.path.slice(0, change.path.lastIndexOf('/'))));
+      const counts = make('span', 'run-written-file-counts');
+      counts.append(make('span', 'run-written-add', '+' + added), make('span', 'run-written-del', '−' + removed));
+      counts.setAttribute('aria-label', tx(`${added} lines added, ${removed} removed`, `新增 ${added} 行，删除 ${removed} 行`));
+      summary.append(counts);
+      file.append(summary);
+      // Lazy body: thesis chapters produce long diffs, so build on first open.
+      file.addEventListener('toggle', () => {
+        if (!file.open || file.dataset.built) return;
+        file.dataset.built = 'true';
+        const body = make('div', 'run-written-body');
+        for (const hunk of change.diff) {
+          if (hunk?.truncated) {
+            body.append(make('div', 'run-written-row run-written-note', String(hunk.lines?.[0]?.text || '')));
+            continue;
+          }
+          const head = make('div', 'run-written-hunk', tx(`Line ${hunk?.startB ?? '?'}`, `第 ${hunk?.startB ?? '?'} 行`));
+          body.append(head);
+          for (const row of buildRows(hunk?.lines || [])) {
+            if (row.kind === 'gap') {
+              body.append(make('div', 'run-written-row run-written-gap', tx(`… ${row.count} unchanged lines`, `… ${row.count} 行未改动`)));
+            } else if (row.kind === 'context') {
+              body.append(make('div', 'run-written-row', row.text || ' '));
+            } else {
+              const line = make('div', 'run-written-row is-changed');
+              for (const part of row.parts) {
+                line.append(part.type === 'same' ? doc.createTextNode(part.text)
+                  : make(part.type === 'ins' ? 'ins' : 'del', '', part.text));
+              }
+              body.append(line);
+            }
+          }
+        }
+        file.append(body);
+      });
+      list.append(file);
+    }
+    return list;
+  }
+
+  return { render, diffWords, buildRows, countLines };
+});

package/extension/src/page/binaryAssetUploader.js

@@ -13,6 +13,18 @@
     const treeOperations = deps.treeOperations;
     const snapshotRouter = deps.snapshotRouter;
     const transfers = new Map();
+    // Keep bounded receipts after payload release; status reads never re-upload.
+    const receipts = new Map();
+    function pruneReceipts() {
+      for (const [id, transfer] of receipts) {
+        if (transfer.finishedAt && Date.now() - transfer.finishedAt > 600000) receipts.delete(id);
+      }
+      while (receipts.size >= 32) {
+        const entry = Array.from(receipts).find(([, value]) => value.finishedAt);
+        if (!entry) break;
+        receipts.delete(entry[0]);
+      }
+    }
 
     function begin(params = {}) {
       let transferId;
@@ -30,14 +42,26 @@
       if (!/^[a-f0-9]{64}$/i.test(String(params.sha256 || ''))) {
         return failure('binary_asset_hash_invalid', 'Asset SHA-256 is missing or invalid.');
       }
+      if (params.overwrite === true && !/^[a-f0-9]{64}$/i.test(String(params.previousSha256 || ''))) {
+        return failure('binary_asset_baseline_missing', 'The original binary version is unavailable. Read the project again before replacing this file.');
+      }
+      pruneReceipts();
+      if (transfers.has(transferId) || receipts.has(transferId)) {
+        return failure('binary_upload_transfer_conflict', 'Asset transfer ID is already in use.');
+      }
+      if (transfers.size >= 32 || receipts.size >= 32) {
+        return failure('binary_upload_busy', 'Too many asset transfers are pending.');
+      }
       transfers.set(transferId, {
         id: transferId,
         path: projectPath,
         size,
         sha256: String(params.sha256).toLowerCase(),
+        previousSha256: params.overwrite === true ? String(params.previousSha256).toLowerCase() : '',
         mimeType: String(params.mimeType || 'application/octet-stream'),
         projectId: treeOperations.getProjectId(),
         overwrite: params.overwrite === true,
+        createdDirectories: [], folderChanged: false, fileUploadAttempted: false,
         chunks: [],
         received: 0
       });
@@ -62,7 +86,59 @@
       return { ok: true, transferId: transfer.id, received: transfer.received };
     }
 
-    async function commit(params = {}) {
+    function commit(params = {}) {
+      const id = String(params.transferId || '');
+      const existing = receipts.get(id);
+      if (existing) {
+        if (existing.projectId !== treeOperations.getProjectId()) {
+          return Promise.resolve(failure('binary_upload_scope_changed', 'Asset project changed.'));
+        }
+        return existing.promise;
+      }
+      const transfer = transfers.get(id);
+      if (!transfer) return Promise.resolve(failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.'));
+      receipts.set(id, transfer);
+      transfer.promise = commitOnce(params).catch(error => ({
+        ...failure(error.code || 'binary_upload_failed', error.message),
+        changedDocument: transfer.mutationAttempted === true
+      })).then(async result => {
+        if (result.ok !== true && transfer.createdDirectories.length && typeof deps.cleanupCreatedDirectories === 'function') {
+          try {
+            const cleanup = await deps.cleanupCreatedDirectories(transfer.createdDirectories, {
+              projectId: transfer.projectId, isCurrent: () => treeOperations.getProjectId() === transfer.projectId && receipts.get(id) === transfer
+            });
+            transfer.createdDirectories = cleanup.remaining || transfer.createdDirectories;
+          } catch (_error) { /* Retain ownership proofs when cleanup cannot be confirmed. */ }
+        }
+        transfer.result = { ...result, ...directoryFacts(transfer, result.ok !== true) };
+        transfer.finishedAt = Date.now();
+        transfer.chunks = [];
+        return transfer.result;
+      });
+      return transfer.promise;
+    }
+
+    async function status(params = {}) {
+      pruneReceipts();
+      const transfer = receipts.get(String(params.transferId || ''));
+      if (!transfer || !params.runProjectId || transfer.projectId !== params.runProjectId
+        || treeOperations.getProjectId() !== transfer.projectId) {
+        return failure('binary_upload_receipt_missing', 'Asset upload receipt is unavailable for this project.');
+      }
+      if (transfer.result?.ok !== true && transfer.fileUploadAttempted === true) {
+        const evidence = await waitForPath(transfer, {}, 2500).catch(() => null);
+        if (evidence?.hashVerified === true) {
+          transfer.result = { ok: true, written: true, path: transfer.path,
+            changedDocument: true, method: 'remote-hash-reconciliation', ...directoryFacts(transfer),
+            entityId: evidence.observed?.id || readTreeEntityId(evidence.observed), sha256: transfer.sha256 };
+        }
+      }
+      return { ok: true, transferId: transfer.id, runProjectId: transfer.projectId,
+        state: transfer.finishedAt || transfer.result?.ok === true ? 'completed' : 'running',
+        result: transfer.result || null, changedDocument: transfer.mutationAttempted === true };
+    }
+
+    async function commitOnce(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.');
@@ -92,15 +168,30 @@
             const observed = evidence?.observed;
             const hashVerified = evidence?.hashVerified === true;
             assertTransferProject(transfer);
-            const overwriteVerified = !transfer.overwrite || hashVerified || result?.confirmedByTransport === true;
+            const overwriteVerified = hashVerified || result?.confirmedByTransport === true;
             if (result?.ok && observed && overwriteVerified) {
-              return { ok: true, written: true, path: transfer.path, method: result.method, changedDocument: true };
+              return { ok: true, written: true, path: transfer.path, method: result.method, changedDocument: true,
+                entityId: observed.id || observed._id || observed.entityId || observed.fileId || '', sha256: transfer.sha256 };
             }
             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) {
+            if (error?.code?.startsWith('binary_asset_baseline_')) return {
+              ...failure(error.code, error.message), changedDocument: transfer.mutationAttempted === true
+            };
             errors.push(error.message);
           }
+          // Once submission may have happened, changing transports can duplicate
+          // or overwrite a successful upload. Reconcile the same attempt instead.
+          if (transfer.mutationAttempted === true) {
+            const evidence = transfer.fileUploadAttempted === true
+              ? await waitForPath(transfer, {}, 12000).catch(() => null) : null;
+            if (evidence?.hashVerified === true) {
+              return { ok: true, written: true, path: transfer.path,
+                method: 'remote-hash-reconciliation', changedDocument: true };
+            }
+            break;
+          }
         }
         return { ...failure('binary_upload_unavailable', errors.filter(Boolean).join('; ') || 'No supported Overleaf asset upload path succeeded.'),
           changedDocument: transfer.mutationAttempted === true };
@@ -110,16 +201,24 @@
     }
 
     function abort(params = {}) {
-      return { ok: true, aborted: transfers.delete(String(params.transferId || '')) };
+      const id = String(params.transferId || '');
+      if (receipts.has(id)) return { ok: true, aborted: false, committed: true };
+      return { ok: true, aborted: transfers.delete(id) };
     }
 
     function assertTransferProject(transfer) {
-      if (transfers.get(transfer.id) !== transfer) throw new Error('Asset upload was cancelled or replaced.');
+      if (transfers.get(transfer.id) !== transfer && receipts.get(transfer.id) !== transfer) throw new Error('Asset upload was cancelled or replaced.');
       if (!transfer.projectId || treeOperations.getProjectId() !== transfer.projectId) {
         throw new Error('Project changed during asset upload.');
       }
     }
 
+    function directoryFacts(transfer, requireCleanup = false) {
+      return { createdDirectories: transfer.createdDirectories.map(proof => ({ ...proof })),
+        folderChanged: transfer.folderChanged === true, fileUploadAttempted: transfer.fileUploadAttempted === true,
+        directoryCleanupRequired: requireCleanup && transfer.createdDirectories.length > 0 };
+    }
+
     async function uploadWithMultipart(file, transfer) {
       const projectId = treeOperations.getProjectId();
       if (!projectId || typeof windowRef.fetch !== 'function') return { ok: false, reason: 'Project upload endpoint is unavailable.' };
@@ -134,6 +233,11 @@
       const headers = csrf ? { 'X-CSRF-Token': csrf } : {};
       const query = folderId ? `?folder_id=${encodeURIComponent(folderId)}` : '';
       assertTransferProject(transfer);
+      await assertBinaryBaseline(transfer);
+      if (parentPath && await findFolderId(parentPath) !== folderId) throw baselineError('The target folder changed before replacement.');
+      assertTransferProject(transfer);
+      transfer.mutationAttempted = true;
+      transfer.fileUploadAttempted = true;
       const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/upload${query}`, {
         method: 'POST', body: form, credentials: 'same-origin', headers
       });
@@ -156,17 +260,24 @@
 
     async function uploadWithDom(file, transfer) {
       const parentPath = transfer.path.split('/').slice(0, -1).join('/');
-      if (parentPath) {
-        if (typeof deps.prepareUploadParent !== 'function') {
-          return { ok: false, reason: 'Verified folder selection is unavailable for nested asset upload.' };
-        }
-        await deps.prepareUploadParent(parentPath, {
-          createMissing: true,
-          onMutation: () => { transfer.mutationAttempted = true; },
-          isCurrent: () => treeOperations.getProjectId() === transfer.projectId && transfers.get(transfer.id) === transfer
-        });
+      if (typeof deps.prepareUploadParent !== 'function' || typeof deps.isUploadParentCurrent !== 'function') {
+        return { ok: false, reason: 'Verified folder selection is unavailable for asset upload.' };
       }
+      transfer.uploadParent = await deps.prepareUploadParent(parentPath, {
+        createMissing: true,
+        onMutation: () => { transfer.mutationAttempted = true; transfer.folderChanged = true; },
+        onCreatedDirectory: proof => {
+          if (proof?.v !== 1 || proof.projectId !== transfer.projectId || typeof proof.path !== 'string'
+            || !transfer.path.startsWith(proof.path + '/')) return;
+          const next = { v: 1, projectId: proof.projectId, path: proof.path, nativeFolderId: String(proof.nativeFolderId || ''),
+            ownershipConfirmed: proof.ownershipConfirmed === true, observedAfterCreate: proof.observedAfterCreate === true };
+          const index = transfer.createdDirectories.findIndex(value => value.path === proof.path);
+          if (index >= 0) transfer.createdDirectories[index] = next; else transfer.createdDirectories.push(next);
+        },
+        isCurrent: () => treeOperations.getProjectId() === transfer.projectId && transfers.get(transfer.id) === transfer
+      });
       assertTransferProject(transfer);
+      transfer.uploadParentPath = parentPath;
       let input = findFileInput();
       if (!input) {
         const button = findUploadButton();
@@ -178,8 +289,13 @@
       const data = new windowRef.DataTransfer();
       data.items.add(file);
       assertTransferProject(transfer);
+      await assertBinaryBaseline(transfer);
+      assertTransferProject(transfer);
+      if (deps.isUploadParentCurrent(parentPath, transfer.uploadParent) !== true) throw baselineError('The selected upload folder changed before submission.');
+      if (input.isConnected === false || findFileInput() !== input) throw baselineError('The upload input changed before submission.');
       assignFilesToInput(input, data.files, windowRef);
       transfer.mutationAttempted = true;
+      transfer.fileUploadAttempted = true;
       input.dispatchEvent(new windowRef.Event('input', { bubbles: true }));
       input.dispatchEvent(new windowRef.Event('change', { bubbles: true }));
       await clickReplaceIfShown(transfer);
@@ -192,9 +308,14 @@
       for (const name of ['uploadFile', 'uploadAsset', 'createBinaryFile', 'createFile', 'addFile']) {
         if (typeof manager[name] !== 'function') continue;
         try {
+          await assertBinaryBaseline(transfer);
+          assertTransferProject(transfer);
+          if (treeOperations.findFileTreeManager() !== manager) throw baselineError('The upload manager changed before submission.');
+          transfer.mutationAttempted = true;
+          transfer.fileUploadAttempted = true;
           await manager[name](transfer.path, file);
           return { ok: true, method: `fileTreeManager.${name}`, confirmedByTransport: true };
-        } catch (_error) { /* try the next adapter */ }
+        } catch (error) { if (error?.code?.startsWith('binary_asset_baseline_')) throw error; return { ok: false, reason: error.message }; }
       }
       return { ok: false, reason: 'Legacy file-tree manager has no compatible asset method.' };
     }
@@ -248,9 +369,84 @@
       await delay(180);
       assertTransferProject(transfer);
       if (!transfer.overwrite) return;
-      const button = Array.from(documentRef.querySelectorAll('[role="dialog"] button')).find(node => !isCodexOwnedNode(node)
-        && /replace|overwrite|替换|覆盖/i.test(node.textContent || ''));
-      if (button) button.click();
+      const candidates = () => Array.from(documentRef.querySelectorAll('[role="dialog"] button')).filter(node => !isCodexOwnedNode(node)
+        && /^(replace|overwrite|替换|覆盖)(?:\b|\s|$)/i.test(String(node.textContent || '').trim()));
+      const buttons = candidates();
+      if (!buttons.length) return;
+      const matchesTarget = node => {
+        const dialog = node.closest?.('[role="dialog"]');
+        const text = String(dialog?.textContent || '');
+        return [transfer.path, transfer.path.split('/').pop()].some(path =>
+          new RegExp('(^|[^\\w./-])' + path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + '($|[^\\w./-])').test(text));
+      };
+      const intended = buttons.filter(matchesTarget);
+      if (intended.length !== 1) throw baselineError('The replacement dialog could not be bound to the target file.');
+      const button = intended[0], dialog = button.closest('[role="dialog"]');
+      await assertBinaryBaseline(transfer);
+      assertTransferProject(transfer);
+      if (deps.isUploadParentCurrent(transfer.uploadParentPath, transfer.uploadParent) !== true) throw baselineError('The selected upload folder changed before replacement confirmation.');
+      const current = candidates().filter(matchesTarget);
+      if (current.length !== 1 || current[0] !== button || button.isConnected === false
+        || button.closest('[role="dialog"]') !== dialog) throw baselineError('The replacement dialog changed before confirmation.');
+      button.click();
+    }
+    async function binaryIdentity(transfer) {
+      assertTransferProject(transfer);
+      const nativeRoot = documentRef.querySelector?.('[data-testid="file-tree-list-root"]');
+      // The generic adapter may resolve a root basename to another folder.
+      // Only the native ancestry or an exact metadata path can bind old bytes.
+      const node = nativeRoot ? findNativeTreeNode(transfer.path, 'file') : null;
+      let id = readTreeEntityId(node);
+      if (!id) {
+        const list = await snapshotRouter?.buildProjectFileList({ force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false });
+        const file = list?.files?.find(file => file.path === transfer.path);
+        id = file?.id || file?._id || file?.entityId || file?.fileId || '';
+      }
+      assertTransferProject(transfer);
+      return id;
+    }
+    async function assertBinaryBaseline(transfer) {
+      if (!transfer.overwrite) return;
+      const { id, digest } = await readBaselineDigest(transfer);
+      assertTransferProject(transfer);
+      if (digest !== transfer.previousSha256) throw baselineError('The binary file changed since Codex read it. Read the project again before replacing it.');
+      transfer.previousEntityId = id;
+    }
+    function baselineError(message) { return Object.assign(new Error(message), { code: 'binary_asset_baseline_changed' }); }
+    async function readBaselineDigest(transfer) {
+      const controller = new AbortController();
+      let timer, reader;
+      const timeout = new Promise((_resolve, reject) => { timer = setTimeout(() => {
+        controller.abort(); reader?.cancel().catch(() => {});
+        reject(baselineError('Reading the original binary file timed out.'));
+      }, 8000); });
+      try {
+        return await Promise.race([timeout, (async () => {
+          const id = await binaryIdentity(transfer);
+          if (controller.signal.aborted) throw baselineError('Reading the original binary file timed out.');
+          if (!id || (transfer.previousEntityId && transfer.previousEntityId !== id)) throw baselineError('The binary file identity changed before replacement.');
+          const response = await windowRef.fetch(`/project/${encodeURIComponent(transfer.projectId)}/file/${encodeURIComponent(id)}`, {
+            credentials: 'same-origin', cache: 'no-store', signal: controller.signal
+          });
+          if (!response.ok || Number(response.headers?.get?.('content-length')) > MAX_ASSET_BYTES) throw baselineError('The original binary file is unavailable or exceeds the read limit.');
+          let bytes;
+          if (response.body?.getReader) {
+            reader = response.body.getReader(); const chunks = []; let size = 0;
+            for (;;) { const chunk = await reader.read(); if (chunk.done) break;
+              size += chunk.value.byteLength;
+              if (size > MAX_ASSET_BYTES) throw baselineError('The original binary file exceeds the read limit.');
+              chunks.push(chunk.value);
+            }
+            bytes = joinChunks(chunks, size);
+          } else bytes = new Uint8Array(await response.arrayBuffer());
+          if (bytes.byteLength > MAX_ASSET_BYTES) throw baselineError('The original binary file exceeds the read limit.');
+          const digest = await sha256Hex(bytes, windowRef.crypto);
+          if (await binaryIdentity(transfer) !== id) throw baselineError('The binary file identity changed while its original bytes were read.');
+          assertTransferProject(transfer);
+          if (controller.signal.aborted) throw baselineError('Reading the original binary file timed out.');
+          return { id, digest };
+        })()]);
+      } finally { clearTimeout(timer); controller.abort(); reader?.cancel().catch(() => {}); }
     }
     function readTreeEntityId(node) {
       const owner = node?.closest?.('[data-entity-id], [data-file-id], [data-folder-id], [data-id]');
@@ -293,9 +489,13 @@
       let lastObserved = null;
       while (Date.now() < deadline) {
         assertTransferProject(transfer);
-        const node = findNativeTreeNode(projectPath, 'file')
-          || treeOperations.findFileTreeNode(projectPath, { invalidateCache: true });
-        let observed = node || treeOperations.projectPathExists(projectPath)
+        // A matching digest identifies bytes, not their project path. In the
+        // native tree, require the exact ancestry; the generic tree adapter
+        // can resolve a root name to an identically named nested file.
+        const nativeRoot = documentRef.querySelector?.('[data-testid="file-tree-list-root"]');
+        const node = nativeRoot ? findNativeTreeNode(projectPath, 'file')
+          : treeOperations.findFileTreeNode(projectPath, { invalidateCache: true });
+        let observed = node || (!nativeRoot && treeOperations.projectPathExists(projectPath))
           ? { path: projectPath, id: readTreeEntityId(node) } : null;
         if (!observed?.id) {
           try {
@@ -313,7 +513,7 @@
           assertTransferProject(transfer);
           // An existing path is not replacement evidence. Re-read identity and
           // bytes while the native uploader and file-tree events settle.
-          if (!transfer.overwrite || hashVerified || result.confirmedByTransport === true) {
+          if (hashVerified || result.confirmedByTransport === true) {
             return { observed, hashVerified };
           }
         }
@@ -333,7 +533,7 @@
       return digest === transfer.sha256;
     }
     function delay(ms) { return new Promise(resolve => windowRef.setTimeout(resolve, ms)); }
-    return { abort, append, begin, commit };
+    return { abort, append, begin, commit, status };
   }
 
   function normalizePath(value) {