@@ -954,3 +954,59 @@ describe("server facts", () => {
     expect(member.meta?.facts).toEqual(["30 fps"]);
   });
 });
+
+describe("locked regions", () => {
+  const fireReplaceInput = async (refs: HarnessRefs, file: File) => {
+    await act(async () =>
+      refs.api!.replaceInput.onChange({
+        target: { files: [file], value: "" } as unknown as HTMLInputElement,
+      }),
+    );
+  };
+
+  it("a locked region offers neither Replace nor Remove while its neighbour offers both", async () => {
+    const engine = new FakeEngine(() => undefined);
+    const { refs, Host } = makeHarness({
+      engine,
+      initialRegions: [{ ...region(70, 0), locked: true }, region(71, 1)],
+    });
+    render(<Host />);
+    await waitFor(() => expect(refs.api!.members).toHaveLength(2));
+    expect(refs.api!.members[0].state).toBe("uploaded");
+    expect(refs.api!.members[0].onReplace).toBeUndefined();
+    expect(refs.api!.members[0].onRemove).toBeUndefined();
+    expect(refs.api!.members[1].onReplace).toBeDefined();
+    expect(refs.api!.members[1].onRemove).toBeDefined();
+  });
+
+  it("a replace pick is ignored when the region was locked while the file dialog was open", async () => {
+    const engine = new FakeEngine(() => undefined);
+    const { refs, Host } = makeHarness({ engine, initialRegions: [region(70, 0)] });
+    render(<Host />);
+    await act(async () => refs.api!.members[0].onReplace!());
+    await act(async () => refs.setRegions!([{ ...region(70, 0), locked: true }]));
+    await fireReplaceInput(refs, pdf("new.pdf", 2222));
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(engine.rows).toHaveLength(0);
+    expect(refs.api!.members).toHaveLength(1);
+    expect(refs.regions[0]._submission!.upload_id).toBe(70);
+  });
+
+  it("a region locked while its replacement uploads keeps the original and drops the new file", async () => {
+    const engine = new FakeEngine(() => undefined);
+    const { refs, Host } = makeHarness({ engine, initialRegions: [region(70, 0)] });
+    render(<Host />);
+    await act(async () => refs.api!.members[0].onReplace!());
+    await fireReplaceInput(refs, pdf("new.pdf", 2222));
+    await waitFor(() => expect(engine.rows).toHaveLength(1));
+    await act(async () => refs.setRegions!([{ ...region(70, 0), locked: true }]));
+    await act(async () => engine.complete(engine.rows[0].clientRef, 99));
+    await waitFor(() => expect(engine.discarded).toContain(99));
+    expect(engine.discarded).not.toContain(70);
+    expect(refs.regions).toHaveLength(1);
+    expect(refs.regions[0]._submission!.upload_id).toBe(70);
+    expect(refs.api!.members).toHaveLength(1);
+    expect(refs.api!.members[0].state).toBe("uploaded");
+    expect(refs.api!.members[0].file.name).toBe("f70.pdf");
+  });
+});
@@ -485,6 +485,13 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
     () => (props.visibleRegions || []).filter((r) => r.type === "submission" && r._submission),
     [props.visibleRegions],
   );
+  // Upload completions read the lock state at that moment, not at pick time.
+  const regionsRef = useRef(regions);
+  regionsRef.current = regions;
+  const isRegionLocked = useCallback(
+    (regionId: string) => regionsRef.current.some((r) => r.id === regionId && r.locked === true),
+    [],
+  );
 
   const pdfjsLib = deps?.documentAI?.pdfjsLib;
   const memberPdf = useCallback(
@@ -689,12 +696,19 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
           ? pending.clientRef === row.clientRef
           : pending.name === row.filename && pending.size === row.size);
       if (pending && pendingMatches) {
+        replacePendingRef.current = null;
+        const engine = engineRef.current;
+        // The host rejects updates to a locked region, so the original stays
+        // and the replacement is dropped instead of lingering as an extra card.
+        if (isRegionLocked(pending.regionId)) {
+          removedUploadIds.current.add(String(row.uploadId));
+          if (engine) engine.discard(row.uploadId).catch(() => undefined);
+          return;
+        }
         // Swap in place: same slot, new file. The old upload is tombstoned so
         // recovery never resurrects it, and discarded best-effort - the server
         // refuses while an annotation or history revision still needs it.
-        replacePendingRef.current = null;
         removedUploadIds.current.add(String(pending.oldUploadId));
-        const engine = engineRef.current;
         if (engine && pending.oldUploadId) engine.discard(pending.oldUploadId).catch(() => undefined);
         if (pending.url && row.key) {
           previewCache(taskId)[row.key] = {
@@ -741,7 +755,7 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
         previewCache(taskId)[row.key] = { url: picked.url, kind: submissionMediaKind(row.filename, row.contentType) };
       }
     },
-    [visibleRegions, addRegion, updateRegion, taskId, bounds.max, rules],
+    [visibleRegions, addRegion, updateRegion, isRegionLocked, taskId, bounds.max, rules],
   );
 
   // Bind the in-flight replace to its engine row once, by clientRef. Name+size
@@ -955,6 +969,7 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
       replaceTargetRef.current = null;
       const engine = getEngine();
       if (!file || !target || !engine) return;
+      if (isRegionLocked(target.regionId)) return;
       validateAndHandle(file, (validFile, meta, url) => {
         const priorRefs = new Set((engine.rows || []).map((row) => row.clientRef));
         const pendingEntry = {
@@ -986,7 +1001,7 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
           });
       });
     },
-    [getEngine, validateAndHandle, startUpload, attachRow, taskId],
+    [getEngine, isRegionLocked, validateAndHandle, startUpload, attachRow, taskId],
   );
 
   const replaceInput = useMemo(
@@ -1074,6 +1089,7 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
 
   const storedMembers: CollectionMember[] = regions.map((region) => {
     const sub = region._submission!;
+    const locked = region.locked === true;
     const server = serverByUploadId[String(sub.upload_id)];
     const submitted =
       !!(server && server.referenced_by_annotation) ||
@@ -1147,22 +1163,23 @@ export function useCollectionSubmission(options: UseCollectionSubmissionOptions)
       submitted,
       storedHint: true,
       duplicate: (server && server.duplicate) || undefined,
-      onReplace: readonly
-        ? undefined
-        : () => {
-            replaceTargetRef.current = {
-              regionId: region.id,
-              index: sub.index || 0,
-              oldUploadId: sub.upload_id,
-              oldKey: sub.key,
-            };
-            replacePendingRef.current = null;
-            if (replaceInputElRef.current) replaceInputElRef.current.click();
-          },
+      onReplace:
+        readonly || locked
+          ? undefined
+          : () => {
+              replaceTargetRef.current = {
+                regionId: region.id,
+                index: sub.index || 0,
+                oldUploadId: sub.upload_id,
+                oldKey: sub.key,
+              };
+              replacePendingRef.current = null;
+              if (replaceInputElRef.current) replaceInputElRef.current.click();
+            },
       // Submitted members are Replace-only - except when the collection is
       // over the (lowered) capacity: trimming must stay possible, and the old
       // revision keeps its files regardless (removal lands on Update).
-      onRemove: readonly || (submitted && !capacityOver) ? undefined : () => removeRegion(region),
+      onRemove: readonly || locked || (submitted && !capacityOver) ? undefined : () => removeRegion(region),
       onRetryPreview: sub.key
         ? () =>
             setPreviewRetryNonce((prior) => ({ ...prior, [sub.key as string]: (prior[sub.key as string] || 0) + 1 }))