From 1391dc578d034843c2033412025c9bec902496c2 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Tue, 21 Jul 2026 12:41:59 +0200
Subject: [PATCH 01/10] feat(upload-manager): add progress counts to uploads
 manager item (WEBAPP-65289)

---
 src/common/types/upload.js                    |  3 +
 .../content-uploader/ContentUploader.tsx      | 12 +++
 .../__tests__/ContentUploader.test.js         | 65 ++++++++++++++++
 .../stories/ContentUploader.stories.js        | 75 +++++++++++++++++++
 .../mapToModernizedUploadItem.test.ts         | 18 +++++
 .../utils/__tests__/uploadEta.test.ts         | 56 ++++++++++++++
 .../utils/mapToModernizedUploadItem.ts        |  6 ++
 .../content-uploader/utils/uploadEta.ts       | 53 +++++++++++++
 8 files changed, 288 insertions(+)
 create mode 100644 src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
 create mode 100644 src/elements/content-uploader/utils/uploadEta.ts

diff --git a/src/common/types/upload.js b/src/common/types/upload.js
index 15d710ad81..6419ed1f71 100644
--- a/src/common/types/upload.js
+++ b/src/common/types/upload.js
@@ -65,6 +65,7 @@ type FolderUploadItem = {
 type UploadItem = {
     api: PlainUploadAPI | MultiputUploadAPI,
     boxFile?: BoxItem,
+    bytesUploaded?: number,
     bytesUploadedOnLastResume?: number,
     dedupeKey?: string,
     error?: Object,
@@ -74,8 +75,10 @@ type UploadItem = {
     name: string,
     options?: UploadItemAPIOptions,
     progress: number,
+    remainingSeconds?: number,
     size: number,
     status: UploadStatus,
+    totalBytes?: number,
 };
 
 type MultiputConfig = {
diff --git a/src/elements/content-uploader/ContentUploader.tsx b/src/elements/content-uploader/ContentUploader.tsx
index bb7f84ae05..dd139ee39b 100644
--- a/src/elements/content-uploader/ContentUploader.tsx
+++ b/src/elements/content-uploader/ContentUploader.tsx
@@ -16,6 +16,7 @@ import Footer from './Footer';
 import ModernizedUploadsManagerDropZone from './ModernizedUploadsManagerDropZone';
 import UploadsManager from './UploadsManager';
 import { getUploadItemKey, mapToModernizedUploadItems } from './utils/mapToModernizedUploadItem';
+import { updateEta, getRemainingSeconds, type EtaState } from './utils/uploadEta';
 import './ModernizedUploadsManagerPanel.scss';
 import API from '../../api';
 import Browser from '../../utils/Browser';
@@ -171,6 +172,10 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
 
     itemIdsRef: React.MutableRefObject<Object>;
 
+    // Per-item upload speed tracking for the modernized manager's ETA. WeakMap so
+    // entries are garbage-collected with their item; no manual cleanup needed.
+    etaByItem: WeakMap<UploadItem, EtaState> = new WeakMap();
+
     static defaultProps = {
         apiHost: DEFAULT_HOSTNAME_API,
         chunked: true,
@@ -1260,6 +1265,13 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
         item.progress = Math.min(Math.round((event.loaded / event.total) * 100), 100);
         item.status = item.progress === 100 ? STATUS_STAGED : STATUS_IN_PROGRESS;
 
+        // Track byte-level progress and a smoothed ETA for the modernized manager.
+        const nextEta = updateEta(this.etaByItem.get(item), event.loaded, Date.now());
+        this.etaByItem.set(item, nextEta);
+        item.bytesUploaded = event.loaded;
+        item.totalBytes = event.total;
+        item.remainingSeconds = getRemainingSeconds(nextEta, event.loaded, event.total);
+
         const { onProgress } = this.props;
         onProgress(item);
 
diff --git a/src/elements/content-uploader/__tests__/ContentUploader.test.js b/src/elements/content-uploader/__tests__/ContentUploader.test.js
index b238206c56..c0e02f79f4 100644
--- a/src/elements/content-uploader/__tests__/ContentUploader.test.js
+++ b/src/elements/content-uploader/__tests__/ContentUploader.test.js
@@ -2251,4 +2251,69 @@ describe('elements/content-uploader/ContentUploader', () => {
             expect(wrapper.state('isLargeFileWarningModalOpen')).toBe(false);
         });
     });
+
+    describe('handleUploadProgress()', () => {
+        const makeProgressItem = () => ({
+            api: {},
+            extension: 'txt',
+            file: new File(['contents'], 'a.txt'),
+            name: 'a.txt',
+            progress: 0,
+            size: 1000,
+            status: STATUS_PENDING,
+        });
+
+        test('records byte progress and total on the item', () => {
+            const wrapper = getWrapper({ enableModernizedUploads: true });
+            const instance = wrapper.instance();
+            const item = makeProgressItem();
+            instance.itemsRef.current = [item];
+
+            instance.handleUploadProgress(item, { loaded: 400, total: 1000 });
+
+            expect(item.bytesUploaded).toBe(400);
+            expect(item.totalBytes).toBe(1000);
+            expect(item.progress).toBe(40);
+        });
+
+        test('leaves remainingSeconds undefined on the first progress event (no speed sample yet)', () => {
+            const wrapper = getWrapper({ enableModernizedUploads: true });
+            const instance = wrapper.instance();
+            const item = makeProgressItem();
+            instance.itemsRef.current = [item];
+
+            instance.handleUploadProgress(item, { loaded: 400, total: 1000 });
+
+            expect(item.remainingSeconds).toBeUndefined();
+        });
+
+        test('estimates remainingSeconds once a second sample arrives', () => {
+            const wrapper = getWrapper({ enableModernizedUploads: true });
+            const instance = wrapper.instance();
+            const item = makeProgressItem();
+            instance.itemsRef.current = [item];
+
+            const nowSpy = jest.spyOn(Date, 'now');
+            nowSpy.mockReturnValueOnce(0);
+            instance.handleUploadProgress(item, { loaded: 200, total: 1000 });
+            nowSpy.mockReturnValueOnce(1000); // 1s later, +300 bytes -> 300 B/s
+            instance.handleUploadProgress(item, { loaded: 500, total: 1000 });
+
+            // 500 bytes left at 300 B/s
+            expect(item.remainingSeconds).toBeCloseTo(500 / 300, 5);
+            nowSpy.mockRestore();
+        });
+
+        test('ignores progress events without a total', () => {
+            const wrapper = getWrapper({ enableModernizedUploads: true });
+            const instance = wrapper.instance();
+            const item = makeProgressItem();
+            instance.itemsRef.current = [item];
+
+            instance.handleUploadProgress(item, { loaded: 400, total: 0 });
+
+            expect(item.bytesUploaded).toBeUndefined();
+            expect(item.totalBytes).toBeUndefined();
+        });
+    });
 });
diff --git a/src/elements/content-uploader/stories/ContentUploader.stories.js b/src/elements/content-uploader/stories/ContentUploader.stories.js
index 98285e1361..4211abd13f 100644
--- a/src/elements/content-uploader/stories/ContentUploader.stories.js
+++ b/src/elements/content-uploader/stories/ContentUploader.stories.js
@@ -1,9 +1,15 @@
 // @flow
+import * as React from 'react';
 import { http, HttpResponse } from 'msw';
+import { UploadsManager as UploadsManagerBP } from '@box/uploads-manager';
 import ContentUploader from '../ContentUploader';
 import mockTheme from '../../common/__mocks__/mockTheme';
 import { DEFAULT_HOSTNAME_API, DEFAULT_HOSTNAME_UPLOAD } from '../../../constants';
 
+const KB = 1024;
+const MB = 1024 * KB;
+const GB = 1024 * MB;
+
 export const basic = {};
 
 export const withTheming = {
@@ -36,6 +42,75 @@ export const withModernizedUploads = {
     },
 };
 
