chore: Remove all `pub`s

They will not be marked by rustc/cargo as unused, and as atuin doesn't
expose an API all of them _should_ be `pub(crate)`

6 files changed, 72 insertions, 72 deletions

diff --git a/crates/turtle/src/command/client/search/keybindings/actions.rs b/crates/turtle/src/command/client/search/keybindings/actions.rs
index ff2ef7de..341b030c 100644
--- a/crates/turtle/src/command/client/search/keybindings/actions.rs
+++ b/crates/turtle/src/command/client/search/keybindings/actions.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// All possible actions that can be triggered by a keybinding.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Action {
+pub(crate) enum Action {
     // Cursor movement
     CursorLeft,
     CursorRight,
@@ -77,7 +77,7 @@ pub enum Action {
 
 impl Action {
     /// Convert from a kebab-case string.
-    pub fn from_str(s: &str) -> Result<Self, String> {
+    pub(crate) fn from_str(s: &str) -> Result<Self, String> {
         // Handle accept-N and return-selection-N patterns
         if let Some(rest) = s.strip_prefix("accept-")
             && let Ok(n) = rest.parse::<u8>()
@@ -156,7 +156,7 @@ impl Action {
     }
 
     /// Convert to a kebab-case string.
-    pub fn as_str(&self) -> String {
+    pub(crate) fn as_str(&self) -> String {
         match self {
             Action::CursorLeft => "cursor-left".to_string(),
             Action::CursorRight => "cursor-right".to_string(),
diff --git a/crates/turtle/src/command/client/search/keybindings/conditions.rs b/crates/turtle/src/command/client/search/keybindings/conditions.rs
index 055ae905..f870d9a0 100644
--- a/crates/turtle/src/command/client/search/keybindings/conditions.rs
+++ b/crates/turtle/src/command/client/search/keybindings/conditions.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 /// Atomic (leaf) conditions that can be evaluated against state.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ConditionAtom {
+pub(crate) enum ConditionAtom {
     CursorAtStart,
     CursorAtEnd,
     InputEmpty,
@@ -28,7 +28,7 @@ pub enum ConditionAtom {
 /// - `"list-at-start || no-results"` (disjunction)
 /// - `"(cursor-at-start && !input-empty) || no-results"` (grouping)
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ConditionExpr {
+pub(crate) enum ConditionExpr {
     Atom(ConditionAtom),
     Not(Box<ConditionExpr>),
     And(Box<ConditionExpr>, Box<ConditionExpr>),
@@ -37,21 +37,21 @@ pub enum ConditionExpr {
 
 /// Context needed to evaluate conditions. This is a pure snapshot of state —
 /// no references to mutable data.
-pub struct EvalContext {
+pub(crate) struct EvalContext {
     /// Current cursor position (unicode width units).
-    pub cursor_position: usize,
+    pub(crate) cursor_position: usize,
     /// Width of the input string in unicode width units.
-    pub input_width: usize,
+    pub(crate) input_width: usize,
     /// Byte length of the input string.
-    pub input_byte_len: usize,
+    pub(crate) input_byte_len: usize,
     /// Currently selected index in the results list.
-    pub selected_index: usize,
+    pub(crate) selected_index: usize,
     /// Total number of results.
-    pub results_len: usize,
+    pub(crate) results_len: usize,
     /// Whether the original input (query passed to the TUI) was empty.
-    pub original_input_empty: bool,
+    pub(crate) original_input_empty: bool,
     /// Whether we use a search context of a command from the history.
-    pub has_context: bool,
+    pub(crate) has_context: bool,
 }
 
 // ---------------------------------------------------------------------------
@@ -60,7 +60,7 @@ pub struct EvalContext {
 
 impl ConditionAtom {
     /// Evaluate this atom against the given context.
-    pub fn evaluate(&self, ctx: &EvalContext) -> bool {
+    pub(crate) fn evaluate(&self, ctx: &EvalContext) -> bool {
         match self {
             ConditionAtom::CursorAtStart => ctx.cursor_position == 0,
             ConditionAtom::CursorAtEnd => ctx.cursor_position == ctx.input_width,
@@ -77,7 +77,7 @@ impl ConditionAtom {
     }
 
     /// Parse from a kebab-case string.
-    pub fn from_str(s: &str) -> Result<Self, String> {
+    pub(crate) fn from_str(s: &str) -> Result<Self, String> {
         match s {
             "cursor-at-start" => Ok(ConditionAtom::CursorAtStart),
             "cursor-at-end" => Ok(ConditionAtom::CursorAtEnd),
@@ -93,7 +93,7 @@ impl ConditionAtom {
     }
 
     /// Convert to a kebab-case string.
-    pub fn as_str(&self) -> &'static str {
+    pub(crate) fn as_str(&self) -> &'static str {
         match self {
             ConditionAtom::CursorAtStart => "cursor-at-start",
             ConditionAtom::CursorAtEnd => "cursor-at-end",
@@ -120,7 +120,7 @@ impl fmt::Display for ConditionAtom {
 
 impl ConditionExpr {
     /// Evaluate this expression against the given context.
-    pub fn evaluate(&self, ctx: &EvalContext) -> bool {
+    pub(crate) fn evaluate(&self, ctx: &EvalContext) -> bool {
         match self {
             ConditionExpr::Atom(atom) => atom.evaluate(ctx),
             ConditionExpr::Not(inner) => !inner.evaluate(ctx),
@@ -143,17 +143,17 @@ impl From<ConditionAtom> for ConditionExpr {
 #[expect(dead_code)]
 impl ConditionExpr {
     /// Negate this expression: `!self`.
-    pub fn not(self) -> Self {
+    pub(crate) fn not(self) -> Self {
         ConditionExpr::Not(Box::new(self))
     }
 
     /// Conjoin with another expression: `self && other`.
-    pub fn and(self, other: ConditionExpr) -> Self {
+    pub(crate) fn and(self, other: ConditionExpr) -> Self {
         ConditionExpr::And(Box::new(self), Box::new(other))
     }
 
     /// Disjoin with another expression: `self || other`.
-    pub fn or(self, other: ConditionExpr) -> Self {
+    pub(crate) fn or(self, other: ConditionExpr) -> Self {
         ConditionExpr::Or(Box::new(self), Box::new(other))
     }
 }
@@ -286,7 +286,7 @@ impl<'a> ExprParser<'a> {
 
 impl ConditionExpr {
     /// Parse a condition expression from a string.
-    pub fn parse(s: &str) -> Result<Self, String> {
+    pub(crate) fn parse(s: &str) -> Result<Self, String> {
         let parser = ExprParser::new(s);
         parser.parse()
     }
diff --git a/crates/turtle/src/command/client/search/keybindings/defaults.rs b/crates/turtle/src/command/client/search/keybindings/defaults.rs
index c8401e37..6627c84d 100644
--- a/crates/turtle/src/command/client/search/keybindings/defaults.rs
+++ b/crates/turtle/src/command/client/search/keybindings/defaults.rs
@@ -49,12 +49,12 @@ fn key(s: &str) -> KeyInput {
 
 /// All five keymaps bundled together.
 #[derive(Debug, Clone)]
-pub struct KeymapSet {
-    pub emacs: Keymap,
-    pub vim_normal: Keymap,
-    pub vim_insert: Keymap,
-    pub inspector: Keymap,
-    pub prefix: Keymap,
+pub(crate) struct KeymapSet {
+    pub(crate) emacs: Keymap,
+    pub(crate) vim_normal: Keymap,
+    pub(crate) vim_insert: Keymap,
+    pub(crate) inspector: Keymap,
+    pub(crate) prefix: Keymap,
 }
 
 // ---------------------------------------------------------------------------
@@ -101,7 +101,7 @@ fn accept_action(settings: &Settings) -> Action {
 /// - `ctrl_n_shortcuts` — whether alt or ctrl is used for numeric shortcuts
 // Keymap builder that enumerates every default binding; not worth splitting.
 #[expect(clippy::too_many_lines)]
-pub fn default_emacs_keymap(settings: &Settings) -> Keymap {
+pub(crate) fn default_emacs_keymap(settings: &Settings) -> Keymap {
     let mut km = Keymap::new();
     add_common_bindings(&mut km);
 
@@ -252,7 +252,7 @@ pub fn default_emacs_keymap(settings: &Settings) -> Keymap {
 // ---------------------------------------------------------------------------
 
 /// Build the default vim-normal keymap.
-pub fn default_vim_normal_keymap(settings: &Settings) -> Keymap {
+pub(crate) fn default_vim_normal_keymap(settings: &Settings) -> Keymap {
     let mut km = Keymap::new();
     add_common_bindings(&mut km);
 
@@ -333,7 +333,7 @@ pub fn default_vim_normal_keymap(settings: &Settings) -> Keymap {
 
 /// Build the default vim-insert keymap. This clones the emacs keymap and
 /// overlays vim-insert-specific bindings (esc → enter normal mode).
-pub fn default_vim_insert_keymap(settings: &Settings) -> Keymap {
+pub(crate) fn default_vim_insert_keymap(settings: &Settings) -> Keymap {
     let mut km = default_emacs_keymap(settings);
 
     // Override esc and ctrl-[ to enter normal mode instead of exiting
@@ -353,7 +353,7 @@ pub fn default_vim_insert_keymap(settings: &Settings) -> Keymap {
 /// text input, so we build a minimal keymap with only inspector-relevant
 /// bindings. We respect the user's `keymap_mode` to provide vim-style j/k
 /// navigation for vim users.
-pub fn default_inspector_keymap(settings: &Settings) -> Keymap {
+pub(crate) fn default_inspector_keymap(settings: &Settings) -> Keymap {
     use crate::atuin_client::settings::KeymapMode;
 
     let mut km = Keymap::new();
@@ -400,7 +400,7 @@ pub fn default_inspector_keymap(settings: &Settings) -> Keymap {
 // ---------------------------------------------------------------------------
 
 /// Build the default prefix keymap (active after ctrl-a prefix).
-pub fn default_prefix_keymap() -> Keymap {
+pub(crate) fn default_prefix_keymap() -> Keymap {
     let mut km = Keymap::new();
 
     km.bind(key("d"), Action::Delete);
@@ -476,7 +476,7 @@ fn apply_config_to_keymap(keymap: &mut Keymap, overrides: &HashMap<String, KeyBi
 
 impl KeymapSet {
     /// Build the complete set of default keymaps from settings.
-    pub fn defaults(settings: &Settings) -> Self {
+    pub(crate) fn defaults(settings: &Settings) -> Self {
         KeymapSet {
             emacs: default_emacs_keymap(settings),
             vim_normal: default_vim_normal_keymap(settings),
@@ -494,7 +494,7 @@ impl KeymapSet {
     ///   overrides are applied per-key.
     /// - If `[keymap]` is empty/absent, `[keys]` customizes the defaults
     ///   (current behavior for backward compatibility).
-    pub fn from_settings(settings: &Settings) -> Self {
+    pub(crate) fn from_settings(settings: &Settings) -> Self {
         use crate::atuin_client::settings::Keys;
 
         if settings.keymap.is_empty() {
diff --git a/crates/turtle/src/command/client/search/keybindings/key.rs b/crates/turtle/src/command/client/search/keybindings/key.rs
index c2eb31c6..35107a24 100644
--- a/crates/turtle/src/command/client/search/keybindings/key.rs
+++ b/crates/turtle/src/command/client/search/keybindings/key.rs
@@ -6,17 +6,17 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 /// A single key press with modifiers (e.g. `ctrl-c`, `alt-f`, `enter`).
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 #[expect(clippy::struct_excessive_bools)]
-pub struct SingleKey {
-    pub code: KeyCodeValue,
-    pub ctrl: bool,
-    pub alt: bool,
-    pub shift: bool,
-    pub super_key: bool,
+pub(crate) struct SingleKey {
+    pub(crate) code: KeyCodeValue,
+    pub(crate) ctrl: bool,
+    pub(crate) alt: bool,
+    pub(crate) shift: bool,
+    pub(crate) super_key: bool,
 }
 
 /// The key code portion of a key press.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum KeyCodeValue {
+pub(crate) enum KeyCodeValue {
     Char(char),
     Enter,
     Esc,
@@ -39,14 +39,14 @@ pub enum KeyCodeValue {
 
 /// A key input that may be a single key or a multi-key sequence (e.g. `g g`).
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum KeyInput {
+pub(crate) enum KeyInput {
     Single(SingleKey),
     Sequence(Vec<SingleKey>),
 }
 
 impl SingleKey {
     /// Convert a crossterm `KeyEvent` into a `SingleKey`.
-    pub fn from_event(event: &KeyEvent) -> Option<Self> {
+    pub(crate) fn from_event(event: &KeyEvent) -> Option<Self> {
         let ctrl = event.modifiers.contains(KeyModifiers::CONTROL);
         let alt = event.modifiers.contains(KeyModifiers::ALT);
         let shift = event.modifiers.contains(KeyModifiers::SHIFT);
@@ -112,7 +112,7 @@ impl SingleKey {
     }
 
     /// Parse a key string like `"ctrl-c"`, `"alt-f"`, `"enter"`, `"G"`.
-    pub fn parse(s: &str) -> Result<Self, String> {
+    pub(crate) fn parse(s: &str) -> Result<Self, String> {
         let s = s.trim();
         let parts: Vec<&str> = s.split('-').collect();
 
@@ -264,7 +264,7 @@ impl fmt::Display for SingleKey {
 impl KeyInput {
     /// Parse a key input string. Supports multi-key sequences separated by spaces
     /// (e.g. `"g g"`).
-    pub fn parse(s: &str) -> Result<Self, String> {
+    pub(crate) fn parse(s: &str) -> Result<Self, String> {
         let s = s.trim();
         // Check for space-separated multi-key sequences
         // But don't split "space" or modifier combos like "ctrl-a"
diff --git a/crates/turtle/src/command/client/search/keybindings/keymap.rs b/crates/turtle/src/command/client/search/keybindings/keymap.rs
index 0d362863..c3b93b59 100644
--- a/crates/turtle/src/command/client/search/keybindings/keymap.rs
+++ b/crates/turtle/src/command/client/search/keybindings/keymap.rs
@@ -7,27 +7,27 @@ use super::key::{KeyInput, SingleKey};
 /// A single rule within a keybinding: an optional condition and an action.
 /// If the condition is `None`, the rule always matches.
 #[derive(Debug, Clone)]
-pub struct KeyRule {
-    pub condition: Option<ConditionExpr>,
-    pub action: Action,
+pub(crate) struct KeyRule {
+    pub(crate) condition: Option<ConditionExpr>,
+    pub(crate) action: Action,
 }
 
 /// A keybinding is an ordered list of rules. The first rule whose condition
 /// matches (or has no condition) wins.
 #[derive(Debug, Clone)]
-pub struct KeyBinding {
-    pub rules: Vec<KeyRule>,
+pub(crate) struct KeyBinding {
+    pub(crate) rules: Vec<KeyRule>,
 }
 
 /// A keymap is a collection of keybindings indexed by key input.
 #[derive(Debug, Clone)]
-pub struct Keymap {
-    pub bindings: HashMap<KeyInput, KeyBinding>,
+pub(crate) struct Keymap {
+    pub(crate) bindings: HashMap<KeyInput, KeyBinding>,
 }
 
 impl KeyRule {
     /// Create an unconditional rule.
-    pub fn always(action: Action) -> Self {
+    pub(crate) fn always(action: Action) -> Self {
         KeyRule {
             condition: None,
             action,
@@ -36,7 +36,7 @@ impl KeyRule {
 
     /// Create a conditional rule. Accepts any type convertible to `ConditionExpr`,
     /// including bare `ConditionAtom` values.
-    pub fn when(condition: impl Into<ConditionExpr>, action: Action) -> Self {
+    pub(crate) fn when(condition: impl Into<ConditionExpr>, action: Action) -> Self {
         KeyRule {
             condition: Some(condition.into()),
             action,
@@ -46,39 +46,39 @@ impl KeyRule {
 
 impl KeyBinding {
     /// Create a simple (unconditional) binding.
-    pub fn simple(action: Action) -> Self {
+    pub(crate) fn simple(action: Action) -> Self {
         KeyBinding {
             rules: vec![KeyRule::always(action)],
         }
     }
 
     /// Create a conditional binding from a list of rules.
-    pub fn conditional(rules: Vec<KeyRule>) -> Self {
+    pub(crate) fn conditional(rules: Vec<KeyRule>) -> Self {
         KeyBinding { rules }
     }
 }
 
 impl Keymap {
     /// Create an empty keymap.
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         Keymap {
             bindings: HashMap::new(),
         }
     }
 
     /// Bind a key input to a simple (unconditional) action.
-    pub fn bind(&mut self, key: KeyInput, action: Action) {
+    pub(crate) fn bind(&mut self, key: KeyInput, action: Action) {
         self.bindings.insert(key, KeyBinding::simple(action));
     }
 
     /// Bind a key input to a conditional set of rules.
-    pub fn bind_conditional(&mut self, key: KeyInput, rules: Vec<KeyRule>) {
+    pub(crate) fn bind_conditional(&mut self, key: KeyInput, rules: Vec<KeyRule>) {
         self.bindings.insert(key, KeyBinding::conditional(rules));
     }
 
     /// Resolve a key input to an action given the current evaluation context.
     /// Returns `None` if the key has no binding or no rule's condition matches.
-    pub fn resolve(&self, key: &KeyInput, ctx: &EvalContext) -> Option<Action> {
+    pub(crate) fn resolve(&self, key: &KeyInput, ctx: &EvalContext) -> Option<Action> {
         let binding = self.bindings.get(key)?;
         for rule in &binding.rules {
             match &rule.condition {
@@ -92,7 +92,7 @@ impl Keymap {
 
     /// Check if any binding starts with the given single key as the first key
     /// of a multi-key sequence. Used to detect pending multi-key sequences.
-    pub fn has_sequence_starting_with(&self, prefix: &SingleKey) -> bool {
+    pub(crate) fn has_sequence_starting_with(&self, prefix: &SingleKey) -> bool {
         self.bindings.keys().any(|ki| match ki {
             KeyInput::Sequence(keys) => keys.first() == Some(prefix),
             KeyInput::Single(_) => false,
@@ -101,7 +101,7 @@ impl Keymap {
 
     /// Merge another keymap into this one. Keys from `other` override keys in `self`.
     #[expect(dead_code)]
-    pub fn merge(&mut self, other: &Keymap) {
+    pub(crate) fn merge(&mut self, other: &Keymap) {
         for (key, binding) in &other.bindings {
             self.bindings.insert(key.clone(), binding.clone());
         }
diff --git a/crates/turtle/src/command/client/search/keybindings/mod.rs b/crates/turtle/src/command/client/search/keybindings/mod.rs
index 3b6eb2b2..cdca0406 100644
--- a/crates/turtle/src/command/client/search/keybindings/mod.rs
+++ b/crates/turtle/src/command/client/search/keybindings/mod.rs
@@ -1,14 +1,14 @@
-pub mod actions;
-pub mod conditions;
-pub mod defaults;
-pub mod key;
-pub mod keymap;
+pub(crate) mod actions;
+pub(crate) mod conditions;
+pub(crate) mod defaults;
+pub(crate) mod key;
+pub(crate) mod keymap;
 
-pub use actions::Action;
+pub(crate) use actions::Action;
 #[expect(unused_imports)]
-pub use conditions::{ConditionAtom, ConditionExpr, EvalContext};
-pub use defaults::KeymapSet;
+pub(crate) use conditions::{ConditionAtom, ConditionExpr, EvalContext};
+pub(crate) use defaults::KeymapSet;
 #[expect(unused_imports)]
-pub use key::{KeyCodeValue, KeyInput, SingleKey};
+pub(crate) use key::{KeyCodeValue, KeyInput, SingleKey};
 #[expect(unused_imports)]
-pub use keymap::{KeyBinding, KeyRule, Keymap};
+pub(crate) use keymap::{KeyBinding, KeyRule, Keymap};