diff --git a/angular.json b/angular.json
index a032f797530..a7708d10633 100644
--- a/angular.json
+++ b/angular.json
@@ -24,6 +24,7 @@
                 "loaders": "prepend"
               }
             },
+            "indexTransform": "webpack/index-html-transform.ts",
             "allowedCommonJsDependencies": [
               "cerialize",
               "core-js",
diff --git a/package.json b/package.json
index b2317522508..10600248b76 100644
--- a/package.json
+++ b/package.json
@@ -198,6 +198,7 @@
     "sass": "~1.94.2",
     "sass-loader": "^12.6.0",
     "sass-resources-loader": "^2.2.5",
+    "terser": "5.29.1",
     "ts-node": "^8.10.2",
     "typescript": "~5.4.5",
     "webpack": "5.101.0",
diff --git a/src/anti-flicker-overlay.js b/src/anti-flicker-overlay.js
new file mode 100644
index 00000000000..769d59e4fda
--- /dev/null
+++ b/src/anti-flicker-overlay.js
@@ -0,0 +1,197 @@
+/* eslint-disable */
+// This file is inlined verbatim into index.html at build time (see webpack/index-html-transform.ts,
+// wired via the build's indexTransform in angular.json). It must stay dependency-free, ES5-safe and
+// self-contained: it runs as a synchronous inline <script> before the deferred module bundles, which
+// is the only point at which a mask can be installed before the SSR DOM is painted. Editing it here
+// keeps index.html clean while the browser still receives it inline.
+
+/*
+  Anti-flicker overlay: paints a detached clone of the settled page on top while <ds-app> re-renders,
+  and lifts once the routed page is genuinely painted (150ms fade).
+
+  Why it is needed: provideClientHydration() is enabled, but DSpace's theme system defeats it. Every
+  wrapper is a `ds-themed-*` whose real content is built imperatively via ViewContainerRef
+  .createComponent() in a client-side ngAfterViewInit, so hydration cannot reuse it and every themed
+  subtree is destroyed and rebuilt a beat after first paint. Upstream: DSpace/dspace-angular#3867.
+  The same mask covers the post-login white flash, where root.component hides `.outer-wrapper` behind
+  `.ds-full-screen-loader` across the `/reload/<ts>` -> `/home` redirect.
+
+  It must be inline and synchronous: the CLI injects the bundles as deferred module scripts, so no
+  Angular hook can run before the SSR DOM has already been painted.
+
+  Safety rails: self-disables under Cypress / navigator.webdriver, never absorbs input, lifts on the
+  first user interaction, and has a 15s hard cap -- it can never trap the user behind a frozen frame.
+*/
+(function () {
+  if (typeof window === 'undefined' || typeof document === 'undefined') { return; }
+  // Cypress drives the real app; a duplicated clone would break element-uniqueness selectors.
+  if (typeof window.Cypress !== 'undefined') { return; }
+  // Same reasoning for any WebDriver-based automation (Playwright/Selenium/headless CI).
+  if (typeof navigator !== 'undefined' && navigator.webdriver) { return; }
+
+  var STORE_KEY = '__dspace_ssr_frame';
+  var OVERLAY_ID = '__dspace_ssr_overlay';
+  var MIN_CONTENT_HEIGHT = 200; // px: proves #main-content is no longer the d-none'd / empty shell
+  var MASK_MAX_MS = 15000;      // absolute cap per mask -- never trap the user behind a frozen frame
+
+  function dsApp() { return document.querySelector('ds-app'); }
+
+  // "Real content" = has children and is NOT the fullscreen auth/theme loader (white + spinner).
+  function isRealContent(el) {
+    return !!(el && el.firstElementChild && !el.querySelector('.ds-full-screen-loader'));
+  }
+
+  // True if this <ds-app> subtree is rendered in the LOGGED-IN state: the header shows the user-menu
+  // (avatar / logout), never present when logged out. Used to pick a mask source whose auth state (and
+  // therefore its admin sidebar / content offset) matches what the reloaded page will settle to.
+  function loggedInChrome(el) {
+    return !!(el && el.querySelector && el.querySelector('.fa-user-circle, .dropdownLogout, [data-test="user-menu"]'));
+  }
+
+  // The routed page is actually painted (safe to reveal): no fullscreen loader AND #main-content has
+  // real layout height. While the loader shows, root.component.html d-none's #main-content's wrapper,
+  // so its own getBoundingClientRect height is 0 even though it is still in the DOM.
+  function contentPainted() {
+    var app = dsApp();
+    if (!app) { return true; }
+    if (app.querySelector('.ds-full-screen-loader')) { return false; }
+    var mc = app.querySelector('#main-content');
+    var h = (mc && mc.getBoundingClientRect) ? mc.getBoundingClientRect().height : 0;
+    if (h < MIN_CONTENT_HEIGHT) { return false; }
+    // Also require the themed navbar to be present with real height. #main-content reports height even
+    // while the imperative themed re-render (header/navbar) is still mid-flight or the async home data
+    // hasn't landed -- revealing then flashes an unstyled/half-built page. The themed navbar being laid
+    // out is a good "the routed page is really rendered" proxy on the datashare theme. If a route has no
+    // such navbar this stays false and the 15s cap reveals anyway.
+    var nav = app.querySelector('#main-navbar');
+    var nh = (nav && nav.getBoundingClientRect) ? nav.getBoundingClientRect().height : 0;
+    return nh > 0;
+  }
+
+  function currentUrl() { return location.pathname + location.search; }
+
+  // Remember the current real view so a later loader/racy-reload can be masked with it. Keyed by URL:
+  // masking a page with a picture of a DIFFERENT one (or with logged-in chrome after a logout) shows
+  // the user a page they are not on any more.
+  function rememberFrame() {
+    var app = dsApp();
+    if (isRealContent(app)) {
+      try {
+        sessionStorage.setItem(STORE_KEY, JSON.stringify({ url: currentUrl(), html: app.outerHTML }));
+      } catch (e) { /* quota / disabled */ }
+    }
+  }
+  function savedFrameNode() {
+    var saved = null;
+    try { saved = sessionStorage.getItem(STORE_KEY); } catch (e) { /* disabled */ }
+    if (!saved) { return null; }
+    var frame = null;
+    try { frame = JSON.parse(saved); } catch (e) { return null; }
+    if (!frame || !frame.html || frame.url !== currentUrl()) { return null; }
+    var holder = document.createElement('div');
+    holder.innerHTML = frame.html;
+    return holder.firstElementChild; // the saved <ds-app> element, _ngcontent attrs intact
+  }
+
+  // Install an opaque, inert freeze-frame from a detached <ds-app> node, then watch for reveal.
+  function installMask(sourceNode) {
+    if (!sourceNode || document.getElementById(OVERLAY_ID)) { return; }
+    var overlay = document.createElement('div');
+    overlay.id = OVERLAY_ID;
+    // Visual duplicate of content the real app still exposes; hide from a11y tree + make inert so
+    // keyboard focus can't land on the dead cloned controls.
+    overlay.setAttribute('aria-hidden', 'true');
+    overlay.setAttribute('inert', '');
+    overlay.appendChild(sourceNode);
+    overlay._dsDeadline = Date.now() + MASK_MAX_MS;
+    document.body.appendChild(overlay);
+    revealWhenPainted();
+  }
+
+  // DOM activity clock: the MutationObserver below stamps this on every childList change, so the
+  // reveal can wait for the app to go QUIET (the themed re-render on reload, and the loader dance on
+  // login, both churn the DOM) rather than lifting the instant content first appears.
+  var lastMutationAt = Date.now();
+  var SETTLE_QUIET_MS = 800;
+
+  // Lift the current mask once the routed page is painted AND the DOM has settled (or the 15s cap
+  // elapses); 150ms fade. Waiting for both is what keeps the reload's themed-wrapper re-render and
+  // the post-login loader from peeking out: content-painted alone fires a frame or two too early.
+  function revealWhenPainted() {
+    var el = document.getElementById(OVERLAY_ID);
+    if (!el || el._dsFading) { return; }
+    var settled = contentPainted() && (Date.now() - lastMutationAt) >= SETTLE_QUIET_MS;
+    if (!settled && Date.now() < el._dsDeadline) {
+      if (typeof window.requestAnimationFrame === 'function') { window.requestAnimationFrame(revealWhenPainted); }
+      else { setTimeout(revealWhenPainted, 50); }
+      return;
+    }
+    // The live page is now settled: remember it as the frame to mask the NEXT reload with, so that
+    // reload's mask matches this exact rendered state (incl. client-only chrome like the admin sidebar).
+    // Only when genuinely settled -- never on a deadline bail-out over a half-built page.
+    if (settled) { rememberFrame(); }
+    el._dsFading = true;
+    el.style.transition = 'opacity 150ms ease-out';
+    el.style.opacity = '0';
+    setTimeout(function () { if (el && el.parentNode) { el.parentNode.removeChild(el); } }, 200);
+  }
+
+  // The moment the user interacts, drop the mask: their click already went through to the live app
+  // (the overlay is pointer-events: none), so continuing to show a frozen picture of the previous page
+  // would hide the very navigation they just triggered -- and their own click churns the DOM, which
+  // pushes the quiet-window reveal further away. Clearing the deadline makes revealWhenPainted lift on
+  // this frame without remembering a half-built frame.
+  ['pointerdown', 'keydown', 'wheel', 'touchstart'].forEach(function (type) {
+    window.addEventListener(type, function () {
+      var el = document.getElementById(OVERLAY_ID);
+      if (el && !el._dsFading) { el._dsDeadline = 0; revealWhenPainted(); }
+    }, { capture: true, passive: true });
+  });
+
+  try {
+    var app = dsApp();
+    if (!app || !app.firstElementChild) { return; } // SSR-excluded route -> nothing to mask
+
+    // Watch the DOM for the whole session: stamp the activity clock (drives the reveal's quiet
+    // window), keep the page masked whenever the fullscreen auth/theme loader appears unmasked (the
+    // ~1s white spinner shown on the current page right after a login submit -- before the /reload
+    // hard-redirect -- and again across /reload -> /home), and keep the saved frame fresh (debounced)
+    // while idle. Cheap: each mutation runs a couple of querySelectors.
+    var rememberTimer = null;
+    function onDomChanged() {
+      lastMutationAt = Date.now();
+      if (document.getElementById(OVERLAY_ID)) { return; } // already masked; reveal watcher lifts it
+      var app2 = dsApp();
+      if (app2 && app2.querySelector('.ds-full-screen-loader')) {
+        installMask(savedFrameNode()); // fullscreen loader is up and nothing masks it -> re-mask
+      } else {
+        if (rememberTimer) { clearTimeout(rememberTimer); }
+        rememberTimer = setTimeout(function () {
+          if (!document.getElementById(OVERLAY_ID) && contentPainted()) { rememberFrame(); }
+        }, 500);
+      }
+    }
+    if (typeof MutationObserver === 'function') {
+      new MutationObserver(onDomChanged).observe(document.documentElement, { childList: true, subtree: true });
+    }
+
+    // Install the mask FIRST (before anything slow) so it covers the SSR paint with no gap. Mask with
+    // whichever source matches the auth state the page will settle to, so client-only chrome (most
+    // visibly the logged-in admin sidebar, which shifts the body ~55px) is already in the mask and
+    // nothing moves at reveal. The logged-in header user-menu is the tell:
+    //   - login /reload: the fresh SSR renders authenticated (sidebar present) -> clone the live SSR
+    //   - logged-in F5 reload: the SSR renders anonymous, but the remembered settled frame is logged-in
+    //   - logged-out: neither is logged-in -> the remembered settled frame (or SSR clone on first load)
+    // We do NOT rememberFrame() here -- the pre-hydration SSR is the unsettled state we must not save;
+    // rememberFrame() runs at reveal (revealWhenPainted), once the live page has actually settled.
+    var ssrClone = isRealContent(app) ? app.cloneNode(true) : null;
+    var savedNode = savedFrameNode();
+    installMask(loggedInChrome(ssrClone) ? ssrClone
+      : loggedInChrome(savedNode) ? savedNode
+      : (savedNode || ssrClone));
+  } catch (e) {
+    if (window.console && typeof console.warn === 'function') {
+      console.warn('[dspace-ssr-overlay] disabled due to error:', e);
+    }
+  }
+})();
diff --git a/src/app/admin/admin-sidebar/admin-sidebar.component.spec.ts b/src/app/admin/admin-sidebar/admin-sidebar.component.spec.ts
index 25892be2915..4bdf6765ab8 100644
--- a/src/app/admin/admin-sidebar/admin-sidebar.component.spec.ts
+++ b/src/app/admin/admin-sidebar/admin-sidebar.component.spec.ts
@@ -19,10 +19,14 @@ import {
   NgbModalRef,
 } from '@ng-bootstrap/ng-bootstrap';
 import { TranslateModule } from '@ngx-translate/core';
-import { of as observableOf } from 'rxjs';
+import {
+  BehaviorSubject,
+  of as observableOf,
+} from 'rxjs';
 
 import { AuthService } from '../../core/auth/auth.service';
 import { AuthorizationDataService } from '../../core/data/feature-authorization/authorization-data.service';
+import { FeatureID } from '../../core/data/feature-authorization/feature-id';
 import { ScriptDataService } from '../../core/data/processes/script-data.service';
 import { Item } from '../../core/shared/item.model';
 import { MenuService } from '../../shared/menu/menu.service';
@@ -105,6 +109,70 @@ describe('AdminSidebarComponent', () => {
     fixture.detectChanges();
   });
 
+  describe('authorization', () => {
+    /**
+     * Re-create the component so that its single ngOnInit runs under the stubs/spies configured by the
+     * test, instead of the default detectChanges() from the outer beforeEach (which runs before them).
+     */
+    const initFreshComponent = () => {
+      fixture = TestBed.createComponent(AdminSidebarComponent);
+      comp = fixture.componentInstance;
+      comp.sections = observableOf([]);
+      fixture.detectChanges();
+    };
+
+    beforeEach(() => {
+      spyOn(menuService, 'showMenu');
+      spyOn(menuService, 'hideMenu');
+    });
+
+    it('should show the admin menu for a user with an administrative role', () => {
+      authorizationService.isAuthorized = jasmine.createSpy('isAuthorized').and.callFake((featureID: FeatureID) => {
+        return observableOf(featureID === FeatureID.AdministratorOf);
+      });
+
+      initFreshComponent();
+
+      expect(menuService.showMenu).toHaveBeenCalledWith(comp.menuID);
+      expect(menuService.hideMenu).not.toHaveBeenCalled();
+    });
+
+    it('should hide the admin menu for an authenticated non-admin user', () => {
+      authorizationService.isAuthorized = jasmine.createSpy('isAuthorized').and.returnValue(observableOf(false));
+
+      initFreshComponent();
+
+      expect(menuService.showMenu).not.toHaveBeenCalled();
+      expect(menuService.hideMenu).toHaveBeenCalledWith(comp.menuID);
+    });
+
+    it('should hide the admin menu without requesting authorizations for an anonymous user', () => {
+      spyOn(TestBed.inject(AuthService), 'isAuthenticated').and.returnValue(observableOf(false));
+      authorizationService.isAuthorized = jasmine.createSpy('isAuthorized').and.returnValue(observableOf(false));
+
+      initFreshComponent();
+
+      expect(menuService.showMenu).not.toHaveBeenCalled();
+      expect(menuService.hideMenu).toHaveBeenCalledWith(comp.menuID);
+      expect(authorizationService.isAuthorized).not.toHaveBeenCalled();
+    });
+
+    it('should reveal the admin menu once authentication resolves (guards against a one-shot take(1) regression)', () => {
+      const authenticated$ = new BehaviorSubject<boolean>(false);
+      spyOn(TestBed.inject(AuthService), 'isAuthenticated').and.returnValue(authenticated$);
+      authorizationService.isAuthorized = jasmine.createSpy('isAuthorized').and.callFake((featureID: FeatureID) => {
+        return observableOf(featureID === FeatureID.AdministratorOf);
+      });
+
+      initFreshComponent();
+      expect(menuService.hideMenu).toHaveBeenCalledWith(comp.menuID);
+
+      authenticated$.next(true);
+
+      expect(menuService.showMenu).toHaveBeenCalledWith(comp.menuID);
+    });
+  });
+
   describe('startSlide', () => {
     describe('when expanding', () => {
       beforeEach(() => {
diff --git a/src/app/admin/admin-sidebar/admin-sidebar.component.ts b/src/app/admin/admin-sidebar/admin-sidebar.component.ts
index 00514d2afc3..a338a866ce8 100644
--- a/src/app/admin/admin-sidebar/admin-sidebar.component.ts
+++ b/src/app/admin/admin-sidebar/admin-sidebar.component.ts
@@ -19,17 +19,20 @@ import {
   BehaviorSubject,
   combineLatest,
   Observable,
+  of as observableOf,
 } from 'rxjs';
 import {
   debounceTime,
   distinctUntilChanged,
   first,
   map,
+  switchMap,
   withLatestFrom,
 } from 'rxjs/operators';
 
 import { AuthService } from '../../core/auth/auth.service';
 import { AuthorizationDataService } from '../../core/data/feature-authorization/authorization-data.service';
+import { FeatureID } from '../../core/data/feature-authorization/feature-id';
 import { slideSidebar } from '../../shared/animations/slide';
 import { MenuComponent } from '../../shared/menu/menu.component';
 import { MenuService } from '../../shared/menu/menu.service';
@@ -108,12 +111,17 @@ export class AdminSidebarComponent extends MenuComponent implements OnInit {
    */
   ngOnInit(): void {
     super.ngOnInit();
-    this.authService.isAuthenticated()
-      .subscribe((loggedIn: boolean) => {
-        if (loggedIn) {
-          this.menuService.showMenu(this.menuID);
-        }
-      });
+    this.authService.isAuthenticated().pipe(
+      switchMap((isAuthenticated: boolean) => isAuthenticated
+        ? this.authorizationService.isAuthorized(FeatureID.AdministratorOf)
+        : observableOf(false)),
+    ).subscribe((isSiteAdmin: boolean) => {
+      if (isSiteAdmin) {
+        this.menuService.showMenu(this.menuID);
+      } else {
+        this.menuService.hideMenu(this.menuID);
+      }
+    });
     this.menuCollapsed.pipe(first())
       .subscribe((collapsed: boolean) => {
         this.sidebarOpen = !collapsed;
diff --git a/src/app/app.component.spec.ts b/src/app/app.component.spec.ts
index 159fbb38f04..1172bd6b5a6 100644
--- a/src/app/app.component.spec.ts
+++ b/src/app/app.component.spec.ts
@@ -149,4 +149,5 @@ describe('App component', () => {
     });
 
   });
+
 });
diff --git a/src/app/app.component.ts b/src/app/app.component.ts
index b87073c034f..63ee840fb85 100644
--- a/src/app/app.component.ts
+++ b/src/app/app.component.ts
@@ -128,7 +128,13 @@ export class AppComponent implements OnInit, AfterViewInit {
       distinctUntilChanged(),
     );
 
-    this.dispatchWindowSize(this._window.nativeWindow.innerWidth, this._window.nativeWindow.innerHeight);
+    // Window size only has meaning in the browser. On the server `nativeWindow` is unavailable, so
+    // dispatching here would overwrite the desktop default in hostWindow.reducer with an undefined
+    // size — keep the default (which is what SSR renders responsive components with). See the note on
+    // the reducer's initialState.
+    if (isPlatformBrowser(this.platformId)) {
+      this.dispatchWindowSize(this._window.nativeWindow.innerWidth, this._window.nativeWindow.innerHeight);
+    }
   }
 
   private storeCSSVariables() {
@@ -181,5 +187,4 @@ export class AppComponent implements OnInit, AfterViewInit {
         }
       });
   }
-
 }
diff --git a/src/app/core/data/item-data.service.spec.ts b/src/app/core/data/item-data.service.spec.ts
index dd60d940702..0c0cc1730fe 100644
--- a/src/app/core/data/item-data.service.spec.ts
+++ b/src/app/core/data/item-data.service.spec.ts
@@ -133,6 +133,27 @@ describe('ItemDataService', () => {
     });
   });
 
+  describe('getMoveItemEndpoint', () => {
+    beforeEach(() => {
+      service = initTestService();
+    });
+
+    it('should append keepEmbargoPolicies when inheriting policies', (done) => {
+      service.getMoveItemEndpoint('item-id', true, false).subscribe((href) => {
+        expect(href).toContain('item-id/owningCollection?inheritPolicies=true&keepEmbargoPolicies=false');
+        done();
+      });
+    });
+
+    it('should omit keepEmbargoPolicies when not inheriting policies', (done) => {
+      service.getMoveItemEndpoint('item-id', false, true).subscribe((href) => {
+        expect(href).toContain('item-id/owningCollection?inheritPolicies=false');
+        expect(href).not.toContain('keepEmbargoPolicies');
+        done();
+      });
+    });
+  });
+
   describe('removeMappingFromCollection', () => {
     let result;
 
diff --git a/src/app/core/data/item-data.service.ts b/src/app/core/data/item-data.service.ts
index e1f789b5da7..2fdad85b482 100644
--- a/src/app/core/data/item-data.service.ts
+++ b/src/app/core/data/item-data.service.ts
@@ -272,11 +272,20 @@ export abstract class BaseItemDataService extends IdentifiableDataService<Item>
   /**
    * Get the endpoint to move the item
    * @param itemId
+   * @param inheritPolicies whether to inherit the destination collection's default policies
+   * @param keepEmbargoPolicies when inheriting, keep an existing embargo instead of letting it be lifted
    */
-  public getMoveItemEndpoint(itemId: string, inheritPolicies: boolean): Observable<string> {
+  public getMoveItemEndpoint(itemId: string, inheritPolicies: boolean, keepEmbargoPolicies = true): Observable<string> {
     return this.halService.getEndpoint(this.linkPath).pipe(
       map((endpoint: string) => this.getIDHref(endpoint, itemId)),
-      map((endpoint: string) => `${endpoint}/owningCollection?inheritPolicies=${inheritPolicies}`),
+      map((endpoint: string) => {
+        let href = `${endpoint}/owningCollection?inheritPolicies=${inheritPolicies}`;
+        // Only relevant when inheriting.
+        if (inheritPolicies) {
+          href += `&keepEmbargoPolicies=${keepEmbargoPolicies}`;
+        }
+        return href;
+      }),
     );
   }
 
@@ -284,15 +293,19 @@ export abstract class BaseItemDataService extends IdentifiableDataService<Item>
    * Move the item to a different owning collection
    * @param itemId
    * @param collection
+   * @param inheritPolicies whether to inherit the destination collection's default policies
+   * @param keepEmbargoPolicies when inheriting, whether to keep an existing embargo
    */
-  public moveToCollection(itemId: string, collection: Collection, inheritPolicies: boolean): Observable<RemoteData<any>> {
+  public moveToCollection(
+    itemId: string, collection: Collection, inheritPolicies: boolean, keepEmbargoPolicies = true,
+  ): Observable<RemoteData<any>> {
     const options: HttpOptions = Object.create({});
     let headers = new HttpHeaders();
     headers = headers.append('Content-Type', 'text/uri-list');
     options.headers = headers;
 
     const requestId = this.requestService.generateRequestId();
-    const hrefObs = this.getMoveItemEndpoint(itemId, inheritPolicies);
+    const hrefObs = this.getMoveItemEndpoint(itemId, inheritPolicies, keepEmbargoPolicies);
 
     hrefObs.pipe(
       find((href: string) => hasValue(href)),
diff --git a/src/app/datashare/datashare-submission.service.ts b/src/app/datashare/datashare-submission.service.ts
index 63a4d10484d..3a4cf1e3bc8 100644
--- a/src/app/datashare/datashare-submission.service.ts
+++ b/src/app/datashare/datashare-submission.service.ts
@@ -1,36 +1,12 @@
-import {
-  computed,
-  Injectable,
-  signal,
-} from '@angular/core';
-import { TranslateService } from '@ngx-translate/core';
-import { Observable } from 'rxjs';
-
-import { NotificationsService } from '../shared/notifications/notifications.service';
+import { Injectable } from '@angular/core';
 
 @Injectable({
   providedIn: 'root',
 })
 export class DatashareSubmissionService {
 
-  MAX_FILE_SIZE_GB = 20;
-  MAX_FILE_SIZE_BYTES = this.MAX_FILE_SIZE_GB * 1024 * 1024 * 1024;
-
-  // Single shared signal for deposit button state
-  private _hasUploadFilesErrorsSignal = signal<boolean>(true);
-  public readonly hasUploadFilesErrorsSignal = this._hasUploadFilesErrorsSignal.asReadonly();
-
-  constructor(private notificationsService: NotificationsService,
-    private translate: TranslateService,
-  ) {
-  }
-
-  /**
-   * Update the deposit button visibility state
-   */
-  updatehasUploadFilesErrors(show: boolean): void {
-    this._hasUploadFilesErrorsSignal.set(show);
-  }
+  private readonly MAX_FILE_SIZE_GB = 20;
+  private readonly MAX_FILE_SIZE_BYTES = this.MAX_FILE_SIZE_GB * 1024 * 1024 * 1024;
 
   /**
    * Calculate total size of uploaded files
@@ -63,72 +39,10 @@ export class DatashareSubmissionService {
     }
 
     const k = 1024;
-    const sizes = ['Bytes', 'KB', 'MB', 'GB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    // Clamp the index so very large values never index past the units array (which would render "undefined").
+    const i = Math.min(Math.floor(Math.log(bytes) / Math.log(k)), sizes.length - 1);
 
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
   }
-
-  /**
-   * Get duplicate file names from an array of file names
-   * @param fileNames Array of file names
-   * @returns Array of duplicate file names
-   */
-  getDuplicateFileNames(fileNames: string[]): string[] {
-    const counts = fileNames.reduce((acc, fileName) => {
-      acc[fileName] = (acc[fileName] || 0) + 1;
-      return acc;
-    }, {} as Record<string, number>);
-
-    return Object.keys(counts).filter(fileName => counts[fileName] > 1);
-  }
-
-  /**
-   * Get duplicate file names as a formatted string
-   * @param fileNames Array of file names
-   * @returns Comma-separated string of duplicates or 'None'
-   */
-  getDuplicateFileNamesDisplay(fileNames: string[]): string {
-    const duplicates = this.getDuplicateFileNames(fileNames);
-    return duplicates.length > 0 ? duplicates.join(', ') : '';
-  }
-
-  /**
-   * Create a signal-based duplicate file name detector
-   * @param initialFileNames Initial array of file names
-   * @returns Object with fileNamesSignal and hasUploadFilesErrorsSignal
-   */
-  createDuplicateFileNameDetector(initialFileNames: string[] = []) {
-    const fileNamesSignal = signal<string[]>(initialFileNames);
-
-    const hasUploadFilesErrorsSignal = computed(() => {
-      const duplicates = this.getDuplicateFileNames(fileNamesSignal());
-      return duplicates.length !== 0;
-    });
-
-    return {
-      fileNamesSignal,
-      hasUploadFilesErrorsSignal,
-      updateFileNames: (newFileNames: string[]) => fileNamesSignal.set(newFileNames),
-      getDuplicates: () => this.getDuplicateFileNames(fileNamesSignal()),
-      getDuplicateFileNamesDisplay: () => this.getDuplicateFileNamesDisplay(fileNamesSignal()),
-    };
-  }
-
-  createObservableDuplicateDetector$(fileNames$: Observable<string[]>): Observable<boolean> {
-    return new Observable<boolean>(subscriber => {
-      fileNames$.subscribe(fileNames => {
-        const duplicates = this.getDuplicateFileNames(fileNames);
-        subscriber.next(duplicates.length === 0);
-      });
-    });
-  }
-
-  /**
-   * Send a notification that the submission cannot be submitted.
-   */
-  sendCannotSubmitNotification(): void {
-    this.notificationsService.error(null, this.translate.get('datashare.submission.sections.upload.submit.errors'));
-  }
 }
-
diff --git a/src/app/datashare/datashare-upload-from-path.service.spec.ts b/src/app/datashare/datashare-upload-from-path.service.spec.ts
new file mode 100644
index 00000000000..44fb3b1e0b1
--- /dev/null
+++ b/src/app/datashare/datashare-upload-from-path.service.spec.ts
@@ -0,0 +1,218 @@
+import { BehaviorSubject } from 'rxjs';
+
+import { JsonPatchOperationType } from '../core/json-patch/json-patch.model';
+import {
+  JsonPatchOperationObject,
+  JsonPatchOperationsResourceEntry,
+} from '../core/json-patch/json-patch-operations.reducer';
+import { SubmissionObjectEntry } from '../submission/objects/submission-objects.reducer';
+import { DatashareUploadFromPathService } from './datashare-upload-from-path.service';
+
+describe('DatashareUploadFromPathService', () => {
+
+  const submissionId = '826';
+  const sectionId = 'metadatapageone';
+  const otherSectionId = 'sectionOfAnotherSubmission';
+  const serverPath = '/srv/dspace/ingest/dataset.zip';
+
+  let submission$: BehaviorSubject<SubmissionObjectEntry>;
+  let sectionOperations$: BehaviorSubject<JsonPatchOperationsResourceEntry>;
+  let service: DatashareUploadFromPathService;
+
+  const submissionWithSectionData = (data: any): SubmissionObjectEntry => ({
+    sections: {
+      [sectionId]: { data } as any,
+    },
+  });
+
+  const operationOn = (path: string, value: any): JsonPatchOperationObject => ({
+    operation: {
+      op: JsonPatchOperationType.add,
+      path,
+      value,
+    },
+    timeCompleted: 1,
+  });
+
+  const pendingOperations = (children: { [resourceId: string]: JsonPatchOperationObject[] }): JsonPatchOperationsResourceEntry => ({
+    children: Object.keys(children).reduce((acc: any, key: string) => Object.assign(acc, { [key]: { body: children[key] } }), {}),
+    transactionStartTime: null,
+    commitPending: false,
+  });
+
+  const pathOperation = (value: any, onSectionId = sectionId): JsonPatchOperationObject =>
+    operationOn(`/sections/${onSectionId}/${DatashareUploadFromPathService.PATH_FIELD}`, value);
+
+  const removeOperationOn = (path: string): JsonPatchOperationObject => ({
+    operation: {
+      op: JsonPatchOperationType.remove,
+      path,
+      value: null,
+    },
+    timeCompleted: 2,
+  });
+
+  const pathRemoveOperation = (onSectionId = sectionId): JsonPatchOperationObject =>
+    removeOperationOn(`/sections/${onSectionId}/${DatashareUploadFromPathService.PATH_FIELD}`);
+
+  const collectEmissions = (): boolean[] => {
+    const emitted: boolean[] = [];
+    service.isPendingForSubmission(submissionId).subscribe((pending: boolean) => emitted.push(pending));
+    return emitted;
+  };
+
+  beforeEach(() => {
+    submission$ = new BehaviorSubject(submissionWithSectionData({}));
+    sectionOperations$ = new BehaviorSubject(pendingOperations({ [sectionId]: [] }));
+
+    const submissionServiceMock = {
+      getSubmissionObject: () => submission$.asObservable(),
+    };
+    const storeMock = {
+      select: () => sectionOperations$.asObservable(),
+    };
+
+    service = new DatashareUploadFromPathService(submissionServiceMock as any, storeMock as any);
+  });
+
+  it('should emit true when the submission already carries a non-empty path value', () => {
+    submission$.next(submissionWithSectionData({
+      'dc.title': [{ value: 'A dataset' }],
+      [DatashareUploadFromPathService.PATH_FIELD]: [{ value: serverPath }],
+    }));
+
+    expect(collectEmissions()).toEqual([true]);
+  });
+
+  it('should emit true while an unsaved patch operation carries a non-empty path value', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathOperation([{ value: serverPath }])],
+    }));
+
+    expect(collectEmissions()).toEqual([true]);
+  });
+
+  it('should emit false when the path field is absent', () => {
+    submission$.next(submissionWithSectionData({ 'dc.title': [{ value: 'A dataset' }] }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should emit false when the path field holds only blank values', () => {
+    submission$.next(submissionWithSectionData({
+      [DatashareUploadFromPathService.PATH_FIELD]: [{ value: '   ' }],
+    }));
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathOperation([{ value: '' }])],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should emit false when a pending remove clears a path that is still in the saved section data', () => {
+    // Section data is only refreshed from a server response, so it still holds the old path while the
+    // administrator is clearing the field. The save will ingest nothing, and must not be labelled as
+    // an ingest. A value can be in the field without this feature having put it there - an import or
+    // the item-edit page can set it too.
+    submission$.next(submissionWithSectionData({
+      [DatashareUploadFromPathService.PATH_FIELD]: [{ value: serverPath }],
+    }));
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathRemoveOperation()],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should still emit true when the saved path is left untouched by the pending operations', () => {
+    submission$.next(submissionWithSectionData({
+      [DatashareUploadFromPathService.PATH_FIELD]: [{ value: serverPath }],
+    }));
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [operationOn(`/sections/${sectionId}/dc.title`, [{ value: 'A dataset' }])],
+    }));
+
+    expect(collectEmissions()).toEqual([true]);
+  });
+
+  it('should emit false when a later remove cancels the add of a path', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathOperation([{ value: serverPath }]), pathRemoveOperation()],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should emit true when a path is added again after being removed', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [
+        pathOperation([{ value: serverPath }]),
+        pathRemoveOperation(),
+        pathOperation([{ value: serverPath }]),
+      ],
+    }));
+
+    expect(collectEmissions()).toEqual([true]);
+  });
+
+  it('should emit false when a later operation replaces the path with whitespace', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathOperation([{ value: serverPath }]), pathOperation([{ value: '  \t ' }])],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should not let a remove on another field cancel the path', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [
+        pathOperation([{ value: serverPath }]),
+        removeOperationOn(`/sections/${sectionId}/dc.title`),
+      ],
+    }));
+
+    expect(collectEmissions()).toEqual([true]);
+  });
+
+  it('should ignore pending operations belonging to a section of another submission', () => {
+    sectionOperations$.next(pendingOperations({
+      [otherSectionId]: [pathOperation([{ value: serverPath }], otherSectionId)],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should ignore pending operations on other metadata fields', () => {
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [operationOn(`/sections/${sectionId}/dc.title`, [{ value: serverPath }])],
+    }));
+
+    expect(collectEmissions()).toEqual([false]);
+  });
+
+  it('should not re-emit when an unrelated change occurs', () => {
+    const emitted = collectEmissions();
+
+    submission$.next(submissionWithSectionData({ 'dc.title': [{ value: 'A dataset' }] }));
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [operationOn(`/sections/${sectionId}/dc.title`, [{ value: 'A dataset' }])],
+    }));
+
+    expect(emitted).toEqual([false]);
+  });
+
+  it('should emit once per change of the pending state', () => {
+    const emitted = collectEmissions();
+
+    sectionOperations$.next(pendingOperations({
+      [sectionId]: [pathOperation([{ value: serverPath }])],
+    }));
+    submission$.next(submissionWithSectionData({
+      [DatashareUploadFromPathService.PATH_FIELD]: [{ value: serverPath }],
+    }));
+    sectionOperations$.next(pendingOperations({ [sectionId]: [] }));
+
+    expect(emitted).toEqual([false, true]);
+  });
+
+});
diff --git a/src/app/datashare/datashare-upload-from-path.service.ts b/src/app/datashare/datashare-upload-from-path.service.ts
new file mode 100644
index 00000000000..d4b22128bc5
--- /dev/null
+++ b/src/app/datashare/datashare-upload-from-path.service.ts
@@ -0,0 +1,164 @@
+import { Injectable } from '@angular/core';
+import { Store } from '@ngrx/store';
+import {
+  combineLatest as observableCombineLatest,
+  Observable,
+} from 'rxjs';
+import {
+  distinctUntilChanged,
+  map,
+  startWith,
+} from 'rxjs/operators';
+
+import { CoreState } from '../core/core-state.model';
+import { JsonPatchOperationType } from '../core/json-patch/json-patch.model';
+import {
+  JsonPatchOperationObject,
+  JsonPatchOperationsResourceEntry,
+} from '../core/json-patch/json-patch-operations.reducer';
+import { jsonPatchOperationsByResourceType } from '../core/json-patch/selectors';
+import { hasValue } from '../shared/empty.util';
+import {
+  SubmissionObjectEntry,
+  SubmissionSectionEntry,
+} from '../submission/objects/submission-objects.reducer';
+import { SubmissionService } from '../submission/submission.service';
+
+/**
+ * The JSON PATCH resource type under which every submission section stores its unsaved operations.
+ */
+const SECTIONS_RESOURCE_TYPE = 'sections';
+
+/**
+ * Tells the submission UI whether the next (or running) save will make the server ingest a bitstream
+ * from a server path, so a long-running indicator can be shown instead of the ordinary "Saving" one.
+ * Read from two places: the unsaved JSON PATCH operations (the path from when it is typed until the
+ * response) and the submission object's section data (a path a previous ingest did not clear).
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class DatashareUploadFromPathService {
+
+  /**
+   * Metadata field whose presence means that a save will trigger a server-side ingest.
+   */
+  public static readonly PATH_FIELD = 'local.bitstream.redirectToURL';
+
+  constructor(private submissionService: SubmissionService,
+              private store: Store<CoreState>) {
+  }
+
+  /**
+   * Emits true while the submission carries a non-empty {@link PATH_FIELD} value, saved or pending.
+   *
+   * @param submissionId the id of the submission being edited
+   * @return an observable that emits only when the pending state changes
+   */
+  public isPendingForSubmission(submissionId: string): Observable<boolean> {
+    const sections$: Observable<SubmissionSectionEntry> = this.submissionService.getSubmissionObject(submissionId).pipe(
+      map((submission: SubmissionObjectEntry) => hasValue(submission) && hasValue(submission.sections) ? submission.sections : {}),
+      startWith({} as SubmissionSectionEntry),
+    );
+
+    const operations$: Observable<JsonPatchOperationsResourceEntry> =
+      this.store.select(jsonPatchOperationsByResourceType(SECTIONS_RESOURCE_TYPE));
+
+    return observableCombineLatest([sections$, operations$]).pipe(
+      map(([sections, operations]: [SubmissionSectionEntry, JsonPatchOperationsResourceEntry]) => {
+        // Section data lags behind (server-refreshed only), so a pending operation has the final say;
+        // the saved value is consulted only when nothing pending touches the field.
+        const pending: boolean | undefined = this.pendingOutcome(sections, operations);
+        return hasValue(pending) ? pending : this.isInSectionData(sections);
+      }),
+      distinctUntilChanged(),
+    );
+  }
+
+  /**
+   * Does any section of the submission already hold a saved path value?
+   *
+   * @param sections the submission's sections as held in the store
+   * @return true when at least one section's data carries a non-blank path
+   */
+  private isInSectionData(sections: SubmissionSectionEntry): boolean {
+    return Object.keys(sections)
+      .map((sectionId: string) => sections[sectionId]?.data)
+      .some((data: any) => hasValue(data) && this.isNonBlankValue(data[DatashareUploadFromPathService.PATH_FIELD]));
+  }
+
+  /**
+   * What do the unsaved JSON PATCH operations do to the path field? Scoped back to the submission by
+   * keeping only the sections it owns, since the JSON PATCH state is keyed by section id alone.
+   *
+   * @param sections   the submission's sections as held in the store
+   * @param operations the JSON PATCH operations pending for every submission section
+   * @return true when they leave a non-blank path, false when they clear it, undefined when untouched
+   */
+  private pendingOutcome(sections: SubmissionSectionEntry, operations: JsonPatchOperationsResourceEntry): boolean | undefined {
+    if (!hasValue(operations) || !hasValue(operations.children)) {
+      return undefined;
+    }
+    const outcomes: boolean[] = Object.keys(operations.children)
+      .filter((sectionId: string) => hasValue(sections[sectionId]))
+      .map((sectionId: string) => this.pathOutcome(operations.children[sectionId]?.body ?? []))
+      .filter((outcome: boolean | undefined): outcome is boolean => hasValue(outcome));
+
+    if (outcomes.length === 0) {
+      return undefined;
+    }
+    return outcomes.some((outcome: boolean) => outcome);
+  }
+
+  /**
+   * Replay a section's pending operations in order and report the state the path field is left in.
+   * Folded, not tested one by one, because only the last operation touching the field describes the save.
+   *
+   * @param body the section's pending JSON PATCH operations, in the order they were dispatched
+   * @return true when the last operation on the path field leaves a non-blank value, false when it clears
+   *         it, undefined when no operation touches the field
+   */
+  private pathOutcome(body: JsonPatchOperationObject[]): boolean | undefined {
+    return body.reduce((leftBehind: boolean | undefined, entry: JsonPatchOperationObject) => {
+      if (!this.isPathFieldOperation(entry)) {
+        return leftBehind;
+      }
+      if (entry.operation.op === JsonPatchOperationType.remove) {
+        return false;
+      }
+      return this.isNonBlankValue(entry.operation.value);
+    }, undefined);
+  }
+
+  /**
+   * Does this operation target the path field of a section, whatever it does to it?
+   *
+   * @param entry a pending JSON PATCH operation
+   * @return true when the operation's path addresses the path field
+   */
+  private isPathFieldOperation(entry: JsonPatchOperationObject): boolean {
+    const path: string = entry?.operation?.path;
+    if (!hasValue(path)) {
+      return false;
+    }
+    // Path is '/sections/<sectionId>/<field>' or '/sections/<sectionId>/<field>/<index>'.
+    return path.split('/')[3] === DatashareUploadFromPathService.PATH_FIELD;
+  }
+
+  /**
+   * Is this a metadata value, or list of metadata values, carrying actual text?
+   *
+   * @param value a raw string, a metadata value object, or a list of either
+   * @return true when at least one of the values is a non-blank string
+   */
+  private isNonBlankValue(value: any): boolean {
+    const candidates: any[] = Array.isArray(value) ? value : [value];
+    return candidates.some((candidate: any) => {
+      if (typeof candidate === 'string') {
+        return candidate.trim().length > 0;
+      }
+      return hasValue(candidate) && typeof candidate === 'object' && this.isNonBlankValue(candidate.value);
+    });
+  }
+
+}
diff --git a/src/app/item-page/edit-item-page/item-move/item-move.component.html b/src/app/item-page/edit-item-page/item-move/item-move.component.html
index 63378f5afe2..99decf2dd26 100644
--- a/src/app/item-page/edit-item-page/item-move/item-move.component.html
+++ b/src/app/item-page/edit-item-page/item-move/item-move.component.html
@@ -32,6 +32,19 @@ <h1>{{'item.edit.move.head' | translate: {id: (itemRD$ | async)?.payload?.handle
                     <p>
                         {{'item.edit.move.inheritpolicies.description' | translate}}
                     </p>
+                    <p *ngIf="inheritPolicies">
+                      <label for="keepEmbargoPoliciesCheckbox">
+                        <ng-template #keepEmbargoTooltipContent>
+                          {{ 'item.edit.move.keepembargopolicies.tooltip' | translate }}
+                        </ng-template>
+                        <input type="checkbox" name="keepEmbargo" [(ngModel)]="keepEmbargoPolicies" id="keepEmbargoPoliciesCheckbox" [ngbTooltip]="keepEmbargoTooltipContent"
+                        >
+                        {{'item.edit.move.keepembargopolicies.checkbox' | translate}}
+                      </label>
+                    </p>
+                    <p *ngIf="inheritPolicies">
+                        {{'item.edit.move.keepembargopolicies.description' | translate}}
+                    </p>
                 </div>
             </div>
 
diff --git a/src/app/item-page/edit-item-page/item-move/item-move.component.spec.ts b/src/app/item-page/edit-item-page/item-move/item-move.component.spec.ts
index 658223c661a..c7e202b20a0 100644
--- a/src/app/item-page/edit-item-page/item-move/item-move.component.spec.ts
+++ b/src/app/item-page/edit-item-page/item-move/item-move.component.spec.ts
@@ -150,7 +150,20 @@ describe('ItemMoveComponent', () => {
         comp.inheritPolicies = false;
         comp.moveToCollection();
 
-        expect(itemDataService.moveToCollection).toHaveBeenCalledWith('item-id', collection1, false);
+        // keepEmbargoPolicies defaults to true; it is only sent on the request URL when inheriting
+        expect(itemDataService.moveToCollection).toHaveBeenCalledWith('item-id', collection1, false, true);
+      });
+      it('should pass keepEmbargoPolicies through when inheriting policies', () => {
+        comp.item = Object.assign(new Item(), {
+          id: 'item-id',
+          uuid: 'item-id',
+        });
+        comp.selectedCollection = collection1;
+        comp.inheritPolicies = true;
+        comp.keepEmbargoPolicies = false;
+        comp.moveToCollection();
+
+        expect(itemDataService.moveToCollection).toHaveBeenCalledWith('item-id', collection1, true, false);
       });
       it('should call notificationsService success message on success', () => {
         comp.moveToCollection();
diff --git a/src/app/item-page/edit-item-page/item-move/item-move.component.ts b/src/app/item-page/edit-item-page/item-move/item-move.component.ts
index e13b1d2282c..a688211be8f 100644
--- a/src/app/item-page/edit-item-page/item-move/item-move.component.ts
+++ b/src/app/item-page/edit-item-page/item-move/item-move.component.ts
@@ -72,7 +72,10 @@ export class ItemMoveComponent implements OnInit {
 
   selectorType = DSpaceObjectType.COLLECTION;
 
-  inheritPolicies = false;
+  inheritPolicies = true;
+
+  /** When inheriting, keep an existing embargo instead of letting the inherited default read lift it. */
+  keepEmbargoPolicies = true;
   itemRD$: Observable<RemoteData<Item>>;
   originalCollection: Collection;
 
@@ -145,8 +148,9 @@ export class ItemMoveComponent implements OnInit {
    */
   moveToCollection() {
     this.processing = true;
-    const move$ = this.itemDataService.moveToCollection(this.item.id, this.selectedCollection, this.inheritPolicies)
-      .pipe(getFirstCompletedRemoteData());
+    const move$ = this.itemDataService.moveToCollection(
+      this.item.id, this.selectedCollection, this.inheritPolicies, this.keepEmbargoPolicies,
+    ).pipe(getFirstCompletedRemoteData());
 
     move$.subscribe((response: RemoteData<any>) => {
       if (response.hasSucceeded) {
diff --git a/src/app/item-page/simple/field-components/file-section/file-section.component.spec.ts b/src/app/item-page/simple/field-components/file-section/file-section.component.spec.ts
index 9d4f00c1c1a..1f072f6ffa1 100644
--- a/src/app/item-page/simple/field-components/file-section/file-section.component.spec.ts
+++ b/src/app/item-page/simple/field-components/file-section/file-section.component.spec.ts
@@ -152,6 +152,16 @@ describe('FileSectionComponent', () => {
       expect(bitstreamDataService.findAllByItemAndBundleName).toHaveBeenCalled();
     });
 
+    it('should fetch only the ORIGINAL bundle, never the licence bundles', () => {
+      // Ignore the ngOnInit call from detectChanges; assert on the click only.
+      bitstreamDataService.findAllByItemAndBundleName.calls.reset();
+      const viewMore = fixture.debugElement.query(By.css('.bitstream-view-more'));
+      viewMore.triggerEventHandler('click', null);
+      // Assert on the bundle-name argument of every call, independent of the item argument.
+      const requestedBundles = bitstreamDataService.findAllByItemAndBundleName.calls.allArgs().map((args) => args[1]);
+      expect(requestedBundles).toEqual(['ORIGINAL']);
+    });
+
     it('one bitstream should be on the page', () => {
       const viewMore = fixture.debugElement.query(By.css('.bitstream-view-more'));
       viewMore.triggerEventHandler('click', null);
@@ -169,8 +179,7 @@ describe('FileSectionComponent', () => {
       });
       it('should contain another bitstream', () => {
         const fileDownloadLink = fixture.debugElement.queryAll(By.css('ds-file-download-link'));
-        // DATASHARE: getNextPage() fetches both ORIGINAL and CC-LICENSE bundles
-        expect(fileDownloadLink.length).toEqual(3);
+        expect(fileDownloadLink.length).toEqual(2);
       });
     });
   });
diff --git a/src/app/item-page/simple/field-components/file-section/file-section.component.ts b/src/app/item-page/simple/field-components/file-section/file-section.component.ts
index 09131f6d997..9e7c5effb2a 100644
--- a/src/app/item-page/simple/field-components/file-section/file-section.component.ts
+++ b/src/app/item-page/simple/field-components/file-section/file-section.component.ts
@@ -33,6 +33,11 @@ import { VarDirective } from '../../../../shared/utils/var.directive';
 /**
  * This component renders the file section of the item
  * inside a 'ds-metadata-field-wrapper' component.
+ *
+ * It lists the ORIGINAL bundle only. Licence bundles (CC-LICENSE / LICENSE) are the
+ * responsibility of the theme: the datashare theme renders them in a separate "Licences"
+ * section. Do not fetch them here - they have far fewer pages than ORIGINAL, so paging them
+ * in lockstep would request a page past their end and the REST API would return 500.
  */
 @Component({
   selector: 'ds-base-item-page-file-section',
@@ -76,8 +81,9 @@ export class FileSectionComponent implements OnInit {
     @Inject(APP_CONFIG) protected appConfig: AppConfig,
   ) {
     // DATASHARE - start
-    // this.pageSize = this.appConfig.item.bitstream.pageSize;
-    this.pageSize = 25; // DATASHARE - override to 5 (default) as per config.prod.yml
+    // Override the configured page size (item.bitstream.pageSize, default 5) with a larger
+    // value so more files load per "Show more" click. Hard-coded on purpose, not read from config.
+    this.pageSize = 25;
     // DATASHARE - end
   }
 
@@ -110,44 +116,11 @@ export class FileSectionComponent implements OnInit {
       this.currentPage++;
     }
 
-    // DATASHARE -start
-    // Rewritten to make two separate calls to get both ORIGINAL and CC-LICENSE bitstreams
-    // and combine them into the same bitstreams$ observable
-    // Previous code:
-    //   this.bitstreamDataService.findAllByItemAndBundleName(this.item, 'ORIGINAL', {
-    //     currentPage: this.currentPage,
-    //     elementsPerPage: this.pageSize,
-    //   }).pipe(
-    //     getFirstCompletedRemoteData(),
-    //   ).subscribe((bitstreamsRD: RemoteData<PaginatedList<Bitstream>>) => {
-    //     if (bitstreamsRD.errorMessage) {
-    //       this.notificationsService.error(this.translateService.get('file-section.error.header'), `${bitstreamsRD.statusCode} ${bitstreamsRD.errorMessage}`);
-    //     } else if (hasValue(bitstreamsRD.payload)) {
-    //       const current: Bitstream[] = this.bitstreams$.getValue();
-    //       // DATASHARE -start
-    //       // Console log bitstreams for easy debugging
-    //       bitstreamsRD.payload.page.forEach(bitstream => {
-    //         console.log('Bitstream:', bitstream);
-    //       });
-    //       // DATASHARE - end
-    //       this.bitstreams$.next([...current, ...bitstreamsRD.payload.page]);
-    //       this.isLoading = false;
-    //       this.isLastPage = this.currentPage === bitstreamsRD.payload.totalPages;
-    //     }
-    //   });
-    // }
-    // Replaced code:
-    const original$ = this.bitstreamDataService.findAllByItemAndBundleName(this.item, 'ORIGINAL', {
+    // CC-LICENSE/LICENSE come from the datashare theme's own Licences section - don't fetch them here.
+    this.bitstreamDataService.findAllByItemAndBundleName(this.item, 'ORIGINAL', {
       currentPage: this.currentPage,
       elementsPerPage: this.pageSize,
-    });
-
-    const license$ = this.bitstreamDataService.findAllByItemAndBundleName(this.item, 'CC-LICENSE', {
-      currentPage: this.currentPage,
-      elementsPerPage: this.pageSize,
-    });
-
-    original$.pipe(
+    }).pipe(
       getFirstCompletedRemoteData(),
     ).subscribe((bitstreamsRD: RemoteData<PaginatedList<Bitstream>>) => {
       if (bitstreamsRD.errorMessage) {
@@ -157,21 +130,6 @@ export class FileSectionComponent implements OnInit {
         this.bitstreams$.next([...current, ...bitstreamsRD.payload.page]);
         this.isLoading = false;
         this.isLastPage = this.currentPage === bitstreamsRD.payload.totalPages;
-        // Now subscribe to license$
-        license$.pipe(
-          getFirstCompletedRemoteData(),
-        ).subscribe((licenseRD: RemoteData<PaginatedList<Bitstream>>) => {
-          if (licenseRD.errorMessage) {
-            this.notificationsService.error(this.translateService.get('file-section.error.header'), `${licenseRD.statusCode} ${licenseRD.errorMessage}`);
-          } else if (hasValue(licenseRD.payload)) {
-            const updated: Bitstream[] = this.bitstreams$.getValue();
-            this.bitstreams$.next([...updated, ...licenseRD.payload.page]);
-          }
-          this.isLoading = false;
-        });
-
-      } else {
-        this.isLoading = false;
       }
     });
   }
diff --git a/src/app/root/root.component.html b/src/app/root/root.component.html
index 1fb9f786b43..d898c7c8e82 100644
--- a/src/app/root/root.component.html
+++ b/src/app/root/root.component.html
@@ -2,10 +2,9 @@
   {{ 'root.skip-to-content' | translate }}
 </button>
 
-<div class="outer-wrapper" [class.d-none]="shouldShowFullscreenLoader" [ngClass]="browserOsClasses.asObservable() | async" [@slideSidebarPadding]="{
-     value: ((isSidebarVisible$ | async) !== true ? 'hidden' : (slideSidebarOver$ | async) ? 'unpinned' : 'pinned'),
-     params: { collapsedWidth: (collapsedSidebarWidth$ | async), expandedWidth: (expandedSidebarWidth$ | async) }
-    }">
+<div class="outer-wrapper" [class.d-none]="shouldShowFullscreenLoader"
+     [class.ds-admin-sidebar-animate]="gutterTransitionEnabled"
+     [ngClass]="outerWrapperClasses$ | async">
   <ds-admin-sidebar [expandedSidebarWidth$]="expandedSidebarWidth$" [collapsedSidebarWidth$]="collapsedSidebarWidth$"></ds-admin-sidebar>
   <div class="inner-wrapper">
     <ds-system-wide-alert-banner></ds-system-wide-alert-banner>
diff --git a/src/app/root/root.component.scss b/src/app/root/root.component.scss
index 9eb198417ad..fae4632c7da 100644
--- a/src/app/root/root.component.scss
+++ b/src/app/root/root.component.scss
@@ -14,3 +14,32 @@
     top: 0;
   }
 }
+
+// Admin-sidebar left gutter. Driven by the `ds-admin-sidebar-*` class set in root.component.html (from
+// sidebarPaddingState$) rather than the @slideSidebarPadding Angular animation. The animation needed a
+// concrete width from the browser-only CSS-variable store, so on the server it rendered padding-left:0
+// and the authenticated page jumped right when the anti-flicker SSR snapshot was removed. Resolving the
+// gutter from the `--ds-admin-sidebar-*` custom properties in CSS instead renders identically on the
+// server (snapshot) and the browser (live app) — no hardcoded px, theme- and viewport-aware — and the
+// transition keeps the pin/unpin slide. 'hidden' (no admin sidebar) keeps the default padding-left: 0.
+.outer-wrapper {
+  // padding-left:0 (no admin sidebar); explicit for self-documentation.
+  &.ds-admin-sidebar-hidden {
+    padding-left: 0;
+  }
+
+  &.ds-admin-sidebar-unpinned {
+    padding-left: var(--ds-admin-sidebar-fixed-element-width);
+  }
+
+  &.ds-admin-sidebar-pinned {
+    padding-left: var(--ds-admin-sidebar-total-width);
+  }
+
+  // Slide only genuine pin/unpin toggles. The class is added once the sidebar has resolved to visible
+  // after bootstrap (gutterTransitionEnabled), so the initial SSR->CSR gutter resolution -- which on
+  // DSpace 8 happens well after first paint, because Angular re-renders the server DOM -- never animates.
+  &.ds-admin-sidebar-animate {
+    transition: padding-left 300ms ease-in-out;
+  }
+}
diff --git a/src/app/root/root.component.ts b/src/app/root/root.component.ts
index b5c1c9be48e..324bee8b3e4 100644
--- a/src/app/root/root.component.ts
+++ b/src/app/root/root.component.ts
@@ -4,6 +4,7 @@ import {
   NgIf,
 } from '@angular/common';
 import {
+  AfterViewInit,
   Component,
   Inject,
   Input,
@@ -21,10 +22,12 @@ import {
   of,
 } from 'rxjs';
 import {
+  filter,
   first,
   map,
   skipWhile,
   startWith,
+  take,
 } from 'rxjs/operators';
 import { INotificationBoardOptions } from 'src/config/notifications-config.interfaces';
 
@@ -39,7 +42,6 @@ import {
 } from '../core/services/window.service';
 import { ThemedFooterComponent } from '../footer/themed-footer.component';
 import { ThemedHeaderNavbarWrapperComponent } from '../header-nav-wrapper/themed-header-navbar-wrapper.component';
-import { slideSidebarPadding } from '../shared/animations/slide';
 import { HostWindowService } from '../shared/host-window.service';
 import { LiveRegionComponent } from '../shared/live-region/live-region.component';
 import { ThemedLoadingComponent } from '../shared/loading/themed-loading.component';
@@ -53,7 +55,6 @@ import { SystemWideAlertBannerComponent } from '../system-wide-alert/alert-banne
   selector: 'ds-base-root',
   templateUrl: './root.component.html',
   styleUrls: ['./root.component.scss'],
-  animations: [slideSidebarPadding],
   standalone: true,
   imports: [
     TranslateModule,
@@ -71,7 +72,7 @@ import { SystemWideAlertBannerComponent } from '../system-wide-alert/alert-banne
     LiveRegionComponent,
   ],
 })
-export class RootComponent implements OnInit {
+export class RootComponent implements OnInit, AfterViewInit {
   theme: Observable<ThemeConfig> = of({} as any);
   isSidebarVisible$: Observable<boolean>;
   slideSidebarOver$: Observable<boolean>;
@@ -82,6 +83,24 @@ export class RootComponent implements OnInit {
 
   browserOsClasses = new BehaviorSubject<string[]>([]);
 
+  /**
+   * The admin-sidebar gutter state ('hidden' | 'unpinned' | 'pinned'), applied as a CSS class on the
+   * outer wrapper. See {@link gutterTransitionEnabled}.
+   */
+  sidebarPaddingState$: Observable<string>;
+
+  /**
+   * The classes on the outer wrapper: the browser/OS classes plus the admin-sidebar gutter state.
+   */
+  outerWrapperClasses$: Observable<string[]>;
+
+  /**
+   * Whether the gutter may slide. Only enabled once the sidebar has resolved to visible after
+   * bootstrap (see ngAfterViewInit), so that the initial gutter resolution never animates while
+   * genuine pin/unpin toggles still do.
+   */
+  gutterTransitionEnabled = false;
+
   /**
    * Whether or not to show a full screen loader
    */
@@ -132,11 +151,51 @@ export class RootComponent implements OnInit {
         startWith(true),
       );
 
+    // Drive the outer-wrapper gutter via a CSS class instead of the @slideSidebarPadding animation: the
+    // animation needs a concrete width from the browser-only CSS-variable store, so on the server it
+    // rendered padding-left:0 and the authenticated page jumped right when the SSR snapshot was removed.
+    // The CSS class resolves the gutter from `--ds-admin-sidebar-*` (see root.component.scss), identically
+    // on server and browser -- fixing the jump without any hardcoded width.
+    this.sidebarPaddingState$ = combineLatestObservable([this.isSidebarVisible$, this.slideSidebarOver$]).pipe(
+      map(([visible, over]: [boolean, boolean]) => !visible ? 'hidden' : over ? 'unpinned' : 'pinned'),
+    );
+
+    this.outerWrapperClasses$ = combineLatestObservable([
+      this.browserOsClasses.asObservable(),
+      this.sidebarPaddingState$,
+    ]).pipe(
+      map(([osClasses, paddingState]: [string[], string]) => [...osClasses, `ds-admin-sidebar-${paddingState}`]),
+    );
+
     if (this.router.url === getPageInternalServerErrorRoute()) {
       this.shouldShowRouteLoader = false;
     }
   }
 
+  ngAfterViewInit(): void {
+    // Browser only; requestAnimationFrame is not defined under SSR.
+    if (typeof requestAnimationFrame !== 'function') {
+      return;
+    }
+    // Enable the gutter slide only once the sidebar has resolved to visible *after bootstrap*, not
+    // merely after the first paint. Angular discards the server-rendered DOM and re-renders it from
+    // scratch, so the gutter briefly falls back to 'hidden' well after that first paint; enabling the
+    // transition any earlier makes that recovery slide the whole page sideways -- the very jump this
+    // fixes. Waiting for `visible` also means the class is only armed when there is a sidebar to pin,
+    // which is the only case where the slide is wanted.
+    // The frames are nested because `visible` turning true is the very change that sets the gutter
+    // class: arming after a single frame can land in the same style recalculation and animate the one
+    // transition that must be instant. The inner frame makes the arming a guaranteed paint boundary.
+    // This is defensive -- the gutter was already applying instantly with a single frame in every run
+    // measured here -- but the failure it prevents is exactly the bug being fixed.
+    this.isSidebarVisible$.pipe(
+      filter((visible: boolean) => visible),
+      take(1),
+    ).subscribe(() => requestAnimationFrame(() =>
+      requestAnimationFrame(() => this.gutterTransitionEnabled = true),
+    ));
+  }
+
   skipToMainContent() {
     const mainContent = document.getElementById('main-content');
     if (mainContent) {
diff --git a/src/app/shared/btn-disabled.directive.ts b/src/app/shared/btn-disabled.directive.ts
index 427d1654da0..bbc21fef7f8 100644
--- a/src/app/shared/btn-disabled.directive.ts
+++ b/src/app/shared/btn-disabled.directive.ts
@@ -59,5 +59,19 @@ export class BtnDisabledDirective {
         event.stopImmediatePropagation();
       }
     }
+
+    /**
+     * Prevents the default action and stops the event from propagating when the element is disabled.
+     * Some controls (e.g. dropdown options) commit on mousedown rather than click, so a disabled
+     * element must ignore mousedown as well to stay non-interactive.
+     * @param event The mousedown event.
+     */
+    @HostListener('mousedown', ['$event'])
+  handleMousedown(event: Event) {
+    if (this.isDisabled) {
+      event.preventDefault();
+      event.stopImmediatePropagation();
+    }
+  }
 }
 
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
index 48a8ebbc0cc..cc64784b626 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/ds-dynamic-form-control-container.component.ts
@@ -306,7 +306,10 @@ export class DsDynamicFormControlContainerComponent extends DynamicFormControlCo
   }
 
   ngOnChanges(changes: SimpleChanges) {
-    if (changes && !this.isRelationship && hasValue(this.group.get(this.model.id))) {
+    // `group` can legitimately be null for one tick while a repeatable field is being re-rendered
+    // (a row was added or removed). Dereferencing it there threw inside change detection and
+    // aborted the pass for the whole field, so the remaining rows stopped updating.
+    if (changes && !this.isRelationship && hasValue(this.group) && hasValue(this.group.get(this.model.id))) {
       super.ngOnChanges(changes);
       if (this.model && this.model.placeholder) {
         this.model.placeholder = this.translateService.instant(this.model.placeholder);
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.row-binding.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.row-binding.spec.ts
new file mode 100644
index 00000000000..e15c215da6b
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.row-binding.spec.ts
@@ -0,0 +1,217 @@
+// Regression specs for the row -> FormControl binding of a repeatable field.
+//
+// `getControlOfGroup()` used to stamp a `startingIndex` on the group model the first time a row
+// rendered and then resolve that row's FormGroup as `control.get([startingIndex])` forever.
+// Nothing re-synced it when the FormArray was mutated, so after removing a non-last row the
+// surviving rows bound to the wrong FormGroup (or to null), and after remove+insert two rows
+// could alias onto the same FormGroup.
+//
+// That is what let a value the user never touched be overwritten, and what made the duplicate
+// detection in DsDynamicScrollableDropdownComponent read stale sibling values.
+import { HttpClient } from '@angular/common/http';
+import { EventEmitter } from '@angular/core';
+import {
+  ComponentFixture,
+  inject,
+  TestBed,
+} from '@angular/core/testing';
+import {
+  ReactiveFormsModule,
+  UntypedFormArray,
+} from '@angular/forms';
+import { By } from '@angular/platform-browser';
+import {
+  DYNAMIC_FORM_CONTROL_MAP_FN,
+  DynamicFormLayoutService,
+  DynamicFormService,
+  DynamicFormValidationService,
+  DynamicInputModel,
+} from '@ng-dynamic-forms/core';
+import { provideMockStore } from '@ngrx/store/testing';
+import {
+  TranslateModule,
+  TranslateService,
+} from '@ngx-translate/core';
+import { NgxMaskModule } from 'ngx-mask';
+import { of } from 'rxjs';
+
+import {
+  APP_CONFIG,
+  APP_DATA_SERVICES_MAP,
+} from '../../../../../../../config/app-config.interface';
+import { environment } from '../../../../../../../environments/environment.test';
+import { SubmissionService } from '../../../../../../submission/submission.service';
+import { LiveRegionService } from '../../../../../live-region/live-region.service';
+import { getLiveRegionServiceStub } from '../../../../../live-region/live-region.service.stub';
+import { DsDynamicFormControlContainerComponent } from '../../ds-dynamic-form-control-container.component';
+import { dsDynamicFormControlMapFn } from '../../ds-dynamic-form-control-map-fn';
+import { DynamicRowArrayModel } from '../ds-dynamic-row-array-model';
+import { DsDynamicFormArrayComponent } from './dynamic-form-array.component';
+
+describe('DsDynamicFormArrayComponent row/control binding', () => {
+  const translateServiceStub = {
+    get: () => of('translated-text'),
+    instant: () => 'translated-text',
+    onLangChange: new EventEmitter(),
+    onTranslationChange: new EventEmitter(),
+    onDefaultLangChange: new EventEmitter(),
+  };
+
+  let component: DsDynamicFormArrayComponent;
+  let fixture: ComponentFixture<DsDynamicFormArrayComponent>;
+  // FormBuilderService only inherits these from DynamicFormService; using the base service keeps
+  // the fixture free of the whole submission dependency graph.
+  let forms: DynamicFormService;
+
+  /** The FormArray backing the rows of the repeatable field. */
+  const formArray = (): UntypedFormArray => component.group.get(component.model.id) as UntypedFormArray;
+
+  /** Value currently held by the control that row `i` is bound to. */
+  const boundValue = (i: number): any =>
+    (component.getControlOfGroup(component.model.groups[i]) as any)?.get('rowInput')?.value;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [
+        ReactiveFormsModule,
+        DsDynamicFormArrayComponent,
+        NgxMaskModule.forRoot(),
+        TranslateModule.forRoot(),
+      ],
+      providers: [
+        DynamicFormLayoutService,
+        DynamicFormValidationService,
+        provideMockStore(),
+        { provide: APP_DATA_SERVICES_MAP, useValue: {} },
+        { provide: TranslateService, useValue: translateServiceStub },
+        { provide: HttpClient, useValue: {} },
+        { provide: SubmissionService, useValue: {} },
+        { provide: APP_CONFIG, useValue: environment },
+        { provide: DYNAMIC_FORM_CONTROL_MAP_FN, useValue: dsDynamicFormControlMapFn },
+        { provide: LiveRegionService, useValue: getLiveRegionServiceStub() },
+      ],
+    }).overrideComponent(DsDynamicFormArrayComponent, {
+      remove: { imports: [DsDynamicFormControlContainerComponent] },
+    }).compileComponents();
+  });
+
+  beforeEach(inject([DynamicFormService],
+    (service: DynamicFormService) => {
+      forms = service;
+
+      const formModel = [
+        new DynamicRowArrayModel({
+          id: 'typeArray',
+          initialCount: 3,
+          notRepeatable: false,
+          relationshipConfig: undefined,
+          submissionId: '1234',
+          isDraggable: true,
+          groupFactory: () => [new DynamicInputModel({ id: 'rowInput' })],
+          required: false,
+          metadataKey: 'dc.type',
+          metadataFields: ['dc.type'],
+          hasSelectableMetadata: true,
+          showButtons: true,
+        }),
+      ];
+
+      fixture = TestBed.createComponent(DsDynamicFormArrayComponent);
+      component = fixture.componentInstance;
+      component.model = formModel[0] as DynamicRowArrayModel;
+      component.group = service.createFormGroup(formModel);
+      fixture.detectChanges();
+
+      // Give each row a distinct value, as if the user had picked three Types.
+      ['Article', 'Book', 'Dataset'].forEach((value, i) => {
+        formArray().at(i).get('rowInput').setValue(value);
+        (component.model.groups[i].group[0] as any).value = value;
+      });
+
+      // Render once so every row gets its binding resolved (this is what used to freeze it).
+      component.model.groups.forEach((g) => component.getControlOfGroup(g));
+    }));
+
+  it('binds every row to its own control before any mutation', () => {
+    expect([boundValue(0), boundValue(1), boundValue(2)]).toEqual(['Article', 'Book', 'Dataset']);
+  });
+
+  it('rebinds the surviving rows after the MIDDLE row is removed', () => {
+    forms.removeFormArrayGroup(1, formArray(), component.model);
+    fixture.detectChanges();
+
+    expect(component.model.groups.length).withContext('one row removed').toBe(2);
+    expect(boundValue(0)).withContext('row 0 keeps Article').toBe('Article');
+    expect(boundValue(1)).withContext('row 1 must now resolve to Dataset, not to Book or null').toBe('Dataset');
+  });
+
+  it('never resolves two rows to the same control after remove + insert', () => {
+    forms.removeFormArrayGroup(1, formArray(), component.model);
+    forms.insertFormArrayGroup(component.model.groups.length, formArray(), component.model);
+    fixture.detectChanges();
+
+    const controls = component.model.groups.map((g) => component.getControlOfGroup(g));
+    expect(controls.length).toBe(3);
+    controls.forEach((c, i) => expect(c).withContext(`row ${i} must be bound to a control`).not.toBeNull());
+    expect(new Set(controls).size).withContext('each row must own a distinct FormGroup').toBe(controls.length);
+  });
+
+  it('keeps the surviving row\'s value intact after remove + insert', () => {
+    forms.removeFormArrayGroup(1, formArray(), component.model);
+    forms.insertFormArrayGroup(component.model.groups.length, formArray(), component.model);
+    fixture.detectChanges();
+
+    expect(boundValue(0)).withContext('Article untouched').toBe('Article');
+    expect(boundValue(1)).withContext('Dataset must survive the delete+add').toBe('Dataset');
+    expect(boundValue(2)).withContext('the freshly added row is empty').toBeFalsy();
+  });
+
+  it('rebinds after the FIRST row is removed', () => {
+    forms.removeFormArrayGroup(0, formArray(), component.model);
+    fixture.detectChanges();
+
+    expect(boundValue(0)).withContext('Book moved up into position 0').toBe('Book');
+    expect(boundValue(1)).withContext('Dataset moved up into position 1').toBe('Dataset');
+  });
+
+  it('keeps rows and controls in sync when a keyboard reorder is cancelled', () => {
+    const dropList = fixture.debugElement.query(By.css('.cdk-drop-list')).nativeElement;
+    const rowEl = dropList.querySelectorAll('[cdkDrag]')[0] as HTMLDivElement;
+
+    // Pick row 0 up, move it down twice, then abandon the reorder with Escape.
+    component.toggleKeyboardDragAndDrop(new KeyboardEvent('keydown', { key: ' ' }), rowEl, 0, 3);
+    component.handleArrowPress(new KeyboardEvent('keydown', { key: 'ArrowDown' }), dropList, 3, 0, 'down');
+    component.handleArrowPress(new KeyboardEvent('keydown', { key: 'ArrowDown' }), dropList, 3, 1, 'down');
+    fixture.detectChanges();
+
+    component.cancelKeyboardDragAndDrop(rowEl, 2, 3);
+    fixture.detectChanges();
+
+    expect([boundValue(0), boundValue(1), boundValue(2)])
+      .withContext('cancelling must restore the original order for models AND controls')
+      .toEqual(['Article', 'Book', 'Dataset']);
+  });
+
+  it('keeps rows and controls in sync through a completed keyboard reorder', () => {
+    const dropList = fixture.debugElement.query(By.css('.cdk-drop-list')).nativeElement;
+    const rowEl = dropList.querySelectorAll('[cdkDrag]')[0] as HTMLDivElement;
+
+    component.toggleKeyboardDragAndDrop(new KeyboardEvent('keydown', { key: ' ' }), rowEl, 0, 3);
+    component.handleArrowPress(new KeyboardEvent('keydown', { key: 'ArrowDown' }), dropList, 3, 0, 'down');
+    fixture.detectChanges();
+
+    expect([boundValue(0), boundValue(1), boundValue(2)])
+      .withContext('Article moved down one place, controls followed')
+      .toEqual(['Book', 'Article', 'Dataset']);
+  });
+
+  it('rebinds after a row is inserted in the middle', () => {
+    forms.insertFormArrayGroup(1, formArray(), component.model);
+    fixture.detectChanges();
+
+    expect(boundValue(0)).toBe('Article');
+    expect(boundValue(1)).withContext('the inserted row is empty').toBeFalsy();
+    expect(boundValue(2)).withContext('Book shifted down').toBe('Book');
+    expect(boundValue(3)).withContext('Dataset shifted down').toBe('Dataset');
+  });
+});
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.ts
index 220143291eb..933d1ceb905 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/array-group/dynamic-form-array.component.ts
@@ -19,10 +19,12 @@ import {
 } from '@angular/core';
 import {
   ReactiveFormsModule,
+  UntypedFormArray,
   UntypedFormGroup,
 } from '@angular/forms';
 import {
   DynamicFormArrayComponent,
+  DynamicFormArrayGroupModel,
   DynamicFormControlCustomEvent,
   DynamicFormControlEvent,
   DynamicFormControlLayout,
@@ -96,7 +98,7 @@ export class DsDynamicFormArrayComponent extends DynamicFormArrayComponent {
       return;
     }
 
-    this.model.moveGroup(event.previousIndex, event.currentIndex - event.previousIndex);
+    this.moveGroupAndControl(event.previousIndex, event.currentIndex);
     const prevIndex = event.previousIndex;
     const index = event.currentIndex;
 
@@ -127,16 +129,38 @@ export class DsDynamicFormArrayComponent extends DynamicFormArrayComponent {
   }
 
   /**
-   * Gets the control of the specified group model. It adds the startingIndex property to the group model if it does not
-   * already have it. This ensures that the controls are always linked to the correct group model.
+   * Moves a row, keeping the group models and the form controls in the same order.
+   *
+   * Both are addressed by the same live index (see {@link getControlOfGroup}), so reordering only
+   * the models would leave every row from the drop position onwards pointing at another row's
+   * control — which is how values ended up moving between rows.
+   *
+   * @param from The index the row is moved from.
+   * @param to The index the row is moved to.
+   */
+  protected moveGroupAndControl(from: number, to: number): void {
+    const controls = this.control as unknown as UntypedFormArray;
+    if (hasValue(controls?.at(from))) {
+      const moved = controls.at(from);
+      controls.removeAt(from, { emitEvent: false });
+      controls.insert(to, moved, { emitEvent: false });
+    }
+    this.model.moveGroup(from, to - from);
+  }
+
+  /**
+   * Gets the control of the specified group model.
+   *
+   * The group's *live* index is the only authority: `DynamicFormArrayModel` re-indexes its groups
+   * on every insert/remove/move, and the template binds `formGroupName` to that same index. Caching
+   * the index of the first render instead would leave a row pointing at another row's control (or at
+   * none) as soon as a row is added or removed, which silently moves values between rows.
+   *
    * @param groupModel The group model to get the control for.
    * @returns The form control of the specified group model.
    */
-  getControlOfGroup(groupModel: any) {
-    if (!groupModel.hasOwnProperty('startingIndex')) {
-      groupModel.startingIndex = groupModel.index;
-    }
-    return this.control.get([groupModel.startingIndex]);
+  getControlOfGroup(groupModel: DynamicFormArrayGroupModel) {
+    return this.control.get([groupModel.index]);
   }
 
   /**
@@ -200,7 +224,7 @@ export class DsDynamicFormArrayComponent extends DynamicFormArrayComponent {
     }
 
     if (this.elementBeingSorted) {
-      this.model.moveGroup(idx, newIndex - idx);
+      this.moveGroupAndControl(idx, newIndex);
       if (hasValue(this.model.groups[newIndex]) && hasValue((this.control as any).controls[newIndex])) {
         this.onCustomEvent({
           previousIndex: idx,
@@ -228,7 +252,7 @@ export class DsDynamicFormArrayComponent extends DynamicFormArrayComponent {
   }
 
   cancelKeyboardDragAndDrop(sortableElement: HTMLDivElement, index: number, length: number) {
-    this.model.moveGroup(index, this.elementBeingSortedStartingIndex - index);
+    this.moveGroupAndControl(index, this.elementBeingSortedStartingIndex);
     if (hasValue(this.model.groups[this.elementBeingSortedStartingIndex]) && hasValue((this.control as any).controls[this.elementBeingSortedStartingIndex])) {
       this.onCustomEvent({
         previousIndex: index,
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.html b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.html
index 6236028f2e3..510028c90d6 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.html
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.html
@@ -1,4 +1,5 @@
-<div #sdRef="ngbDropdown" ngbDropdown display="dynamic" placement="bottom-right" class="w-100">
+<div #sdRef="ngbDropdown" ngbDropdown display="dynamic" placement="bottom-right" class="w-100"
+     (openChange)="onOpenChange($event)">
   <div class="position-relative right-addon"
        role="combobox"
        [attr.aria-label]="model.label"
@@ -41,20 +42,32 @@
          [scrollWindow]="false">
 
       <button class="dropdown-item disabled" type="button" *ngIf="optionsList && optionsList.length === 0">{{'form.no-results' | translate}}</button>
-      <button class="dropdown-item collection-item text-truncate"
-              (click)="onSelect(undefined); sdRef.close()" (mousedown)="onSelect(undefined); sdRef.close()"
-              title="{{ 'dropdown.clear.tooltip' | translate }}" role="option"
-              type="button">
-        <i>{{ 'dropdown.clear' | translate }}</i>
-      </button>
+      <!-- Options commit on (mousedown) rather than (click) by design: blurring the input flips
+           showErrorMessages on a required field, and DsDynamicFormControlContainerComponent then
+           destroys and re-creates this control (forceShowErrorDetection), so the option element is
+           already gone by the time a click event could be produced. -->
       <button class="dropdown-item collection-item text-truncate" *ngFor="let listEntry of optionsList; let i = index"
               [class.active]="i === selectedIndex"
-              (keydown.enter)="onSelect(listEntry); sdRef.close()" (mousedown)="onSelect(listEntry); sdRef.close()"
+              [attr.aria-selected]="inputFormatter(listEntry) === (currentValue | async)"
+              [dsBtnDisabled]="isOptionDisabled(listEntry)"
+              (keydown.enter)="selectEntry(listEntry, sdRef)" (mousedown)="selectEntry(listEntry, sdRef)"
               title="{{ inputFormatter(listEntry) }}" role="option" type="button"
               [attr.id]="inputFormatter(listEntry) === (currentValue|async) ? ('combobox_' + id + '_selected') : null">
         {{inputFormatter(listEntry)}}
       </button>
       <div class="scrollable-dropdown-loading text-center" *ngIf="loading"><p>{{'form.loading' | translate}}</p></div>
+      <!-- Clearing is destructive and must sit at the END of the menu. As the first entry it was
+           rendered directly beneath the input, exactly where a click meant to close the menu lands,
+           so dismissing the dropdown wiped the value instead.
+           (mousedown) + (keydown.enter) mirrors the options above: carrying (click) as well fired
+           it twice per mouse interaction, but dropping it outright left clearing mouse-only. -->
+      <button class="dropdown-item collection-item text-truncate scrollable-dropdown-clear"
+              (keydown.enter)="onSelect(undefined); sdRef.close()"
+              (mousedown)="onSelect(undefined); sdRef.close()"
+              title="{{ 'dropdown.clear.tooltip' | translate }}" role="option"
+              type="button">
+        <i>{{ 'dropdown.clear' | translate }}</i>
+      </button>
     </div>
 
   </div>
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.scss b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.scss
index bd0b160622e..9e8b6eef470 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.scss
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.scss
@@ -10,6 +10,13 @@
   border-bottom: var(--bs-dropdown-border-width) solid var(--bs-dropdown-border-color);
 }
 
+.collection-item.disabled {
+  background-color: var(--bs-gray-200) !important;
+  color: var(--bs-dropdown-link-disabled-color) !important;
+  pointer-events: auto !important;
+  cursor: default !important;
+}
+
 .scrollable-dropdown-loading {
   background-color: var(--bs-primary);
   color: white;
@@ -23,6 +30,16 @@
   left: 0 !important;
   margin-bottom: var(--bs-spacer);
   z-index: 1000;
+  // The menu is positioned flush against the input and covers the rows underneath it. Keeping a
+  // small gap leaves a strip right below the field where a click closes the menu instead of
+  // activating whichever entry happens to be drawn there.
+  margin-top: 0.35rem;
+}
+
+// Clearing is separated from the options so it cannot be hit by accident.
+.collection-item.scrollable-dropdown-clear {
+  border-bottom: 0;
+  border-top: calc(var(--bs-dropdown-border-width) * 2) solid var(--bs-dropdown-border-color);
 }
 
 .scrollable-dropdown-toggle {
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.spec.ts
index f427c95cbaf..14d96afcc34 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.spec.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.spec.ts
@@ -22,6 +22,7 @@ import {
 import { By } from '@angular/platform-browser';
 import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
 import {
+  DynamicFormArrayModel,
   DynamicFormLayoutService,
   DynamicFormsCoreModule,
   DynamicFormValidationService,
@@ -185,17 +186,12 @@ describe('Dynamic Dynamic Scrollable Dropdown component', () => {
         const selectedValue = Object.assign(new VocabularyEntry(), { authority: 1, display: 'one', value: 1 });
 
         let de: any = scrollableDropdownFixture.debugElement.query(By.css('input.form-control'));
-        let btnEl = de.nativeElement;
-
-        const mousedownEvent = new MouseEvent('mousedown');
-
-        btnEl.dispatchEvent(mousedownEvent);
+        de.nativeElement.click();
         scrollableDropdownFixture.detectChanges();
 
-        de = scrollableDropdownFixture.debugElement.queryAll(By.css('button.dropdown-item'));
-        btnEl = de[1].nativeElement;
-
-        btnEl.dispatchEvent(mousedownEvent);
+        // Options commit on mousedown by design (the control is re-created on blur).
+        de = scrollableDropdownFixture.debugElement.queryAll(By.css('button.dropdown-item.collection-item'));
+        de[0].nativeElement.dispatchEvent(new MouseEvent('mousedown'));
         scrollableDropdownFixture.detectChanges();
 
         expect((scrollableDropdownComp.model as any).value).toEqual(selectedValue);
@@ -215,6 +211,96 @@ describe('Dynamic Dynamic Scrollable Dropdown component', () => {
 
     });
 
+    describe('duplicate values in repeatable fields', () => {
+      beforeEach(() => {
+        scrollableDropdownFixture = TestBed.createComponent(DsDynamicScrollableDropdownComponent);
+        scrollableDropdownComp = scrollableDropdownFixture.componentInstance;
+        scrollableDropdownComp.group = SD_TEST_GROUP;
+
+        const arrayModel = new DynamicFormArrayModel({
+          id: 'dropdownArray',
+          groupFactory: () => [new DynamicScrollableDropdownModel(SD_TEST_MODEL_CONFIG)],
+          initialCount: 2,
+        });
+        const ownGroup = arrayModel.get(0);
+        const siblingGroup = arrayModel.get(1);
+        (siblingGroup.group[0] as any).value = Object.assign(new VocabularyEntry(), { authority: 1, display: 'one', value: 1 });
+
+        const ownModel = ownGroup.group[0] as DynamicScrollableDropdownModel;
+        (ownModel as any).parent = ownGroup;
+        scrollableDropdownComp.model = ownModel;
+        scrollableDropdownFixture.detectChanges();
+      });
+
+      afterEach(() => {
+        scrollableDropdownFixture.destroy();
+        scrollableDropdownComp = null;
+      });
+
+      it('should disable an option already selected in another row of the same field', () => {
+        const de = scrollableDropdownFixture.debugElement.query(By.css('input.form-control'));
+        de.nativeElement.click();
+        scrollableDropdownFixture.detectChanges();
+
+        expect(scrollableDropdownComp.isOptionDisabled({ value: 1 })).toBeTruthy();
+        expect(scrollableDropdownComp.isOptionDisabled({ value: 2 })).toBeFalsy();
+
+        // The options are rendered first; the clear entry is last.
+        const options = scrollableDropdownFixture.debugElement.queryAll(By.css('button.dropdown-item.collection-item'));
+        expect(hasClass(options[0].nativeElement, 'disabled')).toBeTruthy();
+        expect(hasClass(options[1].nativeElement, 'disabled')).toBeFalsy();
+      });
+
+      it('should ignore selection of a disabled option', () => {
+        spyOn(scrollableDropdownComp.change, 'emit');
+
+        scrollableDropdownComp.onSelect(Object.assign(new VocabularyEntry(), { authority: 1, display: 'one', value: 1 }));
+
+        expect(scrollableDropdownComp.change.emit).not.toHaveBeenCalled();
+        expect((scrollableDropdownComp.model as any).value).toBeUndefined();
+      });
+
+      it('should not select a disabled option via keyboard and keep the dropdown open', () => {
+        scrollableDropdownComp.optionsList = [Object.assign(new VocabularyEntry(), { authority: 1, display: 'one', value: 1 })];
+        scrollableDropdownComp.selectedIndex = 0;
+        spyOn(scrollableDropdownComp.change, 'emit');
+        const sdRef = jasmine.createSpyObj('NgbDropdown', ['isOpen', 'open', 'close']);
+        sdRef.isOpen.and.returnValue(true);
+
+        scrollableDropdownComp.selectOnKeyDown(new KeyboardEvent('keydown', { key: 'Enter' }), sdRef);
+
+        expect(scrollableDropdownComp.change.emit).not.toHaveBeenCalled();
+        expect(sdRef.close).not.toHaveBeenCalled();
+      });
+
+      it('should refresh used sibling values when opened via keyboard', () => {
+        spyOn(scrollableDropdownComp, 'openDropdown');
+        const sdRef = jasmine.createSpyObj('NgbDropdown', ['isOpen', 'open', 'close']);
+        sdRef.isOpen.and.returnValue(false);
+
+        scrollableDropdownComp.selectOnKeyDown(new KeyboardEvent('keydown', { key: 'Enter' }), sdRef);
+
+        expect(scrollableDropdownComp.openDropdown).toHaveBeenCalledWith(sdRef);
+        expect(sdRef.open).not.toHaveBeenCalled();
+      });
+
+      it('should still allow clearing the value', () => {
+        spyOn(scrollableDropdownComp.change, 'emit');
+
+        scrollableDropdownComp.onSelect(undefined);
+
+        expect(scrollableDropdownComp.change.emit).toHaveBeenCalled();
+      });
+
+      it('should not disable any option for a field without repeatable siblings', () => {
+        scrollableDropdownComp.model = new DynamicScrollableDropdownModel(SD_TEST_MODEL_CONFIG);
+
+        expect(scrollableDropdownComp.usedSiblingValues.size).toBe(0);
+        expect(scrollableDropdownComp.isOptionDisabled({ value: 1 })).toBeFalsy();
+      });
+
+    });
+
     describe('when init model value is not empty', () => {
       beforeEach(() => {
 
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.ts
index 486f6b77b89..1d3024b433c 100644
--- a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.ts
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.component.ts
@@ -21,6 +21,7 @@ import {
   NgbDropdownModule,
 } from '@ng-bootstrap/ng-bootstrap';
 import {
+  DynamicFormArrayGroupModel,
   DynamicFormLayoutService,
   DynamicFormValidationService,
 } from '@ng-dynamic-forms/core';
@@ -59,6 +60,7 @@ import { BtnDisabledDirective } from '../../../../../btn-disabled.directive';
 import {
   hasValue,
   isEmpty,
+  isNotEmpty,
 } from '../../../../../empty.util';
 import { FormFieldMetadataValueObject } from '../../../models/form-field-metadata-value.model';
 import { DsDynamicVocabularyComponent } from '../dynamic-vocabulary.component';
@@ -203,14 +205,93 @@ export class DsDynamicScrollableDropdownComponent extends DsDynamicVocabularyCom
    */
   openDropdown(sdRef: NgbDropdown) {
     if (!this.model.readOnly) {
+      sdRef.open();
+    }
+  }
+
+  /**
+   * Called by the NgbDropdown itself, so it covers every way the menu can be opened — the input,
+   * the keyboard, and the toggle caret, which opens the menu through the directive without going
+   * through {@link openDropdown} and therefore used to show an unfiltered, stale option list.
+   *
+   * @param open Whether the dropdown is now open.
+   */
+  onOpenChange(open: boolean) {
+    if (open) {
       this.group.markAsUntouched();
       this.inputText = null;
       this.updatePageInfo(this.model.maxOptions, 1);
       this.loadOptions(false);
-      sdRef.open();
     }
   }
 
+  /**
+   * The identities already selected in the OTHER rows of the same repeatable field.
+   *
+   * Always read from the live models. A snapshot taken when the dropdown was opened went stale as
+   * soon as any row was added, removed or edited, which both hid options that had become free again
+   * and offered options that were in use.
+   */
+  get usedSiblingValues(): Set<any> {
+    const used = new Set<any>();
+    const parent = this.model.parent;
+    if (parent instanceof DynamicFormArrayGroupModel) {
+      parent.context.groups
+        .filter((rowGroup) => rowGroup !== parent)
+        .forEach((rowGroup) => {
+          rowGroup.group
+            .filter((siblingModel) => siblingModel.name === this.model.name)
+            .forEach((siblingModel) => {
+              this.identityKeys((siblingModel as any).value).forEach((key) => used.add(key));
+            });
+        });
+    }
+    return used;
+  }
+
+  /**
+   * Every identity a vocabulary value can be recognised by.
+   *
+   * The same entry reaches this component in two different shapes: as a `VocabularyEntry` when it
+   * was picked in this session, and as a `FormFieldMetadataValueObject` when it was rebuilt from
+   * the stored metadata — and only one of the two may carry an authority. Comparing a single
+   * "canonical" key therefore missed duplicates whenever the two sides disagreed about it, so both
+   * the authority and the normalised value are emitted and a match on either one is a duplicate.
+   */
+  private identityKeys(entry: any): string[] {
+    if (isEmpty(entry)) {
+      return [];
+    }
+    if (typeof entry === 'string') {
+      return [`v:${entry.trim().toLowerCase()}`];
+    }
+    const keys = [];
+    if (isNotEmpty(entry.authority)) {
+      keys.push(`a:${entry.authority}`);
+    }
+    if (isNotEmpty(entry.value)) {
+      keys.push(`v:${String(entry.value).trim().toLowerCase()}`);
+    }
+    return keys;
+  }
+
+  isOptionDisabled(entry: any): boolean {
+    const keys = this.identityKeys(entry);
+    if (isEmpty(keys)) {
+      return false;
+    }
+    const used = this.usedSiblingValues;
+    return keys.some((key) => used.has(key));
+  }
+
+  selectEntry(entry: any, sdRef: NgbDropdown) {
+    if (this.isOptionDisabled(entry)) {
+      return;
+    }
+    this.onSelect(entry);
+    sdRef.close();
+  }
+
   navigateDropdown(event: KeyboardEvent) {
     if (event.key === 'ArrowDown') {
       this.selectedIndex = Math.min(this.selectedIndex + 1, this.optionsList.length - 1);
@@ -240,10 +321,14 @@ export class DsDynamicScrollableDropdownComponent extends DsDynamicVocabularyCom
       event.preventDefault();
       event.stopPropagation();
       if (sdRef.isOpen()) {
-        this.onSelect(this.optionsList[this.selectedIndex]);
-        sdRef.close();
+        // Guard against selecting a stale/undefined entry while options are still
+        // (re)loading after a keyboard filter keystroke.
+        const candidate = this.optionsList?.[this.selectedIndex];
+        if (!this.loading && hasValue(candidate)) {
+          this.selectEntry(candidate, sdRef);
+        }
       } else {
-        sdRef.open();
+        this.openDropdown(sdRef);
       }
     } else if (keyName === 'ArrowDown' || keyName === 'ArrowUp') {
       event.preventDefault();
@@ -330,6 +415,9 @@ export class DsDynamicScrollableDropdownComponent extends DsDynamicVocabularyCom
    * @param event The value to emit.
    */
   onSelect(event) {
+    if (this.isOptionDisabled(event)) {
+      return;
+    }
     this.group.markAsDirty();
     this.dispatchUpdate(event);
     this.setCurrentValue(event);
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.duplicate.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.duplicate.spec.ts
new file mode 100644
index 00000000000..241990fd07f
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.duplicate.spec.ts
@@ -0,0 +1,321 @@
+// Regression specs for the two problems reported against #26/#32 on a repeatable,
+// vocabulary-backed submission dropdown (Type, Funder):
+//
+//   BUG A - an option already chosen in another row could be picked again, producing
+//           duplicate metadata. Three separate gaps: the caret opens the menu without
+//           refreshing the used-value state, the state was a snapshot that nothing
+//           invalidated, and the identity used for comparison did not survive a
+//           server round-trip (authority vs plain value).
+//
+//   BUG B - clicking "next to" an open dropdown wiped the selected values, because the
+//           options commit on mousedown and the destructive "Clear selection" entry sits
+//           directly under the input, where a dismissing click lands.
+import {
+  ChangeDetectorRef,
+  CUSTOM_ELEMENTS_SCHEMA,
+  Injector,
+} from '@angular/core';
+import {
+  ComponentFixture,
+  fakeAsync,
+  TestBed,
+  tick,
+  waitForAsync,
+} from '@angular/core/testing';
+import {
+  FormsModule,
+  ReactiveFormsModule,
+  UntypedFormControl,
+  UntypedFormGroup,
+} from '@angular/forms';
+import { By } from '@angular/platform-browser';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import {
+  DynamicFormArrayModel,
+  DynamicFormLayoutService,
+  DynamicFormsCoreModule,
+  DynamicFormValidationService,
+} from '@ng-dynamic-forms/core';
+import { DynamicFormsNGBootstrapUIModule } from '@ng-dynamic-forms/ui-ng-bootstrap';
+import { TranslateModule } from '@ngx-translate/core';
+import { InfiniteScrollModule } from 'ngx-infinite-scroll';
+
+import { APP_DATA_SERVICES_MAP } from '../../../../../../../config/app-config.interface';
+import { VocabularyEntry } from '../../../../../../core/submission/vocabularies/models/vocabulary-entry.model';
+import { VocabularyOptions } from '../../../../../../core/submission/vocabularies/models/vocabulary-options.model';
+import { VocabularyService } from '../../../../../../core/submission/vocabularies/vocabulary.service';
+import { NotificationsService } from '../../../../../notifications/notifications.service';
+import {
+  mockDynamicFormLayoutService,
+  mockDynamicFormValidationService,
+} from '../../../../../testing/dynamic-form-mock-services';
+import { NotificationsServiceStub } from '../../../../../testing/notifications-service.stub';
+import { VocabularyServiceStub } from '../../../../../testing/vocabulary-service.stub';
+import { FormFieldMetadataValueObject } from '../../../models/form-field-metadata-value.model';
+import { DsDynamicScrollableDropdownComponent } from './dynamic-scrollable-dropdown.component';
+import { DynamicScrollableDropdownModel } from './dynamic-scrollable-dropdown.model';
+
+const MODEL_CONFIG = {
+  vocabularyOptions: { closed: false, name: 'common_types' } as VocabularyOptions,
+  disabled: false,
+  errorMessages: { required: 'Required field.' },
+  id: 'dropdown',
+  label: 'Type',
+  maxOptions: 10,
+  name: 'dropdown',
+  placeholder: 'Type',
+  readOnly: false,
+  required: false,
+  repeatable: true,
+  value: undefined,
+  metadataFields: [],
+  submissionId: '1234',
+  hasSelectableMetadata: false,
+};
+
+const entry = (value: any, authority: any = null, display?: string) =>
+  Object.assign(new VocabularyEntry(), { authority, value, display: display ?? value });
+
+describe('DsDynamicScrollableDropdownComponent duplicate/clearing regressions', () => {
+  let fixture: ComponentFixture<DsDynamicScrollableDropdownComponent>;
+  let comp: DsDynamicScrollableDropdownComponent;
+  const vocabularyServiceStub = new VocabularyServiceStub();
+
+  beforeEach(waitForAsync(() => {
+    vocabularyServiceStub.setNewPayload([
+      entry('Article'), entry('Book'), entry('Dataset'),
+    ]);
+    TestBed.configureTestingModule({
+      imports: [
+        DynamicFormsCoreModule,
+        DynamicFormsNGBootstrapUIModule,
+        FormsModule,
+        InfiniteScrollModule,
+        ReactiveFormsModule,
+        NgbModule,
+        TranslateModule.forRoot(),
+        DsDynamicScrollableDropdownComponent,
+      ],
+      providers: [
+        { provide: NotificationsService, useValue: new NotificationsServiceStub() },
+        Injector,
+        ChangeDetectorRef,
+        DsDynamicScrollableDropdownComponent,
+        { provide: VocabularyService, useValue: vocabularyServiceStub },
+        { provide: DynamicFormLayoutService, useValue: mockDynamicFormLayoutService },
+        { provide: DynamicFormValidationService, useValue: mockDynamicFormValidationService },
+        { provide: APP_DATA_SERVICES_MAP, useValue: {} },
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    });
+  }));
+
+  /** Build a repeatable field of `count` rows, wiring parents the way the form service does. */
+  function buildArray(count: number): DynamicFormArrayModel {
+    const arrayModel = new DynamicFormArrayModel({
+      id: 'dropdownArray',
+      groupFactory: () => [new DynamicScrollableDropdownModel(MODEL_CONFIG)],
+      initialCount: count,
+    });
+    arrayModel.groups.forEach((g) => g.group.forEach((m) => ((m as any).parent = g)));
+    return arrayModel;
+  }
+
+  function bindTo(rowModel: DynamicScrollableDropdownModel) {
+    fixture = TestBed.createComponent(DsDynamicScrollableDropdownComponent);
+    comp = fixture.componentInstance;
+    comp.group = new UntypedFormGroup({ dropdown: new UntypedFormControl() });
+    comp.model = rowModel;
+    fixture.detectChanges();
+  }
+
+  const fakeRef: any = { open: () => undefined, close: () => undefined, isOpen: () => false };
+
+  // ------------------------------------------------------------------ BUG A
+  describe('BUG A - duplicate values', () => {
+
+    it('disables a sibling value WITHOUT the dropdown having been opened first', fakeAsync(() => {
+      // The caret (ngbDropdownToggle) opens the menu without going through openDropdown(),
+      // so the disabled state must not depend on openDropdown() having run.
+      const arr = buildArray(2);
+      (arr.get(0).group[0] as any).value = entry('Article');
+      bindTo(arr.get(1).group[0] as any);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('Article')))
+        .withContext('used by the sibling row -> must be disabled even before openDropdown()').toBeTruthy();
+      expect(comp.isOptionDisabled(entry('Book')))
+        .withContext('free -> selectable').toBeFalsy();
+    }));
+
+    it('re-evaluates when a sibling row changes AFTER the dropdown was opened', fakeAsync(() => {
+      const arr = buildArray(2);
+      bindTo(arr.get(1).group[0] as any);
+      comp.openDropdown(fakeRef);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('Article'))).withContext('nothing used yet').toBeFalsy();
+
+      // Another row gains the value while this menu is already open.
+      (arr.get(0).group[0] as any).value = entry('Article');
+
+      expect(comp.isOptionDisabled(entry('Article')))
+        .withContext('must reflect the sibling chosen after opening').toBeTruthy();
+    }));
+
+    it('stops disabling a value once the row that used it is removed', fakeAsync(() => {
+      const arr = buildArray(3);
+      (arr.get(0).group[0] as any).value = entry('Article');
+      (arr.get(1).group[0] as any).value = entry('Book');
+      bindTo(arr.get(2).group[0] as any);
+      comp.openDropdown(fakeRef);
+      tick();
+      expect(comp.isOptionDisabled(entry('Book'))).withContext('Book is used').toBeTruthy();
+
+      arr.removeGroup(1);       // the user deletes the "Book" row
+
+      expect(comp.isOptionDisabled(entry('Book')))
+        .withContext('Book is free again -> must not stay greyed out').toBeFalsy();
+      expect(comp.isOptionDisabled(entry('Article')))
+        .withContext('Article is still used').toBeTruthy();
+    }));
+
+    it('detects a duplicate when the sibling lost its authority in a server round-trip', fakeAsync(() => {
+      // Picked in-session the value is a VocabularyEntry carrying an authority; rebuilt from the
+      // server it is a FormFieldMetadataValueObject whose authority may be null. Keying on
+      // `authority ?? value` made the two incomparable.
+      const arr = buildArray(2);
+      (arr.get(0).group[0] as any).value = new FormFieldMetadataValueObject('Article', null, null, 'Article');
+      bindTo(arr.get(1).group[0] as any);
+      comp.openDropdown(fakeRef);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('Article', 'auth-article')))
+        .withContext('same value, authority only on the option -> still a duplicate').toBeTruthy();
+    }));
+
+    it('detects a duplicate when only the sibling carries an authority', fakeAsync(() => {
+      const arr = buildArray(2);
+      (arr.get(0).group[0] as any).value = new FormFieldMetadataValueObject('Article', null, 'auth-article', 'Article');
+      bindTo(arr.get(1).group[0] as any);
+      comp.openDropdown(fakeRef);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('Article')))
+        .withContext('same value, authority only on the sibling -> still a duplicate').toBeTruthy();
+    }));
+
+    it('still matches on authority when the displayed values differ', fakeAsync(() => {
+      const arr = buildArray(2);
+      (arr.get(0).group[0] as any).value = new FormFieldMetadataValueObject('NSF', null, 'auth-1', 'NSF');
+      bindTo(arr.get(1).group[0] as any);
+      comp.openDropdown(fakeRef);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('National Science Foundation', 'auth-1')))
+        .withContext('same authority -> same entity -> duplicate').toBeTruthy();
+    }));
+
+    it('refuses to commit a duplicate even if the option is somehow activated', fakeAsync(() => {
+      const arr = buildArray(2);
+      (arr.get(0).group[0] as any).value = entry('Article');
+      const rowModel = arr.get(1).group[0] as any;
+      bindTo(rowModel);
+      tick();
+
+      spyOn(comp.change, 'emit');
+      comp.selectEntry(entry('Article'), fakeRef);
+
+      expect(comp.change.emit).not.toHaveBeenCalled();
+      expect(rowModel.value).toBeUndefined();
+    }));
+
+    it('does not disable anything for a field that is not repeatable', fakeAsync(() => {
+      bindTo(new DynamicScrollableDropdownModel(MODEL_CONFIG));
+      comp.openDropdown(fakeRef);
+      tick();
+
+      expect(comp.isOptionDisabled(entry('Article'))).toBeFalsy();
+    }));
+  });
+
+  // ------------------------------------------------------------------ BUG B
+  describe('BUG B - values cleared by a click next to the field', () => {
+
+    beforeEach(fakeAsync(() => {
+      const arr = buildArray(1);
+      bindTo(arr.get(0).group[0] as any);
+      comp.optionsList = [entry('Article'), entry('Book'), entry('Dataset')];
+      fixture.detectChanges();
+      tick();
+    }));
+
+    it('clears exactly once for one full mouse interaction, not twice', () => {
+      // The clear entry used to carry BOTH (click) and (mousedown), so a real mouse press fired
+      // onSelect(undefined) twice and produced two change events / two JSON patches.
+      const clear = fixture.debugElement.query(By.css('button.dropdown-item.scrollable-dropdown-clear'));
+      expect(clear).withContext('the clear entry is rendered').not.toBeNull();
+
+      spyOn(comp, 'onSelect');
+      clear.nativeElement.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+      clear.nativeElement.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+      clear.nativeElement.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+
+      expect(comp.onSelect).toHaveBeenCalledTimes(1);
+    });
+
+    it('commits an option exactly once for one full mouse interaction', () => {
+      // Options intentionally commit on mousedown: blurring the input flips showErrorMessages on a
+      // required field and DsDynamicFormControlContainerComponent then destroys and re-creates this
+      // control, so the element is gone before a click event could reach it. Committing on
+      // mousedown must therefore not be paired with a second handler.
+      const option = fixture.debugElement.queryAll(By.css('button.dropdown-item.collection-item'))
+        .find((de) => (de.nativeElement.textContent || '').trim() === 'Article');
+      expect(option).withContext('the Article option is rendered').toBeDefined();
+
+      spyOn(comp, 'selectEntry');
+      option.nativeElement.dispatchEvent(new MouseEvent('mousedown', { bubbles: true }));
+      option.nativeElement.dispatchEvent(new MouseEvent('mouseup', { bubbles: true }));
+      option.nativeElement.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+
+      expect(comp.selectEntry).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not put the destructive clear entry directly under the input', () => {
+      // The menu overlays the field and the rows beneath it, so whatever sits at the top of the
+      // menu is what a dismissing click lands on. That must never be "Clear selection".
+      const items = fixture.debugElement.queryAll(By.css('.scrollable-menu button.dropdown-item'));
+      const firstItem = items[0].nativeElement;
+
+      expect(firstItem.classList.contains('scrollable-dropdown-clear'))
+        .withContext('the first entry of the menu must not be the clear action').toBeFalsy();
+    });
+
+    it('clears from the keyboard as well as the mouse', () => {
+      // The options are reachable with Enter; dropping the clear entry's (click) handler in favour
+      // of (mousedown) must not leave it mouse-only.
+      const clear = fixture.debugElement.query(By.css('button.dropdown-item.scrollable-dropdown-clear'));
+      spyOn(comp, 'onSelect');
+
+      clear.nativeElement.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true }));
+
+      expect(comp.onSelect).toHaveBeenCalledTimes(1);
+    });
+
+    it('keeps the clear entry available (further down the menu)', () => {
+      const clear = fixture.debugElement.query(By.css('button.dropdown-item.scrollable-dropdown-clear'));
+      expect(clear).withContext('clearing must still be possible').not.toBeNull();
+    });
+
+    it('clears the value when the clear entry is actually chosen', fakeAsync(() => {
+      (comp.model as any).value = entry('Article');
+      spyOn(comp.change, 'emit');
+
+      comp.onSelect(undefined);
+      tick();
+
+      expect(comp.change.emit).toHaveBeenCalled();
+      expect((comp.model as any).value).toBeFalsy();
+    }));
+  });
+});
diff --git a/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.repro.spec.ts b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.repro.spec.ts
new file mode 100644
index 00000000000..fcd44d507d3
--- /dev/null
+++ b/src/app/shared/form/builder/ds-dynamic-form-ui/models/scrollable-dropdown/dynamic-scrollable-dropdown.repro.spec.ts
@@ -0,0 +1,261 @@
+// Reproduction spec for PR #26 reported issues:
+//  Issue 1: duplicate value can be added after deleting a row.
+//  Issue 2: opening the dropdown and clicking outside (blur) clears selected value(s).
+//
+// This spec uses the REAL @ng-dynamic-forms DynamicFormArrayModel semantics
+// (parent wiring, removeGroup/insertGroup reindex) that the production form builder uses.
+import {
+  ChangeDetectorRef,
+  CUSTOM_ELEMENTS_SCHEMA,
+  Injector,
+} from '@angular/core';
+import {
+  ComponentFixture,
+  fakeAsync,
+  TestBed,
+  tick,
+  waitForAsync,
+} from '@angular/core/testing';
+import {
+  FormsModule,
+  ReactiveFormsModule,
+  UntypedFormControl,
+  UntypedFormGroup,
+} from '@angular/forms';
+import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
+import {
+  DynamicFormArrayModel,
+  DynamicFormLayoutService,
+  DynamicFormsCoreModule,
+  DynamicFormValidationService,
+} from '@ng-dynamic-forms/core';
+import { DynamicFormsNGBootstrapUIModule } from '@ng-dynamic-forms/ui-ng-bootstrap';
+import { TranslateModule } from '@ngx-translate/core';
+import { InfiniteScrollModule } from 'ngx-infinite-scroll';
+
+import { APP_DATA_SERVICES_MAP } from '../../../../../../../config/app-config.interface';
+import { VocabularyEntry } from '../../../../../../core/submission/vocabularies/models/vocabulary-entry.model';
+import { VocabularyOptions } from '../../../../../../core/submission/vocabularies/models/vocabulary-options.model';
+import { VocabularyService } from '../../../../../../core/submission/vocabularies/vocabulary.service';
+import { NotificationsService } from '../../../../../notifications/notifications.service';
+import {
+  mockDynamicFormLayoutService,
+  mockDynamicFormValidationService,
+} from '../../../../../testing/dynamic-form-mock-services';
+import { NotificationsServiceStub } from '../../../../../testing/notifications-service.stub';
+import { VocabularyServiceStub } from '../../../../../testing/vocabulary-service.stub';
+import { FormFieldMetadataValueObject } from '../../../models/form-field-metadata-value.model';
+import { DsDynamicScrollableDropdownComponent } from './dynamic-scrollable-dropdown.component';
+import { DynamicScrollableDropdownModel } from './dynamic-scrollable-dropdown.model';
+
+const SD_TEST_MODEL_CONFIG = {
+  vocabularyOptions: {
+    closed: false,
+    name: 'common_iso_languages',
+  } as VocabularyOptions,
+  disabled: false,
+  errorMessages: { required: 'Required field.' },
+  id: 'dropdown',
+  label: 'Language',
+  maxOptions: 10,
+  name: 'dropdown',
+  placeholder: 'Language',
+  readOnly: false,
+  required: false,
+  repeatable: true,
+  value: undefined,
+  metadataFields: [],
+  submissionId: '1234',
+  hasSelectableMetadata: false,
+};
+
+const entry = (v: any, display?: string) =>
+  Object.assign(new VocabularyEntry(), { authority: v, display: display ?? ('e' + v), value: v });
+
+/**
+ * Build a repeatable DynamicFormArrayModel and wire each child model's `parent`
+ * to its group, exactly like the library's createFormArray/createFormGroup does.
+ */
+function buildArray(count: number): DynamicFormArrayModel {
+  const arrayModel = new DynamicFormArrayModel({
+    id: 'dropdownArray',
+    groupFactory: () => [new DynamicScrollableDropdownModel(SD_TEST_MODEL_CONFIG)],
+    initialCount: count,
+  });
+  arrayModel.groups.forEach((g) => g.group.forEach((m) => ((m as any).parent = g)));
+  return arrayModel;
+}
+
+/** Faithful to DynamicFormService.insertFormArrayGroup: insertGroup + createFormGroup(parent). */
+function addRow(arrayModel: DynamicFormArrayModel, index: number) {
+  const g = arrayModel.insertGroup(index);
+  g.group.forEach((m) => ((m as any).parent = g));
+  return g;
+}
+
+/** Faithful to DynamicFormService.removeFormArrayGroup (model side): removeGroup(splice+reindex). */
+function removeRow(arrayModel: DynamicFormArrayModel, index: number) {
+  arrayModel.removeGroup(index);
+}
+
+describe('REPRO PR#26 – duplicate + clear-on-blur', () => {
+  let fixture: ComponentFixture<DsDynamicScrollableDropdownComponent>;
+  let comp: DsDynamicScrollableDropdownComponent;
+  const vocabularyServiceStub = new VocabularyServiceStub();
+
+  beforeEach(waitForAsync(() => {
+    // Options available: value 1 ('one') and value 2 ('two') from the stub.
+    vocabularyServiceStub.setNewPayload([
+      Object.assign(new VocabularyEntry(), { authority: 1, display: 'one', value: 1 }),
+      Object.assign(new VocabularyEntry(), { authority: 2, display: 'two', value: 2 }),
+      Object.assign(new VocabularyEntry(), { authority: 3, display: 'three', value: 3 }),
+    ]);
+    TestBed.configureTestingModule({
+      imports: [
+        DynamicFormsCoreModule,
+        DynamicFormsNGBootstrapUIModule,
+        FormsModule,
+        InfiniteScrollModule,
+        ReactiveFormsModule,
+        NgbModule,
+        TranslateModule.forRoot(),
+        DsDynamicScrollableDropdownComponent,
+      ],
+      providers: [
+        { provide: NotificationsService, useValue: new NotificationsServiceStub() },
+        Injector,
+        ChangeDetectorRef,
+        DsDynamicScrollableDropdownComponent,
+        { provide: VocabularyService, useValue: vocabularyServiceStub },
+        { provide: DynamicFormLayoutService, useValue: mockDynamicFormLayoutService },
+        { provide: DynamicFormValidationService, useValue: mockDynamicFormValidationService },
+        { provide: APP_DATA_SERVICES_MAP, useValue: {} },
+      ],
+      schemas: [CUSTOM_ELEMENTS_SCHEMA],
+    });
+  }));
+
+  /** Bind the component under test to a specific row model of the array. */
+  function bindComponentToRow(rowModel: DynamicScrollableDropdownModel) {
+    fixture = TestBed.createComponent(DsDynamicScrollableDropdownComponent);
+    comp = fixture.componentInstance;
+    comp.group = new UntypedFormGroup({ dropdown: new UntypedFormControl() });
+    comp.model = rowModel;
+    fixture.detectChanges();
+  }
+
+  const fakeRef: any = { open: () => undefined, close: () => undefined, isOpen: () => false };
+
+  it('SANITY: sibling value is disabled in a fresh 2-row array', fakeAsync(() => {
+    const arr = buildArray(2);
+    (arr.get(0).group[0] as any).value = entry(1);        // row0 -> value 1
+    bindComponentToRow(arr.get(1).group[0] as any);        // component = row1
+    comp.openDropdown(fakeRef);
+    tick();
+    expect(comp.isOptionDisabled(entry(1))).withContext('value 1 used by row0').toBeTruthy();
+    expect(comp.isOptionDisabled({ value: 1 })).withContext('option 1 disabled').toBeTruthy();
+    expect(comp.isOptionDisabled({ value: 2 })).withContext('option 2 free').toBeFalsy();
+  }));
+
+  it('ISSUE 1a: after deleting the MIDDLE row and adding a new row, still-present values must stay disabled', fakeAsync(() => {
+    const arr = buildArray(3);
+    (arr.get(0).group[0] as any).value = entry(1); // A=1
+    (arr.get(1).group[0] as any).value = entry(2); // B=2
+    (arr.get(2).group[0] as any).value = entry(3); // C=3
+
+    removeRow(arr, 1);          // delete middle (B=2) -> rows [A=1, C=3]
+    const newGroup = addRow(arr, 2); // add new empty row -> [A=1, C=3, new]
+    bindComponentToRow(newGroup.group[0] as any);
+
+    comp.openDropdown(fakeRef);
+    tick();
+
+    // A(1) and C(3) are still used in other rows => must be disabled. B(2) is free.
+    expect(comp.isOptionDisabled({ value: 1 })).withContext('A=1 still used -> disabled').toBeTruthy();
+    expect(comp.isOptionDisabled({ value: 3 })).withContext('C=3 still used -> disabled').toBeTruthy();
+    expect(comp.isOptionDisabled({ value: 2 })).withContext('B=2 removed -> free').toBeFalsy();
+  }));
+
+  it('ISSUE 1b: sibling stored as FormFieldMetadataValueObject (server round-trip shape) must be detected', fakeAsync(() => {
+    const arr = buildArray(2);
+    // Plain (non-authority) vocabulary value after a server round-trip.
+    (arr.get(0).group[0] as any).value = new FormFieldMetadataValueObject('one', null, null, 'one');
+    bindComponentToRow(arr.get(1).group[0] as any);
+    comp.openDropdown(fakeRef);
+    tick();
+    expect(comp.isOptionDisabled({ value: 'one' })).withContext('option one disabled').toBeTruthy();
+  }));
+
+  it('ISSUE 1e: authority-controlled duplicate IS detected via authority even when the display value differs', fakeAsync(() => {
+    const arr = buildArray(2);
+    // Sibling as it looks after a server round-trip for an authority vocabulary (Funder):
+    // short value 'NSF' with an authority key.
+    (arr.get(0).group[0] as any).value = new FormFieldMetadataValueObject('NSF', null, 'auth-1', 'NSF');
+    bindComponentToRow(arr.get(1).group[0] as any);
+    comp.openDropdown(fakeRef);
+    tick();
+    // The freshly-loaded option for the SAME funder (authority 'auth-1') whose value is
+    // rendered as the full name. Same funder -> must be treated as a duplicate.
+    const sameFunder = Object.assign(new VocabularyEntry(), {
+      authority: 'auth-1', value: 'National Science Foundation', display: 'National Science Foundation',
+    });
+    expect(comp.isOptionDisabled(sameFunder))
+      .withContext('same authority => same funder => must be disabled (dedup ignores authority)').toBeTruthy();
+  }));
+
+  it('ISSUE 1d: a value chosen by a sibling AFTER open is still blocked at commit (live re-check)', fakeAsync(() => {
+    const arr = buildArray(2);
+    (arr.get(0).group[0] as any).value = entry(1);
+    const rowModel = arr.get(1).group[0] as any;
+    bindComponentToRow(rowModel);
+    comp.openDropdown(fakeRef);
+    tick();
+
+    // A sibling row gains value 2 AFTER this dropdown was opened.
+    const g2 = addRow(arr, 2);
+    (g2.group[0] as any).value = entry(2);
+
+    spyOn(comp.change, 'emit');
+    comp.selectEntry(entry(2), fakeRef); // must refresh live + block
+    expect(comp.change.emit).withContext('duplicate committed via stale set').not.toHaveBeenCalled();
+    expect(rowModel.value).withContext('value must remain unset').toBeUndefined();
+  }));
+
+  it('ISSUE 2: opening the dropdown then blurring (click outside) must NOT clear the selected value', fakeAsync(() => {
+    const arr = buildArray(2);
+    const rowModel = arr.get(0).group[0] as any;
+    bindComponentToRow(rowModel);
+
+    // user has selected value 1 (display 'e1')
+    comp.onSelect(entry(1));
+    tick();
+    let displayed: any;
+    comp.currentValue.subscribe((v) => (displayed = v));
+    expect(rowModel.value).withContext('value selected').toEqual(entry(1));
+    expect(displayed).withContext('display shows selection').toBe('e1');
+
+    // user re-opens the dropdown, then clicks outside (blur) without selecting
+    comp.openDropdown(fakeRef);
+    tick();
+    comp.onBlur(new Event('blur'));
+    tick();
+    comp.currentValue.subscribe((v) => (displayed = v));
+
+    expect(rowModel.value).withContext('value must be preserved after blur').toEqual(entry(1));
+    expect(displayed).withContext('display must be preserved after blur').toBe('e1');
+  }));
+
+  it('GUARD: a disabled option selected via mousedown path is ignored by selectEntry', fakeAsync(() => {
+    const arr = buildArray(2);
+    (arr.get(0).group[0] as any).value = entry(1);
+    const rowModel = arr.get(1).group[0] as any;
+    bindComponentToRow(rowModel);
+    comp.openDropdown(fakeRef);
+    tick();
+    spyOn(comp.change, 'emit');
+    // dsBtnDisabled does NOT block mousedown; selectEntry must guard instead.
+    comp.selectEntry(entry(1), fakeRef);
+    expect(comp.change.emit).withContext('disabled option must not be selected').not.toHaveBeenCalled();
+    expect(rowModel.value).withContext('value untouched').toBeUndefined();
+  }));
+});
diff --git a/src/app/shared/host-window.reducer.spec.ts b/src/app/shared/host-window.reducer.spec.ts
index 7e1fe3761b5..1845c6ec991 100644
--- a/src/app/shared/host-window.reducer.spec.ts
+++ b/src/app/shared/host-window.reducer.spec.ts
@@ -22,12 +22,16 @@ describe('hostWindowReducer', () => {
     expect(newState).toEqual(state);
   });
 
-  it('should start with width = null and height = null', () => {
+  it('should start with a desktop default width and height (so SSR renders the desktop layout)', () => {
+    // The initial width/height default to a desktop viewport so responsive components render their
+    // desktop branch during SSR, matching the common (desktop) client hydration and avoiding a
+    // layout shift on load. The browser overrides these with the real window size immediately
+    // (see StoreEffects.resize / AppComponent).
     const action = new NullAction();
     const initialState = hostWindowReducer(undefined, action);
 
-    expect(initialState.width).toEqual(null);
-    expect(initialState.height).toEqual(null);
+    expect(initialState.width).toEqual(1200);
+    expect(initialState.height).toEqual(800);
   });
 
   it('should update the width and height in the state in response to a RESIZE action', () => {
diff --git a/src/app/shared/search/host-window.reducer.ts b/src/app/shared/search/host-window.reducer.ts
index a8cefb992a5..da14ce9c492 100644
--- a/src/app/shared/search/host-window.reducer.ts
+++ b/src/app/shared/search/host-window.reducer.ts
@@ -8,9 +8,17 @@ export interface HostWindowState {
   height: number;
 }
 
+// Assume a desktop viewport until the real one is measured in the browser (see StoreEffects.resize
+// and AppComponent, which dispatch the true window size on the client). This default is what SSR
+// renders with: with `width: null` the width observable stayed empty during SSR (HostWindowService
+// filters out null widths), so responsive components — most visibly <ds-auth-nav-menu> — rendered
+// their *mobile* branch on the server and then snapped to the *desktop* branch once the client
+// measured the real width, shifting the header (login link -> login dropdown button) and resizing the
+// search box on every page load. Defaulting to a desktop width makes the server markup match the
+// common (desktop) hydration, so there is no branch swap and no header/search shift.
 const initialState: HostWindowState = {
-  width: null,
-  height: null,
+  width: 1200,
+  height: 800,
 };
 
 export function hostWindowReducer(state = initialState, action: HostWindowAction): HostWindowState {
diff --git a/src/app/shared/search/search-filters/search-filter/search-facet-filter-options/search-facet-option/search-facet-option.component.ts b/src/app/shared/search/search-filters/search-filter/search-facet-filter-options/search-facet-option/search-facet-option.component.ts
index 17615e62218..9893ec4da61 100644
--- a/src/app/shared/search/search-filters/search-filter/search-facet-filter-options/search-facet-option/search-facet-option.component.ts
+++ b/src/app/shared/search/search-filters/search-filter/search-facet-filter-options/search-facet-option/search-facet-option.component.ts
@@ -129,7 +129,13 @@ export class SearchFacetOptionComponent implements OnInit {
    * Announces to the screen reader that the page will be reloaded, which filter has been selected
    */
   announceFilter() {
-    const message = this.translateService.instant('search-facet-option.update.announcement', { filter: this.filterValue.value });
+    // DATASHARE - start: announce the same label the checkbox shows, not the raw Solr value (LUC070-260)
+    const label = this.translateService.instant(
+      `search.filters.${this.filterConfig.name}.${this.filterValue.value}`,
+      { default: this.filterValue.value },
+    );
+    const message = this.translateService.instant('search-facet-option.update.announcement', { filter: label });
+    // DATASHARE - end
     this.liveRegionService.addMessage(message);
   }
 }
diff --git a/src/app/shared/search/search-labels/search-label/search-label.component.html b/src/app/shared/search/search-labels/search-label/search-label.component.html
index 3abdbb6965b..17b40b948b6 100644
--- a/src/app/shared/search/search-labels/search-label/search-label.component.html
+++ b/src/app/shared/search/search-labels/search-label/search-label.component.html
@@ -1,5 +1,6 @@
+<!-- DATASHARE - start: aria-label announces the translated value, not the raw Solr token (LUC070-260) -->
 <a class="badge badge-primary"
-   [attr.aria-label]="'search.filters.remove' | translate:{ type: ('search.filters.applied.f.' + appliedFilter.filter) | translate, value: appliedFilter.label }"
+   [attr.aria-label]="'search.filters.remove' | translate:{ type: ('search.filters.applied.f.' + appliedFilter.filter) | translate, value: ('search.filters.' + appliedFilter.filter + '.' + appliedFilter.label | translate: { default: appliedFilter.label }) }"
    [routerLink]="searchLink"
    [queryParams]="(removeParameters$ | async)"
    (click)="searchFilterService.minimizeAll()">
@@ -8,3 +9,4 @@
     <span class="pl-2" aria-hidden="true">×</span>
   </span>
 </a>
+<!-- DATASHARE - end -->
diff --git a/src/app/shared/testing/menu-service.stub.ts b/src/app/shared/testing/menu-service.stub.ts
index e2e11180218..6cbdfb9e197 100644
--- a/src/app/shared/testing/menu-service.stub.ts
+++ b/src/app/shared/testing/menu-service.stub.ts
@@ -36,10 +36,10 @@ export class MenuServiceStub {
   collapseMenu(): void { /***/
   }
 
-  showMenu(): void { /***/
+  showMenu(menuID?: MenuID): void { /***/
   }
 
-  hideMenu(): void { /***/
+  hideMenu(menuID?: MenuID): void { /***/
   }
 
   expandMenuPreview(): void { /***/
diff --git a/src/app/shared/upload/uploader/uploader-complete-event.model.ts b/src/app/shared/upload/uploader/uploader-complete-event.model.ts
new file mode 100644
index 00000000000..aee97950017
--- /dev/null
+++ b/src/app/shared/upload/uploader/uploader-complete-event.model.ts
@@ -0,0 +1,15 @@
+/**
+ * An interface that represents a completed single-file upload, carrying both the
+ * parsed response body and the client-side file name of the file that completed.
+ */
+export interface UploaderCompleteEvent {
+  /**
+   * The parsed response body (e.g. a WorkspaceItem in the submission workflow)
+   */
+  response: any;
+
+  /**
+   * The client-side name of the file that completed uploading, when available
+   */
+  fileName?: string;
+}
diff --git a/src/app/shared/upload/uploader/uploader.component.spec.ts b/src/app/shared/upload/uploader/uploader.component.spec.ts
index 90563f10802..b715dd26c40 100644
--- a/src/app/shared/upload/uploader/uploader.component.spec.ts
+++ b/src/app/shared/upload/uploader/uploader.component.spec.ts
@@ -66,6 +66,44 @@ describe('Chips component', () => {
     expect(app).toBeDefined();
   }));
 
+  it('should emit both onCompleteItem and onCompleteItemWithFile on a completed upload', inject([UploaderComponent], (app: UploaderComponent) => {
+    app.uploadFilesOptions = Object.assign(new UploaderOptions(), {
+      url: 'http://test',
+      authToken: null,
+      disableMultipart: false,
+      itemAlias: null,
+    });
+    app.ngOnInit();
+    app.ngAfterViewInit();
+
+    spyOn(app.onCompleteItem, 'emit');
+    spyOn(app.onCompleteItemWithFile, 'emit');
+
+    const parsed = { foo: 'bar' };
+    app.uploader.onCompleteItem({ file: { name: 'test.pdf' } } as any, JSON.stringify(parsed), 200, {});
+
+    expect(app.onCompleteItem.emit).toHaveBeenCalledWith(parsed);
+    expect(app.onCompleteItemWithFile.emit).toHaveBeenCalledWith({ response: parsed, fileName: 'test.pdf' });
+  }));
+
+  it('should emit onCompleteItemWithFile without a fileName when the item has no file name', inject([UploaderComponent], (app: UploaderComponent) => {
+    app.uploadFilesOptions = Object.assign(new UploaderOptions(), {
+      url: 'http://test',
+      authToken: null,
+      disableMultipart: false,
+      itemAlias: null,
+    });
+    app.ngOnInit();
+    app.ngAfterViewInit();
+
+    spyOn(app.onCompleteItemWithFile, 'emit');
+
+    const parsed = { foo: 'bar' };
+    app.uploader.onCompleteItem(undefined, JSON.stringify(parsed), 200, {});
+
+    expect(app.onCompleteItemWithFile.emit).toHaveBeenCalledWith({ response: parsed });
+  }));
+
 });
 
 // declare a test component
diff --git a/src/app/shared/upload/uploader/uploader.component.ts b/src/app/shared/upload/uploader/uploader.component.ts
index 804200d220b..e3532d1456b 100644
--- a/src/app/shared/upload/uploader/uploader.component.ts
+++ b/src/app/shared/upload/uploader/uploader.component.ts
@@ -33,6 +33,8 @@ import {
   isNotEmpty,
   isUndefined,
 } from '../../empty.util';
+import { UploaderCompleteEvent } from './uploader-complete-event.model';
+import { UploaderError } from './uploader-error.model';
 import { UploaderOptions } from './uploader-options.model';
 import { UploaderProperties } from './uploader-properties.model';
 
@@ -92,10 +94,16 @@ export class UploaderComponent implements OnInit, AfterViewInit {
    */
   @Output() onCompleteItem: EventEmitter<any> = new EventEmitter<any>();
 
+  /**
+   * The function to call when upload is completed, carrying the parsed response together with the
+   * client-side file name. Emitted alongside {@link onCompleteItem} so existing consumers are unaffected.
+   */
+  @Output() onCompleteItemWithFile: EventEmitter<UploaderCompleteEvent> = new EventEmitter<UploaderCompleteEvent>();
+
   /**
    * The function to call on error occurred
    */
-  @Output() onUploadError: EventEmitter<any> = new EventEmitter<any>();
+  @Output() onUploadError: EventEmitter<UploaderError> = new EventEmitter<UploaderError>();
 
   /**
    * The function to call when a file is selected
@@ -195,6 +203,8 @@ export class UploaderComponent implements OnInit, AfterViewInit {
       if (isNotEmpty(response)) {
         const responsePath = JSON.parse(response);
         this.onCompleteItem.emit(responsePath);
+        const fileName = item?.file?.name;
+        this.onCompleteItemWithFile.emit(hasValue(fileName) ? { response: responsePath, fileName } : { response: responsePath });
       }
     };
     this.uploader.onErrorItem = (item: any, response: any, status: any, headers: any) => {
diff --git a/src/app/statistics-page/collection-statistics-page/collection-statistics-page.component.spec.ts b/src/app/statistics-page/collection-statistics-page/collection-statistics-page.component.spec.ts
index 08c7c7c6b8c..7072499b4ec 100644
--- a/src/app/statistics-page/collection-statistics-page/collection-statistics-page.component.spec.ts
+++ b/src/app/statistics-page/collection-statistics-page/collection-statistics-page.component.spec.ts
@@ -83,7 +83,7 @@ describe('CollectionStatisticsPageComponent', () => {
         { provide: DSpaceObjectDataService, useValue: {} },
         { provide: DSONameService, useValue: nameService },
         { provide: AuthService, useValue: authService },
-        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }) } },
+        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }), clearPagination: () => undefined } },
       ],
     })
       .compileComponents();
diff --git a/src/app/statistics-page/community-statistics-page/community-statistics-page.component.spec.ts b/src/app/statistics-page/community-statistics-page/community-statistics-page.component.spec.ts
index 8ce3eb9cb1c..4da4a64edcd 100644
--- a/src/app/statistics-page/community-statistics-page/community-statistics-page.component.spec.ts
+++ b/src/app/statistics-page/community-statistics-page/community-statistics-page.component.spec.ts
@@ -83,7 +83,7 @@ describe('CommunityStatisticsPageComponent', () => {
         { provide: DSpaceObjectDataService, useValue: {} },
         { provide: DSONameService, useValue: nameService },
         { provide: AuthService, useValue: authService },
-        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }) } },
+        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }), clearPagination: () => undefined } },
       ],
     })
       .compileComponents();
diff --git a/src/app/statistics-page/item-statistics-page/item-statistics-page.component.spec.ts b/src/app/statistics-page/item-statistics-page/item-statistics-page.component.spec.ts
index 133e98acfc3..f0d2d53def9 100644
--- a/src/app/statistics-page/item-statistics-page/item-statistics-page.component.spec.ts
+++ b/src/app/statistics-page/item-statistics-page/item-statistics-page.component.spec.ts
@@ -83,7 +83,7 @@ describe('ItemStatisticsPageComponent', () => {
         { provide: DSpaceObjectDataService, useValue: {} },
         { provide: DSONameService, useValue: nameService },
         { provide: AuthService, useValue: authService },
-        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }) } },
+        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }), clearPagination: () => undefined } },
       ],
     })
       .compileComponents();
diff --git a/src/app/statistics-page/site-statistics-page/site-statistics-page.component.spec.ts b/src/app/statistics-page/site-statistics-page/site-statistics-page.component.spec.ts
index a7c5192fe88..c38198cd98e 100644
--- a/src/app/statistics-page/site-statistics-page/site-statistics-page.component.spec.ts
+++ b/src/app/statistics-page/site-statistics-page/site-statistics-page.component.spec.ts
@@ -84,7 +84,7 @@ describe('SiteStatisticsPageComponent', () => {
         { provide: DSONameService, useValue: nameService },
         { provide: SiteDataService, useValue: siteService },
         { provide: AuthService, useValue: authService },
-        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }) } },
+        { provide: PaginationService, useValue: { getCurrentPagination: () => observableOf({ currentPage: 1, pageSize: 10 }), clearPagination: () => undefined } },
       ],
     })
       .compileComponents();
diff --git a/src/app/statistics-page/statistics-table/statistics-table.component.spec.ts b/src/app/statistics-page/statistics-table/statistics-table.component.spec.ts
index d8e010ecc05..27dc9e576e7 100644
--- a/src/app/statistics-page/statistics-table/statistics-table.component.spec.ts
+++ b/src/app/statistics-page/statistics-table/statistics-table.component.spec.ts
@@ -47,6 +47,7 @@ describe('StatisticsTableComponent', () => {
 
   const paginationService = {
     getCurrentPagination: (_id: string, _options: PaginationComponentOptions) => currentPagination$.asObservable(),
+    clearPagination: (_id: string) => undefined,
   };
 
   const setPage = (currentPage: number, pageSize = 10) => {
@@ -221,4 +222,27 @@ describe('StatisticsTableComponent', () => {
       expect(de.query(By.css(`td.item_${numberOfPoints - 1}-views-data`))).toBeTruthy();
     });
   });
+
+  describe('on destroy', () => {
+
+    it('should clear its own pagination params so they do not leak to the next scope', () => {
+      component.report = Object.assign(new UsageReport(), {
+        id: 'uuid_TotalVisits',
+        points: [],
+      });
+      component.ngOnInit();
+      const spy = spyOn(paginationService, 'clearPagination');
+
+      fixture.destroy();
+
+      expect(spy).toHaveBeenCalledWith('stats-uuid_TotalVisits');
+    });
+
+    it('should not throw when destroyed before initialisation', () => {
+      // createComponent alone runs only the constructor; destroying without detectChanges makes
+      // Angular itself invoke ngOnDestroy on a component whose ngOnInit never ran.
+      const uninitialised = TestBed.createComponent(StatisticsTableComponent);
+      expect(() => uninitialised.destroy()).not.toThrow();
+    });
+  });
 });
diff --git a/src/app/statistics-page/statistics-table/statistics-table.component.ts b/src/app/statistics-page/statistics-table/statistics-table.component.ts
index cb5f1c7fe12..ddd20d56f48 100644
--- a/src/app/statistics-page/statistics-table/statistics-table.component.ts
+++ b/src/app/statistics-page/statistics-table/statistics-table.component.ts
@@ -6,6 +6,7 @@ import {
 import {
   Component,
   Input,
+  OnDestroy,
   OnInit,
 } from '@angular/core';
 import {
@@ -43,7 +44,7 @@ import { PaginationComponentOptions } from '../../shared/pagination/pagination-c
   standalone: true,
   imports: [NgIf, NgFor, AsyncPipe, TranslateModule, PaginationComponent],
 })
-export class StatisticsTableComponent implements OnInit {
+export class StatisticsTableComponent implements OnInit, OnDestroy {
 
   /**
    * The usage report to display a statistics table for
@@ -110,6 +111,18 @@ export class StatisticsTableComponent implements OnInit {
     );
   }
 
+  ngOnDestroy() {
+    // Stage this table's stats-* params for removal. Plain navigations drop query params anyway, but
+    // 'merge' navigations (e.g. the navbar search form) carry them along; PaginationService applies the
+    // staged nulls on its next updateRoute, scrubbing them from the URL. Deliberately NOT navigating from
+    // here: several tables are destroyed at once and an eager update would race the in-flight navigation.
+    // Same idiom as the other paginated components. Guarded in case the component is destroyed before
+    // ngOnInit ran.
+    if (this.paginationOptions) {
+      this.paginationService.clearPagination(this.paginationOptions.id);
+    }
+  }
+
   /**
    * Get the row label to display for a statistics point.
    * @param point the statistics point to get the label for
diff --git a/src/app/submission/form/footer/submission-form-footer.component.html b/src/app/submission/form/footer/submission-form-footer.component.html
index 6ba0d4b9682..b8dbf4d3ab0 100644
--- a/src/app/submission/form/footer/submission-form-footer.component.html
+++ b/src/app/submission/form/footer/submission-form-footer.component.html
@@ -1,12 +1,3 @@
-<!-- DATASHARE - start -->
-<!-- Debug section - remove after fixing -->
-<!-- div style="background: yellow; padding: 10px; margin: 10px;">
-  <strong>DEBUG:</strong><br>
-  Signal value: {{ showDepositButtonSignal() }}<br>
-  Signal function: {{ (showDepositAndDiscard | async) && showDepositButtonSignal()  }}
-</div -->
-<!-- DATASHARE - end -->
-
 <div class="d-flex flex-row gap-1 justify-content-between" *ngIf="!!submissionId">
   <div class="flex-grow-0">
     <button *ngIf="(showDepositAndDiscard | async)"
@@ -27,9 +18,18 @@
       <i class="fas fa-exclamation-circle"></i> {{'submission.general.info.pending-changes' | translate}}
     </span>
     <div *ngIf="(processingSaveStatus | async) || (processingDepositStatus | async)" class="col d-flex justify-content-end align-items-center">
+      <!-- DATASHARE - start -->
+      <small *ngIf="(pathIngestPending$ | async) && (processingSaveStatus | async)" class="mr-2 text-right" role="status" aria-live="polite">{{'submission.general.info.ingesting-from-path-hint' | translate}}</small>
+      <!-- DATASHARE - end -->
       <div class="progress w-75">
-        <div *ngIf="(processingSaveStatus | async)" class="progress-bar progress-bar-striped progress-bar-animated bg-info" [style.width]="'100%'" role="progressbar" aria-valuenow="100" aria-valuemin="0" aria-valuemax="100">Saving...</div>
-        <div *ngIf="(processingDepositStatus | async)" class="progress-bar progress-bar-striped progress-bar-animated bg-info" [style.width]="'100%'" role="progressbar" aria-valuenow="100" aria-valuemin="0" aria-valuemax="100">Depositing...</div>
+        <div *ngIf="(processingSaveStatus | async)" class="progress-bar progress-bar-striped progress-bar-animated bg-info" [style.width]="'100%'" role="progressbar" aria-valuenow="100" aria-valuemin="0" aria-valuemax="100">
+          <!-- DATASHARE - start -->
+          <!-- One inline child: .progress-bar is flex-direction:column, so separate text nodes
+               would stack on top of each other inside its 1rem height. -->
+          <span class="ds-progress-label px-2 text-truncate">{{(savingLabelKey$ | async) | translate}}<ng-container *ngIf="(pathIngestPending$ | async)">&nbsp;{{'submission.general.info.ingesting-from-path-elapsed' | translate:{ elapsed: (elapsed$ | async) } }}</ng-container></span>
+          <!-- DATASHARE - end -->
+        </div>
+        <div *ngIf="(processingDepositStatus | async)" class="progress-bar progress-bar-striped progress-bar-animated bg-info" [style.width]="'100%'" role="progressbar" aria-valuenow="100" aria-valuemin="0" aria-valuemax="100">{{'submission.general.info.depositing' | translate}}</div>
       </div>
     </div>
     <div class="ml-2 space-children-mr">
diff --git a/src/app/submission/form/footer/submission-form-footer.component.scss b/src/app/submission/form/footer/submission-form-footer.component.scss
index e69de29bb2d..f1a2cf0f940 100644
--- a/src/app/submission/form/footer/submission-form-footer.component.scss
+++ b/src/app/submission/form/footer/submission-form-footer.component.scss
@@ -0,0 +1,12 @@
+/* DATASHARE - start */
+/* The save progress bar carries a label that has to sit on one line.
+ *
+ * .progress-bar is a column flex container with line-height: 0 and overflow: hidden, so a child
+ * element inherits that zero line-height, collapses to zero height and is clipped away entirely.
+ * Wrapping the label in a single child is what keeps the message and the elapsed time on one line
+ * rather than stacked on top of each other, so that child needs a line box of its own.
+ */
+.progress-bar > .ds-progress-label {
+  line-height: 1;
+}
+/* DATASHARE - end */
diff --git a/src/app/submission/form/footer/submission-form-footer.component.spec.ts b/src/app/submission/form/footer/submission-form-footer.component.spec.ts
index ac6561350cb..855f1569e99 100644
--- a/src/app/submission/form/footer/submission-form-footer.component.spec.ts
+++ b/src/app/submission/form/footer/submission-form-footer.component.spec.ts
@@ -2,13 +2,15 @@ import {
   ChangeDetectorRef,
   Component,
   CUSTOM_ELEMENTS_SCHEMA,
-  signal,
   SimpleChange,
 } from '@angular/core';
 import {
   ComponentFixture,
+  discardPeriodicTasks,
+  fakeAsync,
   inject,
   TestBed,
+  tick,
   waitForAsync,
 } from '@angular/core/testing';
 import { By } from '@angular/platform-browser';
@@ -22,11 +24,14 @@ import {
   getTestScheduler,
   hot,
 } from 'jasmine-marbles';
-import { of as observableOf } from 'rxjs';
+import {
+  BehaviorSubject,
+  of as observableOf,
+} from 'rxjs';
 import { TestScheduler } from 'rxjs/testing';
 
 import { SubmissionRestService } from '../../../core/submission/submission-rest.service';
-import { DatashareSubmissionService } from '../../../datashare/datashare-submission.service';
+import { DatashareUploadFromPathService } from '../../../datashare/datashare-upload-from-path.service';
 import { BtnDisabledDirective } from '../../../shared/btn-disabled.directive';
 import { mockSubmissionId } from '../../../shared/mocks/submission.mock';
 import { SubmissionRestServiceStub } from '../../../shared/testing/submission-rest-service.stub';
@@ -39,8 +44,10 @@ const submissionServiceStub: SubmissionServiceStub = new SubmissionServiceStub()
 
 const submissionId = mockSubmissionId;
 
-const mockDatashareSubmissionService = {
-  hasUploadFilesErrorsSignal: signal(true),
+const pathIngestPending$ = new BehaviorSubject<boolean>(false);
+
+const mockDatashareUploadFromPathService = {
+  isPendingForSubmission: () => pathIngestPending$.asObservable(),
 };
 
 describe('SubmissionFormFooterComponent', () => {
@@ -63,7 +70,7 @@ describe('SubmissionFormFooterComponent', () => {
       providers: [
         { provide: SubmissionService, useValue: submissionServiceStub },
         { provide: SubmissionRestService, useClass: SubmissionRestServiceStub },
-        { provide: DatashareSubmissionService, useValue: mockDatashareSubmissionService },
+        { provide: DatashareUploadFromPathService, useValue: mockDatashareUploadFromPathService },
         ChangeDetectorRef,
         NgbModal,
         SubmissionFormFooterComponent,
@@ -79,6 +86,7 @@ describe('SubmissionFormFooterComponent', () => {
     // synchronous beforeEach
     beforeEach(() => {
       submissionServiceStub.getSubmissionStatus.and.returnValue(observableOf(true));
+      submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(observableOf(false));
       const html = `
         <ds-submission-form-footer [submissionId]="submissionId"></ds-submission-form-footer>`;
 
@@ -268,6 +276,192 @@ describe('SubmissionFormFooterComponent', () => {
       expect(saveBtn.nativeElement.classList.contains('disabled')).toBeFalse();
     });
 
+    // DATASHARE - start
+    describe('when a save is in progress', () => {
+
+      const triggerNgOnChanges = () => comp.ngOnChanges({
+        submissionId: new SimpleChange(null, submissionId, true),
+      });
+
+      beforeEach(() => {
+        pathIngestPending$.next(false);
+        submissionServiceStub.getSubmissionStatus.and.returnValue(observableOf(true));
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(observableOf(false));
+        submissionServiceStub.getSubmissionDepositProcessingStatus.and.returnValue(observableOf(false));
+        submissionServiceStub.hasUnsavedModification.and.returnValue(observableOf(false));
+      });
+
+      it('should label the save progress bar with the plain saving message when no path ingest is pending', () => {
+        triggerNgOnChanges();
+
+        let label: string;
+        comp.savingLabelKey$.subscribe((key: string) => label = key);
+
+        expect(label).toBe('submission.general.info.saving');
+      });
+
+      it('should label the save progress bar with the ingest message when a path ingest is pending', () => {
+        pathIngestPending$.next(true);
+        triggerNgOnChanges();
+
+        let label: string;
+        comp.savingLabelKey$.subscribe((key: string) => label = key);
+
+        expect(label).toBe('submission.general.info.ingesting-from-path');
+      });
+
+      it('should render a translation key rather than hardcoded English while saving', () => {
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(observableOf(true));
+        triggerNgOnChanges();
+        fixture.detectChanges();
+
+        const progressBar: any = fixture.debugElement.query(By.css('.progress-bar'));
+
+        expect(progressBar.nativeElement.textContent).toContain('submission.general.info.saving');
+        expect(progressBar.nativeElement.textContent).not.toContain('Saving...');
+      });
+
+      it('should render the ingest message while a path ingest is in progress', fakeAsync(() => {
+        pathIngestPending$.next(true);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(observableOf(true));
+        triggerNgOnChanges();
+        fixture.detectChanges();
+
+        const progressBar: any = fixture.debugElement.query(By.css('.progress-bar'));
+
+        expect(progressBar.nativeElement.textContent).toContain('submission.general.info.ingesting-from-path');
+        discardPeriodicTasks();
+      }));
+
+      it('should render a translation key rather than hardcoded English while depositing', () => {
+        submissionServiceStub.getSubmissionDepositProcessingStatus.and.returnValue(observableOf(true));
+        triggerNgOnChanges();
+        fixture.detectChanges();
+
+        const progressBar: any = fixture.debugElement.query(By.css('.progress-bar'));
+
+        expect(progressBar.nativeElement.textContent).toContain('submission.general.info.depositing');
+        expect(progressBar.nativeElement.textContent).not.toContain('Depositing...');
+      });
+
+      it('should run the elapsed timer only while a save is in progress', fakeAsync(() => {
+        const saving$ = new BehaviorSubject<boolean>(false);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(saving$.asObservable());
+        triggerNgOnChanges();
+
+        const emitted: string[] = [];
+        const subscription = comp.elapsed$.subscribe((elapsed: string) => emitted.push(elapsed));
+
+        tick(3000);
+        expect(emitted).toEqual(['']);
+
+        saving$.next(true);
+        tick(0);
+        expect(emitted[emitted.length - 1]).toBe('00:00');
+
+        tick(2000);
+        expect(emitted[emitted.length - 1]).toBe('00:02');
+
+        saving$.next(false);
+        expect(emitted[emitted.length - 1]).toBe('');
+
+        tick(5000);
+        expect(emitted[emitted.length - 1]).toBe('');
+
+        subscription.unsubscribe();
+        discardPeriodicTasks();
+      }));
+
+      it('should count elapsed wall-clock time rather than timer ticks', fakeAsync(() => {
+        const saving$ = new BehaviorSubject<boolean>(false);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(saving$.asObservable());
+        triggerNgOnChanges();
+
+        // A tab that has been hidden for a while gets roughly one timer callback a minute, so the
+        // number of emissions says nothing about how long the ingest has really been running.
+        let clock = Date.now();
+        spyOn(Date, 'now').and.callFake(() => clock);
+
+        const emitted: string[] = [];
+        const subscription = comp.elapsed$.subscribe((elapsed: string) => emitted.push(elapsed));
+
+        saving$.next(true);
+        tick(0);
+        expect(emitted[emitted.length - 1]).toBe('00:00');
+
+        clock += 180000;
+        tick(1000);
+        expect(emitted[emitted.length - 1]).toBe('03:00');
+
+        clock += 120000;
+        tick(1000);
+        expect(emitted[emitted.length - 1]).toBe('05:00');
+
+        subscription.unsubscribe();
+        discardPeriodicTasks();
+      }));
+
+      it('should let the minutes run past 59 for an ingest longer than an hour', fakeAsync(() => {
+        const saving$ = new BehaviorSubject<boolean>(false);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(saving$.asObservable());
+        triggerNgOnChanges();
+
+        let clock = Date.now();
+        spyOn(Date, 'now').and.callFake(() => clock);
+
+        const emitted: string[] = [];
+        const subscription = comp.elapsed$.subscribe((elapsed: string) => emitted.push(elapsed));
+
+        saving$.next(true);
+        tick(0);
+
+        // 65 minutes and 15 seconds
+        clock += 3915000;
+        tick(1000);
+        expect(emitted[emitted.length - 1]).toBe('65:15');
+
+        subscription.unsubscribe();
+        discardPeriodicTasks();
+      }));
+
+      it('should latch the pending state of the save that is running and ignore a later change', () => {
+        const saving$ = new BehaviorSubject<boolean>(false);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(saving$.asObservable());
+        triggerNgOnChanges();
+
+        const labels: string[] = [];
+        const subscription = comp.savingLabelKey$.subscribe((key: string) => labels.push(key));
+
+        saving$.next(true);
+        // the path is typed while the PATCH that does not carry it is still in flight
+        pathIngestPending$.next(true);
+
+        expect(labels).toEqual(['submission.general.info.saving']);
+
+        subscription.unsubscribe();
+      });
+
+      it('should keep claiming an ingest for the whole of a save that was dispatched with a path', () => {
+        const saving$ = new BehaviorSubject<boolean>(false);
+        submissionServiceStub.getSubmissionSaveProcessingStatus.and.returnValue(saving$.asObservable());
+        pathIngestPending$.next(true);
+        triggerNgOnChanges();
+
+        const labels: string[] = [];
+        const subscription = comp.savingLabelKey$.subscribe((key: string) => labels.push(key));
+
+        saving$.next(true);
+        // the server clears the field, so the live state goes false before the save has come back
+        pathIngestPending$.next(false);
+
+        expect(labels).toEqual(['submission.general.info.ingesting-from-path']);
+
+        subscription.unsubscribe();
+      });
+
+    });
+    // DATASHARE - end
+
   });
 });
 
diff --git a/src/app/submission/form/footer/submission-form-footer.component.ts b/src/app/submission/form/footer/submission-form-footer.component.ts
index ffbc8d5ca97..9a1ebb185c3 100644
--- a/src/app/submission/form/footer/submission-form-footer.component.ts
+++ b/src/app/submission/form/footer/submission-form-footer.component.ts
@@ -1,7 +1,6 @@
 import { CommonModule } from '@angular/common';
 import {
   Component,
-  computed,
   Input,
   OnChanges,
   SimpleChanges,
@@ -11,17 +10,35 @@ import { TranslateModule } from '@ngx-translate/core';
 import {
   Observable,
   of as observableOf,
+  timer,
 } from 'rxjs';
-import { map } from 'rxjs/operators';
+import {
+  distinctUntilChanged,
+  map,
+  switchMap,
+  take,
+} from 'rxjs/operators';
 
 import { SubmissionRestService } from '../../../core/submission/submission-rest.service';
 import { SubmissionScopeType } from '../../../core/submission/submission-scope-type';
-import { DatashareSubmissionService } from '../../../datashare/datashare-submission.service';
+import { DatashareUploadFromPathService } from '../../../datashare/datashare-upload-from-path.service';
 import { BtnDisabledDirective } from '../../../shared/btn-disabled.directive';
 import { isNotEmpty } from '../../../shared/empty.util';
 import { BrowserOnlyPipe } from '../../../shared/utils/browser-only.pipe';
 import { SubmissionService } from '../../submission.service';
 
+// DATASHARE - start
+/**
+ * Message shown by the save progress bar for an ordinary save.
+ */
+export const SAVING_MESSAGE_KEY = 'submission.general.info.saving';
+
+/**
+ * Message shown by the save progress bar when the save also ingests a file from the server filesystem.
+ */
+export const INGESTING_FROM_PATH_MESSAGE_KEY = 'submission.general.info.ingesting-from-path';
+// DATASHARE - end
+
 /**
  * This component represents submission form footer bar.
  */
@@ -69,16 +86,25 @@ export class SubmissionFormFooterComponent implements OnChanges {
    */
   public hasUnsavedModification: Observable<boolean>;
 
-  // DATASHARE - Start
-  // Signal access
-  public  hasUploadFileErrorsSignal = this.datashareSubmissionService.hasUploadFilesErrorsSignal;
+  // DATASHARE - start
+  /**
+   * Whether the running save will make the server ingest a file; latched while a save runs.
+   * @type {Observable<boolean>}
+   */
+  public pathIngestPending$: Observable<boolean> = observableOf(false);
 
-  // Optional: Create a computed signal for more complex logic
-  public hasUploadFileErrors = computed(() => {
-    // Combine the signal with other conditions if needed
-    return this.hasUploadFileErrorsSignal();
-  });
+  /**
+   * The message key the save progress bar has to show
+   * @type {Observable<string>}
+   */
+  public savingLabelKey$: Observable<string> = observableOf(SAVING_MESSAGE_KEY);
 
+  /**
+   * The mm:ss elapsed since the running save started, empty while no save is running
+   * @type {Observable<string>}
+   */
+  public elapsed$: Observable<string> = observableOf('');
+  // DATASHARE - end
 
   /**
    * Initialize instance variables
@@ -86,14 +112,13 @@ export class SubmissionFormFooterComponent implements OnChanges {
    * @param {NgbModal} modalService
    * @param {SubmissionRestService} restService
    * @param {SubmissionService} submissionService
-   * @param {DatashareSubmissionService} datashareSubmissionService
+   * @param {DatashareUploadFromPathService} uploadFromPathService
    */
   constructor(private modalService: NgbModal,
               private restService: SubmissionRestService,
               private submissionService: SubmissionService,
-              private datashareSubmissionService: DatashareSubmissionService) {
+              private uploadFromPathService: DatashareUploadFromPathService) {
   }
-  // DATASHARE - End
 
   /**
    * Initialize all instance variables
@@ -108,6 +133,34 @@ export class SubmissionFormFooterComponent implements OnChanges {
       this.processingDepositStatus = this.submissionService.getSubmissionDepositProcessingStatus(this.submissionId);
       this.showDepositAndDiscard = observableOf(this.submissionService.getSubmissionScope() === SubmissionScopeType.WorkspaceItem);
       this.hasUnsavedModification = this.submissionService.hasUnsavedModification();
+
+      // DATASHARE - start
+      const livePathIngestPending$ = this.uploadFromPathService.isPendingForSubmission(this.submissionId);
+      // A running save must latch its pending state: read live, the label would track a body already
+      // gone. While nothing is saving, the live value is all there is.
+      this.pathIngestPending$ = this.processingSaveStatus.pipe(
+        distinctUntilChanged(),
+        switchMap((saving: boolean) => saving ? livePathIngestPending$.pipe(take(1)) : livePathIngestPending$),
+        distinctUntilChanged(),
+      );
+      this.savingLabelKey$ = this.pathIngestPending$.pipe(
+        map((pending: boolean) => pending ? INGESTING_FROM_PATH_MESSAGE_KEY : SAVING_MESSAGE_KEY),
+        distinctUntilChanged(),
+      );
+      // The ingest runs inside the save request, so only elapsed time (not byte progress) is available.
+      this.elapsed$ = this.processingSaveStatus.pipe(
+        distinctUntilChanged(),
+        switchMap((saving: boolean) => {
+          if (!saving) {
+            return observableOf('');
+          }
+          // Measured against the clock, not counted ticks: backgrounded tabs throttle timers to ~1/min,
+          // so counting ticks would under-report a long ingest's elapsed time.
+          const startedAt: number = Date.now();
+          return timer(0, 1000).pipe(map(() => this.formatElapsed(Date.now() - startedAt)));
+        }),
+      );
+      // DATASHARE - end
     }
   }
 
@@ -129,12 +182,6 @@ export class SubmissionFormFooterComponent implements OnChanges {
    * Dispatch a submission deposit action
    */
   public deposit(event) {
-    // DATASHARE - start
-    if (!this.hasUploadFileErrors()) {
-      this.datashareSubmissionService.sendCannotSubmitNotification();
-      return;
-    }
-    // DATASHARE - end
     this.submissionService.dispatchDeposit(this.submissionId);
   }
 
@@ -150,4 +197,19 @@ export class SubmissionFormFooterComponent implements OnChanges {
       },
     );
   }
+
+  // DATASHARE - start
+  /**
+   * Render a duration as mm:ss, letting the minutes run past 59 so an hour-plus ingest reads as "72:15".
+   *
+   * @param elapsedMillis the milliseconds since the running save started
+   */
+  private formatElapsed(elapsedMillis: number): string {
+    // Clamp at 0: the clock can step backwards (manual change, NTP), and a negative count would alarm.
+    const elapsedSeconds = Math.max(0, Math.floor(elapsedMillis / 1000));
+    const minutes = Math.floor(elapsedSeconds / 60);
+    const seconds = elapsedSeconds % 60;
+    return `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
+  }
+  // DATASHARE - end
 }
diff --git a/src/app/submission/form/submission-upload-files/submission-upload-files.component.html b/src/app/submission/form/submission-upload-files/submission-upload-files.component.html
index dfad8c422ec..5e7be8fdf7d 100644
--- a/src/app/submission/form/submission-upload-files/submission-upload-files.component.html
+++ b/src/app/submission/form/submission-upload-files/submission-upload-files.component.html
@@ -4,5 +4,5 @@
              [enableDragOverDocument]="enableDragOverDocument"
              [onBeforeUpload]="onBeforeUpload"
              [uploadFilesOptions]="uploadFilesOptions"
-             (onCompleteItem)="onCompleteItem($event)"
-             (onUploadError)="onUploadError()"></ds-uploader>
+             (onCompleteItemWithFile)="onCompleteItem($event)"
+             (onUploadError)="onUploadError($event)"></ds-uploader>
diff --git a/src/app/submission/form/submission-upload-files/submission-upload-files.component.spec.ts b/src/app/submission/form/submission-upload-files/submission-upload-files.component.spec.ts
index 72ae72b8462..15a3e6e5c1e 100644
--- a/src/app/submission/form/submission-upload-files/submission-upload-files.component.spec.ts
+++ b/src/app/submission/form/submission-upload-files/submission-upload-files.component.spec.ts
@@ -167,7 +167,10 @@ describe('SubmissionUploadFilesComponent Component', () => {
         const expectedErrors: any = mockUploadResponse1ParsedErrors;
         fixture.detectChanges();
 
-        comp.onCompleteItem(Object.assign({}, uploadRestResponse, { sections: mockSectionsData }));
+        comp.onCompleteItem({
+          response: Object.assign({}, uploadRestResponse, { sections: mockSectionsData }),
+          fileName: 'test.pdf',
+        });
 
         Object.keys(mockSectionsData).forEach((sectionId) => {
           expect(sectionsServiceStub.updateSectionData).toHaveBeenCalledWith(
@@ -183,15 +186,42 @@ describe('SubmissionUploadFilesComponent Component', () => {
 
       });
 
+      it('should include the file name in the success notification content', () => {
+        fixture.detectChanges();
+
+        comp.onCompleteItem({
+          response: Object.assign({}, uploadRestResponse, { sections: mockSectionsData }),
+          fileName: 'test.pdf',
+        });
+
+        expect(translateService.get).toHaveBeenCalledWith(
+          'submission.sections.upload.upload-successful-file',
+          { fileName: 'test.pdf' },
+        );
+      });
+
+      it('should fall back to the generic success key when no file name is available', () => {
+        fixture.detectChanges();
+
+        comp.onCompleteItem({
+          response: Object.assign({}, uploadRestResponse, { sections: mockSectionsData }),
+        });
+
+        expect(translateService.get).toHaveBeenCalledWith('submission.sections.upload.upload-successful');
+      });
+
       it('should show an error notification and call updateSectionData if unsuccessful', () => {
         const responseErrors = mockUploadResponse2Errors;
         const expectedErrors: any = mockUploadResponse2ParsedErrors;
         fixture.detectChanges();
 
-        comp.onCompleteItem(Object.assign({}, uploadRestResponse, {
-          sections: mockSectionsData,
-          errors: responseErrors.errors,
-        }));
+        comp.onCompleteItem({
+          response: Object.assign({}, uploadRestResponse, {
+            sections: mockSectionsData,
+            errors: responseErrors.errors,
+          }),
+          fileName: 'test.pdf',
+        });
 
         Object.keys(mockSectionsData).forEach((sectionId) => {
           expect(sectionsServiceStub.updateSectionData).toHaveBeenCalledWith(
@@ -207,6 +237,25 @@ describe('SubmissionUploadFilesComponent Component', () => {
 
       });
     });
+
+    describe('on upload error', () => {
+      it('should show an error notification including the file name when available', () => {
+        comp.onUploadError({ item: { file: { name: 'broken.zip' } } });
+
+        expect(notificationsServiceStub.error).toHaveBeenCalled();
+        expect(translateService.get).toHaveBeenCalledWith(
+          'submission.sections.upload.upload-failed-file',
+          { fileName: 'broken.zip' },
+        );
+      });
+
+      it('should fall back to the generic error key when no file name is available', () => {
+        comp.onUploadError();
+
+        expect(notificationsServiceStub.error).toHaveBeenCalled();
+        expect(translateService.get).toHaveBeenCalledWith('submission.sections.upload.upload-failed');
+      });
+    });
   });
 });
 
diff --git a/src/app/submission/form/submission-upload-files/submission-upload-files.component.ts b/src/app/submission/form/submission-upload-files/submission-upload-files.component.ts
index 3632ec6760d..510aaae1758 100644
--- a/src/app/submission/form/submission-upload-files/submission-upload-files.component.ts
+++ b/src/app/submission/form/submission-upload-files/submission-upload-files.component.ts
@@ -26,6 +26,8 @@ import {
 } from '../../../shared/empty.util';
 import { NotificationsService } from '../../../shared/notifications/notifications.service';
 import { UploaderComponent } from '../../../shared/upload/uploader/uploader.component';
+import { UploaderCompleteEvent } from '../../../shared/upload/uploader/uploader-complete-event.model';
+import { UploaderError } from '../../../shared/upload/uploader/uploader-error.model';
 import { UploaderOptions } from '../../../shared/upload/uploader/uploader-options.model';
 import { SectionsService } from '../../sections/sections.service';
 import { SectionsType } from '../../sections/sections-type';
@@ -133,10 +135,13 @@ export class SubmissionUploadFilesComponent implements OnChanges, OnDestroy {
   /**
    * Parse the submission object retrieved from REST after upload
    *
-   * @param workspaceitem
-   *    The submission object retrieved from REST
+   * @param event
+   *    The completed upload event, carrying the submission object retrieved from REST and the
+   *    client-side name of the file that completed
    */
-  public onCompleteItem(workspaceitem: WorkspaceItem) {
+  public onCompleteItem(event: UploaderCompleteEvent) {
+    const workspaceitem = event.response as WorkspaceItem;
+    const fileName = event.fileName;
     // Checks if upload section is enabled so do upload
     this.subs.push(
       this.uploadEnabled
@@ -159,9 +164,9 @@ export class SubmissionUploadFilesComponent implements OnChanges, OnDestroy {
                       if (isUpload) {
                         // Look for errors on upload
                         if ((isEmpty(sectionErrors))) {
-                          this.notificationsService.success(null, this.translate.get('submission.sections.upload.upload-successful'));
+                          this.notificationsService.success(null, this.getNotificationContent('upload-successful', fileName));
                         } else {
-                          this.notificationsService.error(null, this.translate.get('submission.sections.upload.upload-failed'));
+                          this.notificationsService.error(null, this.getNotificationContent('upload-failed', fileName));
                         }
                       }
                     });
@@ -176,9 +181,27 @@ export class SubmissionUploadFilesComponent implements OnChanges, OnDestroy {
 
   /**
    * Show error notification on upload fails
+   *
+   * @param error
+   *    The upload error, carrying the file that failed to upload (when available)
+   */
+  public onUploadError(error?: UploaderError) {
+    this.notificationsService.error(null, this.getNotificationContent('upload-failed', error?.item?.file?.name));
+  }
+
+  /**
+   * Build the translated notification content for an upload outcome, including the file name when
+   * available. Falls back to the generic (file-name-less) message when the file name is missing.
+   *
+   * @param suffix
+   *    The i18n key suffix under `submission.sections.upload.` (e.g. `upload-successful`)
+   * @param fileName
+   *    The name of the file the notification refers to, if known
    */
-  public onUploadError() {
-    this.notificationsService.error(null, this.translate.get('submission.sections.upload.upload-failed'));
+  private getNotificationContent(suffix: string, fileName?: string): Observable<string> {
+    return isNotEmpty(fileName)
+      ? this.translate.get(`submission.sections.upload.${suffix}-file`, { fileName })
+      : this.translate.get(`submission.sections.upload.${suffix}`);
   }
 
   /**
diff --git a/src/app/submission/objects/submission-objects.effects.spec.ts b/src/app/submission/objects/submission-objects.effects.spec.ts
index a16dc365f25..b72c1ffc6e3 100644
--- a/src/app/submission/objects/submission-objects.effects.spec.ts
+++ b/src/app/submission/objects/submission-objects.effects.spec.ts
@@ -30,6 +30,7 @@ import { SubmissionJsonPatchOperationsService } from '../../core/submission/subm
 import { SubmissionObjectDataService } from '../../core/submission/submission-object-data.service';
 import { WorkflowItemDataService } from '../../core/submission/workflowitem-data.service';
 import { WorkspaceitemDataService } from '../../core/submission/workspaceitem-data.service';
+import { DatashareUploadFromPathService } from '../../datashare/datashare-upload-from-path.service';
 import {
   mockSectionsData,
   mockSectionsDataTwo,
@@ -83,6 +84,7 @@ describe('SubmissionObjectEffects test suite', () => {
   let submissionJsonPatchOperationsServiceStub;
   let submissionObjectDataServiceStub;
   let workspaceItemDataService;
+  let uploadFromPathServiceStub;
 
   const collectionId: string = mockSubmissionCollectionId;
   const submissionId: string = mockSubmissionId;
@@ -104,6 +106,10 @@ describe('SubmissionObjectEffects test suite', () => {
       invalidateById: observableOf(true),
     });
 
+    uploadFromPathServiceStub = jasmine.createSpyObj('DatashareUploadFromPathService', {
+      isPendingForSubmission: observableOf(false),
+    });
+
     TestBed.configureTestingModule({
       imports: [
         StoreModule.forRoot({}, storeModuleConfig),
@@ -129,6 +135,7 @@ describe('SubmissionObjectEffects test suite', () => {
         { provide: HALEndpointService, useValue: {} },
         { provide: SubmissionObjectDataService, useValue: submissionObjectDataServiceStub },
         { provide: WorkspaceitemDataService, useValue: workspaceItemDataService },
+        { provide: DatashareUploadFromPathService, useValue: uploadFromPathServiceStub },
       ],
     });
 
@@ -1107,6 +1114,25 @@ describe('SubmissionObjectEffects test suite', () => {
         expect(notificationsServiceStub.error).toHaveBeenCalled();
       });
     });
+
+    it('should show the upload-from-path error when the failed save carried a pending path', () => {
+      const translate = TestBed.inject(TranslateService);
+      spyOn(translate, 'get').and.callThrough();
+      uploadFromPathServiceStub.isPendingForSubmission.and.returnValue(observableOf(true));
+      actions = hot('--a-', {
+        a: {
+          type: SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM_ERROR,
+          payload: {
+            submissionId: submissionId,
+          },
+        },
+      });
+
+      submissionObjectEffects.saveError$.subscribe(() => {
+        expect(notificationsServiceStub.error).toHaveBeenCalled();
+        expect(translate.get).toHaveBeenCalledWith('submission.general.info.upload-from-path-error');
+      });
+    });
   });
 
   describe('discardSubmission$', () => {
diff --git a/src/app/submission/objects/submission-objects.effects.ts b/src/app/submission/objects/submission-objects.effects.ts
index c0f0b321219..7e9b9ae3361 100644
--- a/src/app/submission/objects/submission-objects.effects.ts
+++ b/src/app/submission/objects/submission-objects.effects.ts
@@ -39,6 +39,8 @@ import { WorkspaceitemSectionsObject } from '../../core/submission/models/worksp
 import { SubmissionJsonPatchOperationsService } from '../../core/submission/submission-json-patch-operations.service';
 import { SubmissionObjectDataService } from '../../core/submission/submission-object-data.service';
 import { WorkspaceitemDataService } from '../../core/submission/workspaceitem-data.service';
+// DATASHARE - lets a failed save that carried a server-path ingest report an actionable error.
+import { DatashareUploadFromPathService } from '../../datashare/datashare-upload-from-path.service';
 import {
   isEmpty,
   isNotEmpty,
@@ -227,8 +229,19 @@ export class SubmissionObjectEffects {
    */
   saveError$ = createEffect(() => this.actions$.pipe(
     ofType(SubmissionObjectActionTypes.SAVE_SUBMISSION_FORM_ERROR, SubmissionObjectActionTypes.SAVE_SUBMISSION_SECTION_FORM_ERROR),
-    withLatestFrom(this.store$),
-    tap(() => this.notificationsService.error(null, this.translate.get('submission.sections.general.save_error_notice')))), { dispatch: false });
+    // DATASHARE - start
+    // A save carrying a server-path ingest can fail for a reason the generic notice cannot convey (bad
+    // path, URL, or outside the allowed dirs). The rolled-back operations still hold the value, so we can
+    // detect that case and show an actionable error; any other save error keeps the original notice.
+    switchMap((action: SaveSubmissionFormErrorAction | SaveSubmissionSectionFormErrorAction) =>
+      this.uploadFromPathService.isPendingForSubmission(action.payload.submissionId).pipe(
+        take(1),
+        tap((pendingPathIngest: boolean) => this.notificationsService.error(null, this.translate.get(
+          pendingPathIngest
+            ? 'submission.general.info.upload-from-path-error'
+            : 'submission.sections.general.save_error_notice'))))),
+    // DATASHARE - end
+  ), { dispatch: false });
 
   /**
    * Call parseSaveResponse and dispatch actions or dispatch [SaveSubmissionFormErrorAction] on error
@@ -371,6 +384,7 @@ export class SubmissionObjectEffects {
     private submissionObjectService: SubmissionObjectDataService,
     private translate: TranslateService,
     private workspaceItemDataService: WorkspaceitemDataService,
+    private uploadFromPathService: DatashareUploadFromPathService,
   ) {
   }
 
diff --git a/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.spec.ts b/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.spec.ts
index 015ccd4ae41..3d55784cd7b 100644
--- a/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.spec.ts
+++ b/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.spec.ts
@@ -28,16 +28,21 @@ import {
 import { provideMockStore } from '@ngrx/store/testing';
 import { TranslateModule } from '@ngx-translate/core';
 import { NgxMaskModule } from 'ngx-mask';
-import { of } from 'rxjs';
+import {
+  of,
+  throwError,
+} from 'rxjs';
 
 import {
   APP_CONFIG,
   APP_DATA_SERVICES_MAP,
 } from '../../../../../../config/app-config.interface';
 import { environment } from '../../../../../../environments/environment.test';
+import { AuthorizationDataService } from '../../../../../core/data/feature-authorization/authorization-data.service';
 import { JsonPatchOperationPathCombiner } from '../../../../../core/json-patch/builder/json-patch-operation-path-combiner';
 import { JsonPatchOperationsBuilder } from '../../../../../core/json-patch/builder/json-patch-operations-builder';
 import { SubmissionJsonPatchOperationsService } from '../../../../../core/submission/submission-json-patch-operations.service';
+import { SubmissionScopeType } from '../../../../../core/submission/submission-scope-type';
 import { XSRFService } from '../../../../../core/xsrf/xsrf.service';
 import { dateToISOFormat } from '../../../../../shared/date.util';
 import { DsDynamicTypeBindRelationService } from '../../../../../shared/form/builder/ds-dynamic-form-ui/ds-dynamic-type-bind-relation.service';
@@ -79,6 +84,10 @@ const jsonPatchOpBuilder: any = jasmine.createSpyObj('jsonPatchOpBuilder', {
   remove: jasmine.createSpy('remove'),
 });
 
+const authorizationServiceMock: any = jasmine.createSpyObj('authorizationService', {
+  isAuthorized: of(true),
+});
+
 const formMetadataMock = ['dc.title', 'dc.description'];
 
 const initialState: any = {
@@ -108,6 +117,7 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
   let operationsService: any;
   let formService: any;
   let uploadService: any;
+  let authorizationService: any;
 
   const submissionJsonPatchOperationsServiceStub = new SubmissionJsonPatchOperationsServiceStub();
   const submissionId = mockSubmissionId;
@@ -145,6 +155,7 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
         { provide: SubmissionService, useClass: SubmissionServiceStub },
         { provide: SubmissionJsonPatchOperationsService, useValue: submissionJsonPatchOperationsServiceStub },
         { provide: JsonPatchOperationsBuilder, useValue: jsonPatchOpBuilder },
+        { provide: AuthorizationDataService, useValue: authorizationServiceMock },
         { provide: SectionUploadService, useValue: getMockSectionUploadService() },
         provideMockStore({ initialState }),
         FormBuilderService,
@@ -204,6 +215,7 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
       operationsService = TestBed.inject(SubmissionJsonPatchOperationsService);
       formService = TestBed.inject(FormService);
       uploadService = TestBed.inject(SectionUploadService);
+      authorizationService = TestBed.inject(AuthorizationDataService);
 
       comp.submissionId = submissionId;
       comp.collectionId = collectionId;
@@ -215,6 +227,8 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
       comp.configMetadataForm = configMetadataForm;
       comp.formMetadata = formMetadataMock;
 
+      submissionServiceStub.getSubmissionScope.and.returnValue(SubmissionScopeType.WorkspaceItem);
+      authorizationService.isAuthorized.and.returnValue(of(true));
       formService.isValid.and.returnValue(of(true));
     });
 
@@ -227,6 +241,7 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
     it('should init form model properly', () => {
       comp.fileData = fileData;
       comp.formId = 'testFileForm';
+      comp.canEditAccessConditions = true;
       const maxStartDate = { year: 2022, month: 1, day: 12 };
       const maxEndDate = { year: 2019, month: 7, day: 12 };
 
@@ -267,6 +282,7 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
 
       comp.fileData = fileData;
       comp.formId = 'testFileForm';
+      comp.canEditAccessConditions = true;
 
       comp.formModel = compAsAny.buildFileEditForm();
 
@@ -300,11 +316,40 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
       expect(compAsAny.retrieveValueFromField(field)).toBe('test');
     });
 
+    it('should show access-condition form controls for admin users', () => {
+      comp.fileData = fileData;
+      comp.formId = 'testFileForm';
+      authorizationService.isAuthorized.and.returnValue(of(true));
+      // only the form model is under test — don't render the template
+      spyOn(compAsAny.cdr, 'detectChanges');
+
+      comp.ngOnInit();
+
+      expect(comp.canEditAccessConditions).toBeTrue();
+      expect(comp.formModel).toBeDefined();
+      expect(formbuilderService.findById('accessConditions', comp.formModel)).not.toBeNull();
+    });
+
+    it('should hide access-condition form controls for non-admin users', () => {
+      comp.fileData = fileData;
+      comp.formId = 'testFileForm';
+      authorizationService.isAuthorized.and.returnValue(of(false));
+      // only the form model is under test — don't render the template
+      spyOn(compAsAny.cdr, 'detectChanges');
+
+      comp.ngOnInit();
+
+      expect(comp.canEditAccessConditions).toBeFalse();
+      expect(comp.formModel).toBeDefined();
+      expect(formbuilderService.findById('accessConditions', comp.formModel)).toBeNull();
+    });
+
     it('should save Bitstream File data properly when form is valid', fakeAsync(() => {
       compAsAny.formRef = { formGroup: null };
       compAsAny.fileData = fileData;
       compAsAny.pathCombiner = pathCombiner;
       compAsAny.isPrimary = null;
+      comp.canEditAccessConditions = true;
       formService.validateAllFormFields.and.callFake(() => null);
       formService.isValid.and.returnValue(of(true));
       formService.getFormData.and.returnValue(of(mockFileFormData));
@@ -381,6 +426,56 @@ describe('SubmissionSectionUploadFileEditComponent test suite', () => {
       expect(uploadService.updateFileData).toHaveBeenCalled();
     }));
 
+    it('should not patch access conditions for non-admin users', fakeAsync(() => {
+      compAsAny.formRef = { formGroup: null };
+      compAsAny.fileData = fileData;
+      compAsAny.pathCombiner = pathCombiner;
+      compAsAny.canEditAccessConditions = false;
+
+      operationsBuilder.add.calls.reset();
+      formService.validateAllFormFields.and.callFake(() => null);
+      formService.isValid.and.returnValue(of(true));
+      formService.getFormData.and.returnValue(of(mockFileFormData));
+
+      const response = [
+        Object.assign(mockSubmissionObject, {
+          sections: {
+            upload: {
+              files: mockUploadFiles,
+            },
+          },
+        }),
+      ];
+      operationsService.jsonPatchByResourceID.and.returnValue(of(response));
+
+      comp.saveBitstreamData();
+      tick();
+
+      expect(operationsBuilder.add).not.toHaveBeenCalledWith(
+        pathCombiner.getPath(['files', fileIndex, 'accessConditions']),
+        jasmine.anything(),
+        true,
+      );
+    }));
+
+    it('should clear isSaving and keep the modal open when the patch request fails', fakeAsync(() => {
+      compAsAny.formRef = { formGroup: null };
+      compAsAny.fileData = fileData;
+      compAsAny.pathCombiner = pathCombiner;
+      spyOn(compAsAny.cdr, 'detectChanges');
+      const modalCloseSpy = spyOn(compAsAny.activeModal, 'close');
+      formService.validateAllFormFields.and.callFake(() => null);
+      formService.isValid.and.returnValue(of(true));
+      formService.getFormData.and.returnValue(of(mockFileFormData));
+      operationsService.jsonPatchByResourceID.and.returnValue(throwError(() => new Error('patch failed')));
+
+      comp.saveBitstreamData();
+      tick();
+
+      expect(compAsAny.isSaving).toBeFalse();
+      expect(modalCloseSpy).not.toHaveBeenCalled();
+    }));
+
     it('should not save Bitstream File data properly when form is not valid', fakeAsync(() => {
       compAsAny.formRef = { formGroup: null };
       compAsAny.pathCombiner = pathCombiner;
diff --git a/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.ts b/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.ts
index 79b3d3a5652..3d6bfc69ae9 100644
--- a/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.ts
+++ b/src/app/submission/sections/upload/file/edit/section-upload-file-edit.component.ts
@@ -34,8 +34,11 @@ import { DynamicCustomSwitchModel } from 'src/app/shared/form/builder/ds-dynamic
 
 import { AccessConditionOption } from '../../../../../core/config/models/config-access-condition-option.model';
 import { SubmissionFormsModel } from '../../../../../core/config/models/config-submission-forms.model';
+import { AuthorizationDataService } from '../../../../../core/data/feature-authorization/authorization-data.service';
+import { FeatureID } from '../../../../../core/data/feature-authorization/feature-id';
 import { JsonPatchOperationPathCombiner } from '../../../../../core/json-patch/builder/json-patch-operation-path-combiner';
 import { JsonPatchOperationsBuilder } from '../../../../../core/json-patch/builder/json-patch-operations-builder';
+import { SubmitDataResponseDefinitionObject } from '../../../../../core/shared/submit-data-response-definition.model';
 import { WorkspaceitemSectionUploadFileObject } from '../../../../../core/submission/models/workspaceitem-section-upload-file.model';
 import { SubmissionJsonPatchOperationsService } from '../../../../../core/submission/submission-json-patch-operations.service';
 import { BtnDisabledDirective } from '../../../../../shared/btn-disabled.directive';
@@ -186,6 +189,12 @@ implements OnInit, OnDestroy {
 
   protected subscriptions: Subscription[] = [];
 
+  /**
+   * Whether the current user may edit bitstream access conditions.
+   * Fail-closed: stays false until the site-administrator check resolves in ngOnInit.
+   */
+  public canEditAccessConditions = false;
+
   /**
    * Initialize instance variables
    *
@@ -201,6 +210,7 @@ implements OnInit, OnDestroy {
   constructor(
     protected activeModal: NgbActiveModal,
     private cdr: ChangeDetectorRef,
+    private authorizationService: AuthorizationDataService,
     private formBuilderService: FormBuilderService,
     private formService: FormService,
     private submissionService: SubmissionService,
@@ -294,8 +304,17 @@ implements OnInit, OnDestroy {
    */
   ngOnInit() {
     if (this.fileData && this.formId) {
-      this.formModel = this.buildFileEditForm();
-      this.cdr.detectChanges();
+      const initSubscription = this.authorizationService.isAuthorized(FeatureID.AdministratorOf).pipe(
+        take(1),
+      ).subscribe({
+        next: (canEdit: boolean) => {
+          this.canEditAccessConditions = canEdit;
+          this.formModel = this.buildFileEditForm();
+          this.cdr.detectChanges();
+        },
+      });
+
+      this.subscriptions.push(initSubscription);
     }
   }
 
@@ -337,7 +356,7 @@ implements OnInit, OnDestroy {
     const accessConditionsArrayConfig = Object.assign({}, BITSTREAM_ACCESS_CONDITIONS_FORM_ARRAY_CONFIG);
     const accessConditionTypeOptions = [];
 
-    if (this.collectionPolicyType === POLICY_DEFAULT_WITH_LIST) {
+    if (this.collectionPolicyType === POLICY_DEFAULT_WITH_LIST && this.canEditAccessConditions) {
       for (const accessCondition of this.availableAccessConditionOptions) {
         accessConditionTypeOptions.push(
           {
@@ -455,7 +474,7 @@ implements OnInit, OnDestroy {
             this.operationsBuilder.remove(this.pathCombiner.getPath([...pathFragment, path]));
           });
         const accessConditionsToSave = [];
-        if (formData.hasOwnProperty('accessConditions')) {
+        if (this.canEditAccessConditions && formData.hasOwnProperty('accessConditions')) {
           formData.accessConditions
             .filter((accessConditions) => isNotNull(accessConditions))
             .map((accessConditions) => accessConditions.accessConditionGroup)
@@ -517,22 +536,32 @@ implements OnInit, OnDestroy {
           this.pathCombiner.rootElement,
           this.pathCombiner.subRootElement);
       }),
-    ).subscribe((result: SubmissionObject[]) => {
-      const section = result[0].sections[this.sectionId];
-      if (!section) {
-        return;
-      }
-      const uploadSection = (section as WorkspaceitemSectionUploadObject);
-
-      this.uploadService.updateFilePrimaryBitstream(this.submissionId, this.sectionId, uploadSection.primary);
-
-      Object.keys(uploadSection.files)
-        .filter((key) => uploadSection.files[key].uuid === this.fileId)
-        .forEach((key) => this.uploadService.updateFileData(
-          this.submissionId, this.sectionId, this.fileId, uploadSection.files[key]),
-        );
-      this.isSaving = false;
-      this.activeModal.close();
+    ).subscribe({
+      next: (result: SubmitDataResponseDefinitionObject) => {
+        const submissionObject = result[0] as SubmissionObject;
+        const section = submissionObject?.sections?.[this.sectionId];
+        if (!section) {
+          this.isSaving = false;
+          this.cdr.detectChanges();
+          return;
+        }
+        const uploadSection = (section as WorkspaceitemSectionUploadObject);
+
+        this.uploadService.updateFilePrimaryBitstream(this.submissionId, this.sectionId, uploadSection.primary);
+
+        Object.keys(uploadSection.files)
+          .filter((key) => uploadSection.files[key].uuid === this.fileId)
+          .forEach((key) => this.uploadService.updateFileData(
+            this.submissionId, this.sectionId, this.fileId, uploadSection.files[key]),
+          );
+        this.isSaving = false;
+        this.activeModal.close();
+      },
+      error: () => {
+        // keep the modal usable when the PATCH request fails
+        this.isSaving = false;
+        this.cdr.detectChanges();
+      },
     });
     this.subscriptions.push(saveBitstreamDataSubscription);
   }
diff --git a/src/app/submission/sections/upload/section-upload.component.html b/src/app/submission/sections/upload/section-upload.component.html
index fb9cd39a941..6805b02e6c4 100644
--- a/src/app/submission/sections/upload/section-upload.component.html
+++ b/src/app/submission/sections/upload/section-upload.component.html
@@ -36,14 +36,6 @@
     </div>
   </div>
 
-  <div class="row" *ngIf="getDuplicateFileNames().length > 0">
-    <div class="col-md-12">
-      <p class="text-left">
-        <span class="text-danger font-weight-bold" [innerHTML]="'datashare.submission.sections.upload.duplicates' | translate"></span>
-        {{ getDuplicateFileNames().join(', ') }}
-      </p>
-    </div>
-  </div>
   <!-- <div class="row">
     <div class="col-md-2">
       <span class="text-left font-weight-bold">{{ 'bitstream.edit.form.primaryBitstream.label' | translate }}</span>
diff --git a/src/app/submission/sections/upload/section-upload.component.spec.ts b/src/app/submission/sections/upload/section-upload.component.spec.ts
index ba4a720092c..acb3dc81f59 100644
--- a/src/app/submission/sections/upload/section-upload.component.spec.ts
+++ b/src/app/submission/sections/upload/section-upload.component.spec.ts
@@ -3,7 +3,6 @@ import {
   ChangeDetectorRef,
   Component,
   NO_ERRORS_SCHEMA,
-  signal,
 } from '@angular/core';
 import {
   ComponentFixture,
@@ -55,20 +54,9 @@ import { SubmissionSectionUploadComponent } from './section-upload.component';
 import { SectionUploadService } from './section-upload.service';
 
 const mockDatashareSubmissionService = {
-  hasUploadFilesErrorsSignal: signal(false),
-  updatehasUploadFilesErrors: jasmine.createSpy('updatehasUploadFilesErrors'),
   calculateTotalUploadedFilesSize: jasmine.createSpy('calculateTotalUploadedFilesSize').and.returnValue(0),
   isTotalUploadedFilesSizeExceeded: jasmine.createSpy('isTotalUploadedFilesSizeExceeded').and.returnValue(false),
   formatBytes: jasmine.createSpy('formatBytes').and.returnValue('0 Bytes'),
-  getDuplicateFileNames: jasmine.createSpy('getDuplicateFileNames').and.returnValue([]),
-  createDuplicateFileNameDetector: jasmine.createSpy('createDuplicateFileNameDetector').and.returnValue({
-    fileNamesSignal: signal<string[]>([]),
-    hasUploadFilesErrorsSignal: signal(false),
-    updateFileNames: jasmine.createSpy('updateFileNames'),
-    getDuplicates: jasmine.createSpy('getDuplicates').and.returnValue([]),
-    getDuplicateFileNamesDisplay: jasmine.createSpy('getDuplicateFileNamesDisplay').and.returnValue(''),
-  }),
-  sendCannotSubmitNotification: jasmine.createSpy('sendCannotSubmitNotification'),
 };
 
 function getMockSubmissionUploadsConfigService(): SubmissionFormsConfigDataService {
diff --git a/src/app/submission/sections/upload/section-upload.component.ts b/src/app/submission/sections/upload/section-upload.component.ts
index dc7cfd724df..c0e57c997cc 100644
--- a/src/app/submission/sections/upload/section-upload.component.ts
+++ b/src/app/submission/sections/upload/section-upload.component.ts
@@ -154,12 +154,6 @@ export class SubmissionSectionUploadComponent extends SectionModelComponent {
   // DATASHARE - Start
   public totalUploadedFilesSize = 0;
   public isTotalUploadedFilesSizeExceeded = false;
-
-  // Duplicate file name detector from service
-  private duplicateDetector = this.datashareSubmissionService.createDuplicateFileNameDetector();
-  public fileNamesSignal = this.duplicateDetector.fileNamesSignal;
-  // Use the service signal instead
-  public hasUploadFilesErrorsSignal = this.duplicateDetector.hasUploadFilesErrorsSignal;
   // DATASHARE - End
 
 
@@ -262,15 +256,6 @@ export class SubmissionSectionUploadComponent extends SectionModelComponent {
         this.totalUploadedFilesSize = this.datashareSubmissionService.calculateTotalUploadedFilesSize(files);
         // Has the total uploaded files size exceeded the limit?
         this.isTotalUploadedFilesSizeExceeded = this.datashareSubmissionService.isTotalUploadedFilesSizeExceeded(this.totalUploadedFilesSize);
-
-        // Update the duplicate detector
-        this.duplicateDetector.updateFileNames(this.fileNames);
-
-        // IMPORTANT: Update the shared service signal
-        const hasDuplicates = this.datashareSubmissionService.getDuplicateFileNames(this.fileNames).length > 0;
-
-        // Update the service signal
-        this.datashareSubmissionService.updatehasUploadFilesErrors(!hasDuplicates || this.isTotalUploadedFilesSizeExceeded);
         // DATASHARE - end
         this.changeDetectorRef.detectChanges();
       }),
@@ -329,35 +314,6 @@ export class SubmissionSectionUploadComponent extends SectionModelComponent {
   formatBytes(bytes: number): string {
     return this.datashareSubmissionService.formatBytes(bytes);
   }
-
-  /**
-   * Get duplicate file names from the fileNames array
-   * @returns {string[]} Array of duplicate file names
-   */
-  getDuplicateFileNames(): string[] {
-    return this.duplicateDetector.getDuplicates();
-  }
-
-  /**
-   * Get duplicate file names as a formatted string
-   */
-  get duplicateFileNamesDisplay(): string {
-    return this.duplicateDetector.getDuplicateFileNamesDisplay();
-  }
-
-  /**
-   * Get duplicate file names from signal (using service)
-   */
-  private getDuplicateFileNamesFromSignal(): string[] {
-    return this.duplicateDetector.getDuplicates();
-  }
-
-  // Update wherever you currently update the duplicate detector
-  private updateDepositButtonState(): void {
-    const hasDuplicates = this.getDuplicateFileNames().length > 0;
-    this.isTotalUploadedFilesSizeExceeded = this.datashareSubmissionService.isTotalUploadedFilesSizeExceeded(this.totalUploadedFilesSize);
-    this.datashareSubmissionService.updatehasUploadFilesErrors(!hasDuplicates || this.isTotalUploadedFilesSizeExceeded);
-  }
   // DATASHARE - end
 
 }
diff --git a/src/assets/i18n/en.json5 b/src/assets/i18n/en.json5
index f93e14848f2..0816518b76b 100644
--- a/src/assets/i18n/en.json5
+++ b/src/assets/i18n/en.json5
@@ -772,9 +772,9 @@
 
   "admin.workflow.title": "Administer Workflow",
 
-  "admin.workflow.item.workflow": "Workflow",
+  "admin.workflow.item.workflow": "In review",
 
-  "admin.workflow.item.workspace": "Workspace",
+  "admin.workflow.item.workspace": "In draft",
 
   "admin.workflow.item.delete": "Delete",
 
@@ -2554,6 +2554,12 @@
 
   "item.edit.move.inheritpolicies.tooltip": "Warning: When enabled, the read access policy for the item and any files associated with the item will be replaced by the default read access policy of the collection. This cannot be undone.",
 
+  "item.edit.move.keepembargopolicies.checkbox": "Keep this item's current embargo",
+
+  "item.edit.move.keepembargopolicies.description": "The item keeps the embargo it already has (its files stay embargoed until their original lift date). Everything else is inherited from the destination collection.",
+
+  "item.edit.move.keepembargopolicies.tooltip": "This is about the embargo already on this item, not the destination collection's. When enabled, the item's existing embargo (and its original lift date) is preserved and only the non-embargo access is inherited. When disabled, the destination collection's default read access replaces it and the embargo is lifted immediately.",
+
   "item.edit.move.move": "Move",
 
   "item.edit.move.processing": "Moving...",
@@ -3470,7 +3476,7 @@
 
   "metadata-export-search.submit.error": "Starting the export has failed",
 
-  "mydspace.breadcrumbs": "Submissions",
+  "mydspace.breadcrumbs": "My submissions",
 
   "mydspace.description": "",
 
@@ -3526,9 +3532,9 @@
 
   "mydspace.search-form.placeholder": "Search in Submissions...",
 
-  "mydspace.show.workflow": "Workflow tasks",
+  "mydspace.show.workflow": "Submissions – in review",
 
-  "mydspace.show.workspace": "Submissions",
+  "mydspace.show.workspace": "My submissions",
 
   "mydspace.show.supervisedWorkspace": "Supervised items",
 
@@ -3536,15 +3542,15 @@
 
   "mydspace.status.mydspaceArchived": "Archived",
 
-  "mydspace.status.mydspaceValidation": "Validation",
+  "mydspace.status.mydspaceValidation": "For validation",
 
   "mydspace.status.mydspaceWaitingController": "Waiting for reviewer",
 
-  "mydspace.status.mydspaceWorkflow": "Workflow",
+  "mydspace.status.mydspaceWorkflow": "In review",
 
-  "mydspace.status.mydspaceWorkspace": "Workspace",
+  "mydspace.status.mydspaceWorkspace": "In draft",
 
-  "mydspace.title": "Submissions",
+  "mydspace.title": "My submissions",
 
   "mydspace.upload.upload-failed": "Error creating new workspace. Please verify the content uploaded before retry.",
 
@@ -3580,7 +3586,7 @@
 
   "nav.main.description": "Main navigation bar",
 
-  "nav.mydspace": "Submissions",
+  "nav.mydspace": "My submissions",
 
   "nav.profile": "Profile",
 
@@ -4664,13 +4670,26 @@
 
   "search.filters.namedresourcetype.Archived": "Archived",
 
-  "search.filters.namedresourcetype.Validation": "Validation",
+  "search.filters.namedresourcetype.Validation": "For validation",
 
   "search.filters.namedresourcetype.Waiting for Controller": "Waiting for reviewer",
 
-  "search.filters.namedresourcetype.Workflow": "Workflow",
+  "search.filters.namedresourcetype.Workflow": "In review",
+
+  "search.filters.namedresourcetype.Workspace": "In draft",
+
+  // dspace-api echoes the applied filter back lower-cased, and archived items
+  // come back as "item". Without these aliases the ticked checkbox and the
+  // applied-filter chip fall back to the raw token instead of a readable label.
+  "search.filters.namedresourcetype.item": "Archived",
 
-  "search.filters.namedresourcetype.Workspace": "Workspace",
+  "search.filters.namedresourcetype.validation": "For validation",
+
+  "search.filters.namedresourcetype.waitingforcontroller": "Waiting for reviewer",
+
+  "search.filters.namedresourcetype.workflow": "In review",
+
+  "search.filters.namedresourcetype.workspace": "In draft",
 
   "search.filters.withdrawn.true": "Yes",
 
@@ -4838,6 +4857,18 @@
 
   "submission.general.info.pending-changes": "Unsaved changes",
 
+  "submission.general.info.saving": "Saving...",
+
+  "submission.general.info.depositing": "Depositing...",
+
+  "submission.general.info.ingesting-from-path": "Ingesting file from server...",
+
+  "submission.general.info.ingesting-from-path-elapsed": "Elapsed: {{elapsed}}",
+
+  "submission.general.info.ingesting-from-path-hint": "The file is being read directly from the server. This can take several minutes for a large file, so please keep this tab open.",
+
+  "submission.general.info.upload-from-path-error": "The file could not be found at the path you entered.",
+
   "submission.general.save": "Save",
 
   "submission.general.save-later": "Save for later",
@@ -4864,7 +4895,7 @@
 
   "submission.import-external.page.hint": "Enter a query above to find items from the web to import in to DSpace.",
 
-  "submission.import-external.back-to-my-dspace": "Back to Submissions",
+  "submission.import-external.back-to-my-dspace": "Back to My submissions",
 
   "submission.import-external.search.placeholder": "Search the external source",
 
@@ -5438,8 +5469,12 @@
 
   "submission.sections.upload.upload-failed": "Upload failed",
 
+  "submission.sections.upload.upload-failed-file": "Upload failed for file \"{{fileName}}\"",
+
   "submission.sections.upload.upload-successful": "Upload successful",
 
+  "submission.sections.upload.upload-successful-file": "File \"{{fileName}}\" uploaded successfully",
+
   "submission.sections.accesses.form.discoverable-description": "When checked, this item will be discoverable in search/browse. When unchecked, the item will only be available via a direct link and will never appear in search/browse.",
 
   "submission.sections.accesses.form.discoverable-label": "Discoverable",
@@ -5740,13 +5775,13 @@
 
   "supervisedWorkspace.search.results.head": "Supervised Items",
 
-  "workspace.search.results.head": "Submissions",
+  "workspace.search.results.head": "My submissions",
 
   "workflowAdmin.search.results.head": "Administer Workflow",
 
-  "workflow.search.results.head": "Workflow tasks",
+  "workflow.search.results.head": "Submissions – in review",
 
-  "supervision.search.results.head": "Workflow and Workspace tasks",
+  "supervision.search.results.head": "Submissions in draft and in review",
 
   "workflow-item.edit.breadcrumbs": "Edit workflowitem",
 
@@ -7014,10 +7049,6 @@
 
   "datashare.submission.sections.upload.total_size": "Total Size of Uploaded Files:",
 
-  "datashare.submission.sections.upload.duplicates": "You have files with same name. Please rename or delete:",
-
-  "datashare.submission.sections.upload.submit.errors": "You have errors. Please fix them before submitting.",
-
   "item.page.filesection.cclicense.bundle": "CC-License bundle",
 
   "item.page.filesection.licences": "Licences",
diff --git a/src/index.html b/src/index.html
index 565fc0439d4..2b8c4f94cd2 100644
--- a/src/index.html
+++ b/src/index.html
@@ -7,10 +7,29 @@
   <title>DSpace</title>
   <meta name="viewport" content="width=device-width,minimum-scale=1">
   <meta http-equiv="cache-control" content="no-store">
+  <style>
+    /* Anti-flicker overlay: a detached clone of the settled page painted on top while Angular
+       re-renders underneath. See the bootstrap script in <body> for why it is needed. */
+    #__dspace_ssr_overlay {
+      position: fixed;
+      inset: 0;
+      z-index: 10000;
+      background: #fff;
+      overflow: hidden;
+      /* Never absorb input. `inert` stops the dead clone taking focus, but it does not let a click
+         through to the live app underneath - it swallows it, leaving the whole page unresponsive for
+         as long as the mask is up. The mask also lifts on the first interaction, so the user sees the
+         result of the click they just made rather than a frozen picture of the previous page. */
+      pointer-events: none;
+    }
+  </style>
 </head>
 
 <body>
   <ds-app></ds-app>
+<!-- ANTI_FLICKER_OVERLAY: the anti-flicker bootstrap (src/anti-flicker-overlay.js) is inlined here
+     as a synchronous <script> at build time by webpack/index-html-transform.ts. It must be inline and
+     run before the deferred module bundles, so it cannot live in the Angular app. See that file. -->
 </body>
 
 <!-- do not include client bundle, it is injected with Zone already loaded -->
diff --git a/src/styles/_custom_variables.scss b/src/styles/_custom_variables.scss
index 35f361e0f6d..cd2b144b10c 100644
--- a/src/styles/_custom_variables.scss
+++ b/src/styles/_custom_variables.scss
@@ -78,7 +78,7 @@
   --ds-edit-item-metadata-field-width: 190px;
   --ds-edit-item-language-field-width: 43px;
 
-  --ds-thumbnail-max-width: 125px;
+  --ds-thumbnail-max-width: 175px;
   --ds-thumbnail-placeholder-background: #{$gray-100};
   --ds-thumbnail-placeholder-border: 1px solid #{$gray-300};
   --ds-thumbnail-placeholder-color: #{lighten($gray-800, 7%)};
@@ -126,7 +126,7 @@
   --ds-dso-edit-actions-width: 173px;
   --ds-dso-edit-virtual-tooltip-min-width: 300px;
 
-  --ds-comcol-logo-max-width: 500px;
+  --ds-comcol-logo-max-width: 100%;
   --ds-comcol-logo-max-height: 500px;
 
   --ds-primary-bg: #{$ds-primary-bg};
diff --git a/src/styles/_global-styles.scss b/src/styles/_global-styles.scss
index 05d631e48ae..7f5da7fbdb8 100644
--- a/src/styles/_global-styles.scss
+++ b/src/styles/_global-styles.scss
@@ -1,6 +1,29 @@
 html {
     position: relative;
     min-height: 100%;
+
+    // Always reserve the vertical scrollbar's width. While Angular boots it replaces the
+    // server-rendered DOM, so the page is briefly too short to scroll: the scrollbar disappears and
+    // then comes back, widening and re-narrowing the viewport and sliding every centred container
+    // sideways by half the scrollbar width (~8px right, then back). The anti-flicker overlay cannot
+    // hide that, because the overlay lives in the page and shifts with it.
+    scrollbar-gutter: stable;
+}
+
+// scrollbar-gutter is unsupported before Chrome 94 / Firefox 97 / Safari 16; keeping the scrollbar
+// track permanently visible reserves the same width there.
+@supports not (scrollbar-gutter: stable) {
+    html {
+        overflow-y: scroll;
+    }
+}
+
+// ng-bootstrap pads the body by the scrollbar's width when a modal opens, to compensate for the
+// scrollbar it is about to hide. With the gutter reserved above, that width is never actually freed,
+// so the compensation is pure surplus and shifts the page left by half of it -- the very thing the
+// reserved gutter exists to prevent. Cancel it; the gutter already keeps the width steady.
+body.modal-open {
+    padding-right: 0 !important;
 }
 
 body {
diff --git a/src/themes/custom/app/root/root.component.ts b/src/themes/custom/app/root/root.component.ts
index 4894746e52d..2173592aa75 100644
--- a/src/themes/custom/app/root/root.component.ts
+++ b/src/themes/custom/app/root/root.component.ts
@@ -12,7 +12,6 @@ import { ThemedBreadcrumbsComponent } from '../../../../app/breadcrumbs/themed-b
 import { ThemedFooterComponent } from '../../../../app/footer/themed-footer.component';
 import { ThemedHeaderNavbarWrapperComponent } from '../../../../app/header-nav-wrapper/themed-header-navbar-wrapper.component';
 import { RootComponent as BaseComponent } from '../../../../app/root/root.component';
-import { slideSidebarPadding } from '../../../../app/shared/animations/slide';
 import { LiveRegionComponent } from '../../../../app/shared/live-region/live-region.component';
 import { ThemedLoadingComponent } from '../../../../app/shared/loading/themed-loading.component';
 import { NotificationsBoardComponent } from '../../../../app/shared/notifications/notifications-board/notifications-board.component';
@@ -24,7 +23,6 @@ import { SystemWideAlertBannerComponent } from '../../../../app/system-wide-aler
   styleUrls: ['../../../../app/root/root.component.scss'],
   // templateUrl: './root.component.html',
   templateUrl: '../../../../app/root/root.component.html',
-  animations: [slideSidebarPadding],
   standalone: true,
   imports: [
     TranslateModule,
diff --git a/src/themes/datashare/app/root/root.component.ts b/src/themes/datashare/app/root/root.component.ts
index 4894746e52d..2173592aa75 100644
--- a/src/themes/datashare/app/root/root.component.ts
+++ b/src/themes/datashare/app/root/root.component.ts
@@ -12,7 +12,6 @@ import { ThemedBreadcrumbsComponent } from '../../../../app/breadcrumbs/themed-b
 import { ThemedFooterComponent } from '../../../../app/footer/themed-footer.component';
 import { ThemedHeaderNavbarWrapperComponent } from '../../../../app/header-nav-wrapper/themed-header-navbar-wrapper.component';
 import { RootComponent as BaseComponent } from '../../../../app/root/root.component';
-import { slideSidebarPadding } from '../../../../app/shared/animations/slide';
 import { LiveRegionComponent } from '../../../../app/shared/live-region/live-region.component';
 import { ThemedLoadingComponent } from '../../../../app/shared/loading/themed-loading.component';
 import { NotificationsBoardComponent } from '../../../../app/shared/notifications/notifications-board/notifications-board.component';
@@ -24,7 +23,6 @@ import { SystemWideAlertBannerComponent } from '../../../../app/system-wide-aler
   styleUrls: ['../../../../app/root/root.component.scss'],
   // templateUrl: './root.component.html',
   templateUrl: '../../../../app/root/root.component.html',
-  animations: [slideSidebarPadding],
   standalone: true,
   imports: [
     TranslateModule,
diff --git a/src/themes/datashare/app/submission/form/submission-upload-files/submission-upload-files.component.html b/src/themes/datashare/app/submission/form/submission-upload-files/submission-upload-files.component.html
index 39b338bf410..6ede15875dc 100644
--- a/src/themes/datashare/app/submission/form/submission-upload-files/submission-upload-files.component.html
+++ b/src/themes/datashare/app/submission/form/submission-upload-files/submission-upload-files.component.html
@@ -9,6 +9,6 @@
              [enableDragOverDocument]="enableDragOverDocument"
              [onBeforeUpload]="onBeforeUpload"
              [uploadFilesOptions]="uploadFilesOptions"
-             (onCompleteItem)="onCompleteItem($event)"
-             (onUploadError)="onUploadError()"></ds-uploader>
+             (onCompleteItemWithFile)="onCompleteItem($event)"
+             (onUploadError)="onUploadError($event)"></ds-uploader>
 <!-- DATASHARE - end -->
\ No newline at end of file
diff --git a/src/themes/datashare/assets/i18n/en.json5 b/src/themes/datashare/assets/i18n/en.json5
index 352a523c738..b62fa8d43cb 100644
--- a/src/themes/datashare/assets/i18n/en.json5
+++ b/src/themes/datashare/assets/i18n/en.json5
@@ -5,19 +5,19 @@
 
   // DSpace default: "DSpace Angular :: "
   "repository.title.prefix": "Edinburgh DataShare :: ",
-  "mydspace.breadcrumbs": "Submissions",
+  "mydspace.breadcrumbs": "My submissions",
   "mydspace.search-form.placeholder": "Search in Submissions...",
-  "mydspace.title": "Submissions",
-  "nav.mydspace": "Submissions",
-  "submission.import-external.back-to-my-dspace": "Back to Submissions",
+  "mydspace.title": "My submissions",
+  "nav.mydspace": "My submissions",
+  "submission.import-external.back-to-my-dspace": "Back to My submissions",
 
   // DataShare customised
 
   "submission.sections.submit.progressbar.datashare.license": "End-user Licence",
   "submission.sections.submit.progressbar.license": "Depositor Agreement",
   "mydspace.results.head": "Submissions",
-  "mydspace.show.workspace": "Submissions",
-  "workspace.search.results.head": "Submissions",
+  "mydspace.show.workspace": "My submissions",
+  "workspace.search.results.head": "My submissions",
 
 
   "submission.sections.submit.datashare.dropzone": "TBD: INSTRUCTIONS FOR DROPZONE.",
@@ -29,8 +29,6 @@
   "datashare.submission.sections.upload.info": "If you wish to create a deposit of between 20 GB and 100 GB please contact the Research Data Service to arrange a batch import on <a href='mailto:data-support@64;ed.ac.uk'>data-support@ed.ac.uk</a>.",
   "datashare.submission.sections.upload.exceeded_size_limit": "You have exceeded the maximum upload size of 20 GB. Please delete some files to proceed to the next step.",
   "datashare.submission.sections.upload.total_size": "Total Size of Uploaded Files:",
-  "datashare.submission.sections.upload.duplicates": "You have files with same name. Please rename or delete:",
-  "datashare.submission.sections.upload.submit.errors": "You have errors. Please fix them before submitting.",
 
   "item.page.date.available": "Date Available",
   "item.page.type": "Type",
@@ -124,35 +122,40 @@
   "menu.section.browse_global_by_dateavailable": "By Available Date",
   "menu.section.browse_global_by_dateembargo": "By Embargo Date",
 
-  // Search filters re-named
+  // Submission status wording (LUC070-260).
+  // Supersedes the December 2025 scheme, which mapped workspace -> "In review"
+  // and workflow -> "Draft" (the wrong way round) and was reverted from
+  // src/assets/i18n/en.json5 in 457b86ac9 while staying behind here.
+
+  // Status facet values as Solr reports them.
   "search.filters.namedresourcetype.Archived": "Archived",
-  "search.filters.namedresourcetype.Validation": "Validation",
-  "search.filters.namedresourcetype.Waiting for Controller": "Pool",
-  "search.filters.namedresourcetype.Workflow": "Draft",
-  "search.filters.namedresourcetype.Workspace": "In review",
-
-  "admin.workflow.item.workspace": "In review",
-  "item.version.history.table.workspaceItem": "In review item",
-  "item.version.history.table.action.editWorkspaceItem": "Edit in review item",
-  "mydspace.show.supervisedWorkspace": "In review items",
-  "mydspace.status.mydspaceWorkspace": "In review",
-  "search.filters.namedresourcetype.Workspace": "In review",
-  "supervisedWorkspace.search.results.head": "In Review Items",
-  "supervision.search.results.head": "Draft and In Review tasks",
-  "workspace-item.view.breadcrumbs": "In Review View",
-  "workspace-item.view.title": "In Review View",
-  "workspace-item.delete.breadcrumbs": "In Review Delete",
-
-  "admin.workflow.breadcrumbs": "Administer Draft Items",
-  "admin.workflow.title": "Administer Draft Items",
-  "admin.workflow.item.workflow": "Draft",
-  "item.version.history.table.workflowItem": "Draft item",
-  "menu.section.workflow": "Administer Draft Items",
-  "mydspace.show.workflow": "Draft Items tasks",
-  "mydspace.status.mydspaceWorkflow": "Draft",
-  "search.filters.namedresourcetype.Workflow": "Draft",
-  "workflowAdmin.search.results.head": "Administer Draft Items",
-  "workflow.search.results.head": "Draft Items tasks",
+  "search.filters.namedresourcetype.Validation": "For validation",
+  "search.filters.namedresourcetype.Waiting for Controller": "Waiting for reviewer",
+  "search.filters.namedresourcetype.Workflow": "In review",
+  "search.filters.namedresourcetype.Workspace": "In draft",
+
+  // The same values keyed by the token dspace-api echoes back in appliedFilters:
+  // lower-cased, and "item" for archived. Without these the ticked checkbox and
+  // the applied-filter chip fall back to the raw token ("item", "waitingforcontroller").
+  "search.filters.namedresourcetype.item": "Archived",
+  "search.filters.namedresourcetype.validation": "For validation",
+  "search.filters.namedresourcetype.waitingforcontroller": "Waiting for reviewer",
+  "search.filters.namedresourcetype.workflow": "In review",
+  "search.filters.namedresourcetype.workspace": "In draft",
+
+  // "Show" dropdown option and the page heading beside it: two separate key families.
+  "mydspace.show.workflow": "Submissions – in review",
+  "workflow.search.results.head": "Submissions – in review",
+
+  // Coloured status badges on result cards.
+  "mydspace.status.mydspaceValidation": "For validation",
+  "mydspace.status.mydspaceWorkflow": "In review",
+  "mydspace.status.mydspaceWorkspace": "In draft",
+
+  // Administer Workflow carries its own badge and heading keys.
+  "admin.workflow.item.workflow": "In review",
+  "admin.workflow.item.workspace": "In draft",
+  "supervision.search.results.head": "Submissions in draft and in review",
 
 
   // Custom components
diff --git a/webpack/index-html-transform.ts b/webpack/index-html-transform.ts
new file mode 100644
index 00000000000..9b5cd0dfd29
--- /dev/null
+++ b/webpack/index-html-transform.ts
@@ -0,0 +1,44 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { minify } from 'terser';
+
+/**
+ * Build-time index.html transform (wired via `indexTransform` in angular.json).
+ *
+ * Inlines `src/anti-flicker-overlay.js` into index.html as a synchronous `<script>` at the
+ * ANTI_FLICKER_OVERLAY marker. The overlay has to run inline, before the deferred module bundles,
+ * so it cannot live inside the Angular app — but keeping its source in a real, lint-and-format-able
+ * file rather than pasted into index.html is the only reason this transform exists.
+ *
+ * The script is minified before it is inlined, so the served HTML carries a single compact line
+ * rather than the full readable source. The source file stays readable; the browser gets the minified
+ * form. Runtime behaviour is unchanged.
+ */
+
+const MARKER = /<!--\s*ANTI_FLICKER_OVERLAY:[\s\S]*?-->/;
+const OVERLAY_SRC = join(__dirname, '..', 'src', 'anti-flicker-overlay.js');
+const BANNER = '/* anti-flicker overlay - source: src/anti-flicker-overlay.js */';
+
+export default async function transformIndexHtml(_targetOptions: unknown, indexHtml: string): Promise<string> {
+  if (!MARKER.test(indexHtml)) {
+    throw new Error(
+      'index-html-transform: ANTI_FLICKER_OVERLAY marker not found in index.html — ' +
+      'the anti-flicker overlay would be missing from the build.',
+    );
+  }
+
+  const source = readFileSync(OVERLAY_SRC, 'utf8');
+  const result = await minify(source, {
+    ecma: 5,             // the overlay is ES5 and must stay ES5 (it runs before any polyfill)
+    compress: true,
+    mangle: true,
+    format: { comments: false, preamble: BANNER },
+  });
+  if (!result.code) {
+    throw new Error('index-html-transform: terser produced no output for the anti-flicker overlay.');
+  }
+
+  // Guard against a literal "</script>" in the minified output closing the tag early.
+  const safe = result.code.replace(/<\/script>/gi, '<\\/script>');
+  return indexHtml.replace(MARKER, `<script>${safe}</script>`);
+}