@@ -35,6 +35,10 @@ that object.
   `object_id` cannot be combined with `class_id` (relabel with the `PATCH` route below instead).
 - `POST /api/clips/{id}/mask` (the brush) takes the same required `object_id` and optional `class_id` and returns
   the object id it wrote to as `object_id`.
+- `POST /api/clips/{id}/frames/delete-range` and `POST /api/clips/{id}/frames/restore-range` take
+  `{"start", "end"}` (inclusive) and delete or restore every frame in that range (frames already in that state are
+  left alone; files are never removed) → 200 with the clip detail; 400 when `start > end` or a frame is outside the
+  clip; 404 for an unknown clip.
 - `POST /api/clips/{id}/propagate` and `POST /api/clips/{id}/clear-range` take an `objects` field: `"all"`
   (default) or a non-empty list of object ids. Propagate resolves and validates the objects up front, so an
   unknown id is a 404 and a listed object with no mask on `from_frame` is a 400, both before the job starts, not
 
@@ -70,7 +70,9 @@ with the mouse wheel. Clicking a lane (or its name) selects that class: its lowe
 starts a new object of it, same as the class select — clicking the class already active does nothing. Hovering a
 frame lists every class's state on it. The Propagate panel runs **All objects** (every object with a mask on the
 current frame; the others are named as skipped) or **Selected** only; lost objects are named one by one. Cleanup's
-"Clear masks" acts on the **Active object** (default) or **All objects**. `K`, `G` and "has a mask here" follow the
+"Clear masks" acts on the **Active object** (default) or **All objects**. With a range marked, Cleanup also offers
+**Delete frames** / **Restore frames** for the whole range (counting how many frames each would change); the mark
+stays afterwards, so the other button undoes it at once. `K`, `G` and "has a mask here" follow the
 active object's own lane, not its class's.
 
 ## Hiding confusing areas (regions)
 
@@ -437,3 +437,16 @@ def test_new_object_accept_with_an_unknown_class_writes_nothing(tmp_path):
         assert bad.status_code == 400
         after = client.get(f"/api/clips/{cid}").json()
         assert after["states"] == before["states"] and after["clip"]["objects"] == before["clip"]["objects"]
+
+
+def test_frame_range_delete_and_restore_routes(tmp_path):
+    with _client(tmp_path, FakeEngine()) as client:
+        cid = _clip(client, tmp_path, n=10)
+        r = client.post(f"/api/clips/{cid}/frames/delete-range", json={"start": 2, "end": 5})
+        assert r.status_code == 200 and r.json()["clip"]["deleted_frames"] == [2, 3, 4, 5]
+        assert r.json()["states"][3] == "deleted"
+        r = client.post(f"/api/clips/{cid}/frames/restore-range", json={"start": 4, "end": 9})
+        assert r.json()["clip"]["deleted_frames"] == [2, 3]
+        assert client.post(f"/api/clips/{cid}/frames/delete-range", json={"start": 5, "end": 2}).status_code == 400
+        assert client.post(f"/api/clips/{cid}/frames/delete-range", json={"start": 0, "end": 10}).status_code == 400
+        assert client.post("/api/clips/nope/frames/delete-range", json={"start": 0, "end": 1}).status_code == 404
@@ -2,7 +2,7 @@
 from conftest import OBJ
 from vdp.engine.fake import FakeEngine
 from vdp.labeling.errors import BadRequest
-from vdp.labeling.frames import clear_range, delete_frame, prune_from, restore_frame
+from vdp.labeling.frames import clear_range, delete_frame, prune_from, restore_frame, set_range_deleted
 from vdp.labeling.prompts import PromptSpec, accept
 from vdp.labeling.propagate import run_propagation
 from vdp.store import NotFound
@@ -29,6 +29,20 @@ def test_prune_from_marks_the_tail(store, make_clip):
     assert prune_from(store, clip.id, 3).deleted_frames == [0, 3, 4, 5]
 
 
