kernel: migrate _PULP dir/subdir ops to sd()

* delete 7 remaining KernelHandle forwarding methods:
read_app_data_start, write_app_data, ensure_app_subdir,
read_app_subdir_chunk, write_app_subdir, append_app_subdir,
file_size_app_subdir
* migrate ~30 app callsites across home, settings, reader,
images, cover_cache, stats to k.sd().method() form
* PULP_DIR is now explicit at callsites that previously hid
it behind read_app_data_start/write_app_data wrappers

Co-authored-by: Claude <[e-mail]>

kernel/src/kernel/handle.rs

···
 // rather than through dedicated handle methods
 
 use crate::drivers::sdcard::SdStorage;
-use crate::drivers::storage::{self, DirEntry, DirPage};
+use crate::drivers::storage::{DirEntry, DirPage};
 use crate::error::{Error, Result};
 use crate::kernel::bookmarks::BookmarkCache;
 use crate::kernel::dir_cache::DirCache;
···
                 .map_err(|e: Error| -> &'static str { e.into() })
         };
         f(&mut reader)
-    }
-
-    // storage primitives
-    //
-    // each calls a single storage::* function; return type is
-    // Result<T> (unified Error) throughout
-
-    #[inline]
-    pub fn read_app_data_start(&mut self, name: &str, buf: &mut [u8]) -> Result<(u32, usize)> {
-        self.kernel.sd.read_file_start_in_dir(storage::PULP_DIR, name, buf)
-    }
-
-    #[inline]
-    pub fn write_app_data(&mut self, name: &str, data: &[u8]) -> Result<()> {
-        self.kernel.sd.write_file_in_dir(storage::PULP_DIR, name, data)
-    }
-
-    #[inline]
-    pub fn ensure_app_subdir(&mut self, dir: &str) -> Result<()> {
-        self.kernel.sd.ensure_pulp_subdir(dir)
-    }
-
-    #[inline]
-    pub fn read_app_subdir_chunk(
-        &mut self,
-        dir: &str,
-        name: &str,
-        offset: u32,
-        buf: &mut [u8],
-    ) -> Result<usize> {
-        self.kernel.sd.read_chunk_in_pulp_subdir(dir, name, offset, buf)
-    }
-
-    #[inline]
-    pub fn write_app_subdir(&mut self, dir: &str, name: &str, data: &[u8]) -> Result<()> {
-        self.kernel.sd.write_in_pulp_subdir(dir, name, data)
-    }
-
-    #[inline]
-    pub fn append_app_subdir(&mut self, dir: &str, name: &str, data: &[u8]) -> Result<()> {
-        self.kernel.sd.append_in_pulp_subdir(dir, name, data)
-    }
-
-    #[inline]
-    pub fn file_size_app_subdir(&mut self, dir: &str, name: &str) -> Result<u32> {
-        self.kernel.sd.file_size_in_pulp_subdir(dir, name)
     }
 
     pub fn dir_page(&mut self, offset: usize, buf: &mut [DirEntry]) -> Result<DirPage> {

src/apps/cover_cache.rs

···
     let mut header = [0u8; 4];
     header[0..2].copy_from_slice(&img.width.to_le_bytes());
     header[2..4].copy_from_slice(&img.height.to_le_bytes());
-    k.write_app_subdir(dir, COVER_THUMB_FILE, &header)?;
-    k.append_app_subdir(dir, COVER_THUMB_FILE, &img.data)?;
+    k.sd().write_in_pulp_subdir(dir, COVER_THUMB_FILE, &header)?;
+    k.sd().append_in_pulp_subdir(dir, COVER_THUMB_FILE, &img.data)?;
     Ok(())
 }
 
