Release version 0.5.0

.github/workflows/rust.yml

@@ -2,107 +2,41 @@ name: Rust
 
 on:
   push:
-    branches: ["main"]
-    tags: ["v*.*.*"]
+    branches: [ "main" ]
   pull_request:
-    branches: ["main"]
-  workflow_dispatch:
-  workflow_call:
+    branches: [ "main" ]
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  test-build:
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { os: "macos-latest", target: "aarch64-apple-darwin" }
-          - { os: "ubuntu-latest", target: "x86_64-unknown-linux-gnu" }
-          - {
-              os: "windows-latest",
-              target: "x86_64-pc-windows-msvc",
-              ext: ".exe",
-            }
-          - { os: "ubuntu-24.04-arm", target: "aarch64-unknown-linux-gnu" }
+  build:
 
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v6
-
-      - name: Setup sccache
-        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-        uses: mozilla-actions/sccache-action@v0.0.8
-      - name: Configure sccache
-        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-        run: |
-          echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
-          echo "RUSTC_WRAPPER=sccache" >> "$GITHUB_ENV"
-
-      - name: Setup rust cache action
-        uses: swatinem/rust-cache@v2
-        with:
-          cache-on-failure: true
-
-      - name: install build dependencies on ubuntu and cache
-        if: contains(matrix.os, 'ubuntu')
-        uses: awalsh128/cache-apt-pkgs-action@latest
-        with:
-          packages: libfontconfig1-dev libgoogle-perftools-dev google-perftools
-          version: latest # could be anything
-
-      - name: Install clippy and fmt
-        run: rustup component add clippy rustfmt
-      - name: Clippy
-        run: cargo clippy --locked -- -D warnings
-      - name: Tests
-        run: cargo test --locked
-      - name: Check fmt
-        run: cargo fmt -- --check
-      - name: Run benchmarks as tests
-        run: cargo test --locked --benches -- adobe_example
-
-      - name: Set build mode
-        shell: bash
-        run: if [ "${{github.ref_type}}" == "tag" ] || [ ${{ github.event_name == 'push' && github.ref_name == 'main' }} ]; then echo "BMODE=production">>"$GITHUB_ENV"; fi
-
-      - name: Build in ${{env.BMODE || 'debug'}} mode
-        run: cargo build --verbose --locked --profile ${{env.BMODE || 'dev'}}
-
-      - name: Prepare artifact
-        shell: bash
-        run: |
-          mkdir -p dist
-          cp "target/${{env.BMODE || 'debug'}}/tdf${{ matrix.ext }}" dist/tdf-${{ matrix.target }}${{ matrix.ext }}
-          tree dist || ls -la dist
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v5
-        with:
-          name: tdf-${{ matrix.target }}
-          path: dist/tdf*
-
-  tag-release:
-    name: Release on tag push
-    runs-on: ubuntu-slim
-    if: github.ref_type == 'tag'
-    needs: test-build
-    steps:
-      - uses: actions/download-artifact@v6
-        with:
-          pattern: "**/tdf-*"
-          path: release-artifacts
-          merge-multiple: true
-
-      - name: What's up?
-        run: tree release-artifacts # beautiful!
-
-      - name: Create a GitHub release
-        uses: softprops/action-gh-release@v2
-        with:
-          draft: true
-          generate_release_notes: true
-          files: release-artifacts/*
-          prerelease: ${{ contains(github.ref, 'alpha') || contains(github.ref, 'beta') || contains(github.ref, 'rc') }}
+    - name: Setup sccache
+      if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+      uses: mozilla-actions/sccache-action@v0.0.8
+    - name: Configure sccache
+      if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+      run: |
+        echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
+        echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV
+    - name: Install build dependencies
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libfontconfig1-dev libgoogle-perftools-dev google-perftools
+    - uses: actions/checkout@v4
+    - name: Install clippy and fmt
+      run: rustup component add clippy rustfmt
+    - name: Clippy
+      run: cargo clippy --locked -- -D warnings
+    - name: Tests
+      run: cargo test --locked
+    - name: Check fmt
+      run: cargo fmt -- --check
+    - name: Run benchmarks as tests
+      run: cargo test --locked --benches -- adobe_example
+    - name: Build
+      run: cargo build --locked

.gitignore

@@ -1,4 +1,2 @@
 /target
 debug.log
-/.envrc
-/.direnv/

CHANGELOG.md

@@ -1,10 +1,5 @@
 # Unreleased
 
-- Added windows support! (thank you to [@jarjk](https://github.com/jarjk) for helping out!)
-- Added keybindings (`0`/`$`) to scroll to left or right side of zoomed-in image ([#131](https://github.com/itsjunetime/tdf/pull/131), thank you [@IshDeshpa](https://github.com/IshDeshpa)!)
-- Fixed issue with images clearing/flashing after displaying a certain number on kitty
-- (Internal) decreased runtime footprint of tokio runtime
-
 # v0.5.0
 
 - Switched simd base64 crate for one that works on stable (from `vb64` to `base64_simd`)

Cargo.toml

@@ -11,7 +11,7 @@ license = "AGPL-3.0-only"
 keywords = ["pdf", "tui", "cli", "terminal"]
 categories = ["command-line-utilities", "text-processing", "visualization"]
 default-run = "tdf"
-rust-version = "1.95"
+rust-version = "1.86"
 
 [[bin]]
 name = "tdf"
@@ -23,10 +23,10 @@ name = "tdf"
 
 [dependencies]
 # we're using this branch because it has significant performance fixes that I'm waiting on responses from the upstream devs to get upstreamed. See https://github.com/ratatui-org/ratatui/issues/1116
-ratatui = { git = "https://github.com/itsjunetime/ratatui.git", rev = "720ac2d0cad1ac6424364fea74856fec9c100cb1", default-features = false, features = [ "crossterm", "layout-cache" ] }
+ratatui = { git = "https://github.com/itsjunetime/ratatui.git" }
 # ratatui = { path = "./ratatui/ratatui/" }
 # We're using this to have the vb64 feature (for faster base64 encoding, since that does take up a good bit of time when converting images to the `Protocol`. It also just includes a few more features that I'm waiting on main to upstream
-ratatui-image = { git = "https://github.com/itsjunetime/ratatui-image.git", rev = "8ad154a219c1e4832a378bd07aaf39b3ddff959b", default-features = false }
+ratatui-image = { git = "https://github.com/itsjunetime/ratatui-image.git", branch = "vb64_on_personal", default-features = false }
 # ratatui-image = { path = "./ratatui-image", default-features = false }
 crossterm = { version = "0.29.0", features = ["event-stream"] }
 # crossterm = { path = "../crossterm", features = ["event-stream"] }
@@ -34,18 +34,16 @@ image = { version = "0.25.1", features = ["pnm", "rayon", "png"], default-featur
 notify = { version = "8.0.0", features = ["crossbeam-channel"] }
 tokio = { version = "1.37.0", features = ["rt-multi-thread", "macros"] }
 futures-util = { version = "0.3.30", default-features = false }
-flume = { version = "0.12.0", default-features = false, features = ["async"] }
+flume = { version = "0.11.0", default-features = false, features = ["async"] }
 xflags = "0.4.0-pre.2"
 mimalloc = "0.1.43"
-nix = { version = "0.31.0", features = ["signal"] }
-mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "d7441b9998c92135e329559c0aa71d9dc92cf4de", default-features = false, features = ["svg", "system-fonts", "img"] }
+nix = { version = "0.30.0", features = ["signal"] }
+mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "2e0fae910fac8048c7008211fc4d3b9f5d227a07", default-features = false, features = ["svg", "system-fonts", "img"] }
 rayon = { version = "1", default-features = false }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
-kittage = { version = "0.4.0", features = ["crossterm-tokio", "image-crate", "log"] }
+kittage = { version = "0.1.1", features = ["crossterm-tokio", "image-crate", "log"] }
 memmap2 = "0"
 csscolorparser = { version = "0.8.0", default-features = false }
-debounce = "0.2.2"
-smallvec = "1"
 
 # logging
 log = "0.4.27"
@@ -53,9 +51,7 @@ flexi_logger = "0.31"
 
 # for tracing with tokio-console
 console-subscriber = { version = "0.5.0", optional = true }
-
-[patch.crates-io]
-pathfinder_simd = { git = "https://github.com/itsjunetime/pathfinder.git", rev = "814671e162a1829e074521446317b915311d3d4d" }
+debounce = "0.2.2"
 
 [profile.production]
 inherits = "release"
@@ -68,7 +64,7 @@ epub = ["mupdf/epub"]
 cbz = ["mupdf/cbz"]
 
 [dev-dependencies]
-criterion = { version = "0.8.0", features = ["async_tokio"] }
+criterion = { version = "0.7.0", features = ["async_tokio"] }
 cpuprofiler = "0.0.4"
 
 [[bench]]

benches/rendering.rs

@@ -34,12 +34,7 @@ fn for_all_combos(
 	name: &'static str,
 	mut f: impl FnMut(&Runtime, BenchmarkId, &'static str, ProtocolType)
 ) {
-	let rt = tokio::runtime::Builder::new_multi_thread()
-		.worker_threads(3)
-		.enable_time()
-		.build()
-		.unwrap();
-
+	let rt = tokio::runtime::Runtime::new().unwrap();
 	for proto in PROTOS {
 		for file in FILES {
 			f(

benches/utils.rs

@@ -65,6 +65,7 @@ pub fn start_rendering_loop(
 	Sender<RenderNotif>
 ) {
 	let pathbuf = path.as_ref().canonicalize().unwrap();
+	let str_path = pathbuf.into_os_string().to_string_lossy().to_string();
 
 	let (to_render_tx, from_main_rx) = unbounded();
 	let (to_main_tx, from_render_rx) = unbounded();
@@ -90,7 +91,7 @@ pub fn start_rendering_loop(
 	let cell_width_px = size.width / size.columns;
 	std::thread::spawn(move || {
 		start_rendering(
-			&pathbuf,
+			&str_path,
 			to_main_tx,
 			from_main_rx,
 			cell_height_px,
@@ -116,7 +117,6 @@ pub fn start_converting_loop(
 	let (to_converter_tx, from_main_rx) = unbounded();
 	let (to_main_tx, from_converter_rx) = unbounded();
 
-	#[expect(deprecated)]
 	let mut picker = Picker::from_fontsize(FONT_SIZE);
 	picker.set_protocol_type(proto);
 

shell.nix

@@ -5,7 +5,10 @@ pkgs.mkShell {
   nativeBuildInputs = [ pkgs.pkg-config ];
 
   buildInputs = [
+    pkgs.cargo
+    pkgs.rustc
     pkgs.rustPlatform.bindgenHook
     pkgs.cairo
+    pkgs.rust-analyzer
   ];
 }

src/converter.rs

@@ -1,13 +1,12 @@
 use std::{
-	io::Cursor,
-	num::{NonZeroU32, NonZeroUsize},
+	num::NonZeroUsize,
 	time::{SystemTime, UNIX_EPOCH}
 };
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use futures_util::stream::StreamExt as _;
-use image::{DynamicImage, codecs::pnm::PnmDecoder};
-use kittage::NumberOrId;
+use image::DynamicImage;
+use kittage::{NumberOrId, action::NONZERO_ONE};
 use ratatui::layout::Rect;
 use ratatui_image::{
 	Resize,
@@ -112,26 +111,22 @@ pub async fn run_conversion_loop(
 			return Ok(None);
 		};
 
-		let decoder = PnmDecoder::new(Cursor::new(&page_info.img_data.pixels)).map_err(|e| {
-			RenderError::Converting(format!(
-				"The image data provided from mupdf was not in pnm format ({e}); don't know how to convert"
-			))
-		})?;
+		let mut dyn_img = image::load_from_memory_with_format(
+			&page_info.img_data.pixels,
+			image::ImageFormat::Pnm
+		)
+		.map_err(|e| RenderError::Converting(format!("Can't load image: {e}")))?;
 
-		// The image we get should always already be `ImageRgb8`, so this `into` shouldn't do any
-		// conversions or anything, but just in case some underlying detail of mupdf or image
-		// changes, we do the `into` instead of just `match + unreachable!()` to avoid panicking
-		let mut dyn_img = DynamicImage::from_decoder(decoder)
-			.map_err(|e| RenderError::Converting(format!("Can't load image: {e}")))?
-			.into_rgb8();
-
-		for quad in &*page_info.result_rects {
-			dyn_img
-				.par_enumerate_pixels_mut()
-				.filter(|(x, y, _)| {
-					*x > quad.ul_x && *x < quad.lr_x && *y > quad.ul_y && *y < quad.lr_y
-				})
-				.for_each(|(_, _, px)| px.0[2] = px.0[2].saturating_sub(u8::MAX / 2));
+		match dyn_img {
+			DynamicImage::ImageRgb8(ref mut img) =>
+				for quad in &*page_info.result_rects {
+					img.par_enumerate_pixels_mut()
+						.filter(|(x, y, _)| {
+							*x > quad.ul_x && *x < quad.lr_x && *y > quad.ul_y && *y < quad.lr_y
+						})
+						.for_each(|(_, _, px)| px.0[2] = px.0[2].saturating_sub(u8::MAX / 2));
+				},
+			_ => unreachable!()
 		}
 
 		let img_area = Rect {
@@ -141,8 +136,6 @@ pub async fn run_conversion_loop(
 			y: 0
 		};
 
-		let dyn_img = DynamicImage::ImageRgb8(dyn_img);
-
 		let txt_img = match picker.protocol_type() {
 			ProtocolType::Kitty => {
 				let rn = SystemTime::now()
@@ -151,20 +144,16 @@ pub async fn run_conversion_loop(
 					.as_nanos() % 1_000_000;
 
 				let mut img = if shms_work {
-					let shm_name = format!("/tdf_{pid}_{rn}_{page_num}");
-
-					#[cfg(unix)]
-					let shm_name = &*shm_name;
-
-					kittage::image::Image::shm_from(dyn_img, shm_name).map_err(|e| {
-						RenderError::Converting(format!("Couldn't create shm: {e:?}"))
-					})?
+					kittage::image::Image::shm_from(dyn_img, &format!("/tdf_{pid}_{rn}_{page_num}"))
+						.map_err(|e| {
+							RenderError::Converting(format!("Couldn't write to shm: {e:?}"))
+						})?
 				} else {
 					kittage::image::Image::from(dyn_img)
 				};
 
 				// if ur pdf has 4 billion pages then you deserve to suffer
-				img.num_or_id = NumberOrId::Id(NonZeroU32::MIN.saturating_add(page_num as u32));
+				img.num_or_id = NumberOrId::Id(NONZERO_ONE.saturating_add(page_num as u32));
 
 				ConvertedImage::Kitty {
 					img: MaybeTransferred::NotYet(img),

src/kitty.rs

@@ -1,8 +1,4 @@
-use core::fmt::Display;
-use std::{
-	io::{StdoutLock, Write, stdout},
-	num::NonZeroU32
-};
+use std::{io::Write, num::NonZeroU32};
 
 use crossterm::{
 	cursor::MoveTo,
@@ -18,11 +14,9 @@ use kittage::{
 	display::{CursorMovementPolicy, DisplayConfig, DisplayLocation},
 	error::TransmitError,
 	image::Image,
-	medium::Medium,
-	tmux::TmuxWriter
+	medium::Medium
 };
 use ratatui::layout::Position;
-use smallvec::SmallVec;
 
 use crate::converter::MaybeTransferred;
 
@@ -36,7 +30,7 @@ pub struct KittyReadyToDisplay<'tui> {
 pub enum KittyDisplay<'tui> {
 	NoChange,
 	ClearImages,
-	DisplayImages(SmallVec<[KittyReadyToDisplay<'tui>; 1]>)
+	DisplayImages(Vec<KittyReadyToDisplay<'tui>>)
 }
 
 pub struct DbgWriter<W: Write> {
@@ -66,66 +60,25 @@ impl<W: Write> Write for DbgWriter<W> {
 	}
 }
 
-pub enum MaybeTmuxWriter<W>
-where
-	W: Write
-{
-	Tmux(TmuxWriter<W>),
-	Normal(W)
-}
-
-impl<W: Write> MaybeTmuxWriter<W> {
-	pub fn new(w: W, is_tmux: bool) -> Self {
-		if is_tmux {
-			Self::Tmux(TmuxWriter::new(w))
-		} else {
-			Self::Normal(w)
-		}
-	}
-}
-
-impl<W: Write> Write for &mut MaybeTmuxWriter<W> {
-	fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-		match *self {
-			MaybeTmuxWriter::Tmux(t) => t.write(buf),
-			MaybeTmuxWriter::Normal(w) => w.write(buf)
-		}
-	}
-
-	fn flush(&mut self) -> std::io::Result<()> {
-		match *self {
-			MaybeTmuxWriter::Tmux(t) => t.flush(),
-			MaybeTmuxWriter::Normal(w) => w.flush()
-		}
-	}
-}
-
 pub async fn run_action<'es>(
 	action: Action<'_, '_>,
-	writer: &mut MaybeTmuxWriter<StdoutLock<'_>>,
 	ev_stream: &'es mut EventStream
-) -> Result<Option<ImageId>, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
+) -> Result<ImageId, TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>> {
 	let writer = DbgWriter {
-		w: writer,
+		w: std::io::stdout().lock(),
 		#[cfg(debug_assertions)]
 		buf: String::new()
 	};
-
 	action
 		.execute_async(writer, ev_stream)
 		.await
 		.map(|(_, i)| i)
 }
 
-pub async fn do_shms_work(is_tmux: bool, ev_stream: &mut EventStream) -> bool {
+pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	let img = DynamicImage::new_rgb8(1, 1);
 	let pid = std::process::id();
-	let shm_name = format!("tdf_test_{pid}");
-
-	#[cfg(unix)]
-	let shm_name = &*shm_name;
-
-	let Ok(mut k_img) = kittage::image::Image::shm_from(img, shm_name) else {
+	let Ok(mut k_img) = kittage::image::Image::shm_from(img, &format!("tdf_test_{pid}")) else {
 		return false;
 	};
 
@@ -134,94 +87,60 @@ pub async fn do_shms_work(is_tmux: bool, ev_stream: &mut EventStream) -> bool {
 
 	enable_raw_mode().unwrap();
 
-	let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-	let res = run_action(Action::Query(&k_img), &mut writer, ev_stream).await;
+	let res = run_action(Action::Query(&k_img), ev_stream).await;
 
 	disable_raw_mode().unwrap();
 
 	res.is_ok()
 }
 
-type ESTransErr<'es> = TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>;
-
-pub struct DisplayErr<'es> {
-	pub failed_pages: SmallVec<[usize; 2]>,
-	pub user_facing_err: &'static str,
-	pub source: DisplayErrSource<'es>
-}
-
-impl<'es> DisplayErr<'es> {
-	fn empty(user_facing_err: &'static str, source: ESTransErr<'es>) -> Self {
-		Self {
-			failed_pages: SmallVec::new(),
-			user_facing_err,
-			source: DisplayErrSource::Transmission(source)
-		}
-	}
-}
-
-#[derive(Debug)]
-pub enum DisplayErrSource<'es> {
-	KittageReturnedNoId,
-	Transmission(ESTransErr<'es>)
-}
-
-impl Display for DisplayErrSource<'_> {
-	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		match self {
-			Self::KittageReturnedNoId => write!(
-				f,
-				"Kittage returned no ID when we asked it to display an image. This is a bug in kittage, please report it."
-			),
-			Self::Transmission(t) => write!(f, "Error with talking to the terminal: {t}")
-		}
-	}
-}
-
 pub async fn display_kitty_images<'es>(
 	display: KittyDisplay<'_>,
-	is_tmux: bool,
-	ev_stream: &'es mut EventStream,
-	last_z_index: &mut i32
-) -> Result<(), DisplayErr<'es>> {
-	let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-
+	ev_stream: &'es mut EventStream
+) -> Result<
+	(),
+	(
+		Vec<usize>,
+		&'static str,
+		TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>
+	)
+> {
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
-		KittyDisplay::ClearImages =>
-			return run_action(
+		KittyDisplay::DisplayImages(_) | KittyDisplay::ClearImages => {
+			run_action(
 				Action::Delete(DeleteConfig {
 					effect: ClearOrDelete::Clear,
 					which: WhichToDelete::All
 				}),
-				&mut writer,
 				ev_stream
 			)
 			.await
-			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))
-			.map(|_: Option<ImageId>| ()),
-		KittyDisplay::DisplayImages(imgs) => imgs
+			.map_err(|e| (vec![], "Couldn't clear previous images", e))?;
+
+			let KittyDisplay::DisplayImages(images) = display else {
+				return Ok(());
+			};
+
+			images
+		}
 	};
 
-	let new_z_index = last_z_index.wrapping_add_unsigned(1);
-
-	let mut err = Ok::<(), (SmallVec<[usize; 2]>, DisplayErrSource<'es>)>(());
+	let mut err = None;
 	for KittyReadyToDisplay {
 		img,
 		page_num,
 		pos,
-		mut display_loc
+		display_loc
 	} in images
 	{
-		display_loc.z_index = new_z_index;
-
 		let config = DisplayConfig {
 			location: display_loc,
 			cursor_movement: CursorMovementPolicy::DontMove,
 			..DisplayConfig::default()
 		};
 
-		execute!(&mut writer, MoveTo(pos.x, pos.y)).unwrap();
+		execute!(std::io::stdout(), MoveTo(pos.x, pos.y)).unwrap();
 
 		log::debug!("going to display img {img:#?}");
 		log::debug!("displaying with config {config:#?}");
@@ -244,22 +163,23 @@ pub async fn display_kitty_images<'es>(
 				};
 				std::mem::swap(image, &mut fake_image);
 
-				run_action(
+				let res = run_action(
 					Action::TransmitAndDisplay {
 						image: fake_image,
 						config,
 						placement_id: None
 					},
-					&mut writer,
 					ev_stream
 				)
-				.await
-				.map_err(DisplayErrSource::Transmission)
-				.and_then(|img_id| {
-					img_id
-						.map(|id| *img = MaybeTransferred::Transferred(id))
-						.ok_or(DisplayErrSource::KittageReturnedNoId)
-				})
+				.await;
+
+				match res {
+					Ok(img_id) => {
+						*img = MaybeTransferred::Transferred(img_id);
+						Ok(())
+					}
+					Err(e) => Err((page_num, e))
+				}
 			}
 			MaybeTransferred::Transferred(image_id) => run_action(
 				Action::Display {
@@ -267,44 +187,23 @@ pub async fn display_kitty_images<'es>(
 					placement_id: *image_id,
 					config
 				},
-				&mut writer,
 				ev_stream
 			)
 			.await
-			// don't need the return id 'cause we already know it
-			.map(|_: Option<ImageId>| ())
-			.map_err(DisplayErrSource::Transmission)
+			.map(|_| ())
+			.map_err(|e| (page_num, e))
 		};
 
 		log::debug!("this_err is {this_err:#?}");
 
-		if let Err(e) = this_err {
-			match err.as_mut() {
-				Ok(()) => err = Err((SmallVec::from([page_num].as_slice()), e)),
-				Err((v, _)) => v.push(page_num)
-			}
+		if let Err((id, e)) = this_err {
+			let e = err.get_or_insert_with(|| (vec![], e));
+			e.0.push(id);
 		}
 	}
 
-	let z_idxes_to_remove = *last_z_index;
-	*last_z_index = new_z_index;
-
 	match err {
-		Err((failed_pages, source)) => Err(DisplayErr {
-			failed_pages,
-			user_facing_err: "Couldn't transfer image to the terminal",
-			source
-		}),
-		Ok(()) => run_action(
-			Action::Delete(DeleteConfig {
-				effect: ClearOrDelete::Clear,
-				which: WhichToDelete::PlacementsWithZIndex(z_idxes_to_remove)
-			}),
-			&mut writer,
-			ev_stream
-		)
-		.await
-		.map_err(|e| DisplayErr::empty("Couldn't clear previously-sent images", e))
-		.map(|_| ())
+		Some((replace, e)) => Err((replace, "Couldn't transfer image to the terminal", e)),
+		None => Ok(())
 	}
 }

src/lib.rs

@@ -42,7 +42,7 @@ pub fn scale_img_for_area(
 
 	// and get the ratio that this page would have to be scaled by to fit perfectly within the
 	// area provided to us.
-	// we do this first by comparing the aspect ratio of the page with the aspect ratio of the
+	// we do this first by comparing the aspec ratio of the page with the aspect ratio of the
 	// area to fit it within. If the aspect ratio of the page is larger, then we need to scale
 	// the width of the page to fill perfectly within the height of the area. Otherwise, we
 	// scale the height to fit perfectly. The dimension that _is not_ scaled to fit perfectly

src/main.rs

@@ -1,4 +1,7 @@
-use core::{error::Error, num::NonZeroUsize};
+use core::{
+	error::Error,
+	num::{NonZeroU32, NonZeroUsize}
+};
 use std::{
 	borrow::Cow,
 	ffi::OsString,
@@ -13,8 +16,8 @@ use crossterm::{
 	event::EventStream,
 	execute,
 	terminal::{
-		EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen, WindowSize,
-		disable_raw_mode, enable_raw_mode, window_size
+		EndSynchronizedUpdate, EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode,
+		enable_raw_mode, window_size
 	}
 };
 use debounce::EventDebouncer;
@@ -35,11 +38,8 @@ use ratatui_image::{
 use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
-	kitty::{
-		DisplayErr, DisplayErrSource, KittyDisplay, MaybeTmuxWriter, display_kitty_images,
-		do_shms_work, run_action
-	},
-	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
+	kitty::{KittyDisplay, display_kitty_images, do_shms_work, run_action},
+	renderer::{self, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
 
@@ -70,18 +70,11 @@ fn reset_term() {
 	);
 }
 
-fn main() -> Result<(), WrappedErr> {
-	let rt = tokio::runtime::Builder::new_multi_thread()
-		.worker_threads(3)
-		.enable_time()
-		.build()
-		.unwrap();
-
-	rt.block_on(async move {
-		let result = inner_main().await;
-		reset_term();
-		result
-	})
+#[tokio::main]
+async fn main() -> Result<(), WrappedErr> {
+	let result = inner_main().await;
+	reset_term();
+	result
 }
 
 async fn inner_main() -> Result<(), WrappedErr> {
@@ -135,37 +128,21 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.canonicalize()
 		.map_err(|e| WrappedErr(format!("Cannot canonicalize provided file: {e}").into()))?;
 
-	let black = flags
-		.black_color
-		.as_deref()
-		.map(|color| {
-			parse_color_to_i32(color).map_err(|e| {
-				WrappedErr(
-					format!(
-						"Couldn't parse black color {color:?}: {e} - is it formatted like a CSS color?"
-					)
+	let black =
+		parse_color_to_i32(flags.black_color.as_deref().unwrap_or("000000")).map_err(|e| {
+			WrappedErr(
+				format!("Couldn't parse black color: {e} - is it formatted like a CSS color?")
 					.into()
-				)
-			})
-		})
-		.transpose()?
-		.unwrap_or(MUPDF_BLACK);
+			)
+		})?;
 
-	let white = flags
-		.white_color
-		.as_deref()
-		.map(|color| {
-			parse_color_to_i32(color).map_err(|e| {
-				WrappedErr(
-					format!(
-						"Couldn't parse white color {color:?}: {e} - is it formatted like a CSS color?"
-					)
+	let white =
+		parse_color_to_i32(flags.white_color.as_deref().unwrap_or("FFFFFF")).map_err(|e| {
+			WrappedErr(
+				format!("Couldn't parse white color: {e} - is it formatted like a CSS color?")
 					.into()
-				)
-			})
-		})
-		.transpose()?
-		.unwrap_or(MUPDF_WHITE);
+			)
+		})?;
 
 	// need to keep it around throughout the lifetime of the program, but don't rly need to use it.
 	// Just need to make sure it doesn't get dropped yet.
@@ -216,6 +193,10 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		)
 		.map_err(|e| WrappedErr(format!("Can't watch the provided file: {e}").into()))?;
 
+	// TODO: Handle non-utf8 file names? Maybe by constructing a CString and passing that in to the
+	// mupdf stuff instead of a rust string?
+	let file_path = path.clone().into_os_string().to_string_lossy().to_string();
+
 	let mut window_size = window_size().map_err(|e| {
 		WrappedErr(format!("Can't get your current terminal window size: {e}").into())
 	})?;
@@ -248,20 +229,17 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	// We need to create `picker` on this thread because if we create it on the `renderer` thread,
 	// it messes up something with user input. Input never makes it to the crossterm thing
 	let picker = Picker::from_query_stdio()
-		.or_else(|e| match (e, window_size) {
-			(
-				ratatui_image::errors::Errors::NoFontSize,
-				WindowSize { width: 1.., height: 1.., columns: 1.., rows: 1.. }
-			) => {
-				// the 'equivalent' that is suggested instead is not the same. We need to keep
-				// calling this.
-				#[expect(deprecated)]
-				Ok(Picker::from_fontsize((cell_width_px, cell_height_px)))
-			},
-			(ratatui_image::errors::Errors::NoFontSize, _) => Err(WrappedErr(
+		.or_else(|e| match e {
+			ratatui_image::errors::Errors::NoFontSize if
+				window_size.width != 0
+				&& window_size.height != 0
+				&& window_size.columns != 0
+				&& window_size.rows != 0
+					=> Ok(Picker::from_fontsize((cell_width_px, cell_height_px))),
+			ratatui_image::errors::Errors::NoFontSize => Err(WrappedErr(
 				"Unable to detect your terminal's font size; this is an issue with your terminal emulator.\nPlease use a different terminal emulator or report this bug to tdf.".into()
 			)),
-			(e, _) => Err(WrappedErr(format!("Couldn't get the necessary information to set up images: {e}").into()))
+			e => Err(WrappedErr(format!("Couldn't get the necessary information to set up images: {e}").into()))
 		})?;
 
 	// then we want to spawn off the rendering task
@@ -272,7 +250,6 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.and_then(NonZeroUsize::new)
 		.map_or(PrerenderLimit::All, PrerenderLimit::Limited);
 
-	let file_path = path.clone();
 	std::thread::spawn(move || {
 		renderer::start_rendering(
 			&file_path,
@@ -294,9 +271,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let (to_main, from_converter) = flume::unbounded();
 
 	let is_kitty = picker.protocol_type() == ProtocolType::Kitty;
-	let is_tmux = picker.is_tmux();
 
-	let shms_work = is_kitty && do_shms_work(is_tmux, &mut ev_stream).await;
+	let shms_work = is_kitty && do_shms_work(&mut ev_stream).await;
 
 	tokio::spawn(run_conversion_loop(
 		to_main, from_main, picker, 20, shms_work
@@ -321,13 +297,11 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	})?;
 
 	if is_kitty {
-		let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
 		run_action(
 			Action::Delete(DeleteConfig {
 				effect: ClearOrDelete::Delete,
-				which: WhichToDelete::All
+				which: WhichToDelete::IdRange(NonZeroU32::new(1).unwrap()..=NonZeroU32::MAX)
 			}),
-			&mut writer,
 			&mut ev_stream
 		)
 		.await
@@ -349,14 +323,13 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	let tui_rx = tui_rx.into_stream();
 	let from_converter = from_converter.into_stream();
 
-	let res = enter_redraw_loop(
-		&mut ev_stream,
+	enter_redraw_loop(
+		ev_stream,
 		to_renderer,
 		tui_rx,
 		to_converter,
 		from_converter,
 		fullscreen,
-		is_tmux,
 		tui,
 		&mut term,
 		main_area,
@@ -370,42 +343,26 @@ async fn inner_main() -> Result<(), WrappedErr> {
 			)
 			.into()
 		)
-	});
+	})?;
 
-	if is_kitty {
-		let mut writer = MaybeTmuxWriter::new(stdout().lock(), is_tmux);
-		_ = run_action(
-			Action::Delete(DeleteConfig {
-				effect: ClearOrDelete::Delete,
-				which: WhichToDelete::All
-			}),
-			&mut writer,
-			&mut ev_stream
-		)
-		.await;
-	}
 	drop(maybe_logger);
-
-	res
+	Ok(())
 }
 
 // oh shut up clippy who cares
 #[expect(clippy::too_many_arguments)]
 async fn enter_redraw_loop(
-	ev_stream: &mut EventStream,
+	mut ev_stream: EventStream,
 	to_renderer: Sender<RenderNotif>,
 	mut tui_rx: RecvStream<'_, Result<RenderInfo, RenderError>>,
 	to_converter: Sender<ConverterMsg>,
 	mut from_converter: RecvStream<'_, Result<ConvertedPage, RenderError>>,
 	mut fullscreen: bool,
-	is_tmux: bool,
 	mut tui: Tui,
 	term: &mut Terminal<CrosstermBackend<Stdout>>,
 	mut main_area: tdf::tui::RenderLayout,
 	font_size: FontSize
 ) -> Result<(), Box<dyn Error>> {
-	let mut kitty_z_idx = i32::MIN;
-
 	loop {
 		let mut needs_redraw = true;
 		let next_ev = ev_stream.next().fuse();
@@ -426,7 +383,6 @@ async fn enter_redraw_loop(
 						},
 						InputAction::Search(term) => to_renderer.send(RenderNotif::Search(term))?,
 						InputAction::Invert => to_renderer.send(RenderNotif::Invert)?,
-						InputAction::Rotate => to_renderer.send(RenderNotif::Rotate)?,
 						InputAction::Fullscreen => fullscreen = !fullscreen,
 						InputAction::SwitchRenderZoom(f_or_f) => {
 							to_renderer.send(RenderNotif::SwitchFitOrFill(f_or_f)).unwrap();
@@ -478,16 +434,10 @@ async fn enter_redraw_loop(
 				to_display = tui.render(f, &main_area, font_size);
 			})?;
 
-			let maybe_err =
-				display_kitty_images(to_display, is_tmux, ev_stream, &mut kitty_z_idx).await;
+			let maybe_err = display_kitty_images(to_display, &mut ev_stream).await;
 
-			if let Err(DisplayErr {
-				failed_pages,
-				user_facing_err,
-				source
-			}) = maybe_err
-			{
-				match source {
+			if let Err((to_replace, err_desc, enum_err)) = maybe_err {
+				match enum_err {
 					// This is the error that kitty & ghostty provide us when they delete an
 					// image due to memory constraints, so if we get it, we just fix it by
 					// re-rendering so it don't display it to the user
@@ -495,15 +445,13 @@ async fn enter_redraw_loop(
 					// [TODO] maybe when we detect that an image was deleted, we probe the
 					// terminal for the pages around it to see if they were deleted too and if
 					// they were, we re-render them? idk
-					DisplayErrSource::Transmission(TransmitError::Terminal(
-						TerminalError::NoEntity(_)
-					)) => (),
+					TransmitError::Terminal(TerminalError::NoEntity(_)) => (),
 					_ => tui.set_msg(MessageSetting::Some(BottomMessage::Error(format!(
-						"{user_facing_err}: {source}"
+						"{err_desc}: {enum_err}"
 					))))
 				}
 
-				for page_num in failed_pages {
+				for page_num in to_replace {
 					tui.page_failed_display(page_num);
 					// So that they get re-rendered and sent over again
 					to_renderer.send(RenderNotif::PageNeedsReRender(page_num))?;

src/renderer.rs

@@ -1,4 +1,4 @@
-use std::{collections::VecDeque, num::NonZeroUsize, path::Path, thread::sleep, time::Duration};
+use std::{collections::VecDeque, num::NonZeroUsize, thread::sleep, time::Duration};
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
 use mupdf::{
@@ -20,8 +20,7 @@ pub enum RenderNotif {
 	Search(String),
 	SwitchFitOrFill(FitOrFill),
 	Reload,
-	Invert,
-	Rotate
+	Invert
 }
 
 #[derive(Debug)]
@@ -38,14 +37,6 @@ pub enum RenderInfo {
 	Reloaded
 }
 
-#[derive(Debug, Copy, Clone)]
-pub enum RotateDirection {
-	Deg0,
-	Deg90,
-	Deg180,
-	Deg270
-}
-
 #[derive(Clone)]
 pub struct PageInfo {
 	pub img_data: ImageData,
@@ -66,8 +57,8 @@ struct PrevRender {
 	num_search_found: Option<usize>
 }
 
-pub const MUPDF_BLACK: i32 = 0;
-pub const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
+const MUPDF_BLACK: i32 = 0;
+const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
 
 #[inline]
 pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
@@ -89,7 +80,7 @@ pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
 // probably be more performant if accessed by-value instead of through a reference. Probably.
 #[expect(clippy::needless_pass_by_value, clippy::too_many_arguments)]
 pub fn start_rendering(
-	path: &Path,
+	path: &str,
 	sender: Sender<Result<RenderInfo, RenderError>>,
 	receiver: Receiver<RenderNotif>,
 	col_h: u16,
@@ -107,21 +98,13 @@ pub fn start_rendering(
 
 	let mut stored_doc = None;
 	let mut invert = false;
-	let mut rotate = RotateDirection::Deg0;
 	let mut preserved_area = None;
 	let mut fit_or_fill = FitOrFill::Fit;
 
 	let mut need_rerender = VecDeque::new();
 
-	#[cfg(windows)]
-	let path = path.to_string_lossy();
-
 	'reload: loop {
-		// Need to do this weird borrow thing so that we convert `Cow<'_, str>` -> `&str` on windows
-		// and keep unix a `&Path` -> `&Path` 'cause there are different requirements within mupdf
-		// about file paths per-platform
-		#[cfg_attr(unix, expect(clippy::borrow_deref_ref))]
-		let doc = match Document::open(&*path) {
+		let doc = match Document::open(path) {
 			Err(e) => {
 				// if there's an error, tell the main loop
 				sender.send(Err(RenderError::Doc(e)))?;
@@ -169,8 +152,8 @@ pub fn start_rendering(
 
 		sender.send(Ok(RenderInfo::NumPages(n_pages.get())))?;
 
-		// We're using this vec to indicate which page numbers have already been rendered, to
-		// support people jumping to specific pages and having quick rendering results. We
+		// We're using this vec of bools to indicate which page numbers have already been rendered,
+		// to support people jumping to specific pages and having quick rendering results. We
 		// `split_at_mut` at 0 initially (which bascially makes `right == rendered && left == []`),
 		// doing basically nothing, but if we get a notification that something has been jumped to,
 		// then we can split at that page and render at both sides of it
@@ -255,18 +238,6 @@ pub fn start_rendering(
 							}
 							continue 'render_pages;
 						}
-						RenderNotif::Rotate => {
-							rotate = match rotate {
-								RotateDirection::Deg0 => RotateDirection::Deg90,
-								RotateDirection::Deg90 => RotateDirection::Deg180,
-								RotateDirection::Deg180 => RotateDirection::Deg270,
-								RotateDirection::Deg270 => RotateDirection::Deg0
-							};
-							for page in &mut rendered {
-								page.successful = false;
-							}
-							continue 'render_pages;
-						}
 					}
 				}};
 			}
@@ -306,7 +277,7 @@ pub fn start_rendering(
 				// we only want to continue if one of the following is met:
 				// 1. It failed to render last time (we want to retry)
 				// 2. The `contained_term` is set to Unknown, meaning that we need to at least
-				//    check if it contains the current term to see if it needs a re-render
+				//	  check if it contains the current term to see if it needs a re-render
 				if rendered.successful && rendered.num_search_found.is_some() {
 					continue;
 				}
@@ -330,7 +301,6 @@ pub fn start_rendering(
 					black,
 					white,
 					fit_or_fill,
-					rotate,
 					(area_w, area_h)
 				) {
 					// If that fn returned Some, that means it needed to be re-rendered for some
@@ -485,7 +455,6 @@ fn render_single_page_to_ctx(
 	black: i32,
 	white: i32,
 	fit_or_fill: FitOrFill,
-	rotate: RotateDirection,
 	(area_w, area_h): (f32, f32)
 ) -> Result<RenderedContext, mupdf::error::Error> {
 	let result_rects = match prev_render.num_search_found {
@@ -496,12 +465,7 @@ fn render_single_page_to_ctx(
 
 	// then, get the size of the page
 	let bounds = page.bounds()?;
-	let page_dim = match rotate {
-		RotateDirection::Deg0 | RotateDirection::Deg180 =>
-			(bounds.x1 - bounds.x0, bounds.y1 - bounds.y0),
-		RotateDirection::Deg90 | RotateDirection::Deg270 =>
-			(bounds.y1 - bounds.y0, bounds.x1 - bounds.x0),
-	};
+	let page_dim = (bounds.x1 - bounds.x0, bounds.y1 - bounds.y0);
 
 	let scaled = scale_img_for_area(page_dim, (area_w, area_h), fit_or_fill);
 	let ScaledResult {
@@ -518,13 +482,7 @@ fn render_single_page_to_ctx(
 	}
 
 	let colorspace = Colorspace::device_rgb();
-	let mut matrix = Matrix::new_scale(scale_factor, scale_factor);
-	match rotate {
-		RotateDirection::Deg0 => matrix.rotate(0.0),
-		RotateDirection::Deg90 => matrix.rotate(90.0),
-		RotateDirection::Deg180 => matrix.rotate(180.0),
-		RotateDirection::Deg270 => matrix.rotate(270.0)
-	};
+	let matrix = Matrix::new_scale(scale_factor, scale_factor);
 
 	let mut pixmap = page.to_pixmap(&matrix, &colorspace, false, false)?;
 	if invert {
@@ -536,7 +494,6 @@ fn render_single_page_to_ctx(
 	let (x_res, y_res) = pixmap.resolution();
 	let new_x = (x_res as f32 * scale_factor) as i32;
 	let new_y = (y_res as f32 * scale_factor) as i32;
-
 	pixmap.set_resolution(new_x, new_y);
 
 	let result_rects = result_rects
@@ -613,15 +570,4 @@ impl Iterator for PopOnNext<'_> {
 	fn next(&mut self) -> Option<Self::Item> {
 		self.inner.pop_front()
 	}
-
-	fn size_hint(&self) -> (usize, Option<usize>) {
-		let l = self.len();
-		(l, Some(l))
-	}
-}
-
-impl ExactSizeIterator for PopOnNext<'_> {
-	fn len(&self) -> usize {
-		self.inner.len()
-	}
 }

src/tui.rs

@@ -9,6 +9,10 @@ use crossterm::{
 	}
 };
 use kittage::display::DisplayLocation;
+use nix::{
+	sys::signal::{Signal::SIGSTOP, kill},
+	unistd::Pid
+};
 use ratatui::{
 	Frame,
 	layout::{Constraint, Flex, Layout, Position, Rect},
@@ -19,7 +23,6 @@ use ratatui::{
 	widgets::{Block, Borders, Clear, Padding, Paragraph, Wrap}
 };
 use ratatui_image::{FontSize, Image};
-use smallvec::SmallVec;
 
 use crate::{
 	FitOrFill,
@@ -73,7 +76,7 @@ struct PageConstraints {
 	r_to_l: bool
 }
 
-#[derive(Default, Debug, Clone, Copy)]
+#[derive(Default, Debug)]
 struct Zoom {
 	// just how much 'zoom' you have. 0 means it fills the screen (instead of fits), such
 	// that one axis is fully on-screen
@@ -87,7 +90,7 @@ struct Zoom {
 }
 impl Zoom {
 	/// Returns the zoom factor, where 1 is the default and means fill-screen
-	fn factor(self) -> f32 {
+	fn factor(&self) -> f32 {
 		// TODO: Make these configurable once we have a good way to set options after startup
 		const ZOOM_RATE: f32 = 1.1;
 		const ZOOM_RATE_GRANULAR: f32 = 1.05;
@@ -99,70 +102,6 @@ impl Zoom {
 			ZOOM_RATE_GRANULAR.powi(self.level.into())
 		}
 	}
-
-	fn step_in(&mut self) {
-		self.level = self.level.saturating_add(1);
-	}
-	fn step_out(&mut self) {
-		self.level = self.level.saturating_sub(1);
-	}
-
-	// TODO: Make this configurable, maybe allow fractional steps?
-	// With fractional steps, it might also be a good idea to have these
-	// have the same ratio as the font aspect ratio.
-	const PAN_STEP_X: i16 = 2;
-	const PAN_STEP_Y: i16 = 1;
-
-	fn pan(&mut self, direction: Direction) {
-		let (target, sign) = match direction {
-			Direction::Up => (&mut self.cell_pan_from_top, -1),
-			Direction::Down => (&mut self.cell_pan_from_top, 1),
-			Direction::Left => (&mut self.cell_pan_from_left, -1),
-			Direction::Right => (&mut self.cell_pan_from_left, 1)
-		};
-		let step = if direction.is_vertical() {
-			Self::PAN_STEP_Y
-		} else {
-			Self::PAN_STEP_X
-		};
-		*target = target.saturating_add_signed(sign * step);
-	}
-	fn pan_bottom(&mut self) {
-		self.cell_pan_from_top = 0;
-	}
-	fn pan_top(&mut self) {
-		self.cell_pan_from_top = u16::MAX;
-	}
-	fn pan_left(&mut self) {
-		self.cell_pan_from_left = 0;
-	}
-	fn pan_right(&mut self) {
-		self.cell_pan_from_left = u16::MAX;
-	}
-}
-#[derive(Clone, Copy, Debug)]
-enum Direction {
-	Up,
-	Down,
-	Left,
-	Right
-}
-impl Direction {
-	/// Flips the directions for vertical and horizonal panning.
-	fn flip_mouse_xy(self) -> Self {
-		match self {
-			Self::Up => Self::Left,
-			Self::Left => Self::Up,
-			Self::Down => Self::Right,
-			Self::Right => Self::Down
-		}
-	}
-	fn is_vertical(self) -> bool {
-		match self {
-			Self::Up | Self::Down => true,
-			Self::Left | Self::Right => false
-		}
-	}
 }
 
 // This seems like a kinda weird struct because it holds two optionals but any representation
@@ -263,7 +202,7 @@ impl Tui {
 			let img_page_w_ratio = img_section_w / initial_page_w;
 			let img_page_h_ratio = img_section_h / initial_page_h;
 
-			fn shrink_move_page(dim: &mut u16, pos: &mut u16, axis_zoom_factor: f32) {
+			let shrink_move_page = |dim: &mut u16, pos: &mut u16, axis_zoom_factor: f32| {
 				let old_dim = *dim;
 				// The axis zoom factor tells us what portion of the axis
 				// we need to show.
@@ -273,56 +212,26 @@ impl Tui {
 					.checked_sub(*dim)
 					.expect("zooming out should shrink the image")
 					/ 2;
-			}
-
-			fn shrink_move_two_pass(
-				zoom: &mut Zoom,
-				dim: &mut u16,
-				pos: &mut u16,
-				zoom_factor: f32,
-				axis_zoom_factor: f32
-			) {
-				// To detect if we're already at fit-screen, we perform a first
-				// pass on `img_area` that emulates the last call to
-				// `render_zoomed` by subtracting from the `zoom`'s level. This
-				// holds because the `img_area` that gets passed is always the
-				// same.
-				let mut first_pass_dim = *dim;
-				let mut first_pass_pos = *pos;
-				let mut first_pass_zoom = *zoom;
-
-				if first_pass_zoom.level.is_negative() {
-					first_pass_zoom.step_in();
-				}
-				let first_pass_zoom_factor = first_pass_zoom.factor();
-				shrink_move_page(
-					&mut first_pass_dim,
-					&mut first_pass_pos,
-					first_pass_zoom_factor.max(1.0 / axis_zoom_factor)
-				);
-
-				log::debug!("first_pass_dim: {first_pass_dim}, first_pass_pos: {first_pass_pos}");
-				// vertical scroll / tall image. zooming out means decreasing
-				// the width of the page area
-				// use `max` to disallow zooming out past fit-screen
-				shrink_move_page(dim, pos, zoom_factor.max(1.0 / axis_zoom_factor));
-
-				log::debug!("new dim: {dim}, new pos: {pos}");
-				// The moment the image area is left unmodified, we've hit
-				// fit-screen and the zoom level ought be normalized.
-				if first_pass_dim == *dim && first_pass_pos == *pos {
-					zoom.step_in();
-				}
-			}
-
-			let (dim, pos, axis_zoom_factor) = if img_page_w_ratio < img_page_h_ratio {
-				(&mut img_area.width, &mut img_area.x, img_page_h_ratio)
-			} else {
-				// horizontal scroll / wide image. zooming out means decreasing
-				// the height of the page area
-				(&mut img_area.height, &mut img_area.y, img_page_w_ratio)
 			};
-			shrink_move_two_pass(zoom, dim, pos, zoom_factor, axis_zoom_factor);
+
+			// TODO: Detect max zoom-out in zoom levels
+			if img_page_w_ratio < img_page_h_ratio {
+				// vertical scroll / tall image. zooming out means decreasing the width of the page area
+				shrink_move_page(
+					&mut img_area.width,
+					&mut img_area.x,
+					// disallow zooming out past fit-screen
+					zoom_factor.max(1.0 / img_page_h_ratio)
+				);
+			} else {
+				// horizontal scroll / wide image. zooming out means decreasing the width of the page area
+				shrink_move_page(
+					&mut img_area.height,
+					&mut img_area.y,
+					// disallow zooming out past fit-screen
+					zoom_factor.max(1.0 / img_page_w_ratio)
+				);
+			}
 		}
 		log::debug!("after adjustment, page area is {img_area:#?}");
 
@@ -360,7 +269,7 @@ impl Tui {
 			.cell_pan_from_top
 			.min(img_cell_h.saturating_sub(img_section_h.ceil() as u16));
 
-		KittyDisplay::DisplayImages(SmallVec::from([KittyReadyToDisplay {
+		KittyDisplay::DisplayImages(vec![KittyReadyToDisplay {
 			img,
 			page_num,
 			pos: Position {
@@ -376,9 +285,10 @@ impl Tui {
 				rows: img_area.height,
 				..DisplayLocation::default()
 			}
-		}]))
+		}])
 	}
 
+	// TODO: Make a way to fill the width of the screen with one page and scroll down to view it
 	#[must_use]
 	pub fn render<'s>(
 		&'s mut self,
@@ -518,7 +428,7 @@ impl Tui {
 						display_loc: DisplayLocation::default()
 					})
 				})
-				.collect::<SmallVec<_>>();
+				.collect::<Vec<_>>();
 
 			// we want to set this at the very end so it doesn't get set somewhere halfway through and
 			// then the whole diffing thing messes it up
@@ -727,146 +637,160 @@ impl Tui {
 			InputAction::JumpingToPage(new_page)
 		}
 
-		let can_zoom = self.is_kitty && self.zoom.is_some();
-
 		match ev {
 			Event::Key(key) => {
 				match key.code {
-					KeyCode::Char(c)
+					KeyCode::Char(c) => {
+						// TODO: refactor back to `if let` arm guards when those are stabilized
 						if let BottomMessage::Input(InputCommand::Search(ref mut term)) =
-							self.bottom_msg =>
-					{
-						term.push(c);
-						InputAction::Redraw.into()
-					}
-					KeyCode::Char(c)
+							self.bottom_msg
+						{
+							term.push(c);
+							return Some(InputAction::Redraw);
+						}
+
 						if let BottomMessage::Input(InputCommand::GoToPage(ref mut page)) =
-							self.bottom_msg && matches!(c, 'g' if self.is_kitty) =>
-						c.to_digit(10).map(|input_num| {
-							*page = (*page * 10) + input_num as usize;
-							InputAction::Redraw
-						}),
-					KeyCode::Char(_)
-						if let BottomMessage::Input(InputCommand::GoToPage(_)) =
-							self.bottom_msg =>
-					{
-						self.set_msg(MessageSetting::Pop);
-						self.update_zoom(Zoom::pan_bottom)
-					}
-					KeyCode::Char(c) => match c {
-						'l' => self.change_page(PageChange::Next, ChangeAmount::Single),
-						'j' => self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
-						'h' => self.change_page(PageChange::Prev, ChangeAmount::Single),
-						'k' => self.change_page(PageChange::Prev, ChangeAmount::WholeScreen),
-						'q' => Some(InputAction::QuitApp),
-						'g' => {
-							self.set_msg(MessageSetting::Some(BottomMessage::Input(
-								InputCommand::GoToPage(0)
-							)));
-							Some(InputAction::Redraw)
-						}
-						'/' => {
-							self.set_msg(MessageSetting::Some(BottomMessage::Input(
-								InputCommand::Search(String::new())
-							)));
-							Some(InputAction::Redraw)
-						}
-						'i' => Some(InputAction::Invert),
-						'?' => {
-							self.showing_help_msg = true;
-							Some(InputAction::Redraw)
-						}
-						'f' => Some(InputAction::Fullscreen),
-						// TODO: If we can't find one, then maybe like block until we've verified
-						// all the pages have been checked?
-						'n' if self.page < self.rendered.len() - 1 => self.rendered
-							[(self.page + 1)..]
-							.iter()
-							.enumerate()
-							.find_map(|(idx, p)| {
-								p.num_results
-									.is_some_and(|num| num > 0)
-									.then_some(self.page + 1 + idx)
-							})
-							.map(|next_page| {
-								jump_to_page(&mut self.page, &mut self.last_render.rect, next_page)
-							}),
-						'N' if self.page > 0 => self.rendered[..(self.page)]
-							.iter()
-							.rev()
-							.enumerate()
-							.find_map(|(idx, p)| {
-								p.num_results
-									.is_some_and(|num| num > 0)
-									.then_some(self.page - (idx + 1))
-							})
-							.map(|prev_page| {
-								jump_to_page(&mut self.page, &mut self.last_render.rect, prev_page)
-							}),
-						'z' if key.modifiers.contains(KeyModifiers::CONTROL) => {
-							// [todo] better error handling here?
+							self.bottom_msg
+						{
+							if c == 'g' && self.is_kitty {
+								self.update_zoom(|z| z.cell_pan_from_top = 0);
+								self.set_msg(MessageSetting::Pop);
+								return Some(InputAction::Redraw);
+							}
 
-							let mut backend = stdout();
-							execute!(
-								&mut backend,
-								LeaveAlternateScreen,
-								crossterm::cursor::Show,
-								crossterm::event::DisableMouseCapture
-							)
-							.unwrap();
-							disable_raw_mode().unwrap();
+							return c.to_digit(10).map(|input_num| {
+								*page = (*page * 10) + input_num as usize;
+								InputAction::Redraw
+							});
+						}
+
+						match c {
+							'l' => self.change_page(PageChange::Next, ChangeAmount::Single),
+							'j' => self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
+							'h' => self.change_page(PageChange::Prev, ChangeAmount::Single),
+							'k' => self.change_page(PageChange::Prev, ChangeAmount::WholeScreen),
+							'q' => Some(InputAction::QuitApp),
+							'g' => {
+								self.set_msg(MessageSetting::Some(BottomMessage::Input(
+									InputCommand::GoToPage(0)
+								)));
+								Some(InputAction::Redraw)
+							}
+							'/' => {
+								self.set_msg(MessageSetting::Some(BottomMessage::Input(
+									InputCommand::Search(String::new())
+								)));
+								Some(InputAction::Redraw)
+							}
+							'i' => Some(InputAction::Invert),
+							'?' => {
+								self.showing_help_msg = true;
+								Some(InputAction::Redraw)
+							}
+							'f' => Some(InputAction::Fullscreen),
+							'n' if self.page < self.rendered.len() - 1 => {
+								// TODO: If we can't find one, then maybe like block until we've verified
+								// all the pages have been checked?
+								self.rendered[(self.page + 1)..]
+									.iter()
+									.enumerate()
+									.find_map(|(idx, p)| {
+										p.num_results
+											.is_some_and(|num| num > 0)
+											.then_some(self.page + 1 + idx)
+									})
+									.map(|next_page| {
+										jump_to_page(
+											&mut self.page,
+											&mut self.last_render.rect,
+											next_page
+										)
+									})
+							}
+							'N' if self.page > 0 => self.rendered[..(self.page)]
+								.iter()
+								.rev()
+								.enumerate()
+								.find_map(|(idx, p)| {
+									p.num_results
+										.is_some_and(|num| num > 0)
+										.then_some(self.page - (idx + 1))
+								})
+								.map(|prev_page| {
+									jump_to_page(
+										&mut self.page,
+										&mut self.last_render.rect,
+										prev_page
+									)
+								}),
+							'z' if key.modifiers.contains(KeyModifiers::CONTROL) => {
+								// [todo] better error handling here?
+
+								let mut backend = stdout();
+								execute!(
+									&mut backend,
+									LeaveAlternateScreen,
+									crossterm::cursor::Show,
+									crossterm::event::DisableMouseCapture
+								)
+								.unwrap();
+								disable_raw_mode().unwrap();
 
-							#[cfg(unix)]
-							{
 								// This process will hang after the SIGSTOP call until we get
 								// foregrounded again by something else, at which point we need to
 								// re-setup everything so that it all gets drawn again.
-								nix::sys::signal::kill(
-									nix::unistd::Pid::this(),
-									nix::sys::signal::Signal::SIGSTOP
+								kill(Pid::this(), SIGSTOP).unwrap();
+
+								enable_raw_mode().unwrap();
+								execute!(
+									&mut backend,
+									EnterAlternateScreen,
+									crossterm::cursor::Hide,
+									crossterm::event::EnableMouseCapture
 								)
 								.unwrap();
+
+								self.last_render.rect = Rect::default();
+								Some(InputAction::Redraw)
 							}
-
-							enable_raw_mode().unwrap();
-							execute!(
-								&mut backend,
-								EnterAlternateScreen,
-								crossterm::cursor::Hide,
-								crossterm::event::EnableMouseCapture
-							)
-							.unwrap();
-
-							self.last_render.rect = Rect::default();
-							Some(InputAction::Redraw)
+							'z' if self.is_kitty => {
+								let (zoom, f_or_f) = match self.zoom {
+									None => (Some(Zoom::default()), FitOrFill::Fill),
+									Some(_) => (None, FitOrFill::Fit)
+								};
+								self.zoom = zoom;
+								self.last_render.rect = Rect::default();
+								Some(InputAction::SwitchRenderZoom(f_or_f))
+							}
+							'o' if self.is_kitty =>
+								self.update_zoom(|z| z.level = z.level.saturating_add(1)),
+							'O' if self.is_kitty =>
+								self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
+							'L' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_left = z.cell_pan_from_left.saturating_add(1);
+							}),
+							'H' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_left = z.cell_pan_from_left.saturating_sub(1);
+							}),
+							'J' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_top = z.cell_pan_from_top.saturating_add(1);
+							}),
+							'K' if self.is_kitty => self.update_zoom(|z| {
+								z.cell_pan_from_top = z.cell_pan_from_top.saturating_sub(1);
+							}),
+							'G' if self.is_kitty =>
+								self.update_zoom(|z| z.cell_pan_from_top = u16::MAX),
+							_ => None
 						}
-						'z' if self.is_kitty => {
-							let (zoom, f_or_f) = match self.zoom {
-								None => (Some(Zoom::default()), FitOrFill::Fill),
-								Some(_) => (None, FitOrFill::Fit)
-							};
-							self.zoom = zoom;
-							self.last_render.rect = Rect::default();
-							Some(InputAction::SwitchRenderZoom(f_or_f))
-						}
-						'o' if can_zoom => self.update_zoom(Zoom::step_in),
-						'O' if can_zoom => self.update_zoom(Zoom::step_out),
-						'L' if can_zoom => self.update_zoom(|z| z.pan(Direction::Right)),
-						'H' if can_zoom => self.update_zoom(|z| z.pan(Direction::Left)),
-						'J' if can_zoom => self.update_zoom(|z| z.pan(Direction::Down)),
-						'K' if can_zoom => self.update_zoom(|z| z.pan(Direction::Up)),
-						'G' if can_zoom => self.update_zoom(Zoom::pan_top),
-						'0' if can_zoom => self.update_zoom(Zoom::pan_left),
-						'$' if can_zoom => self.update_zoom(Zoom::pan_right),
-						'r' => Some(InputAction::Rotate),
-						_ => None
-					},
-					KeyCode::Backspace
+					}
+					KeyCode::Backspace => {
 						if let BottomMessage::Input(InputCommand::Search(ref mut term)) =
-							self.bottom_msg =>
-					{
-						term.pop();
-						InputAction::Redraw.into()
+							self.bottom_msg
+						{
+							term.pop();
+							return Some(InputAction::Redraw);
+						}
+						None
 					}
 					KeyCode::Right => self.change_page(PageChange::Next, ChangeAmount::Single),
 					KeyCode::Down | KeyCode::PageDown =>
@@ -942,36 +866,29 @@ impl Tui {
 				}
 			}
 			Event::Mouse(mouse) => {
-				let mut handle_scroll = |mut direction: Direction| {
-					if can_zoom {
-						if mouse.modifiers.contains(KeyModifiers::CONTROL) {
-							match direction {
-								Direction::Up => self.update_zoom(Zoom::step_in),
-								Direction::Down => self.update_zoom(Zoom::step_out),
-								_ => None
-							}
-						} else {
-							if mouse.modifiers.contains(KeyModifiers::SHIFT) {
-								direction = direction.flip_mouse_xy();
-							}
-							self.update_zoom(|z| z.pan(direction))
-						}
-					} else {
-						let (change, amount) = match direction {
-							Direction::Right => (PageChange::Next, ChangeAmount::Single),
-							Direction::Down => (PageChange::Next, ChangeAmount::WholeScreen),
-							Direction::Left => (PageChange::Prev, ChangeAmount::Single),
-							Direction::Up => (PageChange::Prev, ChangeAmount::WholeScreen)
-						};
-						self.change_page(change, amount)
+				if mouse.modifiers.contains(KeyModifiers::CONTROL)
+					&& self.is_kitty
+					&& self.zoom.is_some()
+				{
+					match mouse.kind {
+						MouseEventKind::ScrollUp =>
+							self.update_zoom(|z| z.level = z.level.saturating_add(1).min(0)),
+						MouseEventKind::ScrollDown =>
+							self.update_zoom(|z| z.level = z.level.saturating_sub(1)),
+						_ => None
+					}
+				} else {
+					match mouse.kind {
+						MouseEventKind::ScrollRight =>
+							self.change_page(PageChange::Next, ChangeAmount::Single),
+						MouseEventKind::ScrollDown =>
+							self.change_page(PageChange::Next, ChangeAmount::WholeScreen),
+						MouseEventKind::ScrollLeft =>
+							self.change_page(PageChange::Prev, ChangeAmount::Single),
+						MouseEventKind::ScrollUp =>
+							self.change_page(PageChange::Prev, ChangeAmount::WholeScreen),
+						_ => None
 					}
-				};
-				match mouse.kind {
-					MouseEventKind::ScrollRight => handle_scroll(Direction::Right),
-					MouseEventKind::ScrollDown => handle_scroll(Direction::Down),
-					MouseEventKind::ScrollLeft => handle_scroll(Direction::Left),
-					MouseEventKind::ScrollUp => handle_scroll(Direction::Up),
-					_ => None
 				}
 			}
 			Event::Resize(_, _) => Some(InputAction::Redraw),
@@ -1125,10 +1042,6 @@ gg/G (when on fill-screen):
     Scroll to top/bottom of page
 H, J, K, L (when zoomed in):
     Pan direction around page
-0/$ (when on fill-screen):
-    Scroll to left/right side of page
-r:
-		Rotate by 90 degrees
 ";
 
 pub enum InputAction {
@@ -1137,7 +1050,6 @@ pub enum InputAction {
 	Search(String),
 	QuitApp,
 	Invert,
-	Rotate,
 	Fullscreen,
 	SwitchRenderZoom(crate::FitOrFill)
 }