+// The modernized uploads manager renders the `X / TOTAL · <time> left` status
+// only when items carry byte-level progress and an ETA. A real upload through
+// MSW can't produce a paused mid-transfer state (upload progress isn't streamed
+// and the response resolves immediately), so this story renders the modernized
+// manager directly with fixed in-progress items to make the size + ETA line
+// observable. It also exercises the linked @box/uploads-manager build.
+const modernizedInProgressItems = [
+    {
+        id: '1',
+        name: 'annual-report',
+        extension: 'pdf',
+        status: 'uploading',
+        progress: 45,
+        bytesUploaded: 2.4 * MB,
+        totalBytes: 5.3 * MB,
+        remainingSeconds: 5, // "5 sec left"
+    },
+    {
+        id: '2',
+        name: 'quarterly-presentation',
+        extension: 'pptx',
+        status: 'uploading',
+        progress: 20,
+        bytesUploaded: 50 * MB,
+        totalBytes: 250 * MB,
+        remainingSeconds: 183, // "3 min left"
+    },
+    {
+        id: '3',
+        name: 'full-backup',
+        extension: 'zip',
+        status: 'uploading',
+        progress: 10,
+        bytesUploaded: 0.4 * GB,
+        totalBytes: 4 * GB,
+        remainingSeconds: 4200, // "1 hr left"
+    },
+    {
+        id: '4',
+        name: 'logo',
+        extension: 'png',
+        status: 'uploading',
+        progress: 60,
+        bytesUploaded: 150 * KB,
+        totalBytes: 253 * KB,
+        remainingSeconds: 12, // "12 sec left"
+    },
+];
+
+export const withModernizedUploadsInProgress = {
+    name: 'With Modernized Uploads (in progress · size + ETA)',
+    render: () => (
+        <div style={{ maxWidth: 480 }}>
+            <UploadsManagerBP
+                items={modernizedInProgressItems}
+                isExpanded
+                onToggle={() => {}}
+                onItemCancel={() => {}}
+                onItemRetry={() => {}}
+                onItemRemove={() => {}}
+                onItemShare={() => {}}
+                onItemOpen={() => {}}
+                onCancelAll={() => {}}
+                onRetryAll={() => {}}
+            />
+        </div>
+    ),
+};
+
 export default {
     title: 'Elements/ContentUploader',
     component: ContentUploader,
diff --git a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
index 0f6b08c981..fcb058570e 100644
--- a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
@@ -31,9 +31,27 @@ describe('mapToModernizedUploadItem()', () => {
             isFolder: undefined,
             errorMessage: undefined,
             versionNumber: undefined,
+            bytesUploaded: undefined,
+            totalBytes: 100,
+            remainingSeconds: undefined,
         });
     });
 