+def test_range_delete_and_restore(store, make_clip):
+    _, clip = make_clip(n_frames=8)
+    delete_frame(store, clip.id, 1)
+    assert set_range_deleted(store, clip.id, 2, 4, True).deleted_frames == [1, 2, 3, 4]
+    assert set_range_deleted(store, clip.id, 0, 3, False).deleted_frames == [4]  # already-kept frames are fine
+    assert store.frame_path(clip.id, 3).is_file()
+    assert set_range_deleted(store, clip.id, 5, 5, True).deleted_frames == [4, 5]
+    with pytest.raises(BadRequest, match="after"):
+        set_range_deleted(store, clip.id, 4, 2, True)
+    with pytest.raises(BadRequest, match="out of range"):
+        set_range_deleted(store, clip.id, 6, 8, True)
+    assert store.read_clip(clip.id).deleted_frames == [4, 5]  # a refused request changes nothing
+
+
 def test_index_validation(store, make_clip):
     _, clip = make_clip(n_frames=6)
     for call in (
 
@@ -61,6 +61,11 @@ class RangeBody(BaseModel):
     objects: ObjectSelection = "all"
 
 
+class FrameRangeBody(BaseModel):
+    start: int = Field(ge=0)
+    end: int = Field(ge=0)
+
+
 class RelabelBody(BaseModel):
     class_id: int
 
@@ -138,6 +143,16 @@ def restore_frame(clip_id: str, idx: int, state: State) -> dict:
     return clip_detail(state, frame_ops.restore_frame(state.store, clip_id, idx))
 
 
+@router.post("/frames/delete-range")
+def delete_frames(clip_id: str, body: FrameRangeBody, state: State) -> dict:
+    return clip_detail(state, frame_ops.set_range_deleted(state.store, clip_id, body.start, body.end, True))
+
+
+@router.post("/frames/restore-range")
+def restore_frames(clip_id: str, body: FrameRangeBody, state: State) -> dict:
+    return clip_detail(state, frame_ops.set_range_deleted(state.store, clip_id, body.start, body.end, False))
+
+
 @router.post("/prune")
 def prune(clip_id: str, body: PruneBody, state: State) -> dict:
     return clip_detail(state, frame_ops.prune_from(state.store, clip_id, body.from_))
 
@@ -36,6 +36,13 @@ def restore_frame(store: ProjectStore, clip_id: str, idx: int) -> Clip:
     return _set_deleted(store, clip_id, range(idx, idx + 1), False)
 
 
+def set_range_deleted(store: ProjectStore, clip_id: str, start: int, end: int, deleted: bool) -> Clip:
+    """Delete (or restore) frames start..end, inclusive. Frames already in that state are left as they are."""
+    if start > end:
+        raise BadRequest(f"start {start} is after end {end}")
+    return _set_deleted(store, clip_id, range(start, end + 1), deleted)
+
+
 def prune_from(store: ProjectStore, clip_id: str, from_idx: int) -> Clip:
     clip = store.read_clip(clip_id)
     _check(clip, from_idx)
 
@@ -224,6 +224,11 @@ export const api = {
 
   deleteFrame: (clipId: string, idx: number) => request<ClipDetail>(`/api/clips/${clipId}/frames/${idx}/delete`, post()),
   restoreFrame: (clipId: string, idx: number) => request<ClipDetail>(`/api/clips/${clipId}/frames/${idx}/restore`, post()),
+  /** delete or restore frames start..end (inclusive); frames already in that state are left as they are */
+  deleteFrames: (clipId: string, start: number, end: number) =>
+    request<ClipDetail>(`/api/clips/${clipId}/frames/delete-range`, post({ start, end })),
+  restoreFrames: (clipId: string, start: number, end: number) =>
+    request<ClipDetail>(`/api/clips/${clipId}/frames/restore-range`, post({ start, end })),
   prune: (clipId: string, from: number) => request<ClipDetail>(`/api/clips/${clipId}/prune`, post({ from })),
   clearRange: (clipId: string, start: number, end: number, objects: ObjectSelection = "all") =>
     request<ClipDetail>(`/api/clips/${clipId}/clear-range`, post({ start, end, objects })),
 
@@ -11,7 +11,7 @@ type Props = ComponentProps<typeof CleanupPanel>;
 const props = (over: Partial<Props> = {}): Props => ({
   frame: 0, states: S("kmmde"), lanes: [S("kmmde")], scope: "active", activeLabel: "#1 cup", range: [0, 4],
   clearBlockedReason: null, lockReason: null, error: null, onScope: vi.fn(), onRange: vi.fn(), onToggleDelete: vi.fn(),
-  onPrune: vi.fn(), onClearRange: vi.fn(), ...over,
+  onPrune: vi.fn(), onClearRange: vi.fn(), onDeleteRange: vi.fn(), onRestoreRange: vi.fn(), ...over,
 });
 const group = () => within(screen.getByRole("group", { name: "Objects to clear" }));
 
@@ -37,4 +37,23 @@ describe("CleanupPanel", () => {
     expect((screen.getByRole("button", { name: "Clear masks in frames 0 to 4" }) as HTMLButtonElement).disabled).toBe(true);
     expect(screen.getByText("There is nothing to clear in frames 0 to 4.")).toBeTruthy();
   });
+  it("deletes or restores the whole marked range, counting what would change", () => {
+    const p = props({ range: [1, 4] }); // states k m m d e: frames 1..4 hold 3 kept frames and 1 deleted
+    render(<CleanupPanel {...p} />);
+    expect(screen.getByText("In frames 1 to 4: 3 frames to delete, 1 deleted frame to restore.")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Delete frames 1 to 4" }));
+    expect(p.onDeleteRange).toHaveBeenCalledWith(1, 4);
+    fireEvent.click(screen.getByRole("button", { name: "Restore frames 1 to 4" }));
+    expect(p.onRestoreRange).toHaveBeenCalledWith(1, 4);
+  });
+  it("disables what would change nothing, and hides the range buttons with no range marked", () => {
+    const { rerender } = render(<CleanupPanel {...props({ range: [1, 2] })} />);
+    expect((screen.getByRole("button", { name: "Restore frames 1 to 2" }) as HTMLButtonElement).disabled).toBe(true);
+    rerender(<CleanupPanel {...props({ range: [3, 3] })} />);
+    expect((screen.getByRole("button", { name: "Delete frame 3" }) as HTMLButtonElement).disabled).toBe(true);
+    expect((screen.getByRole("button", { name: "Restore frame 3" }) as HTMLButtonElement).disabled).toBe(false);
+    rerender(<CleanupPanel {...props({ range: null })} />);
+    expect(screen.queryByRole("button", { name: /^Delete frames? \d/ })).toBeNull();
+    expect(screen.getByRole("button", { name: "Delete frame" })).toBeTruthy(); // the single-frame toggle stays
+  });
 });
@@ -27,11 +27,14 @@ type Props = {
   onToggleDelete: () => void;
   onPrune: () => void;
   onClearRange: (start: number, end: number) => void;
+  /** delete / restore every frame of the marked range (shown only while a range is marked) */
+  onDeleteRange: (start: number, end: number) => void;
+  onRestoreRange: (start: number, end: number) => void;
 };
 
 export function CleanupPanel({
   frame, states, lanes, scope, activeLabel, onScope, range, clearBlockedReason, lockReason, error, onRange,
-  onToggleDelete, onPrune, onClearRange,
+  onToggleDelete, onPrune, onClearRange, onDeleteRange, onRestoreRange,
 }: Props) {
   const last = Math.max(0, states.length - 1);
   const clampIndex = (v: string) => Math.max(0, Math.min(last, Math.floor(Number(v)) || 0));
@@ -53,6 +56,10 @@ export function CleanupPanel({
     ...(keyframes > 0 ? [plural(keyframes, "keyframe", "keyframes")] : []),
     ...(deleted > 0 ? [`any mask under the ${plural(deleted, "deleted frame", "deleted frames")}`] : []),
   ];
+  // frames of the marked range that Delete / Restore would actually change
+  const inRange = valid ? states.slice(start, end + 1) : [];
+  const toRestore = inRange.filter((s) => s === "deleted").length;
+  const toDelete = inRange.length - toRestore;
   const outcome = !valid
     ? "The first frame must not come after the last."
     : parts.length === 0
@@ -71,8 +78,8 @@ export function CleanupPanel({
         </summary>
         <div className="mt-2 flex flex-col gap-2">
           <p className="note">
-            To clear masks from a stretch of frames, mark it first: hold <kbd>Shift</kbd> and drag along the timeline,
-            or press <kbd>[</kbd> and <kbd>]</kbd> on its first and last frame.
+            To clear masks from a stretch of frames, or delete or restore it, mark it first: hold <kbd>Shift</kbd> and
+            drag along the timeline, or press <kbd>[</kbd> and <kbd>]</kbd> on its first and last frame.
           </p>
           <div className="flex items-center gap-1">
             <input aria-label="Range start" type="number" min={0} max={last} className="field w-16" value={start}
@@ -99,6 +106,25 @@ export function CleanupPanel({
           </button>
           <p className="note">{lockReason ?? clearBlockedReason ?? outcome}</p>
 
+          {range !== null && (
+            <>
+              <div className="mt-1 flex gap-1">
+                <button type="button" className="btn flex-1" disabled={!valid || toDelete === 0 || lockReason !== null}
+                  onClick={() => onDeleteRange(start, end)}>
+                  Delete {where}
+                </button>
+                <button type="button" className="btn flex-1" disabled={!valid || toRestore === 0 || lockReason !== null}
+                  onClick={() => onRestoreRange(start, end)}>
+                  Restore {where}
+                </button>
+              </div>
+              <p className="note">
+                {!valid
+                  ? "The first frame must not come after the last."
+                  : `In ${where}: ${plural(toDelete, "frame", "frames")} to delete, ${plural(toRestore, "deleted frame", "deleted frames")} to restore.`}
+              </p>
+            </>
+          )}
           <div className="mt-1 flex gap-1">
             <button type="button" aria-keyshortcuts="Delete" className="btn flex-1" disabled={lockReason !== null} onClick={onToggleDelete}>
               {states[frame] === "deleted" ? "Restore frame" : "Delete frame"} <kbd aria-hidden>Del</kbd>
 
@@ -24,6 +24,8 @@ vi.mock("../api/rest", async (original) => ({
     deleteFrame: vi.fn(),
     restoreFrame: vi.fn(),
     prune: vi.fn(),
+    deleteFrames: vi.fn(),
+    restoreFrames: vi.fn(),
     clearRange: vi.fn(),
     getJob: vi.fn(),
     setMask: vi.fn(),
@@ -550,6 +552,19 @@ describe("Label page (propagation, cleanup, keyboard)", () => {
     fireEvent.click(screen.getByRole("button", { name: /Clear masks/ }));
     await waitFor(() => expect(api.clearRange).toHaveBeenCalledWith("c1", 5, 9, [1]));
   });
+
+  it("deletes and restores a marked range of frames, keeping the mark", async () => {
+    vi.mocked(api.getClip).mockResolvedValue(detail);
+    vi.mocked(api.deleteFrames).mockResolvedValue(detail);
+    vi.mocked(api.restoreFrames).mockResolvedValue(detail);
+    renderLabel();
+    await screen.findByText("bench.mp4");
+    fireEvent.change(screen.getByLabelText("Range start"), { target: { value: "5" } });
+    fireEvent.change(screen.getByLabelText("Range end"), { target: { value: "9" } });
+    fireEvent.click(screen.getByRole("button", { name: "Delete frames 5 to 9" }));
+    await waitFor(() => expect(api.deleteFrames).toHaveBeenCalledWith("c1", 5, 9));
+    expect((screen.getByLabelText("Range start") as HTMLInputElement).value).toBe("5"); // still marked
+  });
 });
 
 describe("Label page (brush)", () => {