codex-overleaf-link 2.3.5 → 2.4.0

package/extension/src/content/trackedChangeCaptureController.js

@@ -0,0 +1,153 @@
+(function (root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafTrackedChangeCaptureController = api;
+})(typeof window !== 'undefined' ? window : globalThis, function () {
+  'use strict';
+  function create(deps = {}) {
+    const now = deps.now || (() => Date.now());
+    const defer = deps.setTimeout || setTimeout;
+    const cancelTimer = deps.clearTimeout || clearTimeout;
+    let timer = null, busy = false, disposed = false;
+    const runs = () => deps.getRuns() || [];
+    const pending = run => Array.isArray(run.trackedChangeCaptures)
+      && run.trackedChangeCaptures.some(capture => capture.state === 'pending');
+    const terminal = run => ['accepted', 'rejected'].includes(run.trackedChangeStatus)
+      || run.undoStatus === 'applied' || run.forkSnapshot === true;
+    function buildPostFiles(run) {
+      const expectedFiles = Array.isArray(run?.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      const appliedOperations = Array.isArray(run?.appliedOperations) ? run.appliedOperations : [];
+      if (!expectedFiles.length || !appliedOperations.length) return [];
+      const postFilesByPath = deps.buildExpectedFilesAfterOperations({ files: expectedFiles }, appliedOperations);
+      const expectedPaths = new Set(expectedFiles.map(file => file?.path).filter(Boolean));
+      return Array.from(postFilesByPath.entries())
+        .filter(([path, content]) => expectedPaths.has(path) && typeof content === 'string')
+        .map(([path, content]) => ({ path, content }));
+    }
+    function hasLegacyUntrackedCheckpoint(run) {
+      if (!run || run.executionSnapshot || run.trackedChangeStatus || run.undoStatus === 'applied'
+        || run.forkSnapshot || run.undoTrackedChanges?.length || run.trackedChangeCaptures?.length) return false;
+      const operations = Array.isArray(run.undoOperations) ? run.undoOperations : [];
+      const before = Array.isArray(run.undoExpectedFiles) ? run.undoExpectedFiles : [];
+      if (!operations.length || !before.length || before.some(file => !file?.path || typeof file.content !== 'string')) return false;
+      const paths = new Set(before.map(file => file.path));
+      if (paths.size !== before.length || operations.some(op => op?.type !== 'edit' || !paths.has(op.path))) return false;
+      const complete = files => Array.isArray(files) && files.length === paths.size
+        && new Set(files.map(file => file?.path)).size === paths.size
+        && files.every(file => paths.has(file?.path) && typeof file.content === 'string');
+      const storedPost = run.undoBaseFiles;
+      try {
+        const post = buildPostFiles(run);
+        if (!complete(storedPost) || !complete(post)) return false;
+        const postByPath = new Map(post.map(file => [file.path, file.content]));
+        if (!storedPost.every(file => postByPath.get(file.path) === file.content)) return false;
+        const restored = deps.buildExpectedFilesAfterOperations({ files: storedPost }, operations);
+        // A legacy checkpoint must prove both directions; empty refs alone grant nothing.
+        return before.every(file => restored.get(file.path) === file.content);
+      } catch (_error) { return false; }
+    }
+    function schedule() {
+      if (disposed || timer !== null || busy || !runs().some(pending)) return;
+      timer = defer(() => {
+        timer = null;
+        flush().catch(error => deps.onError?.(error));
+      }, 500);
+    }
+    function record(run, captures) {
+      if (!Array.isArray(captures) || !captures.length) return;
+      const next = [...(run.trackedChangeCaptures || []), ...captures.filter(Boolean)];
+      if (next.every(capture => capture.state === 'observed')) return;
+      run.trackedChangeCaptures = next;
+      deps.notify?.(run, next.some(capture => capture.state === 'pending') ? 'pending' : 'needs_review', {
+        captures: next.map(capture => ({ path: capture.path, reason: capture.reason, ...capture.diagnostics }))
+      });
+      deps.persist().then(schedule).catch(error => deps.onError?.(error));
+    }
+    async function flush() {
+      if (disposed || busy) return;
+      busy = true;
+      try {
+        for (const run of runs().filter(pending)) {
+          if (terminal(run)) { run.trackedChangeCaptures = []; await deps.persist(); continue; }
+          if (run.runProjectId !== deps.getProjectId()) continue;
+          const newer = runs().some(other => other.id !== run.id
+            && other.runProjectId === run.runProjectId
+            && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+          const original = run.trackedChangeCaptures;
+          const captures = original.map(capture => ({ ...capture }));
+          const postFiles = buildPostFiles(run);
+          for (let i = 0; i < captures.length; i++) {
+            const capture = captures[i];
+            if (capture.state !== 'pending') continue;
+            const expected = postFiles.find(file => file.path === capture.path);
+            if (newer || !expected || now() >= capture.expiresAt || run.status === 'cancelled') {
+              capture.state = 'needs_review';
+              capture.reason = newer ? 'capture_superseded' : !expected ? 'capture_baseline_missing'
+                : run.status === 'cancelled' ? 'capture_cancelled' : 'capture_expired';
+              continue;
+            }
+            let response;
+            try {
+              response = await deps.callPageBridge('reconcileTrackedChangeCapture', {
+                runProjectId: run.runProjectId, capture, expectedContent: expected.content
+              });
+            } catch (_error) {
+              response = null;
+            }
+            // Never patch a superseded hydrated record or another project's state.
+            if (disposed || deps.getProjectId() !== run.runProjectId
+              || !runs().includes(run) || terminal(run) || run.trackedChangeCaptures !== original) return;
+            const superseded = runs().some(other => other.id !== run.id
+              && other.runProjectId === run.runProjectId
+              && Date.parse(other.startedAt) > Date.parse(run.startedAt));
+            if (superseded || run.status === 'cancelled') {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_superseded' };
+            } else if (response?.capture?.path === capture.path
+              && response.capture.runProjectId === run.runProjectId
+              && ['observed', 'pending', 'needs_review'].includes(response.capture.state)) {
+              captures[i] = response.capture;
+            } else {
+              captures[i] = { ...capture, state: 'needs_review', reason: 'capture_bridge_unavailable' };
+            }
+          }
+          if (!runs().includes(run) || terminal(run) || deps.getProjectId() !== run.runProjectId) continue;
+          if (captures.length && captures.every(capture => capture.state === 'observed')) {
+            const refs = deps.normalizeTrackedChanges([
+              ...(run.undoTrackedChanges || []), ...captures.flatMap(capture => capture.refs || [])
+            ]);
+            if (refs.length) {
+              run.undoTrackedChanges = refs;
+              run.trackedChangeStatus = 'pending';
+              run.trackedChangeCaptures = [];
+              await deps.persist();
+              deps.refresh(run);
+              deps.notify?.(run, 'observed', { count: refs.length });
+              continue;
+            }
+          }
+          const changed = JSON.stringify(original.map(summary)) !== JSON.stringify(captures.map(summary));
+          if (changed) {
+            run.trackedChangeCaptures = captures;
+            await deps.persist();
+            if (!pending(run)) deps.notify?.(run, 'needs_review', {
+              reasons: captures.filter(capture => capture.state !== 'observed').map(capture => capture.reason)
+            });
+          }
+        }
+      } finally {
+        busy = false;
+        if (runs().some(run => pending(run) && run.runProjectId === deps.getProjectId())) schedule();
+      }
+    }
+    function summary(capture) {
+      return { state: capture.state, reason: capture.reason, refs: (capture.refs || []).map(ref => ref.key) };
+    }
+    function dispose() {
+      disposed = true;
+      if (timer !== null) cancelTimer(timer);
+      timer = null;
+    }
+    return { record, schedule, flush, dispose, buildPostFiles, hasLegacyUntrackedCheckpoint };
+  }
+  return { create };
+});

package/extension/src/content/updateNotice.js

@@ -90,7 +90,8 @@
         install: 'codex-overleaf/consent-update-install',
         retry: 'codex-overleaf/consent-update-check',
         later: 'codex-overleaf/consent-update-later',
-        dismiss: 'codex-overleaf/consent-update-dismiss'
+        dismiss: 'codex-overleaf/consent-update-dismiss',
+        reload: 'codex-overleaf/consent-update-reload'
       }[action]);
     } catch (error) {
       currentView = await reconcileAfterActionError(error, {
@@ -212,7 +213,10 @@
     const stateName = currentView?.state?.state || 'idle';
     let requestedAction = 'check';
     try {
-      if (stateName === 'update_available') {
+      if (['reload_required', 'reload_tabs_required'].includes(stateName)) {
+        requestedAction = 'reload';
+        currentView = await request('codex-overleaf/consent-update-reload');
+      } else if (stateName === 'update_available') {
         requestedAction = 'install';
         currentView = await request('codex-overleaf/consent-update-install');
       } else if (['failed', 'rolled_back'].includes(stateName)) {
@@ -276,7 +280,7 @@
       body.append(recovery, command);
     }
 
-    if (!['update_available', 'failed', 'rolled_back'].includes(state.state)) {
+    if (!['update_available', 'failed', 'rolled_back', 'reload_required', 'reload_tabs_required'].includes(state.state)) {
       const bar = document.createElement('div');
       bar.className = 'codex-update-notice-progress' + (progress.determinate ? '' : ' is-indeterminate');
       bar.setAttribute('role', 'progressbar');
@@ -328,7 +332,11 @@
     let statusText = '';
     let buttonText = tx('Check for updates', '检查更新');
 
-    if (stateName === 'checking') {
+    if (['reload_required', 'reload_tabs_required'].includes(stateName)) {
+      summaryText = tx(`Installed v${latestVersion}; running extension v${currentVersion}.`, `已安装 v${latestVersion}；扩展当前运行 v${currentVersion}。`);
+      statusText = getCopy(state).detail;
+      buttonText = stateName === 'reload_required' ? tx('Reload extension', '重新加载扩展') : tx('Refresh Overleaf tabs', '刷新 Overleaf 标签页');
+    } else if (stateName === 'checking') {
       statusText = tx('Checking the latest stable release…', '正在检查最新稳定版本…');
       buttonText = tx('Checking…', '检查中…');
     } else if (stateName === 'update_available') {
@@ -355,6 +363,10 @@
 
   function visibleActions(state) {
     if (actionInFlight) return [];
+    if (['reload_required', 'reload_tabs_required'].includes(state)) {
+      return [{ id: 'reload', label: state === 'reload_required'
+        ? tx('Reload extension', '重新加载扩展') : tx('Refresh Overleaf tabs', '刷新 Overleaf 标签页'), primary: true }];
+    }
     if (state === 'update_available') {
       return [
         { id: 'later', label: tx('Later', '稍后'), primary: false },
@@ -380,6 +392,14 @@
     const target = state.latestVersion ? 'v' + state.latestVersion : '';
     const blocker = blockersCopy(state.blockers?.length ? state.blockers : [state.blocker]);
     return {
+      reload_required: {
+        eyebrow: tx('Installed, awaiting reload', '已安装，等待加载'), title: target,
+        detail: state.message || tx('The new files are installed. Reload the extension when Overleaf is saved and idle.', '新版文件已安装，请在 Overleaf 保存并空闲后重新加载扩展。')
+      },
+      reload_tabs_required: {
+        eyebrow: tx('Updated runtime is ready', '新版运行组件已就绪'), title: target,
+        detail: state.message || tx('Refresh the saved, idle Overleaf tabs to load the updated panel.', '刷新已保存且空闲的 Overleaf 标签页以加载新版面板。')
+      },
       update_available: {
         eyebrow: tx('Update available', '发现新版本'),
         title: target,

package/extension/src/content/writebackOrchestrator.js

@@ -18,6 +18,7 @@
   let tx;
   let getLocale;
   let appendRunEvent;
+  let appendRunRecordEvent;
   // In-flight background mirror refresh (v1.7.5) — see the writeback path.
   let pendingMirrorRefresh = null;
   let appendChangeSummary;
@@ -69,6 +70,34 @@
       : null;
   }
 
+  function invalidateMirrorAfterUndo(runId, projectId, result = {}) {
+    if (!projectId || (result?.changedDocument !== true && !result?.applied?.length)) return Promise.resolve('not-attempted');
+    const pending = Promise.resolve(pendingMirrorRefresh).catch(() => {}).then(async () => {
+      const response = await sendBackgroundNative({ method: 'mirror.invalidate', params: { projectId } });
+      if (!response?.ok || response.result?.invalidated !== true) {
+        throw new Error(response?.error?.message || 'Native host did not confirm mirror invalidation.');
+      }
+      if (getCurrentProjectId() === projectId) {
+        resetContextProject();
+        await callPageBridge('invalidateProjectSnapshot', { invalidateFileList: true });
+      }
+      return 'invalidated';
+    }).catch(error => {
+      appendRunRecordEvent?.(runId, {
+        status: 'warning',
+        title: tx(
+          `Overleaf undo finished, but local mirror invalidation failed: ${error.message}. Refresh this project or reconnect the native host before running again.`,
+          `Overleaf 撤销已完成，但本地镜像失效处理失败：${error.message}。请刷新项目或重新连接 Native Host 后再运行。`
+        )
+      });
+      return 'failed';
+    }).finally(() => {
+      if (pendingMirrorRefresh === pending) pendingMirrorRefresh = null;
+    });
+    pendingMirrorRefresh = pending;
+    return pending;
+  }
+
   async function applySyncChangesToOverleaf(syncChanges = [], project = {}, options = {}) {
     const runMode = options.mode || getState().mode;
     const runRequireReviewing = typeof options.requireReviewing === 'boolean'
@@ -822,6 +851,7 @@
       tx,
       getLocale,
       appendRunEvent,
+      appendRunRecordEvent,
       appendChangeSummary,
       appendCompletionReport,
       appendOperationsPreview,
@@ -867,6 +897,7 @@
     return {
       applySyncChangesToOverleaf,
       resolveCompileLogContext,
+      invalidateMirrorAfterUndo,
       getPendingMirrorRefresh: () => pendingMirrorRefresh
     };
   }

package/extension/src/page/binaryAssetUploader.js

@@ -36,6 +36,7 @@
         size,
         sha256: String(params.sha256).toLowerCase(),
         mimeType: String(params.mimeType || 'application/octet-stream'),
+        projectId: treeOperations.getProjectId(),
         overwrite: params.overwrite === true,
         chunks: [],
         received: 0
@@ -66,6 +67,7 @@
       const transfer = transfers.get(transferId);
       if (!transfer) return failure('binary_upload_transfer_missing', 'Asset upload transfer was not found.');
       try {
+        assertTransferProject(transfer);
         if (transfer.received !== transfer.size) return failure('binary_upload_incomplete', 'Asset upload is incomplete.');
         const bytes = joinChunks(transfer.chunks, transfer.size);
         const digest = await sha256Hex(bytes, windowRef.crypto);
@@ -84,9 +86,12 @@
         const errors = [];
         for (const attempt of attempts) {
           try {
+            assertTransferProject(transfer);
             const result = await attempt();
-            const observed = result?.ok ? await waitForPath(transfer.path, 12000) : null;
-            const hashVerified = observed ? await verifyRemoteHash(observed, transfer).catch(() => false) : false;
+            const evidence = result?.ok ? await waitForPath(transfer, result, 12000) : null;
+            const observed = evidence?.observed;
+            const hashVerified = evidence?.hashVerified === true;
+            assertTransferProject(transfer);
             const overwriteVerified = !transfer.overwrite || hashVerified || result?.confirmedByTransport === true;
             if (result?.ok && observed && overwriteVerified) {
               return { ok: true, written: true, path: transfer.path, method: result.method, changedDocument: true };
@@ -97,7 +102,8 @@
             errors.push(error.message);
           }
         }
-        return failure('binary_upload_unavailable', errors.filter(Boolean).join('; ') || 'No supported Overleaf asset upload path succeeded.');
+        return { ...failure('binary_upload_unavailable', errors.filter(Boolean).join('; ') || 'No supported Overleaf asset upload path succeeded.'),
+          changedDocument: transfer.mutationAttempted === true };
       } finally {
         transfers.delete(transferId);
       }
@@ -107,6 +113,13 @@
       return { ok: true, aborted: transfers.delete(String(params.transferId || '')) };
     }
 
+    function assertTransferProject(transfer) {
+      if (transfers.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.');
+      }
+    }
+
     async function uploadWithMultipart(file, transfer) {
       const projectId = treeOperations.getProjectId();
       if (!projectId || typeof windowRef.fetch !== 'function') return { ok: false, reason: 'Project upload endpoint is unavailable.' };
@@ -120,6 +133,7 @@
       const csrf = findCsrfToken();
       const headers = csrf ? { 'X-CSRF-Token': csrf } : {};
       const query = folderId ? `?folder_id=${encodeURIComponent(folderId)}` : '';
+      assertTransferProject(transfer);
       const response = await windowRef.fetch(`/project/${encodeURIComponent(projectId)}/upload${query}`, {
         method: 'POST', body: form, credentials: 'same-origin', headers
       });
@@ -143,11 +157,16 @@
     async function uploadWithDom(file, transfer) {
       const parentPath = transfer.path.split('/').slice(0, -1).join('/');
       if (parentPath) {
-        const folderNode = treeOperations.findFileTreeNode(parentPath);
-        if (!folderNode) return { ok: false, reason: `Target folder ${parentPath} is unavailable in the Overleaf file tree.` };
-        folderNode?.dispatchEvent(new windowRef.MouseEvent('click', { bubbles: true }));
-        await delay(120);
+        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
+        });
       }
+      assertTransferProject(transfer);
       let input = findFileInput();
       if (!input) {
         const button = findUploadButton();
@@ -158,10 +177,12 @@
       if (!input) return { ok: false, reason: 'Overleaf upload file input was not found.' };
       const data = new windowRef.DataTransfer();
       data.items.add(file);
+      assertTransferProject(transfer);
       assignFilesToInput(input, data.files, windowRef);
+      transfer.mutationAttempted = true;
       input.dispatchEvent(new windowRef.Event('input', { bubbles: true }));
       input.dispatchEvent(new windowRef.Event('change', { bubbles: true }));
-      await clickReplaceIfShown();
+      await clickReplaceIfShown(transfer);
       return { ok: true, method: 'overleaf.file-input' };
     }
 
@@ -179,9 +200,9 @@
     }
 
     async function findFolderId(parentPath) {
-      const node = parentPath ? treeOperations.findFileTreeNode(parentPath) : null;
-      const element = node?.closest?.('[data-entity-id], [data-folder-id], [data-id]') || node;
-      const domId = element?.dataset?.entityId || element?.dataset?.folderId || element?.dataset?.id;
+      const node = parentPath ? (deps.findFolderNode?.(parentPath)
+        || findNativeTreeNode(parentPath, 'folder') || treeOperations.findFileTreeNode(parentPath)) : null;
+      const domId = readTreeEntityId(node);
       if (domId) return domId;
       for (const root of [windowRef._ide, windowRef.Overleaf, windowRef.overleaf, windowRef.OL]) {
         const folder = root?.project?.rootFolder?.[0] || root?.project?.rootFolder || root?.rootFolder?.[0] || root?.rootFolder;
@@ -223,31 +244,82 @@
       }
       return null;
     }
-    async function clickReplaceIfShown() {
+    async function clickReplaceIfShown(transfer) {
       await delay(180);
-      const button = Array.from(documentRef.querySelectorAll('button')).find(node => /replace|overwrite|替换|覆盖/i.test(node.textContent || ''));
+      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();
     }
-    async function waitForPath(projectPath, timeoutMs) {
+    function readTreeEntityId(node) {
+      const owner = node?.closest?.('[data-entity-id], [data-file-id], [data-folder-id], [data-id]');
+      const row = node?.closest?.('[role="treeitem"]') || node;
+      const entity = row?.querySelector?.(':scope > .entity[data-file-id]');
+      for (const candidate of [node, entity, owner]) {
+        const id = candidate?.dataset?.entityId || candidate?.dataset?.fileId
+          || candidate?.dataset?.folderId || candidate?.dataset?.id;
+        if (id) return id;
+      }
+      return '';
+    }
+    function findNativeTreeNode(projectPath, type) {
+      const root = documentRef.querySelector?.('[data-testid="file-tree-list-root"]');
+      for (const row of root?.querySelectorAll?.('[role="treeitem"]') || []) {
+        const entity = row.querySelector?.(':scope > .entity[data-file-id]');
+        if (entity?.dataset?.fileType === type && readNativeTreePath(row, root) === projectPath) return row;
+      }
+      return null;
+    }
+    function readNativeTreePath(row, root) {
+      const parts = [row.getAttribute('aria-label')];
+      let group = row.closest('[role="tree"]');
+      const seen = new Set();
+      while (group && group !== root) {
+        if (seen.has(group) || seen.size >= 64) return '';
+        seen.add(group);
+        const folder = group.previousElementSibling;
+        const entity = folder?.querySelector?.(':scope > .entity[data-file-id]');
+        if (folder?.getAttribute?.('role') !== 'treeitem' || entity?.dataset?.fileType !== 'folder') return '';
+        parts.unshift(folder.getAttribute('aria-label'));
+        group = group.parentElement?.closest?.('[role="tree"]');
+      }
+      if (group !== root || parts.some(part => !part || /[/\\]/.test(part))) return '';
+      return parts.join('/');
+    }
+    async function waitForPath(transfer, result, timeoutMs) {
+      const projectPath = transfer.path;
       const deadline = Date.now() + timeoutMs;
+      let lastObserved = null;
       while (Date.now() < deadline) {
-        if (treeOperations.projectPathExists(projectPath)) {
-          const node = treeOperations.findFileTreeNode(projectPath);
-          return {
-            path: projectPath,
-            id: node?.dataset?.entityId || node?.dataset?.fileId || node?.dataset?.id || ''
-          };
+        assertTransferProject(transfer);
+        const node = findNativeTreeNode(projectPath, 'file')
+          || treeOperations.findFileTreeNode(projectPath, { invalidateCache: true });
+        let observed = node || treeOperations.projectPathExists(projectPath)
+          ? { path: projectPath, id: readTreeEntityId(node) } : null;
+        if (!observed?.id) {
+          try {
+            const list = await snapshotRouter?.buildProjectFileList({
+              force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
+            });
+            const file = (list?.files || []).find(item => item.path === projectPath);
+            if (file) observed = file;
+          } catch (_error) { /* continue until the deadline */ }
+        }
+        assertTransferProject(transfer);
+        if (observed) {
+          lastObserved = observed;
+          const hashVerified = await verifyRemoteHash(observed, transfer).catch(() => false);
+          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) {
+            return { observed, hashVerified };
+          }
         }
         await delay(250);
-        try {
-          const list = await snapshotRouter?.buildProjectFileList({
-            force: true, maxAgeMs: 0, preferLightweight: true, allowZipFallback: false
-          });
-          const file = (list?.files || []).find(item => item.path === projectPath);
-          if (file) return file;
-        } catch (_error) { /* continue until the deadline */ }
       }
-      return null;
+      return { observed: lastObserved, hashVerified: false };
     }
     async function verifyRemoteHash(observed, transfer) {
       const fileId = observed?.id || observed?._id || observed?.entityId || observed?.fileId || '';
@@ -339,5 +411,5 @@
     return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
   }
   function failure(code, reason) { return { ok: false, code, reason, changedDocument: false }; }
-  return { chooseOverleafFileInput, create, formatUploadHttpError, joinChunks, normalizePath };
+  return { assignFilesToInput, chooseOverleafFileInput, create, formatUploadHttpError, joinChunks, normalizePath };
 });