Require CI to run with locked flag so lockfile is always in sync

.editorconfig

@@ -1,2 +0,0 @@
-[*.rs]
-indent_style = tab

.github/workflows/rust.yml

@@ -2,107 +2,41 @@ name: Rust
 
 on:
   push:
-    branches: ["main"]
+    branches: [ "main" ]
-    tags: ["v*.*.*"]
   pull_request:
-    branches: ["main"]
+    branches: [ "main" ]
-  workflow_dispatch:
-  workflow_call:
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  test-build:
+  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" }
 
-    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'
-      - name: Setup sccache
+      uses: mozilla-actions/sccache-action@v0.0.8
-        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+    - name: Configure sccache
-        uses: mozilla-actions/sccache-action@v0.0.8
+      if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
-      - name: Configure sccache
+      run: |
-        if: github.event_name != 'release' && github.event_name != 'workflow_dispatch'
+        echo "SCCACHE_GHA_ENABLED=true" >> $GITHUB_ENV
-        run: |
+        echo "RUSTC_WRAPPER=sccache" >> $GITHUB_ENV
-          echo "SCCACHE_GHA_ENABLED=true" >> "$GITHUB_ENV"
+    - name: Install build dependencies
-          echo "RUSTC_WRAPPER=sccache" >> "$GITHUB_ENV"
+      run: |
-
+        sudo apt-get update
-      - name: Setup rust cache action
+        sudo apt-get install -y libfontconfig1-dev libgoogle-perftools-dev google-perftools
-        uses: swatinem/rust-cache@v2
+    - uses: actions/checkout@v4
-        with:
+    - name: Install clippy and fmt
-          cache-on-failure: true
+      run: rustup component add clippy rustfmt
-
+    - name: Clippy
-      - name: install build dependencies on ubuntu and cache
+      run: cargo clippy --locked -- -D warnings
-        if: contains(matrix.os, 'ubuntu')
+    - name: Tests
-        uses: awalsh128/cache-apt-pkgs-action@latest
+      run: cargo test --locked
-        with:
+    - name: Check fmt
-          packages: libfontconfig1-dev libgoogle-perftools-dev google-perftools
+      run: cargo fmt -- --check
-          version: latest # could be anything
+    - name: Run benchmarks as tests
-
+      run: cargo test --locked --benches -- adobe_example
-      - name: Install clippy and fmt
+    - name: Build
-        run: rustup component add clippy rustfmt
+      run: cargo build --locked
-      - 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') }}

.gitignore

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

CHANGELOG.md

@@ -1,30 +1,6 @@
 # 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`)