···
 ///
 /// Returns `None` if the file doesn't exist or is invalid.
 pub fn load_cover_thumb(k: &mut KernelHandle<'_>, dir: &str) -> Option<DecodedImage> {
-    let size = k.file_size_app_subdir(dir, COVER_THUMB_FILE).ok()?;
+    let size = k.sd().file_size_in_pulp_subdir(dir, COVER_THUMB_FILE).ok()?;
     if size < 5 {
         return None;
     }
     let mut header = [0u8; 4];
-    k.read_app_subdir_chunk(dir, COVER_THUMB_FILE, 0, &mut header)
+    k.sd().read_chunk_in_pulp_subdir(dir, COVER_THUMB_FILE, 0, &mut header)
         .ok()?;
     let width = u16::from_le_bytes([header[0], header[1]]);
     let height = u16::from_le_bytes([header[2], header[3]]);
···
     let mut data = Vec::new();
     data.try_reserve_exact(data_len).ok()?;
     data.resize(data_len, 0);
-    k.read_app_subdir_chunk(dir, COVER_THUMB_FILE, 4, &mut data)
+    k.sd().read_chunk_in_pulp_subdir(dir, COVER_THUMB_FILE, 4, &mut data)
         .ok()?;
     Some(DecodedImage {
         width,
···
 
 /// Check whether a cover thumbnail already exists for the given cache dir.
 pub fn has_cover_thumb(k: &mut KernelHandle<'_>, dir: &str) -> bool {
-    k.file_size_app_subdir(dir, COVER_THUMB_FILE)
+    k.sd().file_size_in_pulp_subdir(dir, COVER_THUMB_FILE)
         .map(|s| s >= 5)
         .unwrap_or(false)
 }

src/apps/home.rs

···
 use crate::board::action::{Action, ActionEvent};
 use crate::board::{SCREEN_H, SCREEN_W};
 use crate::drivers::battery;
+use crate::drivers::storage::PULP_DIR;
 use crate::drivers::strip::StripBuffer;
 use crate::fonts;
 use crate::kernel::KernelHandle;
···
     // This is intentional for now — see TODO-960fb375 for context.
     pub fn load_recent(&mut self, k: &mut KernelHandle<'_>) {
         let mut buf = [0u8; 196];
-        match k.read_app_data_start(RECENT_FILE, &mut buf) {
+        match k.sd().read_file_start_in_dir(PULP_DIR, RECENT_FILE, &mut buf) {
             Ok((_, n)) if n > 0 => self.parse_recent(&buf[..n]),
             _ => self.recent_book_len = 0,
         }
···
         if self.needs_load_recent {
             let old_count = self.item_count;
             let mut buf = [0u8; 196];
-            match k.read_app_data_start(RECENT_FILE, &mut buf) {
+            match k.sd().read_file_start_in_dir(PULP_DIR, RECENT_FILE, &mut buf) {
                 Ok((_, n)) if n > 0 => self.parse_recent(&buf[..n]),
                 _ => self.recent_book_len = 0,
             }

src/apps/reader/epubs.rs

···
                                 // ensure image subdir exists for skip markers
                                 let dir_buf = self.cache_dir;
                                 let dir = cache::dir_name_str(&dir_buf);
-                                let _ = k.ensure_app_subdir(dir);
+                                let _ = k.sd().ensure_pulp_subdir(dir);
                                 log::info!("epub: v3 cache hit ({} chapters)", count);
                                 return Ok(true);
                             }
···
         // ensure image subdir exists (images stay in _PULP/_XXXXXXX/)
         let dir_buf = self.cache_dir;
         let dir = cache::dir_name_str(&dir_buf);
-        k.ensure_app_subdir(dir)?;
+        k.sd().ensure_pulp_subdir(dir)?;
         self.cache_chapter = 0;
         Ok(false)
     }
···
 
         // ensure the per-book cache directory exists (cover generation
         // runs before NeedCache which normally creates it)
-        if k.ensure_app_subdir(dir).is_err() {
+        if k.sd().ensure_pulp_subdir(dir).is_err() {
             log::warn!("epub: failed to create cache dir for cover thumb");
             return;
         }

src/apps/reader/images.rs

···
                 let resume = (offset + path_start + path_len) as u32;
 
                 // already cached or skip-marked
-                if k.file_size_app_subdir(dir, img_file).is_ok() {
+                if k.sd().file_size_in_pulp_subdir(dir, img_file).is_ok() {
                     self.epub.img_found_count = self.epub.img_found_count.saturating_add(1);
                     self.epub.img_cached_count = self.epub.img_cached_count.saturating_add(1);
                     i = path_start + path_len;
···
 
                 if !is_jpeg && !is_png {
                     log::info!("precache: skip unsupported: {}", full_path);
-                    let _ = k.write_app_subdir(dir, img_file, &[]);
+                    let _ = k.sd().write_in_pulp_subdir(dir, img_file, &[]);
                     self.epub.img_found_count = self.epub.img_found_count.saturating_add(1);
                     self.epub.img_cached_count = self.epub.img_cached_count.saturating_add(1);
                     i = path_start + path_len;
···
                 // remaining large images so the device stays responsive
                 if entry.uncomp_size > PRECACHE_IMG_MAX {
                     if self.epub.skip_large_img {
-                        let _ = k.write_app_subdir(dir, img_file, &[]);
+                        let _ = k.sd().write_in_pulp_subdir(dir, img_file, &[]);
                         self.epub.img_found_count = self.epub.img_found_count.saturating_add(1);
                         self.epub.img_cached_count = self.epub.img_cached_count.saturating_add(1);
                         i = path_start + path_len;
···
                         }
                         Err(e) => {
                             log::warn!("precache: streaming failed: {}", e);
-                            let _ = k.write_app_subdir(dir, img_file, &[]);
+                            let _ = k.sd().write_in_pulp_subdir(dir, img_file, &[]);
                             // stop trying large images this session
                             self.epub.skip_large_img = true;
                         }
···
                     Ok(d) => d,
                     Err(e) => {
                         log::warn!("precache: extract failed: {}", e);
-                        let _ = k.write_app_subdir(dir, img_file, &[]);
+                        let _ = k.sd().write_in_pulp_subdir(dir, img_file, &[]);
                         self.epub.img_found_count = self.epub.img_found_count.saturating_add(1);
                         self.epub.img_cached_count = self.epub.img_cached_count.saturating_add(1);
                         i = path_start + path_len;
···
     dir: &str,
     name: &str,
 ) -> crate::error::Result<DecodedImage> {
-    let size = k.file_size_app_subdir(dir, name)?;
+    let size = k.sd().file_size_in_pulp_subdir(dir, name)?;
     if size < 5 {
         return Err(Error::new(
             ErrorKind::InvalidData,
···
         ));
     }
     let mut header = [0u8; 4];
-    k.read_app_subdir_chunk(dir, name, 0, &mut header)?;
+    k.sd().read_chunk_in_pulp_subdir(dir, name, 0, &mut header)?;
     let width = u16::from_le_bytes([header[0], header[1]]);
     let height = u16::from_le_bytes([header[2], header[3]]);
     if width == 0 || height == 0 {
···
     data.try_reserve_exact(data_len)
         .map_err(|_| Error::new(ErrorKind::OutOfMemory, "load_cached_image"))?;
     data.resize(data_len, 0);
-    k.read_app_subdir_chunk(dir, name, 4, &mut data)?;
+    k.sd().read_chunk_in_pulp_subdir(dir, name, 4, &mut data)?;
     Ok(DecodedImage {
         width,
         height,
···
 // returns None if the file doesn't exist, is too small, or has
 // zero dimensions.
 fn peek_cached_image_size(k: &mut KernelHandle<'_>, dir: &str, name: &str) -> Option<(u16, u16)> {
-    let size = k.file_size_app_subdir(dir, name).ok()?;
+    let size = k.sd().file_size_in_pulp_subdir(dir, name).ok()?;
     if size < 5 {
         return None;
     }
     let mut hdr = [0u8; 4];
-    k.read_app_subdir_chunk(dir, name, 0, &mut hdr).ok()?;
+    k.sd().read_chunk_in_pulp_subdir(dir, name, 0, &mut hdr).ok()?;
     let w = u16::from_le_bytes([hdr[0], hdr[1]]);
     let h = u16::from_le_bytes([hdr[2], hdr[3]]);
     if w == 0 || h == 0 {
···
     let mut header = [0u8; 4];
     header[0..2].copy_from_slice(&img.width.to_le_bytes());
     header[2..4].copy_from_slice(&img.height.to_le_bytes());
-    k.write_app_subdir(dir, name, &header)?;
-    k.append_app_subdir(dir, name, &img.data)?;
+    k.sd().write_in_pulp_subdir(dir, name, &header)?;
+    k.sd().append_in_pulp_subdir(dir, name, &img.data)?;
     Ok(())
 }

src/apps/reader/mod.rs

···
 use embedded_graphics::text::Text;
 
 use crate::apps::{App, AppContext, AppId, DeferredPersistenceReason, RECENT_FILE, Transition};
+use crate::drivers::storage::PULP_DIR;
 use crate::board::action::{Action, ActionEvent};
 use crate::board::{SCREEN_H, SCREEN_W};
 use crate::drivers::strip::{GrayMode, StripBuffer};
···
         buf[pos] = self.progress_pct();
         pos += 1;
 
-        k.write_app_data(RECENT_FILE, &buf[..pos])?;
+        k.sd().write_file_in_dir(PULP_DIR, RECENT_FILE, &buf[..pos])?;
         self.recent_dirty = false;
         pulp_kernel::perf_event!(
             "reader",

src/apps/settings.rs

···
 use crate::apps::{App, AppContext, AppId, Transition};
 use crate::board::action::{Action, ActionEvent};
 use crate::board::{SCREEN_H, SCREEN_W};
+use crate::drivers::storage::PULP_DIR;
 use crate::drivers::strip::StripBuffer;
 use crate::fonts;
 use crate::fonts::max_size_idx;
···
         self.settings = SystemSettings::defaults();
         self.wifi = WifiConfig::empty();
 
-        match k.read_app_data_start(config::SETTINGS_FILE, &mut buf) {
+        match k.sd().read_file_start_in_dir(PULP_DIR, config::SETTINGS_FILE, &mut buf) {
             Ok((_size, n)) if n > 0 => {
                 parse_settings_txt(&buf[..n], &mut self.settings, &mut self.wifi);
                 self.settings.sanitize();
···
     fn save(&self, k: &mut KernelHandle<'_>) -> bool {
         let mut buf = [0u8; 512];
         let len = write_settings_txt(&self.settings, &self.wifi, &mut buf);
-        match k.write_app_data(config::SETTINGS_FILE, &buf[..len]) {
+        match k.sd().write_file_in_dir(PULP_DIR, config::SETTINGS_FILE, &buf[..len]) {
             Ok(_) => {
                 log::info!("settings: saved to {}", config::SETTINGS_FILE);
                 true

src/apps/stats.rs

···
     let s = fmt.as_str().as_bytes();
     let len = s.len().min(buf.len());
     buf[..len].copy_from_slice(&s[..len]);
-    k.ensure_app_subdir(STATS_DIR)?;
-    k.write_app_subdir(STATS_DIR, filename, &buf[..len])
+    k.sd().ensure_pulp_subdir(STATS_DIR)?;
+    k.sd().write_in_pulp_subdir(STATS_DIR, filename, &buf[..len])
 }
 
 pub fn load_book_stats(k: &mut KernelHandle<'_>, filename: &str) -> Option<(u32, u32, u16)> {
     let mut buf = [0u8; 128];
     let n = k
-        .read_app_subdir_chunk(STATS_DIR, filename, 0, &mut buf)
+        .sd().read_chunk_in_pulp_subdir(STATS_DIR, filename, 0, &mut buf)
         .ok()?;
     if n == 0 {
         return None;
···
             let fname = entry.name_str();
 
             // try to load stats for this file
-            let n = match k.read_app_subdir_chunk(STATS_DIR, fname, 0, &mut buf) {
+            let n = match k.sd().read_chunk_in_pulp_subdir(STATS_DIR, fname, 0, &mut buf) {
                 Ok(n) if n > 0 => n,
                 _ => continue,
             };