diff --git a/src/components/compress.tsx b/src/components/compress.tsx
index 2ca55f5..05327bf 100644
--- a/src/components/compress.tsx
+++ b/src/components/compress.tsx
@@ -185,7 +185,7 @@ export function CompressUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/decrypt.tsx b/src/components/decrypt.tsx
index 61f0c15..fcb1660 100644
--- a/src/components/decrypt.tsx
+++ b/src/components/decrypt.tsx
@@ -190,7 +190,7 @@ export function DecryptUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/delete.tsx b/src/components/delete.tsx
index fb9e479..457f24d 100644
--- a/src/components/delete.tsx
+++ b/src/components/delete.tsx
@@ -205,7 +205,7 @@ export function DeleteUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/images-to-pdf.tsx b/src/components/images-to-pdf.tsx
index 5aba572..d9a0b9d 100644
--- a/src/components/images-to-pdf.tsx
+++ b/src/components/images-to-pdf.tsx
@@ -200,7 +200,7 @@ export function ImagesToPDFUI() {
         />
         <Button
           label="Open Output"
-          color="#da7cff"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/merge.tsx b/src/components/merge.tsx
index b1e9655..f864190 100644
--- a/src/components/merge.tsx
+++ b/src/components/merge.tsx
@@ -140,7 +140,7 @@ export function MergeUI() {
         />
         <Button
           label="Open Output"
-          color="#da7cff"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/pdf-to-images.tsx b/src/components/pdf-to-images.tsx
index d045bcb..d67904c 100644
--- a/src/components/pdf-to-images.tsx
+++ b/src/components/pdf-to-images.tsx
@@ -243,7 +243,7 @@ export function PDFToImagesUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/protect.tsx b/src/components/protect.tsx
index aa49a39..7710fae 100644
--- a/src/components/protect.tsx
+++ b/src/components/protect.tsx
@@ -209,7 +209,7 @@ export function ProtectUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/rotate.tsx b/src/components/rotate.tsx
index 368437b..807d99f 100644
--- a/src/components/rotate.tsx
+++ b/src/components/rotate.tsx
@@ -277,7 +277,7 @@ export function RotateUI() {
         />
         <Button
           label="Open Output"
-          color="magenta"
+          color="output"
           onClick={() =>
             openOutputFolder().catch((_) =>
               fl.setStatus({ msg: "Failed to open folder", type: "error" }),
diff --git a/src/components/split-extract.tsx b/src/components/split-extract.tsx
new file mode 100644
index 0000000..18bb59f
--- /dev/null
+++ b/src/components/split-extract.tsx
@@ -0,0 +1,537 @@
+import { createSignal, Show, createEffect, onCleanup } from "solid-js";
+import { useTerminalDimensions } from "@opentui/solid";
+import { extractPDF, splitPDF } from "../tools/split-extract";
+import { getOutputDir, openOutputFolder } from "../utils/utils";
+import { useFileList } from "../hooks/useFileList";
+import { useKeyboardNav } from "../hooks/useKeyboardNav";
+import {
+  ToolContainer,
+  Label,
+  FileList,
+  ButtonRow,
+  Button,
+  StatusBar,
+  ToggleRow,
+  Toggle,
+  TextInput,
+} from "./ui";
+import { TextAttributes } from "@opentui/core";
+import { EmptyBorderChars } from "../constants/constants";
+import type { SplitMode, ExtractMode } from "../model";
+
+type ActionTypes = {
+      action: "split";
+      mode: SplitMode;
+      splitValue: number | number[];
+    } | {
+      action: "extract";
+      mode: ExtractMode;
+      splitValue: number | number[];
+  };
+
+export function SplitExtractUI() {
+  const fl = useFileList({ trackPageCount: true });
+  const nav = useKeyboardNav();
+  const [splitMode, setSplitMode] = createSignal<SplitMode>("at");
+  const [extractMode, setExtractMode] = createSignal<ExtractMode>("range");
+  const [splitPagesInput, setSplitPagesInput] = createSignal("");
+  const [splitEveryN, setSplitEveryN] = createSignal("");
+  const [extractRangeStart, setExtractRangeStart] = createSignal("");
+  const [extractRangeEnd, setExtractRangeEnd] = createSignal("");
+  const [extractEveryN, setExtractEveryN] = createSignal("");
+  const [focusedInput, setFocusedInput] = createSignal<string | null>(null);
+  const terminalDimensions = useTerminalDimensions();
+  const isCompact = () =>
+    terminalDimensions().height < 30 || terminalDimensions().width < 60;
+  const stackToolPanels = () => terminalDimensions().width < 100;
+  const stackRangeInputs = () => isCompact() || stackToolPanels();
+
+  const canSplit = () => fl.selectedFile() !== null && !fl.isProcessing();
+  const canExtract = () => fl.selectedFile() !== null && !fl.isProcessing();
+  const canClearAll = () => fl.fileCount() > 0;
+
+  const clearAll = () => {
+    fl.clearAll();
+    setSplitPagesInput("");
+    setSplitEveryN("");
+    setExtractRangeStart("");
+    setExtractRangeEnd("");
+    setExtractEveryN("");
+  };
+
+  const getRangeValue = () => {
+    const start = parseInt(extractRangeStart()) || 1;
+    const end = parseInt(extractRangeEnd()) || fl.pageCount();
+
+    if (start < 1 || end > fl.pageCount() || start > end) {
+      fl.setStatus({
+        msg: `Page range must be between 1 and ${fl.pageCount()}`,
+        type: "error",
+      });
+      return null;
+    }
+
+    return [start, end] as number[];
+  };
+
+  const getIntervalValue = (value: string, noun: string) => {
+    const interval = parseInt(value) || 0;
+
+    if (interval < 1) {
+      fl.setStatus({
+        msg: `${noun} must be at least 1`,
+        type: "error",
+      });
+      return null;
+    }
+
+    return interval;
+  };
+
+  const runAction = async ({ action, mode, splitValue }: ActionTypes) => {
+    const file = fl.selectedFile();
+    if (!file || fl.isProcessing()) return;
+
+    fl.setIsProcessing(true);
+    fl.setStatus({
+      msg: action === "split" ? "Splitting PDF..." : "Extracting pages...",
+      type: "info",
+    });
+
+    try {
+      const outputDir = await getOutputDir(action);
+
+      const res =
+        action === "split"
+          ? await splitPDF({
+              inputPath: file,
+              outputDir,
+              splitMode: mode,
+              splitValue,
+            })
+          : await extractPDF({
+              inputPath: file,
+              outputDir,
+              extractMode: mode,
+              extractValue: splitValue,
+            });
+
+      if (res.success) {
+        fl.setStatus({
+          msg:
+            action === "split"
+              ? `Created ${res.totalFiles} split file(s)`
+              : `Created ${res.totalFiles} extracted file(s)`,
+          type: "success",
+        });
+        await openOutputFolder(outputDir).catch((_) =>
+          fl.setStatus({ msg: "Failed to open folder", type: "error" }),
+        );
+      } else {
+        fl.setStatus({ msg: res.error || "Unknown error", type: "error" });
+      }
+    } catch (error) {
+      fl.setStatus({
+        msg: error instanceof Error ? error.message : "Unknown error",
+        type: "error",
+      });
+    } finally {
+      fl.setIsProcessing(false);
+    }
+  };
+
+  const handleSplit = async () => {
+    let splitValue: number | number[] | null = null;
+
+    if (splitMode() === "at") {
+      const splitPage = parseInt(splitPagesInput()) || 0;
+      if (splitPage < 1 || splitPage >= fl.pageCount()) {
+        fl.setStatus({
+          msg: `Split page must be between 1 and ${fl.pageCount() - 1}`,
+          type: "error",
+        });
+        return;
+      }
+      splitValue = splitPage;
+    } else {
+      splitValue = getIntervalValue(splitEveryN(), "Split interval");
+    }
+
+    if (splitValue === null) return;
+    await runAction({ action: "split", mode: splitMode(), splitValue });
+  };
+
+  const handleExtract = async () => {
+    let splitValue: number | number[] | null = null;
+
+    if (extractMode() === "range") {
+      splitValue = getRangeValue();
+    } else {
+      splitValue = getIntervalValue(extractEveryN(), "Extract interval");
+    }
+
+    if (splitValue === null) return;
+    await runAction({ action: "extract", mode: extractMode(), splitValue });
+  };
+
+  // Register keyboard navigation elements
+  createEffect(() => {
+    nav.clearElements();
+
+    // Register file list items and remove buttons
+    fl.files().forEach((_, index) => {
+      nav.registerElement({
+        id: `file-${index}`,
+        type: "list-item",
+        onEnter: () => fl.selectFile(index),
+      });
+
+      // Remove button
+      nav.registerElement({
+        id: `file-${index}-remove`,
+        type: "button",
+        onEnter: () => fl.removeFile(index),
+      });
+    });
+
+    // Register split controls
+    nav.registerElement({
+      id: "split-toggle-splitAt",
+      type: "toggle",
+      onEnter: () => setSplitMode("at"),
+    });
+    nav.registerElement({
+      id: "split-toggle-every",
+      type: "toggle",
+      onEnter: () => setSplitMode("every"),
+    });
+
+    // Register extract controls
+    nav.registerElement({
+      id: "extract-toggle-range",
+      type: "toggle",
+      onEnter: () => setExtractMode("range"),
+    });
+    nav.registerElement({
+      id: "extract-toggle-every",
+      type: "toggle",
+      onEnter: () => setExtractMode("every"),
+    });
+
+    // Register mode-specific inputs
+    if (splitMode() === "at") {
+      nav.registerElement({ id: "split-input-splitAt", type: "input" });
+    } else {
+      nav.registerElement({ id: "split-input-every", type: "input" });
+    }
+
+    if (extractMode() === "range") {
+      nav.registerElement({ id: "extract-input-rangeStart", type: "input" });
+      nav.registerElement({ id: "extract-input-rangeEnd", type: "input" });
+    } else {
+      nav.registerElement({ id: "extract-input-every", type: "input" });
+    }
+
+    // Register buttons
+    nav.registerElement({
+      id: "clear-all-btn",
+      type: "button",
+      onEnter: () => clearAll(),
+      canFocus: () => canClearAll(),
+    });
+    nav.registerElement({
+      id: "split-btn",
+      type: "button",
+      onEnter: () => handleSplit(),
+      canFocus: () => canSplit(),
+    });
+    nav.registerElement({
+      id: "extract-btn",
+      type: "button",
+      onEnter: () => handleExtract(),
+      canFocus: () => canExtract(),
+    });
+    nav.registerElement({
+      id: "open-output-btn",
+      type: "button",
+      onEnter: () =>
+        openOutputFolder().catch((_) =>
+          fl.setStatus({ msg: "Failed to open folder", type: "error" }),
+        ),
+    });
+  });
+
+  createEffect(() => {
+    nav.setIsInputMode(focusedInput() !== null);
+  });
+
+  // Sync back: reset focusedInput when nav exits input mode (Tab/Escape)
+  createEffect(() => {
+    if (!nav.isInputMode()) {
+      setFocusedInput(null);
+    }
+  });
+
+  onCleanup(() => {
+    nav.clearElements();
+  });
+
+  return (
+    <ToolContainer>
+      <Label text="Files" count={fl.fileCount()} />
+      <FileList
+        files={fl.files}
+        fileType="pdf"
+        selectedIndex={fl.selectedIndex}
+        onSelect={fl.selectFile}
+        onRemove={fl.removeFile}
+        onFilesSelected={async (paths) => {
+          await fl.addFilesToList(paths);
+        }}
+        focusedIndex={() => {
+          const focusId = nav.getFocusedId();
+          if (focusId && focusId.startsWith("file-")) {
+            const parts = focusId.split("-");
+            return parseInt(parts[1] || "0");
+          }
+          return null;
+        }}
+        focusedButton={() => nav.getFocusedId()}
+      />
+
+      <Show when={fl.selectedFile()}>
+        <box
+          border={["left"]}
+          borderColor="#3498db"
+          borderStyle="heavy"
+          backgroundColor="#1a2f3a"
+          paddingLeft={1}
+          paddingTop={1}
+          paddingBottom={1}
+          marginTop={1}
+          flexShrink={0}
+        >
+          <box flexDirection="row" columnGap={1}>
+            <text fg="#ecf0f1" content={"Selected:"} />
+            <text
+              fg="#3498db"
+              attributes={TextAttributes.BOLD}
+              content={fl.selectedFile() ?? ""}
+            />
+            <text fg="#95a5a6" content={`(${fl.pageCount()} pages)`} />
+          </box>
+        </box>
+      </Show>
+
+      <box
+        flexDirection={stackToolPanels() ? "column" : "row"}
+        columnGap={2}
+        rowGap={1}
+        marginTop={1}
+        marginBottom={1}
+        alignItems="stretch"
+        flexShrink={0}
+      >
+        <box
+          flexDirection="column"
+          rowGap={1}
+          flexShrink={0}
+          flexGrow={1}
+          width={stackToolPanels() ? "100%" : "50%"}
+          border={["left"]}
+          customBorderChars={{
+            ...EmptyBorderChars,
+            vertical: "▌",
+            bottomLeft: "╹",
+          }}
+          borderColor="#3498db"
+          borderStyle="heavy"
+          backgroundColor="#182127"
+          paddingLeft={1}
+          paddingRight={1}
+          paddingTop={1}
+          paddingBottom={1}
+        >
+          <Label text="Split" />
+          <text fg="#95a5a6" content="Break the PDF into multiple files." />
+          <ToggleRow>
+            <Toggle
+              label="Split At"
+              value="at"
+              selected={splitMode()}
+              onSelect={setSplitMode}
+              focused={nav.isFocused("split-toggle-splitAt")}
+            />
+            <Toggle
+              label="Every N Pages"
+              value="every"
+              selected={splitMode()}
+              onSelect={setSplitMode}
+              focused={nav.isFocused("split-toggle-every")}
+            />
+          </ToggleRow>
+
+          <Show when={splitMode() === "at"}>
+            <TextInput
+              label="Split after page:"
+              value={splitPagesInput}
+              onInput={setSplitPagesInput}
+              placeholder={fl.pageCount() > 1 ? `1-${fl.pageCount() - 1}` : "1"}
+              focused={
+                focusedInput() === "split-input-splitAt" ||
+                nav.isFocused("split-input-splitAt")
+              }
+              onFocus={() => setFocusedInput("split-input-splitAt")}
+            />
+          </Show>
+
+          <Show when={splitMode() === "every"}>
+            <TextInput
+              label="Split every N pages:"
+              value={splitEveryN}
+              onInput={setSplitEveryN}
+              placeholder="2"
+              focused={
+                focusedInput() === "split-input-every" ||
+                nav.isFocused("split-input-every")
+              }
+              onFocus={() => setFocusedInput("split-input-every")}
+            />
+          </Show>
+
+          <box marginTop={1}>
+            <Button
+              label={fl.isProcessing() ? "Splitting..." : "Split"}
+              color={canSplit() ? "cyan" : "gray"}
+              disabled={!canSplit()}
+              onClick={handleSplit}
+              focused={nav.isFocused("split-btn")}
+            />
+          </box>
+        </box>
+
+        <box
+          flexDirection="column"
+          rowGap={1}
+          flexShrink={0}
+          flexGrow={1}
+          width={stackToolPanels() ? "100%" : "50%"}
+          border={["left"]}
+          customBorderChars={{
+            ...EmptyBorderChars,
+            vertical: "▌",
+            bottomLeft: "╹",
+          }}
+          borderColor="#9b59b6"
+          borderStyle="heavy"
+          backgroundColor="#211c27"
+          marginRight={2}
+          paddingLeft={1}
+          // paddingRight={1}
+          paddingTop={1}
+          paddingBottom={1}
+        >
+          <Label text="Extract" />
+          <text fg="#b8a7c9" content="Copy selected pages into new files." />
+          <ToggleRow>
+            <Toggle
+              label="Range"
+              value="range"
+              selected={extractMode()}
+              onSelect={setExtractMode}
+              focused={nav.isFocused("extract-toggle-range")}
+            />
+            <Toggle
+              label="Every N Pages"
+              value="every"
+              selected={extractMode()}
+              onSelect={setExtractMode}
+              focused={nav.isFocused("extract-toggle-every")}
+            />
+          </ToggleRow>
+
+          <Show when={extractMode() === "range"}>
+            <box
+              flexDirection={stackRangeInputs() ? "column" : "row"}
+              columnGap={stackRangeInputs() ? 0 : 2}
+              rowGap={stackRangeInputs() ? 1 : 0}
+              marginTop={0}
+              flexShrink={0}
+            >
+              <TextInput
+                label="From Page:"
+                value={extractRangeStart}
+                onInput={setExtractRangeStart}
+                placeholder="1"
+                focused={
+                  focusedInput() === "extract-input-rangeStart" ||
+                  nav.isFocused("extract-input-rangeStart")
+                }
+                onFocus={() => setFocusedInput("extract-input-rangeStart")}
+                flexGrow={1}
+              />
+              <TextInput
+                label="To Page:"
+                value={extractRangeEnd}
+                onInput={setExtractRangeEnd}
+                placeholder={String(fl.pageCount() || "")}
+                focused={
+                  focusedInput() === "extract-input-rangeEnd" ||
+                  nav.isFocused("extract-input-rangeEnd")
+                }
+                onFocus={() => setFocusedInput("extract-input-rangeEnd")}
+                flexGrow={1}
+              />
+            </box>
+          </Show>
+
+          <Show when={extractMode() === "every"}>
+            <TextInput
+              label="Extract every N pages:"
+              value={extractEveryN}
+              onInput={setExtractEveryN}
+              placeholder="2"
+              focused={
+                focusedInput() === "extract-input-every" ||
+                nav.isFocused("extract-input-every")
+              }
+              onFocus={() => setFocusedInput("extract-input-every")}
+            />
+          </Show>
+
+          <box marginTop={1}>
+            <Button
+              label={fl.isProcessing() ? "Extracting..." : "Extract"}
+              color={canExtract() ? "magenta" : "gray"}
+              disabled={!canExtract()}
+              onClick={handleExtract}
+              focused={nav.isFocused("extract-btn")}
+            />
+          </box>
+        </box>
+      </box>
+
+      <ButtonRow>
+        <Button
+          label="Clear All"
+          color={canClearAll() ? "yellow" : "gray"}
+          disabled={!canClearAll()}
+          onClick={clearAll}
+          focused={nav.isFocused("clear-all-btn")}
+        />
+        <Button
+          label="Open Output"
+          color="output"
+          onClick={() =>
+            openOutputFolder().catch((_) =>
+              fl.setStatus({ msg: "Failed to open folder", type: "error" }),
+            )
+          }
+          focused={nav.isFocused("open-output-btn")}
+        />
+      </ButtonRow>
+
+      <StatusBar message={fl.status().msg} type={fl.status().type} />
+    </ToolContainer>
+  );
+}
diff --git a/src/components/split.tsx b/src/components/split.tsx
deleted file mode 100644
index 7bd4d5a..0000000
--- a/src/components/split.tsx
+++ /dev/null
@@ -1,337 +0,0 @@
-import { createSignal, Show, createEffect, onCleanup } from "solid-js";
-import { useTerminalDimensions } from "@opentui/solid";
-import { splitPDF } from "../tools/split";
-import { getOutputDir, openOutputFolder } from "../utils/utils";
-import { useFileList } from "../hooks/useFileList";
-import { useKeyboardNav } from "../hooks/useKeyboardNav";
-import {
-  ToolContainer,
-  Label,
-  FileList,
-  ButtonRow,
-  Button,
-  StatusBar,
-  ToggleRow,
-  Toggle,
-  TextInput,
-} from "./ui";
-import { TextAttributes } from "@opentui/core";
-
-type SplitMode = "splitAt" | "range" | "every";
-
-export function SplitUI() {
-  const fl = useFileList({ trackPageCount: true });
-  const nav = useKeyboardNav();
-  const [splitMode, setSplitMode] = createSignal<SplitMode>("splitAt");
-  const [pagesInput, setPagesInput] = createSignal("");
-  const [rangeStart, setRangeStart] = createSignal("");
-  const [rangeEnd, setRangeEnd] = createSignal("");
-  const [everyN, setEveryN] = createSignal("");
-  const [focusedInput, setFocusedInput] = createSignal<string | null>(null);
-  const terminalDimensions = useTerminalDimensions();
-  const isCompact = () => terminalDimensions().height < 30 || terminalDimensions().width < 60;
-
-  const canSplit = () => fl.selectedFile() !== null && !fl.isProcessing();
-  const canClearAll = () => fl.fileCount() > 0;
-
-  const clearAll = () => {
-    fl.clearAll();
-    setPagesInput("");
-    setRangeStart("");
-    setRangeEnd("");
-    setEveryN("");
-  };
-
-  const handleSplit = async () => {
-    const file = fl.selectedFile();
-    if (!file || fl.isProcessing()) return;
-
-    fl.setIsProcessing(true);
-    fl.setStatus({ msg: "Splitting PDF...", type: "info" });
-
-    try {
-      const outputDir = await getOutputDir("split");
-      let splitValue: number | number[];
-
-      switch (splitMode()) {
-        case "splitAt":
-          splitValue = parseInt(pagesInput()) || 0;
-          if (splitValue < 1 || splitValue >= fl.pageCount()) {
-            fl.setStatus({
-              msg: `Split page must be between 1 and ${fl.pageCount() - 1}`,
-              type: "error",
-            });
-            fl.setIsProcessing(false);
-            return;
-          }
-          break;
-        case "range":
-          const start = parseInt(rangeStart()) || 1;
-          const end = parseInt(rangeEnd()) || fl.pageCount();
-          splitValue = [start, end];
-          break;
-        case "every":
-          splitValue = parseInt(everyN()) || 1;
-          break;
-      }
-
-      const res = await splitPDF({
-        inputPath: file,
-        outputDir,
-        splitMode: splitMode(),
-        splitValue,
-      });
-
-      if (res.success) {
-        fl.setStatus({ msg: `Created ${res.totalFiles} file(s)`, type: "success" });
-        await openOutputFolder(outputDir).catch((_) =>
-          fl.setStatus({ msg: "Failed to open folder", type: "error" }),
-        );
-      } else {
-        fl.setStatus({ msg: res.error || "Unknown error", type: "error" });
-      }
-    } catch (error) {
-      fl.setStatus({
-        msg: error instanceof Error ? error.message : "Unknown error",
-        type: "error",
-      });
-    } finally {
-      fl.setIsProcessing(false);
-    }
-  };
-
-  // Register keyboard navigation elements
-  createEffect(() => {
-    nav.clearElements();
-
-    // Register file list items and remove buttons
-    fl.files().forEach((_, index) => {
-      nav.registerElement({
-        id: `file-${index}`,
-        type: "list-item",
-        onEnter: () => fl.selectFile(index),
-      });
-
-      // Remove button
-      nav.registerElement({
-        id: `file-${index}-remove`,
-        type: "button",
-        onEnter: () => fl.removeFile(index),
-      });
-    });
-
-    // Register mode toggles
-    nav.registerElement({
-      id: "toggle-splitAt",
-      type: "toggle",
-      onEnter: () => setSplitMode("splitAt"),
-    });
-    nav.registerElement({
-      id: "toggle-range",
-      type: "toggle",
-      onEnter: () => setSplitMode("range"),
-    });
-    nav.registerElement({
-      id: "toggle-every",
-      type: "toggle",
-      onEnter: () => setSplitMode("every"),
-    });
-
-    // Register mode-specific inputs
-    if (splitMode() === "splitAt") {
-      nav.registerElement({ id: "input-splitAt", type: "input" });
-    } else if (splitMode() === "range") {
-      nav.registerElement({ id: "input-rangeStart", type: "input" });
-      nav.registerElement({ id: "input-rangeEnd", type: "input" });
-    } else if (splitMode() === "every") {
-      nav.registerElement({ id: "input-every", type: "input" });
-    }
-
-    // Register buttons
-    nav.registerElement({
-      id: "clear-all-btn",
-      type: "button",
-      onEnter: () => clearAll(),
-      canFocus: () => canClearAll(),
-    });
-    nav.registerElement({
-      id: "split-btn",
-      type: "button",
-      onEnter: () => handleSplit(),
-      canFocus: () => canSplit(),
-    });
-    nav.registerElement({
-      id: "open-output-btn",
-      type: "button",
-      onEnter: () =>
-        openOutputFolder().catch((_) =>
-          fl.setStatus({ msg: "Failed to open folder", type: "error" }),
-        ),
-    });
-  });
-
-  createEffect(() => {
-    nav.setIsInputMode(focusedInput() !== null);
-  });
-
-  // Sync back: reset focusedInput when nav exits input mode (Tab/Escape)
-  createEffect(() => {
-    if (!nav.isInputMode()) {
-      setFocusedInput(null);
-    }
-  });
-
-  onCleanup(() => {
-    nav.clearElements();
-  });
-
-  return (
-    <ToolContainer>
-      <Label text="Files" count={fl.fileCount()} />
-      <FileList
-        files={fl.files}
-        fileType="pdf"
-        selectedIndex={fl.selectedIndex}
-        onSelect={fl.selectFile}
-        onRemove={fl.removeFile}
-        onFilesSelected={async (paths) => {
-          await fl.addFilesToList(paths);
-        }}
-        focusedIndex={() => {
-          const focusId = nav.getFocusedId();
-          if (focusId && focusId.startsWith("file-")) {
-            const parts = focusId.split("-");
-            return parseInt(parts[1] || "0");
-          }
-          return null;
-        }}
-        focusedButton={() => nav.getFocusedId()}
-      />
-
-      <Show when={fl.selectedFile()}>
-        <box
-          border={["left"]}
-          borderColor="#3498db"
-          borderStyle="heavy"
-          backgroundColor="#1a2f3a"
-          paddingLeft={1}
-          paddingTop={1}
-          paddingBottom={1}
-          marginTop={1}
-          flexShrink={0}
-        >
-          <box flexDirection="row" columnGap={1}>
-            <text fg="#ecf0f1" content={"Selected:"} />
-            <text fg="#3498db" attributes={TextAttributes.BOLD} content={fl.selectedFile() ?? ""} />
-            <text fg="#95a5a6" content={`(${fl.pageCount()} pages)`} />
-          </box>
-        </box>
-      </Show>
-
-      <Label text="Split Mode" />
-      <ToggleRow>
-        <Toggle
-          label="Split At"
-          value="splitAt"
-          selected={splitMode()}
-          onSelect={setSplitMode}
-          focused={nav.isFocused("toggle-splitAt")}
-        />
-        <Toggle
-          label="Range"
-          value="range"
-          selected={splitMode()}
-          onSelect={setSplitMode}
-          focused={nav.isFocused("toggle-range")}
-        />
-        <Toggle
-          label="Every N Pages"
-          value="every"
-          selected={splitMode()}
-          onSelect={setSplitMode}
-          focused={nav.isFocused("toggle-every")}
-        />
-      </ToggleRow>
-
-      <Show when={splitMode() === "splitAt"}>
-        <TextInput
-          label="Split after page:"
-          value={pagesInput}
-          onInput={setPagesInput}
-          placeholder={fl.pageCount() > 1 ? `1-${fl.pageCount() - 1}` : "1"}
-          focused={focusedInput() === "input-splitAt" || nav.isFocused("input-splitAt")}
-          onFocus={() => setFocusedInput("input-splitAt")}
-        />
-      </Show>
-
-      <Show when={splitMode() === "range"}>
-        <box
-          flexDirection={isCompact() ? "column" : "row"}
-          columnGap={isCompact() ? 0 : 2}
-          rowGap={isCompact() ? 1 : 0}
-          marginTop={0}
-          flexShrink={0}
-        >
-          <TextInput
-            label="From Page:"
-            value={rangeStart}
-            onInput={setRangeStart}
-            placeholder="1"
-            focused={focusedInput() === "input-rangeStart" || nav.isFocused("input-rangeStart")}
-            onFocus={() => setFocusedInput("input-rangeStart")}
-            flexGrow={1}
-          />
-          <TextInput
-            label="To Page:"
-            value={rangeEnd}
-            onInput={setRangeEnd}
-            placeholder={String(fl.pageCount() || "")}
-            focused={focusedInput() === "input-rangeEnd" || nav.isFocused("input-rangeEnd")}
-            onFocus={() => setFocusedInput("input-rangeEnd")}
-            flexGrow={1}
-          />
-        </box>
-      </Show>
-
-      <Show when={splitMode() === "every"}>
-        <TextInput
-          label="Split every N pages:"
-          value={everyN}
-          onInput={setEveryN}
-          placeholder="2"
-          focused={focusedInput() === "input-every" || nav.isFocused("input-every")}
-          onFocus={() => setFocusedInput("input-every")}
-        />
-      </Show>
-
-      <ButtonRow>
-        <Button
-          label="Clear All"
-          color={canClearAll() ? "yellow" : "gray"}
-          disabled={!canClearAll()}
-          onClick={clearAll}
-          focused={nav.isFocused("clear-all-btn")}
-        />
-        <Button
-          label={fl.isProcessing() ? "Splitting..." : "Split"}
-          color={canSplit() ? "cyan" : "gray"}
-          disabled={!canSplit()}
-          onClick={handleSplit}
-          focused={nav.isFocused("split-btn")}
-        />
-        <Button
-          label="Open Output"
-          color="magenta"
-          onClick={() =>
-            openOutputFolder().catch((_) =>
-              fl.setStatus({ msg: "Failed to open folder", type: "error" }),
-            )
-          }
-          focused={nav.isFocused("open-output-btn")}
-        />
-      </ButtonRow>
-
-      <StatusBar message={fl.status().msg} type={fl.status().type} />
-    </ToolContainer>
-  );
-}
diff --git a/src/components/ui.tsx b/src/components/ui.tsx
index d7d9000..a4b0702 100644
--- a/src/components/ui.tsx
+++ b/src/components/ui.tsx
@@ -1,10 +1,10 @@
 import { TextAttributes } from "@opentui/core";
 import { useTerminalDimensions } from "@opentui/solid";
-import { Show, Index, createSignal } from "solid-js";
+import { Show, Index, createSignal, createResource } from "solid-js";
 import type { JSX, Accessor, Setter } from "solid-js";
 import { EmptyBorderChars, STATUS_COLORS } from "../constants/constants";
 import type { StatusType } from "../model/models";
-import { handleFileExplorer } from "../utils/utils";
+import { getFormattedFileMetadata, handleFileExplorer } from "../utils/utils";
 
 // ============ Layout Components ============
 export function ToolContainer(props: { children: JSX.Element }) {
@@ -64,6 +64,8 @@ export function Button(props: ButtonProps) {
         return { bg: "#1e3a28", border: "#27ae60" };
       case "cyan":
         return { bg: "#1a2f3a", border: "#3498db" };
+      case "output":
+        return { bg: "#14353d", border: "#68ffc0" };
       case "yellow":
         return { bg: "#3a321a", border: "#f39c12" };
       case "magenta":
@@ -75,6 +77,12 @@ export function Button(props: ButtonProps) {
     }
   };
 
+  const getTextColor = () => {
+    if (props.disabled) return "#7f8c8d";
+    if (isHighlighted() || props.color === "output") return "#68ffc0";
+    return props.color;
+  };
+
   return (
     <box
       border={["bottom"]}
@@ -97,7 +105,7 @@ export function Button(props: ButtonProps) {
       onMouseOut={() => setHovered(false)}
     >
       <text
-        fg={props.disabled ? "#7f8c8d" : isHighlighted() ? "#68ffc0" : props.color}
+        fg={getTextColor()}
         attributes={TextAttributes.BOLD}
         content={props.label}
       />
@@ -251,6 +259,13 @@ export function FileList(props: FileListProps) {
             {(file, index) => {
               const isSelected = () => props.selectedIndex() === index;
               const isFocused = () => props.focusedIndex?.() === index;
+              const [metadata] = createResource(
+                () => file(),
+                (filePath) =>
+                  getFormattedFileMetadata(filePath, {
+                    includePageCount: props.fileType === "pdf",
+                  }),
+              );
               const [rowHovered, setRowHovered] = createSignal(false);
               const [upHovered, setUpHovered] = createSignal(false);
               const [downHovered, setDownHovered] = createSignal(false);
@@ -258,6 +273,29 @@ export function FileList(props: FileListProps) {
               const isRowHighlighted = () => isFocused() || rowHovered();
               const canMoveUp = () => index > 0;
               const canMoveDown = () => index < fileCount() - 1;
+              const metadataText = () => {
+                const currentMetadata = metadata();
+                if (!currentMetadata) {
+                  return "Loading metadata...";
+                }
+
+                const parts = [currentMetadata.size];
+
+                if (props.fileType === "pdf") {
+                  if (currentMetadata.pageCount === null) {
+                    parts.push("counting pages...");
+                  } else {
+                    const pageLabel = currentMetadata.pageCount === 1 ? "page" : "pages";
+                    parts.push(`${currentMetadata.pageCount} ${pageLabel}`);
+                  }
+                }
+
+                if (currentMetadata.modified) {
+                  parts.push(currentMetadata.modified);
+                }
+
+                return parts.join(" • ");
+              };
               const isUpHighlighted = () =>
                 canMoveUp() && (props.focusedButton?.() === `file-${index}-up` || upHovered());
               const isDownHighlighted = () =>
@@ -281,29 +319,51 @@ export function FileList(props: FileListProps) {
                   borderColor={isRowHighlighted() ? "#68ffc0" : "#3498db"}
                   customBorderChars={{
                     ...EmptyBorderChars,
-                    vertical: isRowHighlighted() ? "▐" : "┃",
+                    vertical: isRowHighlighted() ? "▍" : "┃",
                   }}
                 >
                   <text
-                    fg={isRowHighlighted() ? "#68ffc0" : isSelected() ? "cyan" : "yellow"}
+                    fg={
+                      isRowHighlighted()
+                        ? "#68ffc0"
+                        : isSelected()
+                          ? "cyan"
+                          : "yellow"
+                    }
                     minWidth={3}
                     content={`${index + 1}.`}
                   />
-                  <text
-                    fg={isRowHighlighted() ? "#ffffff" : "#ecf0f1"}
-                    flexGrow={1}
-                    flexShrink={1}
-                    content={String(file())}
-                    attributes={isRowHighlighted() ? TextAttributes.BOLD : undefined}
-                  />
+                  <box flexDirection="column" flexGrow={1} flexShrink={1} minWidth={0}>
+                    <text
+                      fg={isRowHighlighted() ? "#ffffff" : "#ecf0f1"}
+                      flexGrow={1}
+                      flexShrink={1}
+                      content={file()}
+                      attributes={
+                        isRowHighlighted() ? TextAttributes.BOLD : undefined
+                      }
+                    />
+                    <text
+                      fg={isRowHighlighted() ? "#9ed9bc" : "#7f8c8d"}
+                      flexGrow={1}
+                      flexShrink={1}
+                      content={metadataText()}
+                    />
+                  </box>
                   <box flexDirection="row" columnGap={1} flexShrink={0}>
                     <Show when={props.showReorder && props.onMove}>
                       <box
                         border={["bottom"]}
                         borderColor={
-                          isUpHighlighted() ? "#68ffc0" : canMoveUp() ? "#3498db" : "#34495e"
+                          isUpHighlighted()
+                            ? "#68ffc0"
+                            : canMoveUp()
+                              ? "#3498db"
+                              : "#34495e"
+                        }
+                        backgroundColor={
+                          isUpHighlighted() ? "#1a4a3a" : "#2c3e50"
                         }
-                        backgroundColor={isUpHighlighted() ? "#1a4a3a" : "#2c3e50"}
                         customBorderChars={{
                           ...EmptyBorderChars,
                           horizontal: isUpHighlighted() ? "▄" : "▂",
@@ -324,17 +384,31 @@ export function FileList(props: FileListProps) {
                         alignItems="center"
                       >
                         <text
-                          fg={isUpHighlighted() ? "#68ffc0" : canMoveUp() ? "#3498db" : "#7f8c8d"}
-                          attributes={isUpHighlighted() ? TextAttributes.BOLD : undefined}
+                          fg={
+                            isUpHighlighted()
+                              ? "#68ffc0"
+                              : canMoveUp()
+                                ? "#3498db"
+                                : "#7f8c8d"
+                          }
+                          attributes={
+                            isUpHighlighted() ? TextAttributes.BOLD : undefined
+                          }
                           content={"↑"}
                         />
                       </box>
                       <box
                         border={["bottom"]}
                         borderColor={
-                          isDownHighlighted() ? "#68ffc0" : canMoveDown() ? "#3498db" : "#34495e"
+                          isDownHighlighted()
+                            ? "#68ffc0"
+                            : canMoveDown()
+                              ? "#3498db"
+                              : "#34495e"
+                        }
+                        backgroundColor={
+                          isDownHighlighted() ? "#1a4a3a" : "#2c3e50"
                         }
-                        backgroundColor={isDownHighlighted() ? "#1a4a3a" : "#2c3e50"}
                         customBorderChars={{
                           ...EmptyBorderChars,
                           horizontal: isDownHighlighted() ? "▄" : "▂",
@@ -356,17 +430,29 @@ export function FileList(props: FileListProps) {
                       >
                         <text
                           fg={
-                            isDownHighlighted() ? "#68ffc0" : canMoveDown() ? "#3498db" : "#7f8c8d"
+                            isDownHighlighted()
+                              ? "#68ffc0"
+                              : canMoveDown()
+                                ? "#3498db"
+                                : "#7f8c8d"
+                          }
+                          attributes={
+                            isDownHighlighted()
+                              ? TextAttributes.BOLD
+                              : undefined
                           }
-                          attributes={isDownHighlighted() ? TextAttributes.BOLD : undefined}
                           content={"↓"}
                         />
                       </box>
                     </Show>
                     <box
                       border={["bottom"]}
-                      borderColor={isRemoveHighlighted() ? "#ff6b6b" : "#e74c3c"}
-                      backgroundColor={isRemoveHighlighted() ? "#5a1a1a" : "#3a1a1a"}
+                      borderColor={
+                        isRemoveHighlighted() ? "#ff6b6b" : "#e74c3c"
+                      }
+                      backgroundColor={
+                        isRemoveHighlighted() ? "#5a1a1a" : "#3a1a1a"
+                      }
                       customBorderChars={{
                         ...EmptyBorderChars,
                         horizontal: isRemoveHighlighted() ? "▄" : "▂",
diff --git a/src/constants/constants.ts b/src/constants/constants.ts
index 9b3402e..44f5b4d 100644
--- a/src/constants/constants.ts
+++ b/src/constants/constants.ts
@@ -6,7 +6,7 @@ export const OUTPUT_DIR = path.join(homedir(), "Documents", "PDFZen");
 
 export const toolsMenu = [
   { name: "Merge PDFs", command: "merge" },
-  { name: "Split PDF", command: "split" },
+  { name: "Split/Extract PDF", command: "splitExtract" },
   { name: "Compress PDF", command: "compress" },
   { name: "Rotate PDF", command: "rotate" },
   { name: "Delete Pages", command: "delete" },
diff --git a/src/index.tsx b/src/index.tsx
index 09942dd..1f98f0d 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -6,7 +6,7 @@ import { createSignal } from "solid-js";
 import { MergeUI } from "./components/merge";
 import { CompressUI } from "./components/compress";
 import { RotateUI } from "./components/rotate";
-import { SplitUI } from "./components/split";
+import { SplitExtractUI } from "./components/split-extract";
 import { DeleteUI } from "./components/delete";
 import { PDFToImagesUI } from "./components/pdf-to-images";
 import { ImagesToPDFUI } from "./components/images-to-pdf";
@@ -18,7 +18,7 @@ import Hero from "./components/hero";
 // Static tool component mapping - defined outside render for performance
 const toolComponents: Record<string, () => any> = {
   merge: MergeUI,
-  split: SplitUI,
+  splitExtract: SplitExtractUI,
   compress: CompressUI,
   rotate: RotateUI,
   delete: DeleteUI,
diff --git a/src/model/models.ts b/src/model/models.ts
index 91bd733..14a8dc4 100644
--- a/src/model/models.ts
+++ b/src/model/models.ts
@@ -1,7 +1,7 @@
 // ============ Shared Types ============
 export type StatusType = "info" | "error" | "success";
 
-export type FocusableElement = {
+export interface FocusableElement {
   id: string;
   type: "button" | "input" | "list-item" | "toggle" | "tool";
   onEnter?: () => void;
@@ -130,11 +130,15 @@ export interface RotatePDFOutput {
   error?: string;
 }
 
+export type SplitMode = "at" | "range" | "every";
+
+export type ExtractMode = "range" | "every";
+
 // Split
 export interface SplitPDFInput {
   inputPath: string;
   outputDir: string;
-  splitMode: "splitAt" | "range" | "every";
+  splitMode: SplitMode;
   // For 'splitAt' mode: 3 - split into pages 1-3 and pages 4-end
   // For 'range' mode: [1, 5] - extract pages 1-5
   // For 'every' mode: 2 - split every 2 pages
@@ -147,3 +151,18 @@ export interface SplitPDFOutput {
   error?: string;
   totalFiles?: number;
 }
+
+//Extract
+export interface ExtractPDFInput {
+  inputPath: string;
+  outputDir: string;
+  extractMode: ExtractMode;
+  extractValue: number | number[];
+}
+
+export interface ExtractPDFOutput {
+  success: boolean;
+  outputFiles?:string[];
+  error?:string;
+  totalFiles?:number
+}
diff --git a/src/tools/index.ts b/src/tools/index.ts
index 6b09498..b41bed0 100644
--- a/src/tools/index.ts
+++ b/src/tools/index.ts
@@ -1,6 +1,6 @@
 // Export all PDF tools for easy importing
 export * from "./merge";
-export * from "./split";
+export * from "./split-extract";
 export * from "./compress";
 export * from "./rotate";
 export * from "./delete";
diff --git a/src/tools/pdf-to-images.ts b/src/tools/pdf-to-images.ts
index 59c6d0d..551df9c 100644
--- a/src/tools/pdf-to-images.ts
+++ b/src/tools/pdf-to-images.ts
@@ -10,7 +10,6 @@ import type { PDFToImagesInput, PDFToImagesOutput } from "../model/models";
  */
 export async function pdfToImages(input: PDFToImagesInput): Promise<PDFToImagesOutput> {
   try {
-    // Ensure output directory exists
     await mkdir(input.outputDir, { recursive: true });
 
     const pdfBytes = await Bun.file(input.inputPath).arrayBuffer();
diff --git a/src/tools/split.ts b/src/tools/split-extract.ts
similarity index 57%
rename from src/tools/split.ts
rename to src/tools/split-extract.ts
index 5925f35..6595ba4 100644
--- a/src/tools/split.ts
+++ b/src/tools/split-extract.ts
@@ -1,7 +1,7 @@
 import { PDFDocument } from "pdf-lib";
 import { mkdir } from "fs/promises";
-import { join, basename } from "path";
-import type { SplitPDFInput, SplitPDFOutput } from "../model/models";
+import { basename, join } from "path";
+import type { ExtractPDFInput, ExtractPDFOutput, SplitPDFInput, SplitPDFOutput } from "../model/models";
 
 /**
  * Splits a PDF file into multiple files based on the specified mode
@@ -10,18 +10,12 @@ import type { SplitPDFInput, SplitPDFOutput } from "../model/models";
  */
 export async function splitPDF(input: SplitPDFInput): Promise<SplitPDFOutput> {
   try {
-    const pdfBytes = await Bun.file(input.inputPath).arrayBuffer();
-    const pdfDoc = await PDFDocument.load(pdfBytes);
-    const totalPages = pdfDoc.getPageCount();
     const outputFiles: string[] = [];
 
-    // Ensure output directory exists
-    await mkdir(input.outputDir, { recursive: true });
-
-    const baseName = basename(input.inputPath, ".pdf");
+    const {totalPages, baseName, pdfDoc} = await init(input);
 
     switch (input.splitMode) {
-      case "splitAt": {
+      case "at": {
         // Split at a specific page - creates 2 files
         const splitPage =
           typeof input.splitValue === "number" ? input.splitValue : (input.splitValue[0] ?? 1);
@@ -64,8 +58,8 @@ export async function splitPDF(input: SplitPDFInput): Promise<SplitPDFOutput> {
         break;
       }
 
+      // Split a range of pages
       case "range": {
-        // Extract a range of pages
         const range = Array.isArray(input.splitValue) ? input.splitValue : [1, input.splitValue];
         const startPage = Math.max(1, range[0] ?? 1);
         const endPage = Math.min(totalPages, range[1] ?? totalPages);
@@ -89,8 +83,8 @@ export async function splitPDF(input: SplitPDFInput): Promise<SplitPDFOutput> {
         break;
       }
 
+      // Split every N pages
       case "every": {
-        // Split every N pages
         const interval = typeof input.splitValue === "number" ? input.splitValue : 1;
         let fileIndex = 1;
 
@@ -124,3 +118,96 @@ export async function splitPDF(input: SplitPDFInput): Promise<SplitPDFOutput> {
     };
   }
 }
+
+export async function extractPDF(input: ExtractPDFInput): Promise<ExtractPDFOutput> {
+  try {
+    const outputFiles: string[] = [];
+
+    const { totalPages, baseName, pdfDoc } = await init(input);
+
+    switch (input.extractMode) {
+      // Extract every N pages from the PDF
+      case "every": {
+        const interval = typeof input.extractValue === "number" ? input.extractValue : 1;
+
+        for (let i = 0; i < totalPages; i += interval) {
+          const newPdf = await PDFDocument.create();
+          const endIdx = Math.min(totalPages, i + interval);
+
+          const pageIndices = Array.from({length: endIdx - i}, (_, idx) => i + idx);
+
+          const copiedPages = await newPdf.copyPages(pdfDoc, pageIndices);
+
+          copiedPages.forEach((page) => newPdf.addPage(page));
+
+          const outputPath = join(input.outputDir, `${baseName}_page_${i + 1}.pdf`);
+          const newPdfBytes = await newPdf.save();
+          await Bun.write(outputPath, newPdfBytes);
+          outputFiles.push(outputPath);
+        }
+        break;
+      }
+      
+      //Extract [i, j] range of pages from PDF
+      case "range": {
+
+        const range = Array.isArray(input.extractValue) ? input.extractValue : [1, input.extractValue];
+
+        const startPage = Math.max(1, range[0] ?? 1);
+        const endPage = Math.min(totalPages, range[1] ?? totalPages);
+
+        if (startPage > endPage) {
+          return {
+            success: false,
+            error: `Page range must be between 1 and ${totalPages}`,
+          };
+        }
+        
+        const pages = Array.from({length: endPage - startPage + 1}, (_, idx) => startPage + idx - 1);
+
+        const newPdf = await PDFDocument.create();
+
+        const copiedPages = await newPdf.copyPages(pdfDoc, pages);
+
+        copiedPages.forEach((page) => newPdf.addPage(page));
+        
+        const outputPath = join(input.outputDir, `${baseName}_pages_${startPage}-${endPage}.pdf`)
+
+        const newPdfBytes = await newPdf.save();
+
+        await Bun.write(outputPath, newPdfBytes);
+
+        outputFiles.push(outputPath);
+        break;
+      }
+    }
+
+    return {
+      success: true,
+      outputFiles,
+      totalFiles: outputFiles.length,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred",
+    };
+  }
+}
+
+const init = async (input: SplitPDFInput | ExtractPDFInput) => {
+  const pdfBytes = await Bun.file(input.inputPath).arrayBuffer();
+  const pdfDoc = await PDFDocument.load(pdfBytes);
+  const totalPages = pdfDoc.getPageCount();
+
+  // Ensure output directory exists
+  await mkdir(input.outputDir, { recursive: true });
+
+  const baseName = basename(input.inputPath, ".pdf");
+
+  return {
+    totalPages,
+    baseName,
+    pdfDoc
+  }
+}
\ No newline at end of file
diff --git a/src/utils/utils.ts b/src/utils/utils.ts
index f6d4c54..cdba329 100644
--- a/src/utils/utils.ts
+++ b/src/utils/utils.ts
@@ -24,6 +24,55 @@ export const chunkArray = (array: Array<any>, chunkSize: number) => {
   );
 };
 
+export const formatFileSize = (bytes: number) => {
+  const units = ["B", "KB", "MB", "GB"];
+  let size = bytes;
+  let unitIndex = 0;
+
+  while (size >= 1024 && unitIndex < units.length - 1) {
+    size /= 1024;
+    unitIndex++;
+  }
+
+  const decimals = unitIndex === 0 ? 0 : 1;
+  return `${size.toFixed(decimals)} ${units[unitIndex]}`;
+};
+
+export const formatModifiedLabel = (date: Date) => {
+  const now = new Date();
+  const isSameDay =
+    date.getFullYear() === now.getFullYear() &&
+    date.getMonth() === now.getMonth() &&
+    date.getDate() === now.getDate();
+
+  if (isSameDay) {
+    const timeLabel = date.toLocaleTimeString("en-US", {
+      hour: "numeric",
+      minute: "2-digit",
+    });
+    return `updated today ${timeLabel}`;
+  }
+
+  const dateLabel = date.toLocaleDateString("en-US", {
+    month: "short",
+    day: "numeric",
+  });
+
+  return `Updated ${dateLabel}`;
+};
+
+export const getFormattedFileMetadata = async (
+  filePath: string,
+  options: { includePageCount?: boolean } = {},
+) => {
+  const size = formatFileSize(Bun.file(filePath).size);
+  const fileStats = await stat(filePath).catch(() => null);
+  const modified = fileStats ? formatModifiedLabel(fileStats.mtime) : null;
+  const pageCount = options.includePageCount ? await getPageCount(filePath) : null;
+
+  return { size, modified, pageCount };
+};
+
 export const getOutputPath = async (prefix: string, inputFile?: string): Promise<string> => {
   await ensureOutputDir();
   const baseName = inputFile ? basename(inputFile, ".pdf") : "";
diff --git a/tests/components/split.spec.ts b/tests/components/split-extract.spec.ts
similarity index 54%
rename from tests/components/split.spec.ts
rename to tests/components/split-extract.spec.ts
index 13081f4..b28c2e5 100644
--- a/tests/components/split.spec.ts
+++ b/tests/components/split-extract.spec.ts
@@ -1,8 +1,8 @@
 import { describe, expect, it } from "bun:test";
 
-describe("split component wiring", () => {
+describe("split-extract component wiring", () => {
   it("has a matching source file", async () => {
-    const file = new URL("../../src/components/split.tsx", import.meta.url);
+    const file = new URL("../../src/components/split-extract.tsx", import.meta.url);
     expect(await Bun.file(file).exists()).toBe(true);
   });
 });
diff --git a/tests/tools/compress.branches.spec.ts b/tests/tools/compress.branches.spec.ts
deleted file mode 100644
index c39c045..0000000
--- a/tests/tools/compress.branches.spec.ts
+++ /dev/null
@@ -1,37 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { compressPDF, formatFileSize } from "../../src/tools/compress";
-
-describe("compress tool branch coverage", () => {
-  it("returns failure for non-existent input file", async () => {
-    const result = await compressPDF({
-      inputPath: "/tmp/does-not-exist.pdf",
-      outputPath: "/tmp/out.pdf",
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error?.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("handles unexpected thrown values in input access", async () => {
-    const result = await compressPDF({
-      get inputPath() {
-        throw new Error("bad-input-path");
-      },
-      outputPath: "/tmp/out.pdf",
-    } as unknown as Parameters<typeof compressPDF>[0]);
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("bad-input-path");
-    }
-  });
-
-  it("formats file sizes", () => {
-    expect(formatFileSize(512)).toBe("512.00 B");
-    expect(formatFileSize(1024)).toBe("1.00 KB");
-    expect(formatFileSize(1024 * 1024)).toBe("1.00 MB");
-    expect(formatFileSize(1024 * 1024 * 1024)).toBe("1.00 GB");
-  });
-});
diff --git a/tests/tools/compress.spec.ts b/tests/tools/compress.spec.ts
index eec59ba..02f1975 100644
--- a/tests/tools/compress.spec.ts
+++ b/tests/tools/compress.spec.ts
@@ -1,6 +1,68 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
+import { join } from "path";
+import {
+  cleanupTempDir,
+  createPdf,
+  createTempDir,
+  getPdfPageCount,
+  withMockedOpenDocument,
+} from "../utils/test-utils";
+
+let tempDir = "";
+
+afterEach(async () => {
+  if (tempDir) {
+    await cleanupTempDir(tempDir);
+    tempDir = "";
+  }
+});
 
 describe("compress tool", () => {
+  it("compresses a valid pdf and writes the output", async () => {
+    const { compressPDF } = await import("../../src/tools/compress");
+    tempDir = await createTempDir("pdfzen-compress-");
+
+    const input = join(tempDir, "input.pdf");
+    const output = join(tempDir, "compressed.pdf");
+    await createPdf(input, 2);
+
+    const result = await compressPDF({
+      inputPath: input,
+      outputPath: output,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.outputPath).toBe(output);
+      expect(result.originalSize).toBeGreaterThan(0);
+      expect(result.compressedSize).toBeGreaterThan(0);
+      expect(result.compressionRatio).toMatch(/^-?\d+\.\d{2}%$/);
+      expect(await getPdfPageCount(output)).toBe(2);
+    }
+  });
+
+  it("rejects inputs that cannot be treated as pdf documents", async () => {
+    const { compressPDF } = await import("../../src/tools/compress");
+    tempDir = await createTempDir("pdfzen-compress-invalid-doc-");
+
+    const input = join(tempDir, "input.pdf");
+    await createPdf(input, 1);
+
+    const result = await withMockedOpenDocument(
+      () => ({ asPDF: () => null }),
+      () =>
+        compressPDF({
+        inputPath: input,
+        outputPath: join(tempDir, "out.pdf"),
+        }),
+    );
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Not a valid PDF document");
+    }
+  });
+
   it("returns a failure for a missing input file", async () => {
     const { compressPDF } = await import("../../src/tools/compress");
 
diff --git a/tests/tools/delete.spec.ts b/tests/tools/delete.spec.ts
index 3de4390..c342917 100644
--- a/tests/tools/delete.spec.ts
+++ b/tests/tools/delete.spec.ts
@@ -104,6 +104,28 @@ describe("delete tool", () => {
     }
   });
 
+  it("deduplicates repeated pages before deleting", async () => {
+    const { deletePages } = await import("../../src/tools/delete");
+    tempDir = await createTempDir("pdfzen-delete-duplicates-");
+
+    const input = join(tempDir, "input.pdf");
+    const output = join(tempDir, "output.pdf");
+    await createPdf(input, 4);
+
+    const result = await deletePages({
+      inputPath: input,
+      outputPath: output,
+      pagesToDelete: [2, 2, 4],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.deletedPages).toBe(2);
+      expect(result.remainingPages).toBe(2);
+      expect(await getPdfPageCount(output)).toBe(2);
+    }
+  });
+
   it("returns failure when input PDF is missing", async () => {
     const { deletePages } = await import("../../src/tools/delete");
     tempDir = await createTempDir("pdfzen-delete-missing-");
@@ -116,4 +138,21 @@ describe("delete tool", () => {
 
     expect(result.success).toBe(false);
   });
+
+  it("returns an unknown error when a non-Error value is thrown", async () => {
+    const { deletePages } = await import("../../src/tools/delete");
+
+    const result = await deletePages({
+      get inputPath() {
+        throw "bad-input-path";
+      },
+      outputPath: "/tmp/output.pdf",
+      pagesToDelete: [1],
+    } as unknown as Parameters<typeof deletePages>[0]);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Unknown error occurred");
+    }
+  });
 });
diff --git a/tests/tools/images-to-pdf.branches.spec.ts b/tests/tools/images-to-pdf.branches.spec.ts
deleted file mode 100644
index 6dd9c40..0000000
--- a/tests/tools/images-to-pdf.branches.spec.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { imagesToPDF, filterValidImages } from "../../src/tools/images-to-pdf";
-
-describe("images-to-pdf tool branch coverage", () => {
-  it("rejects empty input paths", async () => {
-    const result = await imagesToPDF({
-      inputPaths: [],
-      outputPath: "/tmp/out.pdf",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("No images provided");
-  });
-
-  it("rejects all-invalid image paths", async () => {
-    const result = await imagesToPDF({
-      inputPaths: ["one.gif", "two.bmp"],
-      outputPath: "/tmp/out.pdf",
-    });
-    expect(result.success).toBe(false);
-    expect(result.error).toBe("No valid images provided");
-  });
-
-  it("returns failure when valid image paths do not exist", async () => {
-    const result = await imagesToPDF({
-      inputPaths: ["/tmp/nope.jpg"],
-      outputPath: "/tmp/out.pdf",
-      pageSize: "fit",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("filters supported image extensions", () => {
-    const result = filterValidImages(["one.png", "two.jpg", "three.jpeg", "four.gif", "five.pdf"]);
-    expect(result).toEqual(["one.png", "two.jpg", "three.jpeg"]);
-  });
-});
diff --git a/tests/tools/images-to-pdf.spec.ts b/tests/tools/images-to-pdf.spec.ts
index ef5291d..303ab31 100644
--- a/tests/tools/images-to-pdf.spec.ts
+++ b/tests/tools/images-to-pdf.spec.ts
@@ -1,6 +1,85 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
+import { PDFDocument } from "pdf-lib";
+import { join } from "path";
+import { cleanupTempDir, createJpg, createPng, createTempDir, getPdfPageCount } from "../utils/test-utils";
+
+let tempDir = "";
+
+afterEach(async () => {
+  if (tempDir) {
+    await cleanupTempDir(tempDir);
+    tempDir = "";
+  }
+});
+
+const getFirstPageSize = async (pdfPath: string) => {
+  const pdfBytes = await Bun.file(pdfPath).arrayBuffer();
+  const pdfDoc = await PDFDocument.load(pdfBytes);
+  const page = pdfDoc.getPage(0);
+
+  return {
+    width: page.getWidth(),
+    height: page.getHeight(),
+  };
+};
 
 describe("images-to-pdf tool", () => {
+  it("converts png and jpg images into a single pdf", async () => {
+    const { imagesToPDF } = await import("../../src/tools/images-to-pdf");
+    tempDir = await createTempDir("pdfzen-images-to-pdf-");
+
+    const pngPath = join(tempDir, "pixel.png");
+    const jpgPath = join(tempDir, "pixel.jpg");
+    const output = join(tempDir, "images.pdf");
+
+    await createPng(pngPath);
+    await createJpg(jpgPath);
+
+    const result = await imagesToPDF({
+      inputPaths: [pngPath, jpgPath],
+      outputPath: output,
+      pageSize: "fit",
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalPages).toBe(2);
+      expect(await getPdfPageCount(output)).toBe(2);
+    }
+  });
+
+  it("supports a4 and letter output sizes", async () => {
+    const { imagesToPDF } = await import("../../src/tools/images-to-pdf");
+    tempDir = await createTempDir("pdfzen-images-to-pdf-page-sizes-");
+
+    const pngPath = join(tempDir, "pixel.png");
+    const a4Output = join(tempDir, "a4.pdf");
+    const letterOutput = join(tempDir, "letter.pdf");
+    await createPng(pngPath);
+
+    const a4Result = await imagesToPDF({
+      inputPaths: [pngPath],
+      outputPath: a4Output,
+      pageSize: "a4",
+    });
+    const letterResult = await imagesToPDF({
+      inputPaths: [pngPath],
+      outputPath: letterOutput,
+      pageSize: "letter",
+    });
+
+    expect(a4Result.success).toBe(true);
+    expect(letterResult.success).toBe(true);
+
+    const a4Page = await getFirstPageSize(a4Output);
+    const letterPage = await getFirstPageSize(letterOutput);
+
+    expect(Math.round(a4Page.width)).toBe(595);
+    expect(Math.round(a4Page.height)).toBe(842);
+    expect(Math.round(letterPage.width)).toBe(612);
+    expect(Math.round(letterPage.height)).toBe(792);
+  });
+
   it("filters supported image extensions", async () => {
     const { filterValidImages } = await import("../../src/tools/images-to-pdf");
 
@@ -15,20 +94,32 @@ describe("images-to-pdf tool", () => {
     expect(result).toEqual(["ONE.PNG", "TWO.JPEG"]);
   });
 
-  it("validates missing and unsupported inputs before conversion", async () => {
+  it("rejects empty input paths", async () => {
     const { imagesToPDF } = await import("../../src/tools/images-to-pdf");
 
-    const empty = await imagesToPDF({
+    const result = await imagesToPDF({
       inputPaths: [],
       outputPath: "/tmp/out.pdf",
     });
-    expect(empty.success).toBe(false);
 
-    const invalid = await imagesToPDF({
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("No images provided");
+    }
+  });
+
+  it("rejects unsupported input paths", async () => {
+    const { imagesToPDF } = await import("../../src/tools/images-to-pdf");
+
+    const result = await imagesToPDF({
       inputPaths: ["one.gif", "two.bmp"],
       outputPath: "/tmp/out.pdf",
     });
-    expect(invalid.success).toBe(false);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("No valid images provided");
+    }
   });
 
   it("returns failure when valid image paths do not exist", async () => {
diff --git a/tests/tools/merge.spec.ts b/tests/tools/merge.spec.ts
index 440f543..188e377 100644
--- a/tests/tools/merge.spec.ts
+++ b/tests/tools/merge.spec.ts
@@ -60,4 +60,20 @@ describe("merge tool", () => {
     const result = await mergePDFs({ inputPaths: [valid, invalid], outputPath: output });
     expect(result.success).toBe(false);
   });
+
+  it("returns an unknown error when a non-Error value is thrown", async () => {
+    const { mergePDFs } = await import("../../src/tools/merge");
+
+    const result = await mergePDFs({
+      get inputPaths() {
+        throw "bad-input-paths";
+      },
+      outputPath: "/tmp/merged.pdf",
+    } as unknown as Parameters<typeof mergePDFs>[0]);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Unknown error occurred");
+    }
+  });
 });
diff --git a/tests/tools/pdf-to-images.branches.spec.ts b/tests/tools/pdf-to-images.branches.spec.ts
deleted file mode 100644
index 1a4ebf4..0000000
--- a/tests/tools/pdf-to-images.branches.spec.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { pdfToImages } from "../../src/tools/pdf-to-images";
-
-describe("pdf-to-images tool branch coverage", () => {
-  it("returns failure when input PDF is missing", async () => {
-    const result = await pdfToImages({
-      inputPath: "/tmp/missing.pdf",
-      outputDir: "/tmp/out",
-      pages: [1, 2],
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error?.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("returns failure with pages='all' path when file is missing", async () => {
-    const result = await pdfToImages({
-      inputPath: "/tmp/missing-all.pdf",
-      outputDir: "/tmp/out",
-      pages: "all",
-    });
-
-    expect(result.success).toBe(false);
-  });
-});
diff --git a/tests/tools/pdf-to-images.spec.ts b/tests/tools/pdf-to-images.spec.ts
index 519343b..0c71f24 100644
--- a/tests/tools/pdf-to-images.spec.ts
+++ b/tests/tools/pdf-to-images.spec.ts
@@ -1,6 +1,72 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
+import { join } from "path";
+import { cleanupTempDir, createPdf, createTempDir } from "../utils/test-utils";
+
+let tempDir = "";
+
+afterEach(async () => {
+  if (tempDir) {
+    await cleanupTempDir(tempDir);
+    tempDir = "";
+  }
+});
 
 describe("pdf-to-images tool", () => {
+  it("converts all pages to png with default options", async () => {
+    const { pdfToImages } = await import("../../src/tools/pdf-to-images");
+    tempDir = await createTempDir("pdfzen-pdf-to-images-png-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "png-out");
+    await createPdf(input, 2);
+
+    const result = await pdfToImages({
+      inputPath: input,
+      outputDir,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalImages).toBe(2);
+      expect(result.outputFiles).toHaveLength(2);
+      expect(result.outputFiles?.every((filePath) => filePath.endsWith(".png"))).toBe(true);
+
+      const bytes = new Uint8Array(await Bun.file(result.outputFiles?.[0] ?? "").arrayBuffer());
+      expect(bytes[0]).toBe(0x89);
+      expect(bytes[1]).toBe(0x50);
+      expect(bytes[2]).toBe(0x4e);
+      expect(bytes[3]).toBe(0x47);
+    }
+  });
+
+  it("converts selected pages to jpg", async () => {
+    const { pdfToImages } = await import("../../src/tools/pdf-to-images");
+    tempDir = await createTempDir("pdfzen-pdf-to-images-jpg-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "jpg-out");
+    await createPdf(input, 3);
+
+    const result = await pdfToImages({
+      inputPath: input,
+      outputDir,
+      format: "jpg",
+      dpi: 100,
+      pages: [2, 99],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalImages).toBe(1);
+      expect(result.outputFiles?.[0]).toContain("_page_2.jpg");
+
+      const bytes = new Uint8Array(await Bun.file(result.outputFiles?.[0] ?? "").arrayBuffer());
+      expect(bytes[0]).toBe(0xff);
+      expect(bytes[1]).toBe(0xd8);
+      expect(bytes[2]).toBe(0xff);
+    }
+  });
+
   it("returns failure when input PDF is missing", async () => {
     const { pdfToImages } = await import("../../src/tools/pdf-to-images");
 
diff --git a/tests/tools/protect.branches.spec.ts b/tests/tools/protect.branches.spec.ts
deleted file mode 100644
index c7057e0..0000000
--- a/tests/tools/protect.branches.spec.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { protectPDF, unprotectPDF } from "../../src/tools/protect";
-
-describe("protect tool branch coverage", () => {
-  it("validates password requirements", async () => {
-    const result = await protectPDF({
-      inputPath: "/tmp/in.pdf",
-      outputPath: "/tmp/out.pdf",
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("At least one password");
-    }
-  });
-
-  it("rejects passwords with invalid characters", async () => {
-    const result = await protectPDF({
-      inputPath: "/tmp/in.pdf",
-      outputPath: "/tmp/out.pdf",
-      userPassword: "pass,word",
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("must not contain");
-    }
-  });
-
-  it("returns failure when protecting a missing file", async () => {
-    const result = await protectPDF({
-      inputPath: "/tmp/missing.pdf",
-      outputPath: "/tmp/protected.pdf",
-      userPassword: "pw",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("returns failure when unprotecting a missing file", async () => {
-    const result = await unprotectPDF("/tmp/missing-protected.pdf", "/tmp/unprotected.pdf", "pw");
-    expect(result.success).toBe(false);
-  });
-
-  it("catches thrown input getter errors in protectPDF", async () => {
-    const result = await protectPDF({
-      get userPassword() {
-        throw new Error("bad-password-getter");
-      },
-      ownerPassword: "x",
-      inputPath: "/tmp/in.pdf",
-      outputPath: "/tmp/out.pdf",
-    } as unknown as Parameters<typeof protectPDF>[0]);
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("bad-password-getter");
-    }
-  });
-});
diff --git a/tests/tools/protect.spec.ts b/tests/tools/protect.spec.ts
index 5215934..ff1dae8 100644
--- a/tests/tools/protect.spec.ts
+++ b/tests/tools/protect.spec.ts
@@ -1,6 +1,124 @@
-import { describe, expect, it } from "bun:test";
+import { afterEach, describe, expect, it } from "bun:test";
+import { join } from "path";
+import {
+  cleanupTempDir,
+  createPdf,
+  createTempDir,
+  getPdfPageCount,
+  withMockedOpenDocument,
+} from "../utils/test-utils";
+
+let tempDir = "";
+
+afterEach(async () => {
+  if (tempDir) {
+    await cleanupTempDir(tempDir);
+    tempDir = "";
+  }
+});
 
 describe("protect tool", () => {
+  it("protects and unprotects a pdf with passwords", async () => {
+    const { protectPDF, unprotectPDF } = await import("../../src/tools/protect");
+    tempDir = await createTempDir("pdfzen-protect-");
+
+    const input = join(tempDir, "input.pdf");
+    const protectedPath = join(tempDir, "protected.pdf");
+    const unprotectedPath = join(tempDir, "unprotected.pdf");
+    await createPdf(input, 2);
+
+    const protectedResult = await protectPDF({
+      inputPath: input,
+      outputPath: protectedPath,
+      userPassword: "reader",
+      ownerPassword: "owner",
+      permissions: {
+        print: false,
+        modify: false,
+        copy: false,
+        annotate: false,
+      },
+    });
+
+    expect(protectedResult.success).toBe(true);
+    expect(await Bun.file(protectedPath).exists()).toBe(true);
+
+    const unprotectedResult = await unprotectPDF(protectedPath, unprotectedPath, "reader");
+
+    expect(unprotectedResult.success).toBe(true);
+    if (unprotectedResult.success) {
+      expect(await getPdfPageCount(unprotectedPath)).toBe(2);
+    }
+  });
+
+  it("rejects inputs that cannot be treated as pdf documents", async () => {
+    const { protectPDF } = await import("../../src/tools/protect");
+    tempDir = await createTempDir("pdfzen-protect-invalid-doc-");
+
+    const input = join(tempDir, "input.pdf");
+    await createPdf(input, 1);
+
+    const result = await withMockedOpenDocument(
+      () => ({ asPDF: () => null }),
+      () =>
+        protectPDF({
+        inputPath: input,
+        outputPath: join(tempDir, "out.pdf"),
+        userPassword: "reader",
+        }),
+    );
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Not a valid PDF document");
+    }
+  });
+
+  it("rejects protected inputs that cannot be converted back into pdf documents", async () => {
+    const { unprotectPDF } = await import("../../src/tools/protect");
+    tempDir = await createTempDir("pdfzen-unprotect-invalid-doc-");
+
+    const input = join(tempDir, "input.pdf");
+    await createPdf(input, 1);
+
+    const result = await withMockedOpenDocument(
+      () => ({
+        needsPassword: () => false,
+        asPDF: () => null,
+      }),
+      () => unprotectPDF(input, join(tempDir, "out.pdf"), "reader"),
+    );
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Not a valid PDF document");
+    }
+  });
+
+  it("rejects an incorrect password for a protected pdf", async () => {
+    const { protectPDF, unprotectPDF } = await import("../../src/tools/protect");
+    tempDir = await createTempDir("pdfzen-protect-wrong-password-");
+
+    const input = join(tempDir, "input.pdf");
+    const protectedPath = join(tempDir, "protected.pdf");
+    await createPdf(input, 1);
+
+    const protectedResult = await protectPDF({
+      inputPath: input,
+      outputPath: protectedPath,
+      userPassword: "reader",
+    });
+
+    expect(protectedResult.success).toBe(true);
+
+    const result = await unprotectPDF(protectedPath, join(tempDir, "wrong.pdf"), "wrong");
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Incorrect password");
+    }
+  });
+
   it("validates password requirements", async () => {
     const { protectPDF } = await import("../../src/tools/protect");
 
@@ -15,7 +133,22 @@ describe("protect tool", () => {
     }
   });
 
-  it("returns failure when unprotecting a missing file", async () => {
+  it("rejects passwords with invalid delimiter characters", async () => {
+    const { protectPDF } = await import("../../src/tools/protect");
+
+    const result = await protectPDF({
+      inputPath: "/tmp/in.pdf",
+      outputPath: "/tmp/out.pdf",
+      userPassword: "pass,word",
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("must not contain");
+    }
+  });
+
+  it("returns failure for missing input files", async () => {
     const { protectPDF, unprotectPDF } = await import("../../src/tools/protect");
 
     const protectedResult = await protectPDF({
@@ -33,7 +166,7 @@ describe("protect tool", () => {
     expect(unprotectedResult.success).toBe(false);
   });
 
-  it("accepts owner password path and reaches protect logic", async () => {
+  it("accepts owner-only passwords before failing on a missing input file", async () => {
     const { protectPDF } = await import("../../src/tools/protect");
 
     const result = await protectPDF({
diff --git a/tests/tools/rotate.spec.ts b/tests/tools/rotate.spec.ts
index f8ff204..491f09b 100644
--- a/tests/tools/rotate.spec.ts
+++ b/tests/tools/rotate.spec.ts
@@ -36,6 +36,29 @@ describe("rotate tool", () => {
     expect(rotations.map((r) => r.rotation)).toEqual([90, 90]);
   });
 
+  it("rotates all pages when pages are omitted", async () => {
+    const { rotatePDF, getPDFRotations } = await import("../../src/tools/rotate");
+    tempDir = await createTempDir("pdfzen-rotate-default-pages-");
+
+    const input = join(tempDir, "input.pdf");
+    const output = join(tempDir, "rotated.pdf");
+    await createPdf(input, 3);
+
+    const result = await rotatePDF({
+      inputPath: input,
+      outputPath: output,
+      rotation: 270,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.rotatedPages).toBe(3);
+    }
+
+    const rotations = await getPDFRotations(output);
+    expect(rotations.map((rotation) => rotation.rotation)).toEqual([270, 270, 270]);
+  });
+
   it("rotates only selected valid pages", async () => {
     const { rotatePDF, getPDFRotations } = await import("../../src/tools/rotate");
     tempDir = await createTempDir("pdfzen-rotate-selected-");
@@ -74,6 +97,24 @@ describe("rotate tool", () => {
     expect(result.success).toBe(false);
   });
 
+  it("returns an unknown error when a non-Error value is thrown", async () => {
+    const { rotatePDF } = await import("../../src/tools/rotate");
+
+    const result = await rotatePDF({
+      get inputPath() {
+        throw "bad-input-path";
+      },
+      outputPath: "/tmp/rotated.pdf",
+      rotation: 90,
+      pages: "all",
+    } as unknown as Parameters<typeof rotatePDF>[0]);
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toBe("Unknown error occurred");
+    }
+  });
+
   it("throws clear error for invalid PDF in getPDFRotations", async () => {
     const { getPDFRotations } = await import("../../src/tools/rotate");
     tempDir = await createTempDir("pdfzen-rotate-invalid-");
diff --git a/tests/tools/split-extract.spec.ts b/tests/tools/split-extract.spec.ts
new file mode 100644
index 0000000..862d6b7
--- /dev/null
+++ b/tests/tools/split-extract.spec.ts
@@ -0,0 +1,267 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { join } from "path";
+import { cleanupTempDir, createPdf, createTempDir, getPdfPageCount } from "../utils/test-utils";
+
+let tempDir = "";
+
+afterEach(async () => {
+  if (tempDir) {
+    await cleanupTempDir(tempDir);
+    tempDir = "";
+  }
+});
+
+describe("split tool", () => {
+  it("splits every N pages", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 5);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir,
+      splitMode: "every",
+      splitValue: 2,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(3);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[2])).toBe(1);
+    }
+  });
+
+  it("validates splitAt page range", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-invalid-");
+
+    const input = join(tempDir, "input.pdf");
+    await createPdf(input, 3);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir: join(tempDir, "out"),
+      splitMode: "at",
+      splitValue: 3,
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Split page must be between 1 and 2");
+    }
+  });
+
+  it("splits at a valid page into two files", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-at-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 4);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir,
+      splitMode: "at",
+      splitValue: 2,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(2);
+    }
+  });
+
+  it("uses the first array value when splitting at a page", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-at-array-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 4);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir,
+      splitMode: "at",
+      splitValue: [3, 99],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(3);
+      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(1);
+    }
+  });
+
+  it("extracts a page range", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-range-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 5);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir,
+      splitMode: "range",
+      splitValue: [2, 4],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(1);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(3);
+    }
+  });
+
+  it("uses numeric split range values from the first page", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-range-number-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 4);
+
+    const result = await splitPDF({
+      inputPath: input,
+      outputDir,
+      splitMode: "range",
+      splitValue: 2,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(1);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
+    }
+  });
+
+  it("returns failure for missing input file", async () => {
+    const { splitPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-split-missing-");
+
+    const result = await splitPDF({
+      inputPath: join(tempDir, "missing.pdf"),
+      outputDir: join(tempDir, "out"),
+      splitMode: "every",
+      splitValue: 2,
+    });
+
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("extract tool", () => {
+  it("extracts every N pages into multiple files", async () => {
+    const { extractPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-extract-every-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 5);
+
+    const result = await extractPDF({
+      inputPath: input,
+      outputDir,
+      extractMode: "every",
+      extractValue: 2,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(3);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(2);
+      expect(await getPdfPageCount(result.outputFiles?.[2])).toBe(1);
+    }
+  });
+
+  it("extracts a page range into one file", async () => {
+    const { extractPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-extract-range-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 5);
+
+    const result = await extractPDF({
+      inputPath: input,
+      outputDir,
+      extractMode: "range",
+      extractValue: [2, 4],
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(1);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(3);
+    }
+  });
+
+  it("clamps numeric extract ranges to the total page count", async () => {
+    const { extractPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-extract-range-number-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 3);
+
+    const result = await extractPDF({
+      inputPath: input,
+      outputDir,
+      extractMode: "range",
+      extractValue: 99,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.totalFiles).toBe(1);
+      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(3);
+    }
+  });
+
+  it("validates extract range order", async () => {
+    const { extractPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-extract-invalid-");
+
+    const input = join(tempDir, "input.pdf");
+    const outputDir = join(tempDir, "out");
+    await createPdf(input, 5);
+
+    const result = await extractPDF({
+      inputPath: input,
+      outputDir,
+      extractMode: "range",
+      extractValue: [4, 2],
+    });
+
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error).toContain("Page range must be between 1 and 5");
+    }
+  });
+
+  it("returns failure for missing input file", async () => {
+    const { extractPDF } = await import("../../src/tools/split-extract");
+    tempDir = await createTempDir("pdfzen-extract-missing-");
+
+    const result = await extractPDF({
+      inputPath: join(tempDir, "missing.pdf"),
+      outputDir: join(tempDir, "out"),
+      extractMode: "every",
+      extractValue: 2,
+    });
+
+    expect(result.success).toBe(false);
+  });
+});
diff --git a/tests/tools/split.spec.ts b/tests/tools/split.spec.ts
deleted file mode 100644
index 51627d2..0000000
--- a/tests/tools/split.spec.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { join } from "path";
-import { cleanupTempDir, createPdf, createTempDir, getPdfPageCount } from "../utils/test-utils";
-
-let tempDir = "";
-
-afterEach(async () => {
-  if (tempDir) {
-    await cleanupTempDir(tempDir);
-    tempDir = "";
-  }
-});
-
-describe("split tool", () => {
-  it("splits every N pages", async () => {
-    const { splitPDF } = await import("../../src/tools/split");
-    tempDir = await createTempDir("pdfzen-split-");
-
-    const input = join(tempDir, "input.pdf");
-    const outputDir = join(tempDir, "out");
-    await createPdf(input, 5);
-
-    const result = await splitPDF({
-      inputPath: input,
-      outputDir,
-      splitMode: "every",
-      splitValue: 2,
-    });
-
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.totalFiles).toBe(3);
-      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
-      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(2);
-      expect(await getPdfPageCount(result.outputFiles?.[2])).toBe(1);
-    }
-  });
-
-  it("validates splitAt page range", async () => {
-    const { splitPDF } = await import("../../src/tools/split");
-    tempDir = await createTempDir("pdfzen-split-invalid-");
-
-    const input = join(tempDir, "input.pdf");
-    await createPdf(input, 3);
-
-    const result = await splitPDF({
-      inputPath: input,
-      outputDir: join(tempDir, "out"),
-      splitMode: "splitAt",
-      splitValue: 3,
-    });
-
-    expect(result.success).toBe(false);
-    if (!result.success) {
-      expect(result.error).toContain("Split page must be between 1 and 2");
-    }
-  });
-
-  it("splits at a valid page into two files", async () => {
-    const { splitPDF } = await import("../../src/tools/split");
-    tempDir = await createTempDir("pdfzen-split-at-");
-
-    const input = join(tempDir, "input.pdf");
-    const outputDir = join(tempDir, "out");
-    await createPdf(input, 4);
-
-    const result = await splitPDF({
-      inputPath: input,
-      outputDir,
-      splitMode: "splitAt",
-      splitValue: 2,
-    });
-
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.totalFiles).toBe(2);
-      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(2);
-      expect(await getPdfPageCount(result.outputFiles?.[1])).toBe(2);
-    }
-  });
-
-  it("extracts a page range", async () => {
-    const { splitPDF } = await import("../../src/tools/split");
-    tempDir = await createTempDir("pdfzen-split-range-");
-
-    const input = join(tempDir, "input.pdf");
-    const outputDir = join(tempDir, "out");
-    await createPdf(input, 5);
-
-    const result = await splitPDF({
-      inputPath: input,
-      outputDir,
-      splitMode: "range",
-      splitValue: [2, 4],
-    });
-
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.totalFiles).toBe(1);
-      expect(await getPdfPageCount(result.outputFiles?.[0])).toBe(3);
-    }
-  });
-
-  it("returns failure for missing input file", async () => {
-    const { splitPDF } = await import("../../src/tools/split");
-    tempDir = await createTempDir("pdfzen-split-missing-");
-
-    const result = await splitPDF({
-      inputPath: join(tempDir, "missing.pdf"),
-      outputDir: join(tempDir, "out"),
-      splitMode: "every",
-      splitValue: 2,
-    });
-
-    expect(result.success).toBe(false);
-  });
-});
diff --git a/tests/utils/test-utils.spec.ts b/tests/utils/test-utils.spec.ts
index f9e9d9b..9ef8e93 100644
--- a/tests/utils/test-utils.spec.ts
+++ b/tests/utils/test-utils.spec.ts
@@ -1,7 +1,14 @@
 import { afterEach, describe, expect, it } from "bun:test";
 import { stat } from "fs/promises";
 import { join } from "path";
-import { cleanupTempDir, createPdf, createPng, createTempDir, getPdfPageCount } from "./test-utils";
+import {
+  cleanupTempDir,
+  createJpg,
+  createPdf,
+  createPng,
+  createTempDir,
+  getPdfPageCount,
+} from "./test-utils";
 
 const tempDirs: string[] = [];
 
@@ -53,4 +60,17 @@ describe("test-utils", () => {
     expect(bytes[2]).toBe(0x4e);
     expect(bytes[3]).toBe(0x47);
   });
+
+  it("creates a valid jpg signature", async () => {
+    const dir = await createTempDir("pdfzen-test-utils-");
+    tempDirs.push(dir);
+
+    const jpgPath = join(dir, "pixel.jpg");
+    await createJpg(jpgPath);
+
+    const bytes = new Uint8Array(await Bun.file(jpgPath).arrayBuffer());
+    expect(bytes[0]).toBe(0xff);
+    expect(bytes[1]).toBe(0xd8);
+    expect(bytes[2]).toBe(0xff);
+  });
 });
diff --git a/tests/utils/test-utils.ts b/tests/utils/test-utils.ts
index 152c1ea..8f47373 100644
--- a/tests/utils/test-utils.ts
+++ b/tests/utils/test-utils.ts
@@ -36,3 +36,29 @@ export async function createPng(filePath: string): Promise<void> {
   const bytes = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
   await Bun.write(filePath, bytes);
 }
+
+export async function createJpg(filePath: string): Promise<void> {
+  // 1x1 JPEG
+  const base64 =
+    "/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAgGBgcGBQgHBwcJCQgKDBQNDAsLDBkSEw8UHRofHh0aHBwgJC4nICIsIxwcKDcpLDAxNDQ0Hyc5PTgyPC4zNDL/2wBDAQkJCQwLDBgNDRgyIRwhMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjL/wAARCAABAAEDAREAAhEBAxEB/8QAFQABAQAAAAAAAAAAAAAAAAAAAAX/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAHJAP/EABQQAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQEAAQUCcf/EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQMBAT8BJ//EABQRAQAAAAAAAAAAAAAAAAAAAAD/2gAIAQIBAT8BJ//Z";
+  const bytes = Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  await Bun.write(filePath, bytes);
+}
+
+export async function withMockedOpenDocument<T>(
+  factory: () => unknown,
+  run: () => Promise<T>,
+): Promise<T> {
+  const { default: mupdf } = await import("../../src/utils/mupdf");
+  const originalOpenDocument = mupdf.Document.openDocument;
+
+  (mupdf.Document as unknown as { openDocument: typeof originalOpenDocument }).openDocument =
+    ((() => factory()) as unknown) as typeof originalOpenDocument;
+
+  try {
+    return await run();
+  } finally {
+    (mupdf.Document as unknown as { openDocument: typeof originalOpenDocument }).openDocument =
+      originalOpenDocument;
+  }
+}
diff --git a/tests/utils/utils.spec.ts b/tests/utils/utils.spec.ts
index c11d83f..7fb04b3 100644
--- a/tests/utils/utils.spec.ts
+++ b/tests/utils/utils.spec.ts
@@ -9,6 +9,9 @@ import {
   clearOpenedFiles,
   closeFileTracking,
   chunkArray,
+  formatFileSize,
+  formatModifiedLabel,
+  getFormattedFileMetadata,
   getOutputDir,
   getOutputPath,
   getPageCount,
@@ -76,6 +79,13 @@ describe("utils", () => {
     expect(chunkArray([], 3)).toEqual([]);
   });
 
+  it("formats file sizes and modified timestamps", () => {
+    expect(formatFileSize(512)).toBe("512 B");
+    expect(formatFileSize(1536)).toBe("1.5 KB");
+    expect(formatModifiedLabel(new Date())).toMatch(/^updated today /);
+    expect(formatModifiedLabel(new Date(2020, 0, 2, 12, 0, 0))).toMatch(/^Updated /);
+  });
+
   it("unescapes shell-escaped paths", () => {
     expect(unescapePath("/tmp/My\\ File.pdf")).toBe("/tmp/My File.pdf");
   });
@@ -152,6 +162,28 @@ describe("utils", () => {
     expect(await getPageCount(txtPath)).toBe(0);
   });
 
+  it("returns formatted file metadata with optional page counts", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "pdfzen-metadata-"));
+    tempDirs.push(dir);
+
+    const pdfPath = join(dir, "meta.pdf");
+    await createPdf(pdfPath, 2);
+
+    const withPageCount = await getFormattedFileMetadata(pdfPath, {
+      includePageCount: true,
+    });
+    const withoutPageCount = await getFormattedFileMetadata(pdfPath);
+    const missing = await getFormattedFileMetadata(join(dir, "missing.pdf"));
+
+    expect(withPageCount.pageCount).toBe(2);
+    expect(withPageCount.size.length).toBeGreaterThan(0);
+    expect(withPageCount.modified).toMatch(/^(updated today|Updated )/);
+
+    expect(withoutPageCount.pageCount).toBeNull();
+    expect(missing.modified).toBeNull();
+    expect(missing.pageCount).toBeNull();
+  });
+
   it("creates output paths and reuses cached output for same input+prefix", async () => {
     const first = await getOutputPath("merge", "/tmp/input.pdf");
     const second = await getOutputPath("merge", "/tmp/input.pdf");