-- Allow boolean arguments to function as flags, without a `true` or `false` argument following the flag itself ([#109](https://github.com/itsjunetime/tdf/pull/109), thanks [@tatounee](https://github.com/tatounee)!)
-- Fix cropping issues when zooming out too much while using kitty protocol
-- Added `gg` and `G` keybindings for scrolling to the top and bottom of a page, respectively, when filling the width of the screen with kitty
-- Updated help page to only show kitty keybindings when you're actually using kitty
-- Map page-up and page-down keybindings to do the same thing as up-key and down-key ([#115](https://github.com/itsjunetime/tdf/pull/115), thanks [@maxdexh](https://github.com/maxdexh)!)
-- Vertically center pages within the available space if they are not constrained by the height ([#116](https://github.com/itsjunetime/tdf/pull/116), thanks [@maxdexh](https://github.com/maxdexh)!)
-- Fixed issue with cooked mode not being restored upon panic/error ([#118](https://github.com/itsjunetime/tdf/pull/118), thanks [@maxdexh](https://github.com/maxdexh)!)
-- Implemented a debounce for file reload updates to prevent some editors from paralyzing the app due to a flurry of reloads ([#117](https://github.com/itsjunetime/tdf/pull/117), thanks [@maxdexh](https://github.com/maxdexh))
-- Fixed an overflow when zooming out of horizontal pdfs ([#119](https://github.com/itsjunetime/tdf/pull/119), thanks [@maxdexh](https://github.com/maxdexh)!)
-- Reworked zooming to allow for full zooming in and out and panning in both directions ([#121](https://github.com/itsjunetime/tdf/pull/121), thanks [@maxdexh](https://github.com/maxdexh)!)
-
-# v0.4.3
-
-- Fix issue with some terminals hanging on startup
-- Fix issues with some iterm2-backend terminals not displaying anything
 - Allow using ctrl+scroll to zoom in/out while zoomed using kitty backend
-- (Internal) run CI with `--locked` flag to ensure lockfile is always in-sync
 
 # v0.4.2
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tdf-viewer"
-version = "0.5.0"
+version = "0.4.2"
 authors = ["June Welker <junewelker@gmail.com>"]
 edition = "2024"
 description = "A terminal viewer for PDFs"
@@ -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 = "a276a87cb8e2976442c6cc59db831db81551da89", 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,41 +34,37 @@ 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"] }
+nix = { version = "0.30.0", features = ["signal"] }
-mupdf = { git = "https://github.com/messense/mupdf-rs.git", rev = "d7441b9998c92135e329559c0aa71d9dc92cf4de", default-features = false, features = ["svg", "system-fonts", "img"] }
+mupdf = { version = "0.5.0", default-features = false, features = ["svg", "system-fonts", "img"] }
-rayon = { version = "1", default-features = false }
+rayon = { version = "*", default-features = false }
 # kittage = { path = "../kittage/", features = ["crossterm-tokio", "image-crate", "log"] }
-kittage = { version = "0.4.0", features = ["crossterm-tokio", "image-crate", "log"] }
+kittage = { git = "https://github.com/itsjunetime/kittage.git", features = ["crossterm-tokio", "image-crate", "log"] }
-memmap2 = "0"
+memmap2 = "*"
-csscolorparser = { version = "0.8.0", default-features = false }
-debounce = "0.2.2"
-smallvec = "1"
 
 # logging
 log = "0.4.27"
 flexi_logger = "0.31"
 
 # for tracing with tokio-console
-console-subscriber = { version = "0.5.0", optional = true }
+console-subscriber = { version = "0.4.0", optional = true }
-
+csscolorparser = { version = "0.7.0" }
-[patch.crates-io]
-pathfinder_simd = { git = "https://github.com/itsjunetime/pathfinder.git", rev = "814671e162a1829e074521446317b915311d3d4d" }
 
 [profile.production]
 inherits = "release"
 lto = "fat"
 
 [features]
-default = []
+default = ["nightly"]
+nightly = ["ratatui-image/vb64"]
 tracing = ["tokio/tracing", "dep:console-subscriber"]
 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]]
@@ -80,205 +76,90 @@ name = "for_profiling"
 path = "./benches/for_profiling.rs"
 
 [lints.clippy]
-alloc_instead_of_core = "warn"
+uninlined_format_args = "warn"
-allow_attributes = "warn"
+redundant_closure_for_method_calls = "warn"
-as_pointer_underscore = "warn"
+cast_lossless = "warn"
-as_ptr_cast_mut = "warn"
+single_char_pattern = "warn"
-as_underscore = "warn"
+manual_let_else = "warn"
+ignored_unit_patterns = "warn"
+range_plus_one = "warn"
+unreadable_literal = "warn"
+redundant_else = "warn"
 assigning_clones = "warn"
-assertions_on_result_states = "warn"
 bool_to_int_with_if = "warn"
 borrow_as_ptr = "warn"
-branches_sharing_code = "warn"
-cargo_common_metadata = "warn"
-case_sensitive_file_extension_comparisons = "warn"
-cast_lossless = "warn"
 cast_ptr_alignment = "warn"
-cfg_not_test = "warn"
 checked_conversions = "warn"
-clear_with_drain = "warn"
-cloned_instead_of_copied = "warn"
-coerce_container_to_any = "warn"
-comparison_chain = "warn"
 copy_iterator = "warn"
-create_dir = "warn"
-debug_assert_with_mut_call = "warn"
-decimal_literal_representation = "warn"
 default_trait_access = "warn"
-deref_by_slicing = "warn"
-doc_broken_link = "warn"
-doc_link_code = "warn"
 doc_link_with_quotes = "warn"
-elidable_lifetime_names = "warn"
+empty_enum = "warn"
-empty_drop = "warn"
-empty_enums = "warn"
-empty_enum_variants_with_brackets = "warn"
-empty_structs_with_brackets = "warn"
-equatable_if_let = "warn"
-error_impl_error = "warn"
-expl_impl_clone_on_copy = "warn"
-explicit_deref_methods = "warn"
 explicit_into_iter_loop = "warn"
 explicit_iter_loop = "warn"
-fallible_impl_from = "warn"
-filetype_is_file = "warn"
 filter_map_next = "warn"
 flat_map_option = "warn"
-fn_to_numeric_cast_any = "warn"
 fn_params_excessive_bools = "warn"
-format_collect = "warn"
+from_iter_instead_of_collect = "warn"
-format_push_string = "warn"
-get_unwrap = "warn"
-if_then_some_else_none = "warn"
-ignore_without_reason = "warn"
-ignored_unit_patterns = "warn"
 implicit_clone = "warn"
-imprecise_flops = "warn"
 index_refutable_slice = "warn"
-indexing_slicing = "allow" # can't warn on this cause we basically have to do indexing for some ratatui apis
+inefficient_to_string = "warn"
-infinite_loop = "warn"
 invalid_upcast_comparisons = "warn"
-ip_constant = "warn"
 iter_filter_is_ok = "warn"
 iter_filter_is_some = "warn"
 iter_not_returning_iterator = "warn"
-iter_on_empty_collections = "warn"
-iter_on_single_items = "warn"
-large_digit_groups = "warn"
 large_futures = "warn"
-large_include_file = "warn"
+large_stack_arrays = "warn"
-large_stack_frames = "warn"
 large_types_passed_by_value = "warn"
 linkedlist = "warn"
-literal_string_with_formatting_args = "warn"
-lossy_float_literal = "warn"
 macro_use_imports = "warn"
 manual_assert = "warn"
 manual_instant_elapsed = "warn"
 manual_is_power_of_two = "warn"
 manual_is_variant_and = "warn"
-manual_let_else = "warn"
-manual_midpoint = "warn"
 manual_ok_or = "warn"
+manual_string_new = "warn"
 many_single_char_names = "warn"
-map_err_ignore = "warn"
+manual_unwrap_or = "warn"
-map_unwrap_or = "warn"
-map_with_unused_argument_over_ranges = "warn"
 match_same_arms = "warn"
-match_wild_err_arm = "warn"
 match_wildcard_for_single_variants = "warn"
 maybe_infinite_iter = "warn"
-mem_forget = "warn"
 mismatching_type_param_order = "warn"
-missing_assert_message = "warn"
 missing_fields_in_debug = "warn"
-mixed_read_write_in_expression = "warn"
-multiple_unsafe_ops_per_block = "warn"
-must_use_candidate = "warn"
 mut_mut = "warn"
-mutex_atomic = "warn"
-mutex_integer = "warn"
-naive_bytecount = "warn"
 needless_bitwise_bool = "warn"
-needless_collect = "warn"
 needless_continue = "warn"
 needless_for_each = "warn"
-needless_pass_by_ref_mut = "warn"
 needless_pass_by_value = "warn"
 needless_raw_string_hashes = "warn"
-needless_raw_strings = "warn"
-negative_feature_names = "warn"
 no_effect_underscore_binding = "warn"
 no_mangle_with_rust_abi = "warn"
-non_send_fields_in_send_ty = "warn"
-non_std_lazy_statics = "warn"
-non_zero_suggestions = "warn"
-nonstandard_macro_braces = "warn"
 option_as_ref_cloned = "warn"
 option_option = "warn"
-or_fun_call = "warn"
-path_buf_push_overwrite = "warn"
-pathbuf_init_then_push = "warn"
-precedence_bits = "warn"
 ptr_as_ptr = "warn"
 ptr_cast_constness = "warn"
-pub_underscore_fields = "warn"
-pub_without_shorthand = "warn"
 range_minus_one = "warn"
-range_plus_one = "warn"
-rc_buffer = "warn"
-rc_mutex = "warn"
-read_zero_byte_vec = "warn"
-redundant_clone = "warn"
-redundant_closure_for_method_calls = "warn"
-redundant_else = "warn"
-redundant_pub_crate = "warn"
-redundant_test_prefix = "warn"
 ref_as_ptr = "warn"
 ref_binding_to_reference = "warn"
 ref_option = "warn"
 ref_option_ref = "warn"
-rest_pat_in_fully_bound_structs = "warn"
 return_self_not_must_use = "warn"
 same_functions_in_if_condition = "warn"
-self_named_module_files = "warn"
-semicolon_if_nothing_returned = "warn"
-semicolon_inside_block = "warn"
 should_panic_without_expect = "warn"
-significant_drop_in_scrutinee = "warn" # I thought this was fixed in the 2024 edition. watever
+similar_names = "warn"
-significant_drop_tightening = "warn"
-single_char_pattern = "warn"
-single_option_map = "warn"
 stable_sort_primitive = "warn"
 str_split_at_newline = "warn"
-string_lit_as_bytes = "warn"
-string_lit_chars_any = "warn"
-string_slice = "warn"
 struct_excessive_bools = "warn"
 struct_field_names = "warn"
-suboptimal_flops = "warn"
-suspicious_operation_groupings = "warn"
-suspicious_xor_used_as_pow = "warn"
-tests_outside_test_module = "warn"
-trait_duplication_in_bounds = "warn"
 transmute_ptr_to_ptr = "warn"
-trivial_regex = "warn"
 trivially_copy_pass_by_ref = "warn"
-try_err = "warn"
-tuple_array_conversions = "warn"
-type_repetition_in_bounds = "warn"
-unchecked_time_subtraction = "warn"
-undocumented_unsafe_blocks = "warn"
 unicode_not_nfc = "warn"
-uninhabited_references = "warn"
-uninlined_format_args = "warn"
 unnecessary_box_returns = "warn"
-unnecessary_debug_formatting = "warn"
 unnecessary_join = "warn"
 unnecessary_literal_bound = "warn"
-unnecessary_safety_comment = "warn"
-unnecessary_safety_doc = "warn"
-unnecessary_self_imports = "warn"
-unnecessary_semicolon = "warn"
-unnecessary_struct_initialization = "warn"
 unnecessary_wraps = "warn"
 unnested_or_patterns = "warn"
-unreadable_literal = "warn"
-unsafe_derive_deserialize = "warn"
 unused_async = "warn"
-unused_peekable = "warn"
-unused_result_ok = "warn"
-unused_rounding = "warn"
 unused_self = "warn"
-unused_trait_names = "warn"
-use_self = "warn"
 used_underscore_binding = "warn"
 used_underscore_items = "warn"
-useless_let_if_seq = "warn"
-verbose_bit_mask = "warn"
-verbose_file_reads = "warn"
-volatile_composites = "warn"
-while_float = "warn"
-wildcard_dependencies = "warn"
-wildcard_imports = "warn"
 zero_sized_map_values = "warn"

README.md

@@ -16,9 +16,7 @@ Designed to be performant, very responsive, and work well with even very large P
 ## Installation
 
 1. Get the rust toolchain from [rustup.rs](https://rustup.rs)
-2. Run `cargo install --git https://github.com/itsjunetime/tdf.git`
+2. Run `rustup install nightly && cargo +nightly install --git https://github.com/itsjunetime/tdf.git`
-
-If you want to use this with `epub`s or `cbz`s, add `--features epub` or `--features cbz` to the command line (or `--features cbz,epub` for both)
 
 ## To Build
 First, you need to install the system dependencies. This will generally only include `libfontconfig` and `clang`. If you're on linux, these will probably show up in your package manager as something like `libfontconfig1-devel` or `libfontconfig-dev` and just `clang`.
@@ -27,12 +25,10 @@ If it turns out that you're missing one of these, it will fail to compile and te
 
 1. Get the rust toolchain from [rustup.rs](https://rustup.rs)
 2. Clone the repo and `cd` into it
-3. Run `cargo build --release`
+3. Run `cargo +nightly build --release`
 
 The binary should then be found at `./target/release/tdf`.
 
-You can also pull this in via [radicle](https://radicle.xyz) with `rad clone rad:zb11K1XGfQooopqEfwtCMyvbcyK1`
-
 ## Why in the world would you use this?
 
 I dunno. Just for fun, mostly.
@@ -41,6 +37,4 @@ I dunno. Just for fun, mostly.
 
 Yeah, sure. Please do.
 
-Please note, though, that:
+Please note, though, that all contributions will be treated as licensed under MPL-2.0.
-1. No AI-generated or AI-assisted or AI-viewed or AI-anythinged code will be accepted. "AI" is a plague upon this earth and I won't be caught dead pretending it's normal.
-2. All contributions will be treated as licensed under MPL-2.0 :)

benches/for_profiling.rs

@@ -1,5 +1,3 @@
-use ratatui_image::picker::ProtocolType;
-
 mod utils;
 
 const BLACK: i32 = 0;
@@ -14,5 +12,5 @@ async fn main() {
 		.nth(1)
 		.expect("Please enter a file to profile");
 
-	utils::render_doc(file, None, BLACK, WHITE, ProtocolType::Kitty).await;
+	utils::render_doc(file, None, BLACK, WHITE).await;
 }

benches/rendering.rs

@@ -1,15 +1,17 @@
 mod utils;
 
-use std::{hint::black_box, path::Path};
+use std::{
+	hint::black_box,
+	path::Path,
+	time::{SystemTime, UNIX_EPOCH}
+};
 
-use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
+use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main, profiler::Profiler};
-use futures_util::StreamExt as _;
+use futures_util::StreamExt;
-use ratatui_image::picker::ProtocolType;
 use tdf::{
 	converter::{ConvertedPage, ConverterMsg},
 	renderer::{PageInfo, RenderInfo, fill_default}
 };
-use tokio::runtime::Runtime;
 use utils::{
 	RenderState, handle_converter_msg, handle_renderer_msg, render_doc, start_all_rendering,
 	start_converting_loop, start_rendering_loop
@@ -21,108 +23,90 @@ const FILES: [&str; 3] = [
 	"benches/geotopo.pdf"
 ];
 
-const PROTOS: [ProtocolType; 3] = [
-	ProtocolType::Kitty,
-	ProtocolType::Sixel,
-	ProtocolType::Iterm2
-];
-
 const BLACK: i32 = 0;
 const WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
 
-fn for_all_combos(
+fn render_full(c: &mut Criterion) {
-	name: &'static str,
+	for file in FILES {
-	mut f: impl FnMut(&Runtime, BenchmarkId, &'static str, ProtocolType)
+		c.bench_with_input(BenchmarkId::new("render_full", file), &file, |b, &file| {
-) {
+			b.to_async(tokio::runtime::Runtime::new().unwrap())
-	let rt = tokio::runtime::Builder::new_multi_thread()
+				.iter(|| render_doc(file, None, BLACK, WHITE))
-		.worker_threads(3)
+		});
-		.enable_time()
-		.build()
-		.unwrap();
-
-	for proto in PROTOS {
-		for file in FILES {
-			f(
-				&rt,
-				BenchmarkId::new(name, format!("{file},{proto:?}")),
-				file,
-				proto
-			);
-		}
 	}
 }
 
-fn render_full(c: &mut Criterion) {
-	for_all_combos("render_full", |rt, id, file, proto| {
-		_ = c.bench_with_input(id, &file, |b, &file| {
-			b.to_async(rt)
-				.iter(|| render_doc(file, None, BLACK, WHITE, proto));
-		});
-	});
-}
-
 fn render_to_first_page(c: &mut Criterion) {
-	for_all_combos("render_first_page", |rt, id, file, proto| {
+	for file in FILES {
-		c.bench_with_input(id, &file, |b, &file| {
+		c.bench_with_input(
-			b.to_async(rt)
+			BenchmarkId::new("render_first_page", file),
-				.iter(|| render_first_page(file, BLACK, WHITE, proto));
+			&file,
-		});
+			|b, &file| {
-	});
+				b.to_async(tokio::runtime::Runtime::new().unwrap())
+					.iter(|| render_first_page(file, BLACK, WHITE))
+			}
+		);
+	}
 }
 
 fn only_converting(c: &mut Criterion) {
-	for_all_combos("only_converting", |rt, id, file, proto| {
+	for file in FILES {
-		let all_rendered = rt.block_on(render_all_files(file, BLACK, WHITE));
+		let runtime = tokio::runtime::Runtime::new().unwrap();
+		let all_rendered = runtime.block_on(render_all_files(file, BLACK, WHITE));
 
-		c.bench_with_input(id, &all_rendered, |b, rendered| {
+		c.bench_with_input(
-			b.to_async(rt)
+			BenchmarkId::new("only_converting", file),
-				.iter_with_setup(|| rendered.clone(), |f| convert_all_files(f, proto));
+			&(all_rendered, file),
-		});
+			|b, (rendered, _)| {
-	});
+				b.to_async(tokio::runtime::Runtime::new().unwrap())
+					.iter_with_setup(|| rendered.clone(), convert_all_files)
+			}
+		);
+	}
 }
 
-/*
 fn search_short_common(c: &mut Criterion) {
-	for_all_combos("search_short_common", |rt, id, file, proto| {
+	for file in FILES {
-		c.bench_with_input(id, &file, |b, &file| {
+		c.bench_with_input(
-			b.to_async(rt)
+			BenchmarkId::new("search_short_common", file),
-				.iter(|| render_doc(file, Some("an"), BLACK, WHITE, proto))
+			&file,
-		});
+			|b, &file| {
-	});
+				b.to_async(tokio::runtime::Runtime::new().unwrap())
+					.iter(|| render_doc(file, Some("an"), BLACK, WHITE))
+			}
+		);
+	}
 }
 
 fn search_long_rare(c: &mut Criterion) {
-	for_all_combos("search_long_rare", |rt, id, file, proto| {
+	for file in FILES {
-		c.bench_with_input(id, &file, |b, &file| {
+		c.bench_with_input(
-			b.to_async(rt)
+			BenchmarkId::new("search_long_rare", file),
-				.iter(|| render_doc(file, Some("this is long and rare"), BLACK, WHITE, proto))
+			&file,
-		});
+			|b, &file| {
-	});
+				b.to_async(tokio::runtime::Runtime::new().unwrap())
+					.iter(|| render_doc(file, Some("this is long and rare"), BLACK, WHITE))
+			}
+		);
+	}
 }
-*/
 
-pub async fn render_first_page(
+pub async fn render_first_page(path: impl AsRef<Path>, black: i32, white: i32) {
-	path: impl AsRef<Path>,
-	black: i32,
-	white: i32,
-	proto: ProtocolType
-) {
 	let RenderState {
 		mut from_render_rx,
 		mut from_converter_rx,
 		mut pages,
-		to_converter_tx,
+		mut to_converter_tx,
 		to_render_tx
-	} = start_all_rendering(path, black, white, proto);
+	} = start_all_rendering(path, black, white);
 
 	// we only want to render until the first page is ready to be printed
 	while pages.iter().all(Option::is_none) {
 		tokio::select! {
 			Some(renderer_msg) = from_render_rx.next() => {
-				handle_renderer_msg(renderer_msg, &mut pages, &to_converter_tx);
+				handle_renderer_msg(renderer_msg, &mut pages, &mut to_converter_tx);
 			},
 			Some(converter_msg) = from_converter_rx.next() => {
-				handle_converter_msg(converter_msg, &mut pages, &to_converter_tx);
+				handle_converter_msg(converter_msg, &mut pages, &mut to_converter_tx);
 			}
 		}
 	}
@@ -145,7 +129,7 @@ async fn render_all_files(path: &'static str, black: i32, white: i32) -> Vec<Pag
 				let num = page.page_num;
 				pages[num] = Some(page);
 			}
-		}
+		};
 
 		if pages.iter().all(Option::is_some) {
 			break;
@@ -156,9 +140,9 @@ async fn render_all_files(path: &'static str, black: i32, white: i32) -> Vec<Pag
 	pages.into_iter().flatten().collect()
 }
 
-async fn convert_all_files(files: Vec<PageInfo>, proto: ProtocolType) {
+async fn convert_all_files(files: Vec<PageInfo>) {
 	let num_files = files.len();
-	let (mut from_converter_rx, to_converter_tx) = start_converting_loop(proto, num_files);
+	let (mut from_converter_rx, to_converter_tx) = start_converting_loop(num_files);
 
 	to_converter_tx
 		.send(ConverterMsg::NumPages(num_files))
@@ -197,12 +181,10 @@ async fn convert_all_files(files: Vec<PageInfo>, proto: ProtocolType) {
 	black_box(converted);
 }
 
-/*
 struct CpuProfiler;
 
-impl criterion::profiler::Profiler for CpuProfiler {
+impl Profiler for CpuProfiler {
 	fn start_profiling(&mut self, benchmark_id: &str, _: &std::path::Path) {
-		use std::time::{SystemTime, UNIX_EPOCH}
 		let file = format!(
 			"./{}-{}.profile",
 			benchmark_id.replace('/', "-"),
@@ -218,13 +200,10 @@ impl criterion::profiler::Profiler for CpuProfiler {
 		cpuprofiler::PROFILER.lock().unwrap().stop().unwrap();
 	}
 }
-*/
 
 criterion_group!(
 	name = benches;
-	// config = Criterion::default().sample_size(40).with_profiler(CpuProfiler);
+	config = Criterion::default().sample_size(40).with_profiler(CpuProfiler);
-	config = Criterion::default().sample_size(40);
+	targets = render_full, render_to_first_page, only_converting, search_short_common, search_long_rare
-	// targets = render_full, render_to_first_page, only_converting, search_short_common, search_long_rare
-	targets = render_full, render_to_first_page, only_converting
 );
 criterion_main!(benches);

benches/utils.rs

@@ -13,7 +13,7 @@ use tdf::{
 pub fn handle_renderer_msg(
 	msg: Result<RenderInfo, RenderError>,
 	pages: &mut Vec<Option<ConvertedPage>>,
-	to_converter_tx: &Sender<tdf::converter::ConverterMsg>
+	to_converter_tx: &mut Sender<tdf::converter::ConverterMsg>
 ) {
 	match msg {
 		Ok(RenderInfo::NumPages(num)) => {
@@ -30,7 +30,7 @@ pub fn handle_renderer_msg(
 pub fn handle_converter_msg(
 	msg: Result<ConvertedPage, RenderError>,
 	pages: &mut [Option<ConvertedPage>],
-	to_converter_tx: &Sender<ConverterMsg>
+	to_converter_tx: &mut Sender<ConverterMsg>
 ) {
 	let page = msg.expect("Got error from converter");
 	let num = page.num;
@@ -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,
@@ -105,9 +106,7 @@ pub fn start_rendering_loop(
 	(from_render_rx, to_render_tx)
 }
 
-#[must_use]
 pub fn start_converting_loop(
-	proto: ProtocolType,
 	prerender: usize
 ) -> (
 	RecvStream<'static, Result<ConvertedPage, RenderError>>,
@@ -116,9 +115,8 @@ 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);
+	picker.set_protocol_type(ProtocolType::Kitty);
 
 	tokio::spawn(run_conversion_loop(
 		to_main_tx,
@@ -133,14 +131,9 @@ pub fn start_converting_loop(
 	(from_converter_rx, to_converter_tx)
 }
 
-pub fn start_all_rendering(
+pub fn start_all_rendering(path: impl AsRef<Path>, black: i32, white: i32) -> RenderState {
-	path: impl AsRef<Path>,
-	black: i32,
-	white: i32,
-	proto: ProtocolType
-) -> RenderState {
 	let (from_render_rx, to_render_tx) = start_rendering_loop(path, black, white);
-	let (from_converter_rx, to_converter_tx) = start_converting_loop(proto, 20);
+	let (from_converter_rx, to_converter_tx) = start_converting_loop(20);
 
 	let pages: Vec<Option<ConvertedPage>> = Vec::new();
 
@@ -153,20 +146,14 @@ pub fn start_all_rendering(
 	}
 }
 
-pub async fn render_doc(
+pub async fn render_doc(path: impl AsRef<Path>, search_term: Option<&str>, black: i32, white: i32) {
-	path: impl AsRef<Path>,
-	search_term: Option<&str>,
-	black: i32,
-	white: i32,
-	proto: ProtocolType
-) {
 	let RenderState {
 		mut from_render_rx,
 		mut from_converter_rx,
 		mut pages,
-		to_converter_tx,
+		mut to_converter_tx,
 		to_render_tx
-	} = start_all_rendering(path, black, white, proto);
+	} = start_all_rendering(path, black, white);
 
 	if let Some(term) = search_term {
 		to_render_tx
@@ -177,10 +164,10 @@ pub async fn render_doc(
 	while pages.is_empty() || pages.iter().any(Option::is_none) {
 		tokio::select! {
 			Some(renderer_msg) = from_render_rx.next() => {
-				handle_renderer_msg(renderer_msg, &mut pages, &to_converter_tx);
+				handle_renderer_msg(renderer_msg, &mut pages, &mut to_converter_tx);
 			},
 			Some(converter_msg) = from_converter_rx.next() => {
-				handle_converter_msg(converter_msg, &mut pages, &to_converter_tx);
+				handle_converter_msg(converter_msg, &mut pages, &mut to_converter_tx);
 			}
 		}
 	}

shell.nix

@@ -1,11 +0,0 @@
-{
-  pkgs ? import <nixpkgs> { },
-}:
-pkgs.mkShell {
-  nativeBuildInputs = [ pkgs.pkg-config ];
-
-  buildInputs = [
-    pkgs.rustPlatform.bindgenHook
-    pkgs.cairo
-  ];
-}

src/converter.rs

@@ -1,12 +1,11 @@
 use std::{
-	io::Cursor,
 	num::{NonZeroU32, NonZeroUsize},
 	time::{SystemTime, UNIX_EPOCH}
 };
 
 use flume::{Receiver, SendError, Sender, TryRecvError};
-use futures_util::stream::StreamExt as _;
+use futures_util::stream::StreamExt;
-use image::{DynamicImage, codecs::pnm::PnmDecoder};
+use image::DynamicImage;
 use kittage::NumberOrId;
 use ratatui::layout::Rect;
 use ratatui_image::{
@@ -14,7 +13,7 @@ use ratatui_image::{
 	picker::{Picker, ProtocolType},
 	protocol::Protocol
 };
-use rayon::iter::ParallelIterator as _;
+use rayon::iter::ParallelIterator;
 
 use crate::{
 	renderer::{PageInfo, RenderError, fill_default},
@@ -27,7 +26,6 @@ pub enum MaybeTransferred {
 	Transferred(kittage::ImageId)
 }
 
-#[derive(Debug)]
 pub enum ConvertedImage {
 	Generic(Protocol),
 	Kitty {
@@ -38,7 +36,6 @@ pub enum ConvertedImage {
 }
 
 impl ConvertedImage {
-	#[must_use]
 	pub fn w_h(&self) -> (u16, u16) {
 		match self {
 			Self::Generic(prot) => {
@@ -69,7 +66,7 @@ pub enum ConverterMsg {
 pub async fn run_conversion_loop(
 	sender: Sender<Result<ConvertedPage, RenderError>>,
 	receiver: Receiver<ConverterMsg>,
-	picker: Picker,
+	mut picker: Picker,
 	prerender: usize,
 	shms_work: bool
 ) -> Result<(), SendError<Result<ConvertedPage, RenderError>>> {
@@ -79,7 +76,7 @@ pub async fn run_conversion_loop(
 
 	fn next_page(
 		images: &mut [Option<PageInfo>],
-		picker: &Picker,
+		picker: &mut Picker,
 		page: usize,
 		iteration: &mut usize,
 		prerender: usize,
@@ -112,27 +109,23 @@ pub async fn run_conversion_loop(
 			return Ok(None);
 		};
 
-		let decoder = PnmDecoder::new(Cursor::new(&page_info.img_data.pixels)).map_err(|e| {
+		let mut dyn_img = image::load_from_memory_with_format(
-			RenderError::Converting(format!(
+			&page_info.img_data.pixels,
-				"The image data provided from mupdf was not in pnm format ({e}); don't know how to convert"
+			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
+		match dyn_img {
-		// conversions or anything, but just in case some underlying detail of mupdf or image
+			DynamicImage::ImageRgb8(ref mut img) =>
-		// changes, we do the `into` instead of just `match + unreachable!()` to avoid panicking
+				for quad in &*page_info.result_rects {
-		let mut dyn_img = DynamicImage::from_decoder(decoder)
+					img.par_enumerate_pixels_mut()
-			.map_err(|e| RenderError::Converting(format!("Can't load image: {e}")))?
+						.filter(|(x, y, _)| {
-			.into_rgb8();
+							*x > quad.ul_x && *x < quad.lr_x && *y > quad.ul_y && *y < quad.lr_y
-
+						})
-		for quad in &*page_info.result_rects {
+						.for_each(|(_, _, px)| px.0[2] = px.0[2].saturating_sub(u8::MAX / 2));
-			dyn_img
+				},
-				.par_enumerate_pixels_mut()
+			_ => unreachable!()
-				.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));
-		}
 
 		let img_area = Rect {
 			width: page_info.img_data.cell_w,
@@ -141,31 +134,23 @@ 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()
 					.duration_since(UNIX_EPOCH)
 					.unwrap_or_default()
-					.as_nanos() % 1_000_000;
+					.as_millis() % 1_000_000;
 
 				let mut img = if shms_work {
-					let shm_name = format!("/tdf_{pid}_{rn}_{page_num}");
+					kittage::image::Image::shm_from(dyn_img, &format!("tdf_{pid}_{rn}_{page_num}"))
-
+						.map_err(|e| {
-					#[cfg(unix)]
+							RenderError::Converting(format!("Couldn't write to shm: {e}"))
-					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:?}"))
-					})?
 				} 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::new(page_num as u32 + 1).unwrap());
-				img.num_or_id = NumberOrId::Id(NonZeroU32::MIN.saturating_add(page_num as u32));
-
 				ConvertedImage::Kitty {
 					img: MaybeTransferred::NotYet(img),
 					cell_w: page_info.img_data.cell_w,
@@ -183,12 +168,6 @@ pub async fn run_conversion_loop(
 			)
 		};
 
-		log::debug!(
-			"got converted page for num {} with results {:?}",
-			page_info.page_num,
-			page_info.result_rects
-		);
-
 		// update the iteration to the iteration that we stole this image from
 		*iteration = new_iter;
 
@@ -228,7 +207,7 @@ pub async fn run_conversion_loop(
 
 			match next_page(
 				&mut images,
-				&picker,
+				&mut picker,
 				page,
 				&mut iteration,
 				prerender,

src/kitty.rs

@@ -1,4 +1,3 @@
-use core::fmt::Display;
 use std::{io::Write, num::NonZeroU32};
 
 use crossterm::{
@@ -18,7 +17,6 @@ use kittage::{
 	medium::Medium
 };
 use ratatui::layout::Position;
-use smallvec::SmallVec;
 
 use crate::converter::MaybeTransferred;
 
@@ -62,10 +60,10 @@ impl<W: Write> Write for DbgWriter<W> {
 	}
 }
 
-pub async fn run_action<'es>(
+pub async fn run_action<'image, 'data, 'es>(
-	action: Action<'_, '_>,
+	action: Action<'image, 'data>,
 	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: std::io::stdout().lock(),
 		#[cfg(debug_assertions)]
@@ -80,12 +78,7 @@ pub async fn run_action<'es>(
 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}");
+	let Ok(mut k_img) = kittage::image::Image::shm_from(img, &format!("tdf_test_{pid}")) else {
-
-	#[cfg(unix)]
-	let shm_name = &*shm_name;
-
-	let Ok(mut k_img) = kittage::image::Image::shm_from(img, shm_name) else {
 		return false;
 	};
 
@@ -101,51 +94,21 @@ pub async fn do_shms_work(ev_stream: &mut EventStream) -> bool {
 	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<'_>,
-	ev_stream: &'es mut EventStream,
+	ev_stream: &'es mut EventStream
-	last_z_index: &mut i32
+) -> Result<
-) -> Result<(), DisplayErr<'es>> {
+	(),
+	(
+		Vec<usize>,
+		&'static str,
+		TransmitError<<&'es mut EventStream as AsyncInputReader>::Error>
+	)
+> {
 	let images = match display {
 		KittyDisplay::NoChange => return Ok(()),
-		KittyDisplay::ClearImages =>
+		KittyDisplay::DisplayImages(_) | KittyDisplay::ClearImages => {
-			return run_action(
+			run_action(
 				Action::Delete(DeleteConfig {
 					effect: ClearOrDelete::Clear,
 					which: WhichToDelete::All
@@ -153,23 +116,24 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			.map_err(|e| DisplayErr::empty("Couldn't clear previous images", e))
+			.map_err(|e| (vec![], "Couldn't clear previous images", e))?;
-			.map(|_: Option<ImageId>| ()),
+
-		KittyDisplay::DisplayImages(imgs) => imgs
+			let KittyDisplay::DisplayImages(images) = display else {
+				return Ok(());
+			};
+
+			images
+		}
 	};
 
-	let new_z_index = last_z_index.wrapping_add_unsigned(1);
+	let mut err = None;
-
-	let mut err = Ok::<(), (SmallVec<[usize; 2]>, DisplayErrSource<'es>)>(());
 	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,
@@ -199,7 +163,7 @@ 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,
@@ -207,13 +171,15 @@ pub async fn display_kitty_images<'es>(
 					},
 					ev_stream
 				)
-				.await
+				.await;
-				.map_err(DisplayErrSource::Transmission)
+
-				.and_then(|img_id| {
+				match res {
-					img_id
+					Ok(img_id) => {
-						.map(|id| *img = MaybeTransferred::Transferred(id))
+						*img = MaybeTransferred::Transferred(img_id);
-						.ok_or(DisplayErrSource::KittageReturnedNoId)
+						Ok(())
-				})
+					}
+					Err(e) => Err((page_num, e))
+				}
 			}
 			MaybeTransferred::Transferred(image_id) => run_action(
 				Action::Display {
@@ -224,39 +190,20 @@ pub async fn display_kitty_images<'es>(
 				ev_stream
 			)
 			.await
-			// don't need the return id 'cause we already know it
+			.map(|_| ())
-			.map(|_: Option<ImageId>| ())
+			.map_err(|e| (page_num, e))
-			.map_err(DisplayErrSource::Transmission)
 		};
 
 		log::debug!("this_err is {this_err:#?}");
 
-		if let Err(e) = this_err {
+		if let Err((id, e)) = this_err {
-			match err.as_mut() {
+			let e = err.get_or_insert_with(|| (vec![], e));
-				Ok(()) => err = Err((SmallVec::from([page_num].as_slice()), e)),
+			e.0.push(id);
-				Err((v, _)) => v.push(page_num)
-			}
 		}
 	}
 
-	let z_idxes_to_remove = *last_z_index;
-	*last_z_index = new_z_index;
-
 	match err {
-		Err((failed_pages, source)) => Err(DisplayErr {
+		Some((replace, e)) => Err((replace, "Couldn't transfer image to the terminal", e)),
-			failed_pages,
+		None => Ok(())
-			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)
-			}),
-			ev_stream
-		)
-		.await
-		.map_err(|e| DisplayErr::empty("Couldn't clear previously-sent images", e))
-		.map(|_| ())
 	}
 }

src/lib.rs

@@ -27,7 +27,6 @@ pub struct ScaledResult {
 	scale_factor: f32
 }
 
-#[must_use]
 pub fn scale_img_for_area(
 	(img_width, img_height): (f32, f32),
 	(area_width, area_height): (f32, f32),
@@ -42,7 +41,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,15 +1,10 @@
-use core::{
+use core::error::Error;
-	error::Error,
-	num::{NonZeroU32, NonZeroUsize}
-};
 use std::{
 	borrow::Cow,
 	ffi::OsString,
-	io::{BufReader, Read as _, Stdout, Write as _, stdout},
+	io::{BufReader, Read, Stdout, stdout},
-	mem,
+	num::{NonZeroU32, NonZeroUsize},
-	path::PathBuf,
+	path::PathBuf
-	sync::{Arc, Mutex},
-	time::Duration
 };
 
 use crossterm::{
@@ -20,16 +15,15 @@ use crossterm::{
 		enable_raw_mode, window_size
 	}
 };
-use debounce::EventDebouncer;
 use flexi_logger::FileSpec;
 use flume::{Sender, r#async::RecvStream};
-use futures_util::{FutureExt as _, stream::StreamExt as _};
+use futures_util::{FutureExt, stream::StreamExt};
 use kittage::{
 	action::Action,
 	delete::{ClearOrDelete, DeleteConfig, WhichToDelete},
 	error::{TerminalError, TransmitError}
 };
-use notify::{Event, EventKind, RecursiveMode, Watcher as _};
+use notify::{Event, EventKind, RecursiveMode, Watcher};
 use ratatui::{Terminal, backend::CrosstermBackend};
 use ratatui_image::{
 	FontSize,
@@ -38,10 +32,8 @@ use ratatui_image::{
 use tdf::{
 	PrerenderLimit,
 	converter::{ConvertedPage, ConverterMsg, run_conversion_loop},
-	kitty::{
+	kitty::{KittyDisplay, display_kitty_images, do_shms_work, run_action},
-		DisplayErr, DisplayErrSource, KittyDisplay, display_kitty_images, do_shms_work, run_action
+	renderer::{self, RenderError, RenderInfo, RenderNotif},
-	},
-	renderer::{self, MUPDF_BLACK, MUPDF_WHITE, RenderError, RenderInfo, RenderNotif},
 	tui::{BottomMessage, InputAction, MessageSetting, Tui}
 };
 
@@ -62,53 +54,19 @@ impl std::fmt::Debug for WrappedErr {
 
 impl std::error::Error for WrappedErr {}
 
-fn reset_term() {
+#[tokio::main]
-	_ = disable_raw_mode();
+async fn main() -> Result<(), WrappedErr> {
-	_ = execute!(
-		std::io::stdout(),
-		LeaveAlternateScreen,
-		crossterm::cursor::Show,
-		crossterm::event::DisableMouseCapture
-	);
-}
-
-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
-	})
-}
-
-async fn inner_main() -> Result<(), WrappedErr> {
-	let hook = std::panic::take_hook();
-	std::panic::set_hook(Box::new(move |info| {
-		reset_term();
-		hook(info);
-	}));
-
 	#[cfg(feature = "tracing")]
 	console_subscriber::init();
 
-	const DEFAULT_DEBOUNCE_DELAY: Duration = Duration::from_millis(50);
-
 	let flags = xflags::parse_or_exit! {
 		/// Display the pdf with the pages starting at the right hand size and moving left and
 		/// adjust input keys to match
-		optional -r,--r-to-l
+		optional -r,--r-to-l r_to_l: bool
 		/// The maximum number of pages to display together, horizontally, at a time
 		optional -m,--max-wide max_wide: NonZeroUsize
 		/// Fullscreen the pdf (hide document name, page count, etc)
-		optional -f,--fullscreen
+		optional -f,--fullscreen fullscreen: bool
-		/// The time to wait for the file to stop changing before reloading, in milliseconds.
-		/// Defaults to 50ms.
-		optional --reload-delay reload_delay: u64
 		/// The number of pages to prerender surrounding the currently-shown page; 0 means no
 		/// limit. By default, there is no limit.
 		optional -p,--prerender prerender: usize
@@ -137,42 +95,28 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.canonicalize()
 		.map_err(|e| WrappedErr(format!("Cannot canonicalize provided file: {e}").into()))?;
 
-	let black = flags
+	let black =
-		.black_color
+		parse_color_to_i32(flags.black_color.as_deref().unwrap_or("000000")).map_err(|e| {
-		.as_deref()
+			WrappedErr(
-		.map(|color| {
+				format!("Couldn't parse black color: {e} - is it formatted like a CSS 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?"
-					)
 					.into()
-				)
+			)
-			})
+		})?;
-		})
-		.transpose()?
-		.unwrap_or(MUPDF_BLACK);
 
-	let white = flags
+	let white =
-		.white_color
+		parse_color_to_i32(flags.white_color.as_deref().unwrap_or("FFFFFF")).map_err(|e| {
-		.as_deref()
+			WrappedErr(
-		.map(|color| {
+				format!("Couldn't parse white color: {e} - is it formatted like a CSS 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?"
-					)
 					.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.
-	let maybe_logger = if std::env::var("RUST_LOG").is_ok() {
+	let mut maybe_logger = None;
-		Some(
+
+	if std::env::var("RUST_LOG").is_ok() {
+		maybe_logger = Some(
 			flexi_logger::Logger::try_with_env()
 				.map_err(|e| WrappedErr(format!("Couldn't create initial logger: {e}").into()))?
 				.log_to_file(FileSpec::try_from("./debug.log").map_err(|e| {
@@ -180,10 +124,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 				})?)
 				.start()
 				.map_err(|e| WrappedErr(format!("Can't start logger: {e}").into()))?
-		)
+		);
-	} else {
+	}
-		None
-	};
 
 	let (watch_to_render_tx, render_rx) = flume::unbounded();
 	let to_renderer = watch_to_render_tx.clone();
@@ -195,11 +137,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		watch_to_tui_tx,
 		watch_to_render_tx,
 		path.file_name()
-			.ok_or_else(|| WrappedErr("Path does not have a last component??".into()))?
+			.ok_or(WrappedErr("Path does not have a last component??".into()))?
-			.to_owned(),
+			.to_owned()
-		flags
-			.reload_delay
-			.map_or(DEFAULT_DEBOUNCE_DELAY, Duration::from_millis)
 	))
 	.map_err(|e| WrappedErr(format!("Couldn't start watching the provided file: {e}").into()))?;
 
@@ -218,6 +157,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())
 	})?;
@@ -229,44 +172,14 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		window_size.height = h;
 	}
 
-	let cell_height_px = window_size.height / window_size.rows;
-	let cell_width_px = window_size.width / window_size.columns;
-
-	execute!(
-		std::io::stdout(),
-		EnterAlternateScreen,
-		crossterm::cursor::Hide,
-		crossterm::event::EnableMouseCapture
-	)
-	.map_err(|e| {
-		WrappedErr(
-			format!(
-				"Couldn't enter the alternate screen and hide the cursor for proper presentation: {e}"
-			)
-			.into()
-		)
-	})?;
-
 	// 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 {
+		.map_err(|e| WrappedErr(match e {
-			ratatui_image::errors::Errors::NoFontSize if
+			ratatui_image::errors::Errors::NoFontSize =>
-				window_size.width != 0
+				"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(),
-				&& window_size.height != 0
+			e => format!("Couldn't get the necessary information to set up images: {e}").into()
-				&& window_size.columns != 0
+		}))?;
-				&& window_size.rows != 0 =>
-			{
-				// 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(
-				"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()))
-		})?;
 
 	// then we want to spawn off the rendering task
 	// We need to use the thread::spawn API so that this exists in a thread not owned by tokio,
@@ -276,7 +189,8 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		.and_then(NonZeroUsize::new)
 		.map_or(PrerenderLimit::All, PrerenderLimit::Limited);
 
-	let file_path = path.clone();
+	let cell_height_px = window_size.height / window_size.rows;
+	let cell_width_px = window_size.width / window_size.columns;
 	std::thread::spawn(move || {
 		renderer::start_rendering(
 			&file_path,
@@ -309,7 +223,12 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		|| "Unknown file".into(),
 		|n| n.to_string_lossy().to_string()
 	);
-	let tui = Tui::new(file_name, flags.max_wide, flags.r_to_l, is_kitty);
+	let tui = Tui::new(
+		file_name,
+		flags.max_wide,
+		flags.r_to_l.unwrap_or_default(),
+		is_kitty
+	);
 
 	let backend = CrosstermBackend::new(std::io::stdout());
 	let mut term = Terminal::new(backend).map_err(|e| {
@@ -317,6 +236,20 @@ async fn inner_main() -> Result<(), WrappedErr> {
 	})?;
 	term.skip_diff(true);
 
+	execute!(
+		term.backend_mut(),
+		EnterAlternateScreen,
+		crossterm::cursor::Hide,
+		crossterm::event::EnableMouseCapture
+	)
+	.map_err(|e| {
+		WrappedErr(
+			format!(
+				"Couldn't enter the alternate screen and hide the cursor for proper presentation: {e}"
+			)
+			.into()
+		)
+	})?;
 	enable_raw_mode().map_err(|e| {
 		WrappedErr(
 			format!("Can't enable raw mode, which is necessary to receive input: {e}").into()
@@ -337,7 +270,7 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		})?;
 	}
 
-	let fullscreen = flags.fullscreen;
+	let fullscreen = flags.fullscreen.unwrap_or_default();
 	let main_area = Tui::main_layout(&term.get_frame(), fullscreen);
 	to_renderer
 		.send(RenderNotif::Area(main_area.page_area))
@@ -372,7 +305,17 @@ async fn inner_main() -> Result<(), WrappedErr> {
 		)
 	})?;
 
+	execute!(
+		term.backend_mut(),
+		LeaveAlternateScreen,
+		crossterm::cursor::Show,
+		crossterm::event::DisableMouseCapture
+	)
+	.unwrap();
+	disable_raw_mode().unwrap();
+
 	drop(maybe_logger);
+
 	Ok(())
 }
 
@@ -390,8 +333,6 @@ async fn enter_redraw_loop(
 	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();
@@ -412,7 +353,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();
@@ -464,16 +404,10 @@ async fn enter_redraw_loop(
 				to_display = tui.render(f, &main_area, font_size);
 			})?;
 
-			let maybe_err =
+			let maybe_err = display_kitty_images(to_display, &mut ev_stream).await;
-				display_kitty_images(to_display, &mut ev_stream, &mut kitty_z_idx).await;
 
-			if let Err(DisplayErr {
+			if let Err((to_replace, err_desc, enum_err)) = maybe_err {
-				failed_pages,
+				match enum_err {
-				user_facing_err,
-				source
-			}) = maybe_err
-			{
-				match source {
 					// 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
@@ -481,15 +415,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(
+					TransmitError::Terminal(TerminalError::NoEntity(_)) => (),
-						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))?;
@@ -504,58 +436,38 @@ async fn enter_redraw_loop(
 fn on_notify_ev(
 	to_tui_tx: flume::Sender<Result<RenderInfo, RenderError>>,
 	to_render_tx: flume::Sender<RenderNotif>,
-	file_name: OsString,
+	file_name: OsString
-	debounce_delay: Duration
 ) -> impl Fn(notify::Result<Event>) {
-	let last_event: Mutex<Result<(), RenderError>> = Mutex::new(Ok(()));
+	move |res| match res {
-	let last_event = Arc::new(last_event);
+		// If we get an error here, and then an error sending, everything's going wrong. Just give
+		// up lol.
+		Err(e) => to_tui_tx.send(Err(RenderError::Notify(e))).unwrap(),
+		// TODO: Should we match EventKind::Rename and propogate that so that the other parts of the
+		// process know that too? Or should that be
+		Ok(ev) => {
+			// We only watch the parent directory (see the comment above `watcher.watch` in `fn
+			// main`) so we need to filter out events to only ones that pertain to the single file
+			// we care about
+			if !ev
+				.paths
+				.iter()
+				.any(|path| path.file_name().is_some_and(|f| f == file_name))
+			{
+				return;
+			}
 
-	let debouncer = EventDebouncer::new(debounce_delay, {
+			match ev.kind {
-		let last_event = last_event.clone();
+				EventKind::Access(_) => (),
-		move |()| {
+				EventKind::Remove(_) => to_tui_tx
-			let event = mem::replace(&mut *last_event.lock().unwrap(), Ok(()));
+					.send(Err(RenderError::Converting("File was deleted".into())))
-			match event {
+					.unwrap(),
 				// This shouldn't fail to send unless the receiver gets disconnected. If that's
 				// happened, then like the main thread has panicked or something, so it doesn't matter
 				// we don't handle the error here.
-				Ok(()) => to_render_tx.send(RenderNotif::Reload).unwrap(),
+				EventKind::Other | EventKind::Any | EventKind::Create(_) | EventKind::Modify(_) =>
-				// If we get an error here, and then an error sending, everything's going wrong. Just give
+					to_render_tx.send(RenderNotif::Reload).unwrap(),
-				// up lol.
-				Err(e) => to_tui_tx.send(Err(e)).unwrap()
 			}
 		}
-	});
-
-	move |res| {
-		let event = match res {
-			Err(e) => Err(RenderError::Notify(e)),
-
-			// TODO: Should we match EventKind::Rename and propogate that so that the other parts of the
-			// process know that too? Or should that be
-			Ok(ev) => {
-				// We only watch the parent directory (see the comment above `watcher.watch` in `fn
-				// main`) so we need to filter out events to only ones that pertain to the single file
-				// we care about
-				if !ev
-					.paths
-					.iter()
-					.any(|path| path.file_name().is_some_and(|f| f == file_name))
-				{
-					return;
-				}
-
-				match ev.kind {
-					EventKind::Access(_) => return,
-					EventKind::Remove(_) => Err(RenderError::Converting("File was deleted".into())),
-					EventKind::Other
-					| EventKind::Any
-					| EventKind::Create(_)
-					| EventKind::Modify(_) => Ok(())
-				}
-			}
-		};
-		*last_event.lock().unwrap() = event;
-		debouncer.put(());
 	}
 }
 
@@ -566,10 +478,6 @@ fn parse_color_to_i32(cs: &str) -> Result<i32, csscolorparser::ParseColorError>
 }
 
 fn get_font_size_through_stdio() -> Result<(u16, u16), WrappedErr> {
-	// send the command code to get the terminal window size
-	print!("\x1b[14t");
-	std::io::stdout().flush().unwrap();
-
 	// we need to enable raw mode here since this bit of output won't print a newline; it'll
 	// just print the info it wants to tell us. So we want to get all characters as they come
 	enable_raw_mode().map_err(|e| {
@@ -612,18 +520,18 @@ fn get_font_size_through_stdio() -> Result<(u16, u16), WrappedErr> {
 		));
 	};
 
-	let h = h.parse::<u16>().map_err(|e| {
+	let h = h.parse::<u16>().map_err(|_| {
 		WrappedErr(
 			format!(
-				"Your terminal said its height is {h}, but that is not a 16-bit unsigned integer: {e}"
+				"Your terminal said its height is {h}, but that is not a 16-bit unsigned integer"
 			)
 			.into()
 		)
 	})?;
-	let w = w.parse::<u16>().map_err(|e| {
+	let w = w.parse::<u16>().map_err(|_| {
 		WrappedErr(
 			format!(
-				"Your terminal said its width is {w}, but that is not a 16-bit unsigned integer: {e}"
+				"Your terminal said its width is {w}, but that is not a 16-bit unsigned integer"
 			)
 			.into()
 		)

src/renderer.rs

@@ -1,8 +1,8 @@
-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::{
-	Colorspace, Document, Matrix, Page, Pixmap, Quad, TextPageFlags, text_page::SearchHitResponse
+	Colorspace, Document, Matrix, Page, Pixmap, Quad, TextPageOptions, text_page::SearchHitResponse
 };
 use ratatui::layout::Rect;
 
@@ -20,8 +20,7 @@ pub enum RenderNotif {
 	Search(String),
 	SwitchFitOrFill(FitOrFill),
 	Reload,
-	Invert,
+	Invert
-	Rotate
 }
 
 #[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;
+const MUPDF_BLACK: i32 = 0;
-pub const MUPDF_WHITE: i32 = i32::from_be_bytes([0, 0xff, 0xff, 0xff]);
+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) {
@@ -87,9 +78,9 @@ pub fn fill_default<T: Default>(vec: &mut Vec<T>, size: usize) {
 // We're allowing passing by value here because this is only called once, at the beginning of the
 // program, and the arguments that 'should' be passed by value (`receiver` and `size`) would
 // probably be more performant if accessed by-value instead of through a reference. Probably.
-#[expect(clippy::needless_pass_by_value, clippy::too_many_arguments)]
+#[allow(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
+		let doc = match Document::open(path) {
-		// 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) {
 			Err(e) => {
 				// if there's an error, tell the main loop
 				sender.send(Err(RenderError::Doc(e)))?;
@@ -133,7 +116,7 @@ pub fn start_rendering(
 						// temporarily removed to facilitate a save or something like that)
 						while let Ok(msg) = receiver.recv() {
 							// and once that comes, just try to reload again
-							if matches!(msg, RenderNotif::Reload) {
+							if let RenderNotif::Reload = msg {
 								continue 'reload;
 							}
 						}
@@ -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
+		// We're using this vec of bools to indicate which page numbers have already been rendered,
-		// support people jumping to specific pages and having quick rendering results. We
+		// 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
@@ -343,7 +313,7 @@ pub fn start_rendering(
 						if let Err(e) = ctx.pixmap.write_to(&mut pixels, mupdf::ImageFormat::PNM) {
 							sender.send(Err(RenderError::Doc(e)))?;
 							continue;
-						}
+						};
 
 						log::debug!("got pixmap for page {page_num} with WxH {w}x{h}");
 
@@ -371,7 +341,7 @@ pub fn start_rendering(
 					Err(TryRecvError::Disconnected) => return Ok(()),
 					Ok(notif) => handle_notif!(notif),
 					Err(TryRecvError::Empty) => ()
-				}
+				};
 			}
 
 			// Now, if we have a search term, we want to look through the rest of the document past
@@ -464,7 +434,7 @@ pub fn start_rendering(
 				return Ok(());
 			};
 
-			handle_notif!(msg);
+			handle_notif!(msg)
 		}
 	}
 }
@@ -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 {
+	let page_dim = (bounds.x1 - bounds.x0, bounds.y1 - bounds.y0);
-		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 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);
+	let 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 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
@@ -563,7 +520,7 @@ fn render_single_page_to_ctx(
 	})
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub struct HighlightRect {
 	pub ul_x: u32,
 	pub ul_y: u32,
@@ -579,14 +536,15 @@ fn search_page(
 ) -> Result<Vec<Quad>, mupdf::error::Error> {
 	search_term
 		.map(|term| {
-			page.to_text_page(TextPageFlags::empty()).and_then(|page| {
+			page.to_text_page(TextPageOptions::empty())
-				let mut v = Vec::with_capacity(trusted_search_results);
+				.and_then(|page| {
-				page.search_cb(term, &mut v, |v, results| {
+					let mut v = Vec::with_capacity(trusted_search_results);
-					v.extend(results.iter().cloned());
+					page.search_cb(term, &mut v, |v, results| {
-					SearchHitResponse::ContinueSearch
+						v.extend(results.iter().cloned());
+						SearchHitResponse::ContinueSearch
+					})
+					.map(|_| v)
 				})
-				.map(|_| v)
-			})
 		})
 		.transpose()
 		.map(Option::unwrap_or_default)
@@ -594,34 +552,24 @@ fn search_page(
 
 #[inline]
 fn count_search_results(page: &Page, search_term: &str) -> Result<usize, mupdf::error::Error> {
-	page.to_text_page(TextPageFlags::empty()).and_then(|page| {
+	page.to_text_page(TextPageOptions::empty())
-		let mut count = 0;
+		.and_then(|page| {
-		page.search_cb(search_term, &mut count, |count, results| {
+			let mut count = 0;
-			*count += results.len();
+			page.search_cb(search_term, &mut count, |count, results| {
-			SearchHitResponse::ContinueSearch
+				*count += results.len();
-		})?;
+				SearchHitResponse::ContinueSearch
-		Ok(count)
+			})?;
-	})
+			Ok(count)
+		})
 }
 
 struct PopOnNext<'a> {
 	inner: &'a mut VecDeque<usize>
 }
 
-impl Iterator for PopOnNext<'_> {
+impl<'a> Iterator for PopOnNext<'a> {
 	type Item = usize;
 	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/skip.rs

@@ -7,7 +7,6 @@ pub struct Skip {
 }
 
 impl Skip {
-	#[must_use]
 	pub fn new(skip: bool) -> Self {
 		Self { skip }
 	}
@@ -46,7 +45,6 @@ impl InterleavedAroundWithMax {
 	/// the following must hold or else this is liable to panic or produce nonsense values:
 	/// - inclusive_min < exclusive_max
 	/// - inclusive_min <= around <= exclusive_max
-	#[must_use]
 	pub fn new(around: usize, inclusive_min: usize, exclusive_max: NonZeroUsize) -> Self {
 		Self {
 			around,