+    test('forwards byte progress and ETA fields', () => {
+        const result = mapToModernizedUploadItem(
+            buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingSeconds: 12 }),
+            '0',
+        );
+        expect(result.bytesUploaded).toBe(40);
+        expect(result.totalBytes).toBe(100);
+        expect(result.remainingSeconds).toBe(12);
+    });
+
+    test('falls back to size for totalBytes before first progress event', () => {
+        const result = mapToModernizedUploadItem(buildLegacyItem({ totalBytes: undefined, size: 2048 }), '0');
+        expect(result.totalBytes).toBe(2048);
+    });
+
     test.each([
         [STATUS_PENDING, 'pending'],
         [STATUS_IN_PROGRESS, 'uploading'],
diff --git a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
new file mode 100644
index 0000000000..ae79615307
--- /dev/null
+++ b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
@@ -0,0 +1,56 @@
+import { updateEta, getRemainingSeconds } from '../uploadEta';
+
+describe('updateEta()', () => {
+    test('first sample seeds the baseline with no speed yet', () => {
+        const state = updateEta(undefined, 0, 1000);
+        expect(state).toEqual({ lastTimestampMs: 1000, lastBytes: 0, speedBytesPerSec: 0 });
+    });
+
+    test('computes instantaneous speed on the first usable delta', () => {
+        const seed = updateEta(undefined, 0, 0);
+        const next = updateEta(seed, 1000, 1000); // 1000 bytes in 1s
+        expect(next.speedBytesPerSec).toBe(1000);
+        expect(next.lastBytes).toBe(1000);
+        expect(next.lastTimestampMs).toBe(1000);
+    });
+
+    test('smooths the speed with an EMA across samples', () => {
+        let state = updateEta(undefined, 0, 0);
+        state = updateEta(state, 1000, 1000); // instant 1000 -> speed 1000
+        state = updateEta(state, 1500, 2000); // instant 500 -> 0.3*500 + 0.7*1000 = 850
+        expect(state.speedBytesPerSec).toBeCloseTo(850, 5);
+    });
+
+    test('non-positive time delta advances bytes but keeps speed', () => {
+        const seed = updateEta(undefined, 100, 5000);
+        seed.speedBytesPerSec = 42;
+        const next = updateEta(seed, 200, 5000); // dt = 0
+        expect(next.speedBytesPerSec).toBe(42);
+        expect(next.lastBytes).toBe(200);
+    });
+
+    test('clamps negative byte deltas to zero speed contribution', () => {
+        let state = updateEta(undefined, 1000, 0);
+        state = updateEta(state, 1000, 1000); // no progress -> instant 0, speed 0
+        state = updateEta(state, 500, 2000); // bytes went backwards -> instant clamped to 0
+        expect(state.speedBytesPerSec).toBe(0);
+    });
+});
+
+describe('getRemainingSeconds()', () => {
+    test('returns undefined when there is no speed sample yet', () => {
+        const state = { lastTimestampMs: 0, lastBytes: 0, speedBytesPerSec: 0 };
+        expect(getRemainingSeconds(state, 0, 100)).toBeUndefined();
+    });
+
+    test('estimates remaining time from the smoothed speed', () => {
+        const state = { lastTimestampMs: 0, lastBytes: 500, speedBytesPerSec: 100 };
+        // 500 bytes left at 100 B/s -> 5s
+        expect(getRemainingSeconds(state, 500, 1000)).toBe(5);
+    });
+
+    test('never reports negative time once loaded exceeds total', () => {
+        const state = { lastTimestampMs: 0, lastBytes: 1200, speedBytesPerSec: 100 };
+        expect(getRemainingSeconds(state, 1200, 1000)).toBe(0);
+    });
+});
diff --git a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
index a2e8a28111..99afa4e8df 100644
--- a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
+++ b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
@@ -35,6 +35,7 @@ export function getUploadItemKey(item: LegacyUploadItem | FolderUploadItem, root
 
 export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadItem, rootFolderId: string): UploadItem {
     const errorMessage = item.error ? (item.error as { message?: string }).message : undefined;
+    const fileItem = item as LegacyUploadItem;
 
     return {
         id: getUploadItemKey(item, rootFolderId),
@@ -45,6 +46,11 @@ export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadI
         isFolder: item.isFolder,
         errorMessage,
         versionNumber: item.boxFile?.version_number,
+        bytesUploaded: fileItem.bytesUploaded,
+        // Fall back to the file size so the "X / TOTAL" line shows before the
+        // first progress event lands.
+        totalBytes: fileItem.totalBytes ?? item.size,
+        remainingSeconds: fileItem.remainingSeconds,
     };
 }
 
diff --git a/src/elements/content-uploader/utils/uploadEta.ts b/src/elements/content-uploader/utils/uploadEta.ts
new file mode 100644
index 0000000000..5a5dd92498
--- /dev/null
+++ b/src/elements/content-uploader/utils/uploadEta.ts
@@ -0,0 +1,53 @@
+/**
+ * Upload speed / ETA tracking for the modernized uploads manager.
+ *
+ * XHR progress events give us `loaded` / `total` bytes but no speed, and the
+ * raw per-event rate is jittery (chunks land in bursts). We keep a small piece
+ * of per-item state and smooth the speed with an exponential moving average so
+ * the "time left" figure doesn't jump around.
+ */
+
+const SMOOTHING = 0.3;
+
+export interface EtaState {
+    lastTimestampMs: number;
+    lastBytes: number;
+    /** Smoothed transfer rate in bytes/sec. 0 until we have a usable sample. */
+    speedBytesPerSec: number;
+}
+
+/**
+ * Folds a new progress sample into the running speed estimate.
+ *
+ * The first sample only seeds the baseline (no speed yet). Non-positive time
+ * deltas (duplicate/out-of-order events) update the byte cursor but leave the
+ * speed untouched to avoid division blow-ups.
+ */
+export function updateEta(prev: EtaState | undefined, loaded: number, nowMs: number): EtaState {
+    if (!prev) {
+        return { lastTimestampMs: nowMs, lastBytes: loaded, speedBytesPerSec: 0 };
+    }
+
+    const dtSec = (nowMs - prev.lastTimestampMs) / 1000;
+    if (dtSec <= 0) {
+        return { ...prev, lastBytes: loaded };
+    }
+
+    const instant = Math.max(0, (loaded - prev.lastBytes) / dtSec);
+    const speedBytesPerSec =
+        prev.speedBytesPerSec === 0 ? instant : SMOOTHING * instant + (1 - SMOOTHING) * prev.speedBytesPerSec;
+
+    return { lastTimestampMs: nowMs, lastBytes: loaded, speedBytesPerSec };
+}
+
+/**
+ * Estimated seconds until the transfer completes, or `undefined` when we can't
+ * yet estimate (no speed sample). Callers treat `undefined` as "hide the ETA".
+ */
+export function getRemainingSeconds(state: EtaState, loaded: number, total: number): number | undefined {
+    if (state.speedBytesPerSec <= 0) {
+        return undefined;
+    }
+
+    return Math.max(0, total - loaded) / state.speedBytesPerSec;
+}

From c300b291837af5fd1354512bfae3a77dbb9eabf1 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Wed, 22 Jul 2026 15:10:06 +0200
Subject: [PATCH 02/10] feat(upload-manager): uploadEta algo (WEBAPP-65289)

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 src/common/types/upload.js                    |   2 +-
 .../content-uploader/ContentUploader.tsx      |  11 +-
 .../__tests__/ContentUploader.test.js         |  27 ++++-
 .../stories/ContentUploader.stories.js        |   8 +-
 .../mapToModernizedUploadItem.test.ts         |  45 +++++++-
 .../utils/__tests__/uploadEta.test.ts         | 101 +++++++++++-------
 .../utils/mapToModernizedUploadItem.ts        |  25 +++--
 .../content-uploader/utils/uploadEta.ts       | 101 ++++++++++++------
 8 files changed, 225 insertions(+), 95 deletions(-)

diff --git a/src/common/types/upload.js b/src/common/types/upload.js
index 6419ed1f71..54550095b2 100644
--- a/src/common/types/upload.js
+++ b/src/common/types/upload.js
@@ -75,7 +75,7 @@ type UploadItem = {
     name: string,
     options?: UploadItemAPIOptions,
     progress: number,
-    remainingSeconds?: number,
+    remainingMs?: number,
     size: number,
     status: UploadStatus,
     totalBytes?: number,
diff --git a/src/elements/content-uploader/ContentUploader.tsx b/src/elements/content-uploader/ContentUploader.tsx
index dd139ee39b..7f994967ba 100644
--- a/src/elements/content-uploader/ContentUploader.tsx
+++ b/src/elements/content-uploader/ContentUploader.tsx
@@ -16,7 +16,7 @@ import Footer from './Footer';
 import ModernizedUploadsManagerDropZone from './ModernizedUploadsManagerDropZone';
 import UploadsManager from './UploadsManager';
 import { getUploadItemKey, mapToModernizedUploadItems } from './utils/mapToModernizedUploadItem';
-import { updateEta, getRemainingSeconds, type EtaState } from './utils/uploadEta';
+import { updateEta, getRemainingMs, type EtaState } from './utils/uploadEta';
 import './ModernizedUploadsManagerPanel.scss';
 import API from '../../api';
 import Browser from '../../utils/Browser';
@@ -1022,6 +1022,11 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
         item.status = STATUS_PENDING;
         delete item.error;
 
+        // Drop byte/ETA progress from the previous attempt
+        item.bytesUploaded = 0;
+        item.remainingMs = undefined;
+        this.etaByItem.delete(item);
+
         const updatedItems = [...this.itemsRef.current];
         updatedItems[this.itemsRef.current.indexOf(item)] = item;
 
@@ -1266,11 +1271,11 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
         item.status = item.progress === 100 ? STATUS_STAGED : STATUS_IN_PROGRESS;
 
         // Track byte-level progress and a smoothed ETA for the modernized manager.
-        const nextEta = updateEta(this.etaByItem.get(item), event.loaded, Date.now());
+        const nextEta = updateEta(this.etaByItem.get(item), event.loaded, event.total, Date.now());
         this.etaByItem.set(item, nextEta);
         item.bytesUploaded = event.loaded;
         item.totalBytes = event.total;
-        item.remainingSeconds = getRemainingSeconds(nextEta, event.loaded, event.total);
+        item.remainingMs = getRemainingMs(nextEta);
 
         const { onProgress } = this.props;
         onProgress(item);
diff --git a/src/elements/content-uploader/__tests__/ContentUploader.test.js b/src/elements/content-uploader/__tests__/ContentUploader.test.js
index c0e02f79f4..6845c0c7d2 100644
--- a/src/elements/content-uploader/__tests__/ContentUploader.test.js
+++ b/src/elements/content-uploader/__tests__/ContentUploader.test.js
@@ -360,6 +360,23 @@ describe('elements/content-uploader/ContentUploader', () => {
             expect(item.status).toBe(STATUS_PENDING);
             expect(item.error).toBeUndefined();
         });
+
+        test('should clear byte/ETA progress from the previous attempt', () => {
+            const wrapper = getWrapper();
+            const instance = wrapper.instance();
+            const item = {
+                api: { cancel: jest.fn() },
+                file: { size: 10 },
+                bytesUploaded: 8,
+                remainingMs: 4200,
+            };
+            instance.etaByItem.set(item, { etaMs: 4200 });
+
+            instance.resetFile(item);
+            expect(item.bytesUploaded).toBe(0);
+            expect(item.remainingMs).toBeUndefined();
+            expect(instance.etaByItem.has(item)).toBe(false);
+        });
     });
 
     describe('resumeFile()', () => {
@@ -2276,7 +2293,7 @@ describe('elements/content-uploader/ContentUploader', () => {
             expect(item.progress).toBe(40);
         });
 
-        test('leaves remainingSeconds undefined on the first progress event (no speed sample yet)', () => {
+        test('leaves remainingMs undefined on the first progress event (no speed sample yet)', () => {
             const wrapper = getWrapper({ enableModernizedUploads: true });
             const instance = wrapper.instance();
             const item = makeProgressItem();
@@ -2284,10 +2301,10 @@ describe('elements/content-uploader/ContentUploader', () => {
 
             instance.handleUploadProgress(item, { loaded: 400, total: 1000 });
 
-            expect(item.remainingSeconds).toBeUndefined();
+            expect(item.remainingMs).toBeUndefined();
         });
 
-        test('estimates remainingSeconds once a second sample arrives', () => {
+        test('estimates remainingMs once a second sample arrives', () => {
             const wrapper = getWrapper({ enableModernizedUploads: true });
             const instance = wrapper.instance();
             const item = makeProgressItem();
@@ -2299,8 +2316,8 @@ describe('elements/content-uploader/ContentUploader', () => {
             nowSpy.mockReturnValueOnce(1000); // 1s later, +300 bytes -> 300 B/s
             instance.handleUploadProgress(item, { loaded: 500, total: 1000 });
 
-            // 500 bytes left at 300 B/s
-            expect(item.remainingSeconds).toBeCloseTo(500 / 300, 5);
+            // 500 bytes left at 300 B/s -> ~1.667s -> ~1666.67ms
+            expect(item.remainingMs).toBeCloseTo((500 / 300) * 1000, 5);
             nowSpy.mockRestore();
         });
 
diff --git a/src/elements/content-uploader/stories/ContentUploader.stories.js b/src/elements/content-uploader/stories/ContentUploader.stories.js
index 4211abd13f..8215e866f2 100644
--- a/src/elements/content-uploader/stories/ContentUploader.stories.js
+++ b/src/elements/content-uploader/stories/ContentUploader.stories.js
@@ -57,7 +57,7 @@ const modernizedInProgressItems = [
         progress: 45,
         bytesUploaded: 2.4 * MB,
         totalBytes: 5.3 * MB,
-        remainingSeconds: 5, // "5 sec left"
+        remainingMs: 5000, // "5 sec left"
     },
     {
         id: '2',
@@ -67,7 +67,7 @@ const modernizedInProgressItems = [
         progress: 20,
         bytesUploaded: 50 * MB,
         totalBytes: 250 * MB,
-        remainingSeconds: 183, // "3 min left"
+        remainingMs: 183000, // "3 min left"
     },
     {
         id: '3',
@@ -77,7 +77,7 @@ const modernizedInProgressItems = [
         progress: 10,
         bytesUploaded: 0.4 * GB,
         totalBytes: 4 * GB,
-        remainingSeconds: 4200, // "1 hr left"
+        remainingMs: 4200000, // "1 hr left"
     },
     {
         id: '4',
@@ -87,7 +87,7 @@ const modernizedInProgressItems = [
         progress: 60,
         bytesUploaded: 150 * KB,
         totalBytes: 253 * KB,
-        remainingSeconds: 12, // "12 sec left"
+        remainingMs: 12000, // "12 sec left"
     },
 ];
 
diff --git a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
index fcb058570e..810078e7bd 100644
--- a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
@@ -33,18 +33,18 @@ describe('mapToModernizedUploadItem()', () => {
             versionNumber: undefined,
             bytesUploaded: undefined,
             totalBytes: 100,
-            remainingSeconds: undefined,
+            remainingMs: undefined,
         });
     });
 
     test('forwards byte progress and ETA fields', () => {
         const result = mapToModernizedUploadItem(
-            buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingSeconds: 12 }),
+            buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingMs: 12000 }),
             '0',
         );
         expect(result.bytesUploaded).toBe(40);
         expect(result.totalBytes).toBe(100);
-        expect(result.remainingSeconds).toBe(12);
+        expect(result.remainingMs).toBe(12000);
     });
 
     test('falls back to size for totalBytes before first progress event', () => {
@@ -52,6 +52,45 @@ describe('mapToModernizedUploadItem()', () => {
         expect(result.totalBytes).toBe(2048);
     });
 
+    test.each([STATUS_STAGED, STATUS_COMPLETE])(
+        'reports full bytesUploaded once the item is %s (progress events stop before hitting the total)',
+        status => {
+            const result = mapToModernizedUploadItem(
+                buildLegacyItem({ status, bytesUploaded: 259, totalBytes: 260 }),
+                '0',
+            );
+            expect(result.bytesUploaded).toBe(260);
+            expect(result.totalBytes).toBe(260);
+        },
+    );
+
+    test('does not inflate bytesUploaded while still uploading', () => {
+        const result = mapToModernizedUploadItem(
+            buildLegacyItem({ status: STATUS_IN_PROGRESS, bytesUploaded: 259, totalBytes: 260 }),
+            '0',
+        );
+        expect(result.bytesUploaded).toBe(259);
+    });
+
+    test.each([STATUS_STAGED, STATUS_COMPLETE])(
+        'drops the ETA once the item is %s (the smoothed estimate lags and looks stale)',
+        status => {
+            const result = mapToModernizedUploadItem(
+                buildLegacyItem({ status, bytesUploaded: 260, totalBytes: 260, remainingMs: 3000 }),
+                '0',
+            );
+            expect(result.remainingMs).toBeUndefined();
+        },
+    );
+
+    test('still forwards the ETA while uploading', () => {
+        const result = mapToModernizedUploadItem(
+            buildLegacyItem({ status: STATUS_IN_PROGRESS, remainingMs: 3000 }),
+            '0',
+        );
+        expect(result.remainingMs).toBe(3000);
+    });
+
     test.each([
         [STATUS_PENDING, 'pending'],
         [STATUS_IN_PROGRESS, 'uploading'],
diff --git a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
index ae79615307..be16f2a454 100644
--- a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
@@ -1,56 +1,81 @@
-import { updateEta, getRemainingSeconds } from '../uploadEta';
+import { updateEta, getRemainingMs, type EtaState } from '../uploadEta';
 
 describe('updateEta()', () => {
-    test('first sample seeds the baseline with no speed yet', () => {
-        const state = updateEta(undefined, 0, 1000);
-        expect(state).toEqual({ lastTimestampMs: 1000, lastBytes: 0, speedBytesPerSec: 0 });
+    test('first sample seeds the window with no ETA yet', () => {
+        const state = updateEta(undefined, 0, 100, 1000);
+        expect(state).toEqual({
+            startMs: 1000,
+            lastSampleMs: 1000,
+            times: [1000],
+            loaded: [0],
+            etaMs: null,
+        });
+        expect(getRemainingMs(state)).toBeUndefined();
     });
 
-    test('computes instantaneous speed on the first usable delta', () => {
-        const seed = updateEta(undefined, 0, 0);
-        const next = updateEta(seed, 1000, 1000); // 1000 bytes in 1s
-        expect(next.speedBytesPerSec).toBe(1000);
-        expect(next.lastBytes).toBe(1000);
-        expect(next.lastTimestampMs).toBe(1000);
+    test('withholds the ETA during the grace period', () => {
+        let state = updateEta(undefined, 0, 1000, 0);
+        state = updateEta(state, 500, 1000, 500); // elapsed 500ms < 1s grace
+        expect(getRemainingMs(state)).toBeUndefined();
     });
 
-    test('smooths the speed with an EMA across samples', () => {
-        let state = updateEta(undefined, 0, 0);
-        state = updateEta(state, 1000, 1000); // instant 1000 -> speed 1000
-        state = updateEta(state, 1500, 2000); // instant 500 -> 0.3*500 + 0.7*1000 = 850
-        expect(state.speedBytesPerSec).toBeCloseTo(850, 5);
+    test('produces an estimate once the grace period has passed', () => {
+        let state = updateEta(undefined, 0, 1000, 0);
+        state = updateEta(state, 200, 1000, 1000); // elapsed == grace -> still hidden
+        expect(getRemainingMs(state)).toBeUndefined();
+        state = updateEta(state, 400, 1000, 2000); // elapsed 2s > grace
+        // window [0,1000,2000] / [0,200,400] -> 200 B/s, 600 B left -> ~3s -> 3000ms
+        expect(getRemainingMs(state)).toBeCloseTo(3000, 5);
     });
 
-    test('non-positive time delta advances bytes but keeps speed', () => {
-        const seed = updateEta(undefined, 100, 5000);
-        seed.speedBytesPerSec = 42;
-        const next = updateEta(seed, 200, 5000); // dt = 0
-        expect(next.speedBytesPerSec).toBe(42);
-        expect(next.lastBytes).toBe(200);
+    test('smooths the ETA with heavy inertia (does not jump)', () => {
+        const prev: EtaState = {
+            startMs: 0,
+            lastSampleMs: 2000,
+            times: [0, 2000],
+            loaded: [0, 2000],
+            etaMs: 10000,
+        };
+        // Window [0,2000,3000] / [0,2000,3000] -> 1000 B/s, 7000 B left -> raw ETA 7000ms.
+        // Smoothed: 0.1 * 7000 + 0.9 * 10000 = 9700 (barely moves off the previous 10000).
+        const next = updateEta(prev, 3000, 10000, 3000);
+        expect(next.etaMs).toBeCloseTo(9700, 5);
     });
 
-    test('clamps negative byte deltas to zero speed contribution', () => {
-        let state = updateEta(undefined, 1000, 0);
-        state = updateEta(state, 1000, 1000); // no progress -> instant 0, speed 0
-        state = updateEta(state, 500, 2000); // bytes went backwards -> instant clamped to 0
-        expect(state.speedBytesPerSec).toBe(0);
+    test('throttles samples that arrive faster than the sampling rate', () => {
+        const prev: EtaState = {
+            startMs: 0,
+            lastSampleMs: 1000,
+            times: [0, 1000],
+            loaded: [0, 1000],
+            etaMs: 5000,
+        };
+        const next = updateEta(prev, 1010, 10000, 1030); // 30ms < 50ms sampling rate
+        expect(next).toBe(prev);
     });
-});
 
-describe('getRemainingSeconds()', () => {
-    test('returns undefined when there is no speed sample yet', () => {
-        const state = { lastTimestampMs: 0, lastBytes: 0, speedBytesPerSec: 0 };
-        expect(getRemainingSeconds(state, 0, 100)).toBeUndefined();
+    test('hides the ETA when the whole window stalls (zero speed)', () => {
+        const prev: EtaState = {
+            startMs: 0,
+            lastSampleMs: 3000,
+            times: [1000, 3000],
+            loaded: [5000, 5000],
+            etaMs: 8000,
+        };
+        const next = updateEta(prev, 5000, 10000, 4000); // no bytes moved across the window
+        expect(next.etaMs).toBeNull();
+        expect(getRemainingMs(next)).toBeUndefined();
     });
+});
+
+describe('getRemainingMs()', () => {
+    const emptyWindow = { startMs: 0, lastSampleMs: 0, times: [], loaded: [] };
 
-    test('estimates remaining time from the smoothed speed', () => {
-        const state = { lastTimestampMs: 0, lastBytes: 500, speedBytesPerSec: 100 };
-        // 500 bytes left at 100 B/s -> 5s
-        expect(getRemainingSeconds(state, 500, 1000)).toBe(5);
+    test('returns undefined when there is no estimate', () => {
+        expect(getRemainingMs({ ...emptyWindow, etaMs: null })).toBeUndefined();
     });
 
-    test('never reports negative time once loaded exceeds total', () => {
-        const state = { lastTimestampMs: 0, lastBytes: 1200, speedBytesPerSec: 100 };
-        expect(getRemainingSeconds(state, 1200, 1000)).toBe(0);
+    test('returns the smoothed estimate in milliseconds', () => {
+        expect(getRemainingMs({ ...emptyWindow, etaMs: 12300 })).toBe(12300);
     });
 });
diff --git a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
index 99afa4e8df..3bd870fb48 100644
--- a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
+++ b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
@@ -37,20 +37,33 @@ export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadI
     const errorMessage = item.error ? (item.error as { message?: string }).message : undefined;
     const fileItem = item as LegacyUploadItem;
 
+    const status = STATUS_MAP[item.status] ?? 'pending';
+    // Fall back to the file size so the "X / TOTAL" line shows before the
+    // first progress event lands.
+    const totalBytes = fileItem.totalBytes ?? item.size;
+
+    // Progress rounds to 100% at ~99.5%, which flips the item to "staged" and
+    // stops further progress events — so bytesUploaded can freeze a hair below
+    // the total and the "X / TOTAL" line looks stuck ~1 unit short. Once the
+    // bytes are all in, report the full size and drop the ETA: there's nothing
+    // left to wait for, and the smoothed estimate otherwise lags a few seconds
+    // behind and shows a stale "time left".
+    const isFullyUploaded = status === 'staged' || status === 'complete';
+    const bytesUploaded = isFullyUploaded && totalBytes != null ? totalBytes : fileItem.bytesUploaded;
+    const remainingMs = !isFullyUploaded ? fileItem.remainingMs : undefined;
+
     return {
         id: getUploadItemKey(item, rootFolderId),
         name: item.name,
         extension: item.extension ?? '',
         progress: item.progress ?? 0,
-        status: STATUS_MAP[item.status] ?? 'pending',
+        status,
         isFolder: item.isFolder,
         errorMessage,
         versionNumber: item.boxFile?.version_number,
-        bytesUploaded: fileItem.bytesUploaded,
-        // Fall back to the file size so the "X / TOTAL" line shows before the
-        // first progress event lands.
-        totalBytes: fileItem.totalBytes ?? item.size,
-        remainingSeconds: fileItem.remainingSeconds,
+        bytesUploaded,
+        totalBytes,
+        remainingMs,
     };
 }
 
diff --git a/src/elements/content-uploader/utils/uploadEta.ts b/src/elements/content-uploader/utils/uploadEta.ts
index 5a5dd92498..ebe76a8716 100644
--- a/src/elements/content-uploader/utils/uploadEta.ts
+++ b/src/elements/content-uploader/utils/uploadEta.ts
@@ -1,53 +1,84 @@
+/** Window the speed is measured over */
+const SAMPLING_WINDOW_MS = 3000;
+/** Minimum spacing between recorded samples */
+const SAMPLING_RATE_MS = 50;
+/** How long to wait before surfacing an ETA at all */
+const GRACE_PERIOD_MS = 1000;
 /**
- * Upload speed / ETA tracking for the modernized uploads manager.
- *
- * XHR progress events give us `loaded` / `total` bytes but no speed, and the
- * raw per-event rate is jittery (chunks land in bursts). We keep a small piece
- * of per-item state and smooth the speed with an exponential moving average so
- * the "time left" figure doesn't jump around.
+ * EMA weight kept from the previous smoothed ETA (yt-dlp: 0.9). Higher = more
+ * inertia = steadier countdown. New raw ETA gets weight `1 - ETA_SMOOTHING`.
  */
-
-const SMOOTHING = 0.3;
+const ETA_SMOOTHING = 0.9;
 
 export interface EtaState {
-    lastTimestampMs: number;
-    lastBytes: number;
-    /** Smoothed transfer rate in bytes/sec. 0 until we have a usable sample. */
-    speedBytesPerSec: number;
+    /** Timestamp of the first sample — used for the grace period. */
+    startMs: number;
+    /** Timestamp of the last recorded sample — used to throttle sampling. */
+    lastSampleMs: number;
+    /** Sample timestamps within the sliding window, oldest first. */
+    times: number[];
+    /** Loaded-byte counts matching `times`, oldest first. */
+    loaded: number[];
+    /** EMA(explonential moving average)-smoothed ETA, or `null` when no reliable estimate exists. */
+    etaMs: number | null;
 }
 
 /**
- * Folds a new progress sample into the running speed estimate.
- *
- * The first sample only seeds the baseline (no speed yet). Non-positive time
- * deltas (duplicate/out-of-order events) update the byte cursor but leave the
- * speed untouched to avoid division blow-ups.
+ * Folds a new progress sample into the ETA estimate. Pass the absolute
+ * `loaded`/`total` bytes and the current time in ms.
  */
-export function updateEta(prev: EtaState | undefined, loaded: number, nowMs: number): EtaState {
+export function updateEta(prev: EtaState | undefined, loaded: number, total: number, nowMs: number): EtaState {
     if (!prev) {
-        return { lastTimestampMs: nowMs, lastBytes: loaded, speedBytesPerSec: 0 };
+        return { startMs: nowMs, lastSampleMs: nowMs, times: [nowMs], loaded: [loaded], etaMs: null };
     }
 
-    const dtSec = (nowMs - prev.lastTimestampMs) / 1000;
-    if (dtSec <= 0) {
-        return { ...prev, lastBytes: loaded };
+    // Throttle: ignore samples that arrive faster than the sampling rate so the
+    // window is built from evenly spaced points.
+    if (nowMs - prev.lastSampleMs < SAMPLING_RATE_MS) {
+        return prev;
     }
 
-    const instant = Math.max(0, (loaded - prev.lastBytes) / dtSec);
-    const speedBytesPerSec =
-        prev.speedBytesPerSec === 0 ? instant : SMOOTHING * instant + (1 - SMOOTHING) * prev.speedBytesPerSec;
+    const times = [...prev.times, nowMs];
+    const loadedSamples = [...prev.loaded, loaded];
 
-    return { lastTimestampMs: nowMs, lastBytes: loaded, speedBytesPerSec };
-}
+    // Drop samples that have aged out of the trailing window.
+    const cutoff = nowMs - SAMPLING_WINDOW_MS;
+    let offset = 0;
+    while (offset < times.length && times[offset] < cutoff) {
+        offset += 1;
+    }
 
-/**
- * Estimated seconds until the transfer completes, or `undefined` when we can't
- * yet estimate (no speed sample). Callers treat `undefined` as "hide the ETA".
- */
-export function getRemainingSeconds(state: EtaState, loaded: number, total: number): number | undefined {
-    if (state.speedBytesPerSec <= 0) {
-        return undefined;
+    const base = {
+        startMs: prev.startMs,
+        lastSampleMs: nowMs,
+        times: times.slice(offset),
+        loaded: loadedSamples.slice(offset),
+    };
+
+    // Need at least two points to measure a rate.
+    if (base.times.length < 2) {
+        return { ...base, etaMs: null };
     }
 
-    return Math.max(0, total - loaded) / state.speedBytesPerSec;
+    const spanMs = nowMs - base.times[0];
+    if (spanMs <= 0) {
+        return { ...base, etaMs: prev.etaMs };
+    }
+
+    const speedBytesPerMs = (loaded - base.loaded[0]) / spanMs;
+    const elapsedMs = nowMs - prev.startMs;
+
+    // Only estimate once we have positive speed and the warm-up grace has passed.
+    if (total > 0 && speedBytesPerMs > 0 && elapsedMs > GRACE_PERIOD_MS) {
+        const rawEtaMs = Math.max(0, total - loaded) / speedBytesPerMs;
+        const etaMs = prev.etaMs == null ? rawEtaMs : (1 - ETA_SMOOTHING) * rawEtaMs + ETA_SMOOTHING * prev.etaMs;
+        return { ...base, etaMs };
+    }
+
+    // No reliable estimate right now (warming up, or a full-window stall).
+    return { ...base, etaMs: null };
+}
+
+export function getRemainingMs(state: EtaState): number | undefined {
+    return state.etaMs == null ? undefined : state.etaMs;
 }

From fea13d7be82e194db1f465bfe20c3d3c0c2c5321 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Wed, 22 Jul 2026 15:39:59 +0200
Subject: [PATCH 03/10] feat(upload-manager): remove comments

---
 .../content-uploader/stories/ContentUploader.stories.js  | 6 ------
 .../content-uploader/utils/mapToModernizedUploadItem.ts  | 9 ---------
 2 files changed, 15 deletions(-)

diff --git a/src/elements/content-uploader/stories/ContentUploader.stories.js b/src/elements/content-uploader/stories/ContentUploader.stories.js
index 8215e866f2..fa90c58f0a 100644
--- a/src/elements/content-uploader/stories/ContentUploader.stories.js
+++ b/src/elements/content-uploader/stories/ContentUploader.stories.js
@@ -42,12 +42,6 @@ export const withModernizedUploads = {
     },
 };
 
-// The modernized uploads manager renders the `X / TOTAL · <time> left` status
-// only when items carry byte-level progress and an ETA. A real upload through
-// MSW can't produce a paused mid-transfer state (upload progress isn't streamed
-// and the response resolves immediately), so this story renders the modernized
-// manager directly with fixed in-progress items to make the size + ETA line
-// observable. It also exercises the linked @box/uploads-manager build.
 const modernizedInProgressItems = [
     {
         id: '1',
diff --git a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
index 3bd870fb48..38046437b8 100644
--- a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
+++ b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
@@ -38,16 +38,7 @@ export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadI
     const fileItem = item as LegacyUploadItem;
 
     const status = STATUS_MAP[item.status] ?? 'pending';
-    // Fall back to the file size so the "X / TOTAL" line shows before the
-    // first progress event lands.
     const totalBytes = fileItem.totalBytes ?? item.size;
-
-    // Progress rounds to 100% at ~99.5%, which flips the item to "staged" and
-    // stops further progress events — so bytesUploaded can freeze a hair below
-    // the total and the "X / TOTAL" line looks stuck ~1 unit short. Once the
-    // bytes are all in, report the full size and drop the ETA: there's nothing
-    // left to wait for, and the smoothed estimate otherwise lags a few seconds
-    // behind and shows a stale "time left".
     const isFullyUploaded = status === 'staged' || status === 'complete';
     const bytesUploaded = isFullyUploaded && totalBytes != null ? totalBytes : fileItem.bytesUploaded;
     const remainingMs = !isFullyUploaded ? fileItem.remainingMs : undefined;

From d095424e2911fbada71638a335b449a286231fba Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Wed, 22 Jul 2026 15:43:38 +0200
Subject: [PATCH 04/10] feat(upload-manager): remove comments

---
 src/elements/content-uploader/ContentUploader.tsx | 2 --
 src/elements/content-uploader/utils/uploadEta.ts  | 4 ----
 2 files changed, 6 deletions(-)

diff --git a/src/elements/content-uploader/ContentUploader.tsx b/src/elements/content-uploader/ContentUploader.tsx
index 7f994967ba..fa717a68ed 100644
--- a/src/elements/content-uploader/ContentUploader.tsx
+++ b/src/elements/content-uploader/ContentUploader.tsx
@@ -172,8 +172,6 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
 
     itemIdsRef: React.MutableRefObject<Object>;
 
-    // Per-item upload speed tracking for the modernized manager's ETA. WeakMap so
-    // entries are garbage-collected with their item; no manual cleanup needed.
     etaByItem: WeakMap<UploadItem, EtaState> = new WeakMap();
 
     static defaultProps = {
diff --git a/src/elements/content-uploader/utils/uploadEta.ts b/src/elements/content-uploader/utils/uploadEta.ts
index ebe76a8716..bde1f065ce 100644
--- a/src/elements/content-uploader/utils/uploadEta.ts
+++ b/src/elements/content-uploader/utils/uploadEta.ts
@@ -23,10 +23,6 @@ export interface EtaState {
     etaMs: number | null;
 }
 
-/**
- * Folds a new progress sample into the ETA estimate. Pass the absolute
- * `loaded`/`total` bytes and the current time in ms.
- */
 export function updateEta(prev: EtaState | undefined, loaded: number, total: number, nowMs: number): EtaState {
     if (!prev) {
         return { startMs: nowMs, lastSampleMs: nowMs, times: [nowMs], loaded: [loaded], etaMs: null };

From 033856189733c6c4dcdbf88c3c3ba80e4084c8b9 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 10:51:40 +0200
Subject: [PATCH 05/10] feat(upload-manager): guard with feature flag

---
 .../content-uploader/ContentUploader.tsx      |  9 +++++-
 .../mapToModernizedUploadItem.test.ts         | 31 +++++++++++++++++--
 .../utils/mapToModernizedUploadItem.ts        | 30 +++++++++++++-----
 3 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/src/elements/content-uploader/ContentUploader.tsx b/src/elements/content-uploader/ContentUploader.tsx
index fa717a68ed..58637b4b17 100644
--- a/src/elements/content-uploader/ContentUploader.tsx
+++ b/src/elements/content-uploader/ContentUploader.tsx
@@ -117,6 +117,7 @@ export interface ContentUploaderProps {
     uploadHost: string;
     useUploadsManager?: boolean;
     enableModernizedUploads?: boolean;
+    isUploadEtaEnabled?: boolean;
     isUpgradeModalEnabled?: boolean;
     isExpanded?: boolean;
     onToggle?: (isExpanded: boolean) => void;
@@ -206,6 +207,7 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
         uploadHost: DEFAULT_HOSTNAME_UPLOAD,
         useUploadsManager: false,
         enableModernizedUploads: false,
+        isUploadEtaEnabled: false,
         isUpgradeModalEnabled: false,
         modernizedDismissDelayMs: HIDE_MODERNIZED_UPLOAD_MANAGER_DELAY_MS,
     };
@@ -1841,6 +1843,7 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
             className,
             canDropOnUploadsManager,
             enableModernizedUploads,
+            isUploadEtaEnabled,
             fileLimit,
             isDraggingItemsToUploadsManager = false,
             isFolderUploadEnabled,
@@ -1911,7 +1914,11 @@ class ContentUploader extends Component<ContentUploaderProps, State> {
                             onMouseLeave={this.handleModernizedMouseLeave}
                         >
                             <UploadsManagerBP
-                                items={mapToModernizedUploadItems(uploadsManagerItems, rootFolderId)}
+                                items={mapToModernizedUploadItems(
+                                    uploadsManagerItems,
+                                    rootFolderId,
+                                    isUploadEtaEnabled,
+                                )}
                                 isExpanded={isUploadsManagerExpanded}
                                 onToggle={this.toggleUploadsManager}
                                 onItemCancel={this.handleUploadsManagerItemCancel}
diff --git a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
index 810078e7bd..ea870aaef5 100644
--- a/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/mapToModernizedUploadItem.test.ts
@@ -21,7 +21,7 @@ const buildLegacyItem = (overrides = {}) => ({
 
 describe('mapToModernizedUploadItem()', () => {
     test('maps core fields', () => {
-        const result = mapToModernizedUploadItem(buildLegacyItem(), '0');
+        const result = mapToModernizedUploadItem(buildLegacyItem(), '0', true);
         expect(result).toEqual({
             id: 'foo.pdf',
             name: 'foo.pdf',
@@ -37,10 +37,21 @@ describe('mapToModernizedUploadItem()', () => {
         });
     });
 
+    test('omits byte progress and ETA fields when the treatment is off (kill switch)', () => {
+        const result = mapToModernizedUploadItem(
+            buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingMs: 12000 }),
+            '0',
+        );
+        expect(result.bytesUploaded).toBeUndefined();
+        expect(result.totalBytes).toBeUndefined();
+        expect(result.remainingMs).toBeUndefined();
+    });
+
     test('forwards byte progress and ETA fields', () => {
         const result = mapToModernizedUploadItem(
             buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingMs: 12000 }),
             '0',
+            true,
         );
         expect(result.bytesUploaded).toBe(40);
         expect(result.totalBytes).toBe(100);
@@ -48,7 +59,7 @@ describe('mapToModernizedUploadItem()', () => {
     });
 
     test('falls back to size for totalBytes before first progress event', () => {
-        const result = mapToModernizedUploadItem(buildLegacyItem({ totalBytes: undefined, size: 2048 }), '0');
+        const result = mapToModernizedUploadItem(buildLegacyItem({ totalBytes: undefined, size: 2048 }), '0', true);
         expect(result.totalBytes).toBe(2048);
     });
 
@@ -58,6 +69,7 @@ describe('mapToModernizedUploadItem()', () => {
             const result = mapToModernizedUploadItem(
                 buildLegacyItem({ status, bytesUploaded: 259, totalBytes: 260 }),
                 '0',
+                true,
             );
             expect(result.bytesUploaded).toBe(260);
             expect(result.totalBytes).toBe(260);
@@ -68,6 +80,7 @@ describe('mapToModernizedUploadItem()', () => {
         const result = mapToModernizedUploadItem(
             buildLegacyItem({ status: STATUS_IN_PROGRESS, bytesUploaded: 259, totalBytes: 260 }),
             '0',
+            true,
         );
         expect(result.bytesUploaded).toBe(259);
     });
@@ -78,6 +91,7 @@ describe('mapToModernizedUploadItem()', () => {
             const result = mapToModernizedUploadItem(
                 buildLegacyItem({ status, bytesUploaded: 260, totalBytes: 260, remainingMs: 3000 }),
                 '0',
+                true,
             );
             expect(result.remainingMs).toBeUndefined();
         },
@@ -87,6 +101,7 @@ describe('mapToModernizedUploadItem()', () => {
         const result = mapToModernizedUploadItem(
             buildLegacyItem({ status: STATUS_IN_PROGRESS, remainingMs: 3000 }),
             '0',
+            true,
         );
         expect(result.remainingMs).toBe(3000);
     });
@@ -207,4 +222,16 @@ describe('mapToModernizedUploadItems()', () => {
         const result = mapToModernizedUploadItems([folderA, folderB], '0');
         expect(result[0].id).not.toBe(result[1].id);
     });
+
+    test('forwards the ETA treatment flag to each item', () => {
+        const item = buildLegacyItem({ bytesUploaded: 40, totalBytes: 100, remainingMs: 12000 });
+
+        const disabled = mapToModernizedUploadItems([item], '0');
+        expect(disabled[0].bytesUploaded).toBeUndefined();
+        expect(disabled[0].remainingMs).toBeUndefined();
+
+        const enabled = mapToModernizedUploadItems([item], '0', true);
+        expect(enabled[0].bytesUploaded).toBe(40);
+        expect(enabled[0].remainingMs).toBe(12000);
+    });
 });
diff --git a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
index 38046437b8..ab0ca5650a 100644
--- a/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
+++ b/src/elements/content-uploader/utils/mapToModernizedUploadItem.ts
@@ -33,17 +33,17 @@ export function getUploadItemKey(item: LegacyUploadItem | FolderUploadItem, root
     return `${item.name}_${folderId}_${uploadInitTimestamp}`;
 }
 
-export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadItem, rootFolderId: string): UploadItem {
+export function mapToModernizedUploadItem(
+    item: LegacyUploadItem | FolderUploadItem,
+    rootFolderId: string,
+    isUploadEtaEnabled = false,
+): UploadItem {
     const errorMessage = item.error ? (item.error as { message?: string }).message : undefined;
     const fileItem = item as LegacyUploadItem;
 
     const status = STATUS_MAP[item.status] ?? 'pending';
-    const totalBytes = fileItem.totalBytes ?? item.size;
-    const isFullyUploaded = status === 'staged' || status === 'complete';
-    const bytesUploaded = isFullyUploaded && totalBytes != null ? totalBytes : fileItem.bytesUploaded;
-    const remainingMs = !isFullyUploaded ? fileItem.remainingMs : undefined;
 
-    return {
+    const baseItem: UploadItem = {
         id: getUploadItemKey(item, rootFolderId),
         name: item.name,
         extension: item.extension ?? '',
@@ -52,6 +52,21 @@ export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadI
         isFolder: item.isFolder,
         errorMessage,
         versionNumber: item.boxFile?.version_number,
+    };
+
+    // Kill switch: when the ETA/byte-progress treatment is off, omit the fields
+    // entirely so the modernized manager falls back to the plain percentage.
+    if (!isUploadEtaEnabled) {
+        return baseItem;
+    }
+
+    const totalBytes = fileItem.totalBytes ?? item.size;
+    const isFullyUploaded = status === 'staged' || status === 'complete';
+    const bytesUploaded = isFullyUploaded && totalBytes != null ? totalBytes : fileItem.bytesUploaded;
+    const remainingMs = !isFullyUploaded ? fileItem.remainingMs : undefined;
+
+    return {
+        ...baseItem,
         bytesUploaded,
         totalBytes,
         remainingMs,
@@ -61,6 +76,7 @@ export function mapToModernizedUploadItem(item: LegacyUploadItem | FolderUploadI
 export function mapToModernizedUploadItems(
     items: Array<LegacyUploadItem | FolderUploadItem>,
     rootFolderId: string,
+    isUploadEtaEnabled = false,
 ): UploadItem[] {
-    return items.map(item => mapToModernizedUploadItem(item, rootFolderId));
+    return items.map(item => mapToModernizedUploadItem(item, rootFolderId, isUploadEtaEnabled));
 }

From 1423a22e513d85a2ff36c96ff41e22e0f03b3c36 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 11:56:38 +0200
Subject: [PATCH 06/10] feat(uploads-manager): bump upload-manager to 2.4.0

---
 package.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/package.json b/package.json
index 7e5a830258..db8688d1ff 100644
--- a/package.json
+++ b/package.json
@@ -148,7 +148,7 @@
         "@box/threaded-annotations": "^4.1.12",
         "@box/types": "^2.1.8",
         "@box/unified-share-modal": "^2.15.16",
-        "@box/uploads-manager": "^1.17.2",
+        "@box/uploads-manager": "^2.4.0",
         "@box/user-selector": "^2.1.39",
         "@cfaester/enzyme-adapter-react-18": "^0.8.0",
         "@chromatic-com/storybook": "^5.2.1",
@@ -317,7 +317,7 @@
         "@box/threaded-annotations": "^4.1.12",
         "@box/types": "^2.1.8",
         "@box/unified-share-modal": "^2.15.16",
-        "@box/uploads-manager": "^1.17.2",
+        "@box/uploads-manager": "^2.4.0",
         "@box/user-selector": "^2.1.39",
         "@hapi/address": "^2.1.4",
         "@tanstack/react-virtual": "^3.13.12",

From e9a462a4b68ea77b0985814dee7e63f52744fe4c Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 12:13:40 +0200
Subject: [PATCH 07/10] feat(uploads-manager): bump yarn lock

---
 yarn.lock | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index d05cfdda8e..aeea231cdd 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1252,10 +1252,10 @@
   resolved "https://registry.yarnpkg.com/@box/unified-share-modal/-/unified-share-modal-2.15.16.tgz#49deb182bf1ac7f1ffe4bae713ab12ff2822533e"
   integrity sha512-Y1bE+JWDQm058lT+AcsfwJqK3WvGAsZj6ro9PLvejJZ1LxzexvOzyQFkM0sL4Kmj/93k2VEKoAJ/onBgheAJoQ==
 
-"@box/uploads-manager@^1.17.2":
-  version "1.17.2"
-  resolved "https://registry.yarnpkg.com/@box/uploads-manager/-/uploads-manager-1.17.2.tgz#e7640ca60c0b1eac6fda1ab6dc5d8269a124eb69"
-  integrity sha512-pVXoPDFmAYx/ErD8+kP3yi4/EOG331tWl4yiO7cEDE1ia5X6mmKGp3va5twJfiqmTmnxBJJZAFEBa4QYb5yV5Q==
+"@box/uploads-manager@^2.4.0":
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/@box/uploads-manager/-/uploads-manager-2.4.0.tgz#c336bc4baef6265fa5a75d266dedd8784532f1eb"
+  integrity sha512-8tXfla+FNnKoqLnUSs+CLc2EEIueOJhGvJFhVtnJ8YOKGvoBSC3eiZA9iSScJQ4/OjK0ImqBlCsuLOAReCflfw==
 
 "@box/user-selector@^2.1.39":
   version "2.1.39"

From d9871236ee71cb91945ef3ebb97098fbe62a2965 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 12:37:58 +0200
Subject: [PATCH 08/10] feat(uploads-manager): fix tests

---
 .../utils/__tests__/uploadEta.test.ts               | 13 ++++++++-----
 src/elements/content-uploader/utils/uploadEta.ts    |  2 +-
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
index be16f2a454..9ba668ea58 100644
--- a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
@@ -21,11 +21,14 @@ describe('updateEta()', () => {
 
     test('produces an estimate once the grace period has passed', () => {
         let state = updateEta(undefined, 0, 1000, 0);
-        state = updateEta(state, 200, 1000, 1000); // elapsed == grace -> still hidden
-        expect(getRemainingMs(state)).toBeUndefined();
-        state = updateEta(state, 400, 1000, 2000); // elapsed 2s > grace
-        // window [0,1000,2000] / [0,200,400] -> 200 B/s, 600 B left -> ~3s -> 3000ms
-        expect(getRemainingMs(state)).toBeCloseTo(3000, 5);
+        // elapsed == grace -> the estimate is now surfaced.
+        // window [0,1000] / [0,200] -> 200 B/s, 800 B left -> raw 4000ms (no prior ETA to smooth against).
+        state = updateEta(state, 200, 1000, 1000);
+        expect(getRemainingMs(state)).toBeCloseTo(4000, 5);
+        // window [0,1000,2000] / [0,200,400] -> 200 B/s, 600 B left -> raw 3000ms.
+        // Smoothed against 4000: 0.1 * 3000 + 0.9 * 4000 = 3900ms.
+        state = updateEta(state, 400, 1000, 2000);
+        expect(getRemainingMs(state)).toBeCloseTo(3900, 5);
     });
 
     test('smooths the ETA with heavy inertia (does not jump)', () => {
diff --git a/src/elements/content-uploader/utils/uploadEta.ts b/src/elements/content-uploader/utils/uploadEta.ts
index bde1f065ce..cdbbaa9e0f 100644
--- a/src/elements/content-uploader/utils/uploadEta.ts
+++ b/src/elements/content-uploader/utils/uploadEta.ts
@@ -65,7 +65,7 @@ export function updateEta(prev: EtaState | undefined, loaded: number, total: num
     const elapsedMs = nowMs - prev.startMs;
 
     // Only estimate once we have positive speed and the warm-up grace has passed.
-    if (total > 0 && speedBytesPerMs > 0 && elapsedMs > GRACE_PERIOD_MS) {
+    if (total > 0 && speedBytesPerMs > 0 && elapsedMs >= GRACE_PERIOD_MS) {
         const rawEtaMs = Math.max(0, total - loaded) / speedBytesPerMs;
         const etaMs = prev.etaMs == null ? rawEtaMs : (1 - ETA_SMOOTHING) * rawEtaMs + ETA_SMOOTHING * prev.etaMs;
         return { ...base, etaMs };

From a50a938d17420154de43851c68ec4ef40b6a80ae Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 12:55:17 +0200
Subject: [PATCH 09/10] feat(uploads-manager): force build

---
 src/elements/content-uploader/utils/__tests__/uploadEta.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
index 9ba668ea58..f4ba90786c 100644
--- a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
@@ -40,7 +40,7 @@ describe('updateEta()', () => {
             etaMs: 10000,
         };
         // Window [0,2000,3000] / [0,2000,3000] -> 1000 B/s, 7000 B left -> raw ETA 7000ms.
-        // Smoothed: 0.1 * 7000 + 0.9 * 10000 = 9700 (barely moves off the previous 10000).
+        // Smoothed: 0.1 * 7000 + 0.9 * 10000 = 9700 (barely moves off the previous 10000)
         const next = updateEta(prev, 3000, 10000, 3000);
         expect(next.etaMs).toBeCloseTo(9700, 5);
     });

From 821a65796edfa66ea4a023a0f01b680d0683aa50 Mon Sep 17 00:00:00 2001
From: pgolebiowski <pgolebiowski@box.com>
Date: Thu, 23 Jul 2026 13:08:02 +0200
Subject: [PATCH 10/10] feat(uploads-manager): force build

---
 src/elements/content-uploader/utils/__tests__/uploadEta.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
index f4ba90786c..9ba668ea58 100644
--- a/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
+++ b/src/elements/content-uploader/utils/__tests__/uploadEta.test.ts
@@ -40,7 +40,7 @@ describe('updateEta()', () => {
             etaMs: 10000,
         };
         // Window [0,2000,3000] / [0,2000,3000] -> 1000 B/s, 7000 B left -> raw ETA 7000ms.
-        // Smoothed: 0.1 * 7000 + 0.9 * 10000 = 9700 (barely moves off the previous 10000)
+        // Smoothed: 0.1 * 7000 + 0.9 * 10000 = 9700 (barely moves off the previous 10000).
         const next = updateEta(prev, 3000, 10000, 3000);
         expect(next.etaMs).toBeCloseTo(9700, 5);
     });