diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc504f2..141306b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,17 @@ for GitHub Release notes, so every published version must have a matching
 
 ## [Unreleased]
 
+## [0.6.3] - 2026-08-04
+
+### Added
+
+- Add a dedicated interactive explorer for CSV, TSV, and other delimiter-
+  separated files. It keeps a searchable field sidebar beside the complete
+  selected value, navigates records lazily, and reuses JSON/XML/scalar syntax
+  highlighting inside individual cells without changing redirected output.
+  Structured cells larger than 1 MiB stay in their complete raw layout to
+  avoid retaining another whole formatted copy.
+
 ## [0.6.2] - 2026-07-22
 
 ### Fixed
diff --git a/Cargo.lock b/Cargo.lock
index a4cb907..0969574 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -222,6 +222,27 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "csv"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
+dependencies = [
+ "csv-core",
+ "itoa",
+ "ryu",
+ "serde_core",
+]
+
+[[package]]
+name = "csv-core"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "704a3c26996a80471189265814dbc2c257598b96b8a7feae2d31ace646bb9782"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "darling"
 version = "0.23.0"
@@ -341,7 +362,7 @@ dependencies = [
 
 [[package]]
 name = "fmtview"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -355,9 +376,10 @@ dependencies = [
 
 [[package]]
 name = "fmtview-core"
-version = "0.6.2"
+version = "0.6.3"
 dependencies = [
  "anyhow",
+ "csv",
  "memchr",
  "quick-xml",
  "ratatui",
diff --git a/Cargo.toml b/Cargo.toml
index 4936075..6e27a94 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,14 +5,14 @@ resolver = "3"
 
 [package]
 name = "fmtview"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2024"
 rust-version = "1.85"
-description = "Fast CLI viewer for highlighting, search, and diffs across JSON, JSONL, HTML/XML, Markdown, TOML, text, and Jinja"
+description = "Fast CLI viewer for CSV, JSON, JSONL, HTML/XML, Markdown, TOML, text, and Jinja"
 license = "MIT"
 repository = "https://github.com/siriusctrl/fmtview"
 readme = "README.md"
-keywords = ["json", "jsonl", "markdown", "toml", "cli"]
+keywords = ["csv", "json", "jsonl", "viewer", "cli"]
 categories = ["command-line-utilities", "development-tools"]
 exclude = [".github/", "npm/"]
 
@@ -20,7 +20,7 @@ exclude = [".github/", "npm/"]
 anyhow = "1.0.102"
 clap = { version = "4.6.1", features = ["derive"] }
 crossterm = "0.29.0"
-fmtview-core = { version = "0.6.2", path = "crates/fmtview-core" }
+fmtview-core = { version = "0.6.3", path = "crates/fmtview-core" }
 ratatui = { version = "0.30.0", default-features = false, features = ["crossterm"] }
 tempfile = "3.27.0"
 
diff --git a/README.md b/README.md
index b2abf5e..83ef9c7 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,8 @@
 # fmtview
 
-Fast CLI viewing, highlighting, search, and diffing for JSON, JSONL,
-XML-compatible markup, HTML, Markdown, TOML, plain text, and Jinja templates.
+Fast CLI viewing, highlighting, search, and diffing for CSV/TSV/XSV, JSON,
+JSONL, XML-compatible markup, HTML, Markdown, TOML, plain text, and Jinja
+templates.
 
 `fmtview` is built for the workflow where you want to inspect data quickly in a
 terminal: open large files without waiting for a full render, keep format
@@ -10,6 +11,7 @@ inputs without leaving the CLI.
 
 ```sh
 fmtview payload.json
+fmtview export.csv
 fmtview events.jsonl
 fmtview --follow events.jsonl
 fmtview response.xml
@@ -39,6 +41,8 @@ embedded markup, wrapped records, or formatted diffs.
 
 - View files in a terminal UI with line numbers, progress, and indent-aware
   soft wrap.
+- Explore delimiter-separated records with a searchable field sidebar and a
+  complete, wrapped value pane instead of squeezing wide records into a grid.
 - Highlight JSON, XML-compatible markup, HTML, embedded markup in JSON strings,
   Markdown, TOML, and Jinja templates.
 - Search the visible text without loading rendered output into memory.
@@ -202,6 +206,12 @@ formatting errors instead of silently changing output semantics.
 
 Known extensions still provide a fast, deterministic hint:
 
+- `.csv` -> comma-separated record explorer in a TTY, exact passthrough when
+  redirected.
+- `.tsv` and `.tab` -> tab-separated record explorer.
+- `.xsv`, `.psv`, and `.ssv` -> delimiter-separated explorer; `.psv` and
+  `.ssv` select pipe and semicolon directly, while `.xsv` sniffs comma, tab,
+  pipe, or semicolon from at most 24 records and 256 KiB per candidate.
 - `.json` -> JSON formatting.
 - `.jsonl` and `.ndjson` -> lazy JSONL record formatting.
 - `.xml` and `.xhtml` -> XML-compatible markup formatting.
@@ -237,6 +247,8 @@ Use `--type` when stdin or an unusual extension needs an explicit profile.
 
 Other types are intentionally passthrough:
 
+- CSV/TSV/XSV data keeps its exact source bytes on redirected stdout. In a TTY,
+  the first record supplies field names and later records are indexed lazily.
 - Markdown is indexed, wrapped, and highlighted, but not rendered to HTML or
   reformatted. Known fenced code blocks reuse the same highlighters as
   top-level files.
@@ -437,6 +449,36 @@ toggle, next/previous change navigation, and line/inline diff shading.
 
 ## Viewer
 
+### Delimited record explorer
+
+CSV, TSV, and XSV files use a field/value explorer rather than the ordinary
+line viewer. The left sidebar keeps field names visible and `/` filters them as
+you type. The right pane shows the selected value completely with wrapping; it
+does not replace long content with an ellipsis. JSON and XML values reuse the
+matching formatter and highlighter, while scalar values use number, boolean,
+null, or string colors.
+
+```text
+Up/Down or j/k       previous/next field
+Left/Right or h/l    previous/next record
+/                    find a field
+Enter                focus the complete value
+Esc                  return from the value to fields; quit from fields
+```
+
+While the value is focused, `Up`/`Down`, `j`/`k`, `PageUp`/`PageDown`,
+`Home`, and `End` scroll it. `/` searches inside the value and `n`/`N` repeat
+the search. Record positions are indexed lazily, including quoted CSV fields
+that contain physical newlines. Redirected output remains the original file;
+the explorer is a TTY-only presentation.
+
+The CSV parser holds the selected logical record in memory so quoting and
+multiline fields remain correct. Embedded JSON/XML values up to 1 MiB are
+pretty-formatted for display. Larger structured values remain complete and
+syntax-highlighted in their original layout, avoiding an additional formatted
+copy; selecting an unusually large record still costs memory proportional to
+that raw record.
+
 The viewer is intentionally small and works with both keyboard and pointer
 input:
 
@@ -658,8 +700,9 @@ rendered output in memory for browsing.
   queued, so a burst of scroll events is not delayed by speculative work.
 - Highlighting and wrapping scan only the visible prefix of long lines.
 - Viewer search scans the indexed visible text in bounded chunks.
-- JSON, JSONL, XML-compatible markup, HTML, Markdown, TOML, plain text, and Jinja
-  templates are processed incrementally where their load strategy allows it.
+- CSV/TSV/XSV cell content and JSON, JSONL, XML-compatible markup, HTML,
+  Markdown, TOML, plain text, and Jinja templates are processed incrementally
+  where their load strategy allows it.
 - JSON numbers are written from their original tokens instead of being coerced
   through native integer or floating-point types.
 
diff --git a/crates/fmtview-core/Cargo.toml b/crates/fmtview-core/Cargo.toml
index 6a964a4..ef63533 100644
--- a/crates/fmtview-core/Cargo.toml
+++ b/crates/fmtview-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "fmtview-core"
-version = "0.6.2"
+version = "0.6.3"
 edition = "2024"
 rust-version = "1.85"
 description = "Headless viewer engine for fmtview"
@@ -16,6 +16,7 @@ path = "src/lib.rs"
 
 [dependencies]
 anyhow = "1.0.102"
+csv = "1.3.1"
 memchr = "2.8.0"
 quick-xml = "0.39.2"
 ratatui = { version = "0.30.0", default-features = false }
diff --git a/crates/fmtview-core/src/formats.rs b/crates/fmtview-core/src/formats.rs
index 02469d5..2999599 100644
--- a/crates/fmtview-core/src/formats.rs
+++ b/crates/fmtview-core/src/formats.rs
@@ -1,4 +1,5 @@
 mod checkpoints;
+pub(crate) mod delimited;
 pub(crate) mod html;
 mod indent;
 pub(crate) mod jinja;
@@ -30,6 +31,9 @@ use crate::{
 };
 
 pub(crate) const FORMAT_SPECS: &[FormatSpec] = &[
+    delimited::CSV_SPEC,
+    delimited::TSV_SPEC,
+    delimited::XSV_SPEC,
     json::SPEC,
     jsonl::SPEC,
     xml::SPEC,
@@ -54,6 +58,8 @@ pub enum ContentShape {
     LineIndexed,
     /// Input is a sequence of independent newline-delimited records.
     RecordStream,
+    /// Input is a sequence of delimiter-aware records with named fields.
+    DelimitedRecords,
     /// Formatting requires document-level parser state.
     WholeDocument,
 }
@@ -90,6 +96,9 @@ pub(crate) fn highlight_content_window_indexed(
     let window_start = window_start.min(line.len());
     let window_end = window_end.min(line.len()).max(window_start);
     match format {
+        FormatKind::Csv | FormatKind::Tsv | FormatKind::Xsv => {
+            plain::highlight::highlight_plain_window(line, window_start, window_end)
+        }
         FormatKind::Json | FormatKind::Jsonl => {
             json::highlight::highlight_json_like_window(line, window_start, window_end, index)
         }
@@ -114,6 +123,33 @@ pub(crate) fn highlight_content_window_indexed(
     }
 }
 
+pub(crate) fn highlight_large_content_window(
+    line: &str,
+    format: FormatKind,
+    window_start: usize,
+    window_end: usize,
+) -> Vec<Span<'static>> {
+    const CONTEXT_BYTES: usize = 4 * 1024;
+
+    let window_start = window_start.min(line.len());
+    let window_end = window_end.min(line.len()).max(window_start);
+    let mut context_start = window_start.saturating_sub(CONTEXT_BYTES);
+    while context_start > 0 && !line.is_char_boundary(context_start) {
+        context_start -= 1;
+    }
+    let mut context_end = window_end.saturating_add(CONTEXT_BYTES).min(line.len());
+    while context_end < line.len() && !line.is_char_boundary(context_end) {
+        context_end += 1;
+    }
+    let context = &line[context_start..context_end];
+    highlight_content_window(
+        context,
+        format,
+        window_start - context_start,
+        window_end - context_start,
+    )
+}
+
 pub(crate) fn highlight_structured_window(
     line: &str,
     window_start: usize,
@@ -160,6 +196,7 @@ pub(crate) fn structure_candidate_kind(
     previous_line: Option<&str>,
 ) -> Option<StructureCandidateKind> {
     match format {
+        FormatKind::Csv | FormatKind::Tsv | FormatKind::Xsv => None,
         FormatKind::Json | FormatKind::Jsonl => json::structure::candidate_kind(line),
         FormatKind::Xml | FormatKind::Html => xml::structure::is_start_tag(line.trim_start())
             .then_some(StructureCandidateKind::XmlStartTag),
@@ -185,6 +222,7 @@ pub(crate) fn structure_candidate_kind_in_window(
     offset: usize,
 ) -> Option<StructureCandidateKind> {
     match format {
+        FormatKind::Csv | FormatKind::Tsv | FormatKind::Xsv => None,
         FormatKind::Json | FormatKind::Jsonl => {
             json::structure::candidate_kind_in_window(lines, offset)
         }
@@ -210,6 +248,7 @@ pub(crate) fn structure_block_end(
     line_count_exact: bool,
 ) -> Option<usize> {
     match format {
+        FormatKind::Csv | FormatKind::Tsv | FormatKind::Xsv => None,
         FormatKind::Json | FormatKind::Jsonl => {
             json::structure::block_end(lines, read_start, start_offset, viewport_bottom)
         }
@@ -364,6 +403,15 @@ mod tests {
         assert_eq!(span_text(&spans), r#"{{ item.name }}</div>"#);
     }
 
+    #[test]
+    fn large_highlight_preserves_only_the_requested_deep_window() {
+        let line = format!("[{}true]", "1234567890,".repeat(200_000));
+        let start = line.len() - 64;
+        let spans = highlight_large_content_window(&line, FormatKind::Json, start, line.len());
+
+        assert_eq!(span_text(&spans), &line[start..]);
+    }
+
     fn span_text(spans: &[Span<'static>]) -> String {
         spans
             .iter()
diff --git a/crates/fmtview-core/src/formats/delimited.rs b/crates/fmtview-core/src/formats/delimited.rs
new file mode 100644
index 0000000..74dd1c1
--- /dev/null
+++ b/crates/fmtview-core/src/formats/delimited.rs
@@ -0,0 +1,141 @@
+use std::{ffi::OsStr, io::Read, path::Path};
+
+use anyhow::{Context, Result};
+use csv::{ByteRecord, ReaderBuilder};
+
+use crate::{
+    formats::{ContentShape, FormatSpec},
+    load::LoadPlan,
+    transform::{FormatKind, TransformStrategy},
+};
+
+const SNIFF_RECORDS: usize = 24;
+const SNIFF_BYTES: u64 = 256 * 1024;
+const DELIMITER_CANDIDATES: &[u8] = b",\t|;";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct DelimitedDialect {
+    delimiter: u8,
+}
+
+impl DelimitedDialect {
+    pub const fn delimiter(self) -> u8 {
+        self.delimiter
+    }
+
+    pub fn display(self) -> &'static str {
+        match self.delimiter {
+            b',' => ",",
+            b'\t' => "TAB",
+            b'|' => "|",
+            b';' => ";",
+            _ => "custom",
+        }
+    }
+}
+
+pub(crate) fn resolve_dialect(path: &Path, kind: FormatKind) -> Result<DelimitedDialect> {
+    let delimiter = match kind {
+        FormatKind::Csv => b',',
+        FormatKind::Tsv => b'\t',
+        FormatKind::Xsv => match path
+            .extension()
+            .and_then(OsStr::to_str)
+            .map(str::to_ascii_lowercase)
+            .as_deref()
+        {
+            Some("psv") => b'|',
+            Some("ssv") => b';',
+            _ => sniff_delimiter(path)?,
+        },
+        _ => anyhow::bail!("{kind:?} is not a delimited format"),
+    };
+    Ok(DelimitedDialect { delimiter })
+}
+
+fn sniff_delimiter(path: &Path) -> Result<u8> {
+    let mut best = None;
+    for &delimiter in DELIMITER_CANDIDATES {
+        let file = std::fs::File::open(path)
+            .with_context(|| format!("failed to open {}", path.display()))?;
+        let mut reader = ReaderBuilder::new()
+            .delimiter(delimiter)
+            .has_headers(false)
+            .flexible(true)
+            .from_reader(file.take(SNIFF_BYTES));
+        let mut record = ByteRecord::new();
+        let mut counts = Vec::new();
+        while counts.len() < SNIFF_RECORDS && reader.read_byte_record(&mut record)? {
+            if !record.is_empty() {
+                counts.push(record.len());
+            }
+        }
+        let Some((&columns, consistent)) = most_common_count(&counts) else {
+            continue;
+        };
+        if columns <= 1 {
+            continue;
+        }
+        let score = (consistent, columns);
+        if best.is_none_or(|(_, best_score)| score > best_score) {
+            best = Some((delimiter, score));
+        }
+    }
+    Ok(best.map(|(delimiter, _)| delimiter).unwrap_or(b','))
+}
+
+fn most_common_count(counts: &[usize]) -> Option<(&usize, usize)> {
+    counts
+        .iter()
+        .map(|candidate| {
+            let occurrences = counts.iter().filter(|count| *count == candidate).count();
+            (candidate, occurrences)
+        })
+        .max_by_key(|(columns, occurrences)| (*occurrences, **columns))
+}
+
+pub(crate) const CSV_SPEC: FormatSpec = FormatSpec {
+    kind: FormatKind::Csv,
+    extensions: &["csv"],
+    shape: ContentShape::DelimitedRecords,
+    load: LoadPlan::LazyDelimitedRecords,
+    transform: TransformStrategy::Passthrough,
+};
+
+pub(crate) const TSV_SPEC: FormatSpec = FormatSpec {
+    kind: FormatKind::Tsv,
+    extensions: &["tsv", "tab"],
+    shape: ContentShape::DelimitedRecords,
+    load: LoadPlan::LazyDelimitedRecords,
+    transform: TransformStrategy::Passthrough,
+};
+
+pub(crate) const XSV_SPEC: FormatSpec = FormatSpec {
+    kind: FormatKind::Xsv,
+    extensions: &["xsv", "psv", "ssv"],
+    shape: ContentShape::DelimitedRecords,
+    load: LoadPlan::LazyDelimitedRecords,
+    transform: TransformStrategy::Passthrough,
+};
+
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use tempfile::Builder;
+
+    use super::*;
+
+    #[test]
+    fn xsv_sniff_does_not_read_past_its_byte_budget() {
+        let mut temp = Builder::new().suffix(".xsv").tempfile().unwrap();
+        temp.write_all(&vec![b'x'; SNIFF_BYTES as usize + 32])
+            .unwrap();
+        temp.write_all(b"|outside|budget\n").unwrap();
+        temp.flush().unwrap();
+
+        let dialect = resolve_dialect(temp.path(), FormatKind::Xsv).unwrap();
+
+        assert_eq!(dialect.delimiter(), b',');
+    }
+}
diff --git a/crates/fmtview-core/src/lib.rs b/crates/fmtview-core/src/lib.rs
index 02c2e41..77cde61 100644
--- a/crates/fmtview-core/src/lib.rs
+++ b/crates/fmtview-core/src/lib.rs
@@ -16,8 +16,8 @@ pub use diff::{DiffView, diff_sources, diff_view};
 pub use formats::ContentShape;
 pub use input::InputSource;
 pub use load::{
-    LoadPlan, OpenedViewFile, RecordTimelineViewFile, ViewFile, ViewFileChange,
-    open_follow_view_file, open_view_file, open_view_file_with_fallback,
+    DelimitedDataset, LoadPlan, OpenedViewFile, RecordTimelineViewFile, ViewFile, ViewFileChange,
+    open_delimited_dataset, open_follow_view_file, open_view_file, open_view_file_with_fallback,
 };
 pub use profile::TypeProfile;
 pub use timeline::{
@@ -28,8 +28,8 @@ pub use timeline::{
 pub use transform::{FormatKind, FormatOptions};
 pub use tui::screen::{RenderFrame, ScrollDirection, ScrollHint, ScrollPosition};
 pub use viewer::{
-    DiffViewer, FileViewer, InputEvent, KeyCode, KeyModifiers, MouseEventKind, ViewerAction,
-    ViewerCommand,
+    DelimitedViewer, DiffViewer, FileViewer, InputEvent, KeyCode, KeyModifiers, MouseEventKind,
+    ViewerAction, ViewerCommand,
 };
 
 /// Transform one source according to an already resolved profile.
diff --git a/crates/fmtview-core/src/load.rs b/crates/fmtview-core/src/load.rs
index 5637cfd..f2cdeb6 100644
--- a/crates/fmtview-core/src/load.rs
+++ b/crates/fmtview-core/src/load.rs
@@ -1,3 +1,4 @@
+mod delimited;
 mod indexed;
 mod lazy;
 mod lazy_records;
@@ -9,6 +10,7 @@ pub(crate) mod record_stream;
 mod timeline;
 mod view_file;
 
+pub use delimited::{DelimitedDataset, open_delimited_dataset};
 pub use indexed::IndexedTempFile;
 pub use lazy_records::LazyTransformedRecordsFile;
 pub use open::{
diff --git a/crates/fmtview-core/src/load/delimited.rs b/crates/fmtview-core/src/load/delimited.rs
new file mode 100644
index 0000000..9d2c30e
--- /dev/null
+++ b/crates/fmtview-core/src/load/delimited.rs
@@ -0,0 +1,306 @@
+use std::{
+    collections::{HashMap, HashSet},
+    fs::File,
+    time::{Duration, Instant},
+};
+
+use anyhow::{Context, Result};
+use csv::{ByteRecord, Position, Reader, ReaderBuilder};
+
+use crate::{
+    formats::delimited::{DelimitedDialect, resolve_dialect},
+    input::InputSource,
+    transform::FormatKind,
+};
+
+const DEFAULT_PRELOAD_RECORDS: usize = 128;
+
+pub struct DelimitedDataset {
+    source: InputSource,
+    label: String,
+    kind: FormatKind,
+    dialect: DelimitedDialect,
+    scanner: Reader<File>,
+    headers: Vec<String>,
+    positions: Vec<Position>,
+    complete: bool,
+    current_index: Option<usize>,
+    current: ByteRecord,
+}
+
+pub fn open_delimited_dataset(source: InputSource, kind: FormatKind) -> Result<DelimitedDataset> {
+    DelimitedDataset::open(source, kind)
+}
+
+impl DelimitedDataset {
+    fn open(source: InputSource, kind: FormatKind) -> Result<Self> {
+        let dialect = resolve_dialect(source.path(), kind)?;
+        let file = source.open()?;
+        let mut scanner = reader(file, dialect);
+        let mut header = ByteRecord::new();
+        let has_header = scanner
+            .read_byte_record(&mut header)
+            .with_context(|| format!("failed to read headers from {}", source.label()))?;
+        let headers = if has_header {
+            display_headers(&header)
+        } else {
+            Vec::new()
+        };
+        let mut dataset = Self {
+            label: source.label().to_owned(),
+            source,
+            kind,
+            dialect,
+            scanner,
+            headers,
+            positions: Vec::new(),
+            complete: !has_header,
+            current_index: None,
+            current: ByteRecord::new(),
+        };
+        if has_header {
+            dataset.scan_one()?;
+            if !dataset.positions.is_empty() {
+                dataset.load_record(0)?;
+            }
+        }
+        Ok(dataset)
+    }
+
+    pub fn label(&self) -> &str {
+        &self.label
+    }
+
+    pub const fn kind(&self) -> FormatKind {
+        self.kind
+    }
+
+    pub const fn dialect(&self) -> DelimitedDialect {
+        self.dialect
+    }
+
+    pub fn headers(&self) -> &[String] {
+        &self.headers
+    }
+
+    pub fn record_count(&self) -> usize {
+        self.positions.len()
+    }
+
+    pub const fn record_count_exact(&self) -> bool {
+        self.complete
+    }
+
+    pub const fn current_index(&self) -> Option<usize> {
+        self.current_index
+    }
+
+    pub fn current_value(&self, field: usize) -> String {
+        String::from_utf8_lossy(self.current_value_bytes(field)).into_owned()
+    }
+
+    pub fn current_value_bytes(&self, field: usize) -> &[u8] {
+        self.current.get(field).unwrap_or_default()
+    }
+
+    pub fn move_record(&mut self, delta: isize) -> Result<bool> {
+        let Some(current) = self.current_index else {
+            return Ok(false);
+        };
+        let target = if delta >= 0 {
+            current.saturating_add(delta as usize)
+        } else {
+            current.saturating_sub(delta.unsigned_abs())
+        };
+        self.set_record(target)
+    }
+
+    pub fn set_record(&mut self, index: usize) -> Result<bool> {
+        while index >= self.positions.len() && !self.complete {
+            if !self.scan_one()? {
+                break;
+            }
+        }
+        if index >= self.positions.len() || self.current_index == Some(index) {
+            return Ok(false);
+        }
+        self.load_record(index)?;
+        Ok(true)
+    }
+
+    pub fn preload(&mut self, budget: Duration) -> Result<bool> {
+        if self.complete {
+            return Ok(false);
+        }
+        let started = Instant::now();
+        let before = self.positions.len();
+        for _ in 0..DEFAULT_PRELOAD_RECORDS {
+            if started.elapsed() >= budget || !self.scan_one()? {
+                break;
+            }
+        }
+        Ok(self.positions.len() != before || self.complete)
+    }
+
+    fn scan_one(&mut self) -> Result<bool> {
+        if self.complete {
+            return Ok(false);
+        }
+        let mut record = ByteRecord::new();
+        if !self
+            .scanner
+            .read_byte_record(&mut record)
+            .with_context(|| format!("failed to index record in {}", self.label))?
+        {
+            self.complete = true;
+            return Ok(false);
+        }
+        let position = record
+            .position()
+            .cloned()
+            .context("CSV reader did not report a record position")?;
+        self.positions.push(position);
+        self.extend_headers(record.len());
+        Ok(true)
+    }
+
+    fn load_record(&mut self, index: usize) -> Result<()> {
+        let position = self
+            .positions
+            .get(index)
+            .cloned()
+            .context("record position was not indexed")?;
+        let file = self.source.open()?;
+        let mut reader = reader(file, self.dialect);
+        reader
+            .seek(position)
+            .with_context(|| format!("failed to seek record {}", index + 1))?;
+        self.current.clear();
+        if !reader
+            .read_byte_record(&mut self.current)
+            .with_context(|| format!("failed to read record {}", index + 1))?
+        {
+            anyhow::bail!("record {} ended before its indexed position", index + 1);
+        }
+        self.extend_headers(self.current.len());
+        self.current_index = Some(index);
+        Ok(())
+    }
+
+    fn extend_headers(&mut self, field_count: usize) {
+        while self.headers.len() < field_count {
+            self.headers
+                .push(format!("field_{}", self.headers.len() + 1));
+        }
+    }
+}
+
+fn reader(file: File, dialect: DelimitedDialect) -> Reader<File> {
+    ReaderBuilder::new()
+        .delimiter(dialect.delimiter())
+        .has_headers(false)
+        .flexible(true)
+        .from_reader(file)
+}
+
+fn display_headers(record: &ByteRecord) -> Vec<String> {
+    let mut headers = Vec::with_capacity(record.len());
+    let mut used = HashSet::with_capacity(record.len());
+    let mut next_suffix = HashMap::with_capacity(record.len());
+    for (index, raw) in record.iter().enumerate() {
+        let decoded = String::from_utf8_lossy(raw).into_owned();
+        let base = if decoded.trim().is_empty() {
+            format!("field_{}", index + 1)
+        } else {
+            decoded
+        };
+        let suffix = next_suffix.entry(base.clone()).or_insert(1_usize);
+        let header = loop {
+            let candidate = if *suffix == 1 {
+                base.clone()
+            } else {
+                format!("{base} [{suffix}]")
+            };
+            *suffix += 1;
+            if used.insert(candidate.clone()) {
+                break candidate;
+            }
+        };
+        headers.push(header);
+    }
+    headers
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Write;
+
+    use tempfile::Builder;
+
+    use super::*;
+
+    fn source(suffix: &str, body: &[u8]) -> (tempfile::NamedTempFile, InputSource) {
+        let mut temp = Builder::new().suffix(suffix).tempfile().unwrap();
+        temp.write_all(body).unwrap();
+        temp.flush().unwrap();
+        let source = InputSource::from_path(temp.path(), "sample").unwrap();
+        (temp, source)
+    }
+
+    #[test]
+    fn indexes_quoted_multiline_records_and_seeks_back() {
+        let (_temp, source) = source(
+            ".csv",
+            b"id,payload\n1,\"line one\nline two\"\n2,\"{\"\"ok\"\":true}\"\n",
+        );
+        let mut dataset = open_delimited_dataset(source, FormatKind::Csv).unwrap();
+
+        assert_eq!(dataset.headers(), &["id", "payload"]);
+        assert_eq!(dataset.current_value(1), "line one\nline two");
+        assert!(dataset.move_record(1).unwrap());
+        assert_eq!(dataset.current_value(0), "2");
+        assert_eq!(dataset.current_value(1), r#"{"ok":true}"#);
+        assert!(dataset.move_record(-1).unwrap());
+        assert_eq!(dataset.current_value(1), "line one\nline two");
+    }
+
+    #[test]
+    fn sniffs_pipe_delimited_xsv() {
+        let (_temp, source) = source(".xsv", b"id|status|payload\n1|ok|hello\n");
+        let dataset = open_delimited_dataset(source, FormatKind::Xsv).unwrap();
+        assert_eq!(dataset.dialect().delimiter(), b'|');
+        assert_eq!(dataset.headers(), &["id", "status", "payload"]);
+        assert_eq!(dataset.current_value(2), "hello");
+    }
+
+    #[test]
+    fn duplicate_headers_receive_stable_unique_names() {
+        let (_temp, source) = source(".csv", b"a,a,a,a [2],a,,\n1,2,3,4,5,6,7\n");
+        let dataset = open_delimited_dataset(source, FormatKind::Csv).unwrap();
+
+        assert_eq!(
+            dataset.headers(),
+            &[
+                "a",
+                "a [2]",
+                "a [3]",
+                "a [2] [2]",
+                "a [4]",
+                "field_6",
+                "field_7"
+            ]
+        );
+    }
+
+    #[test]
+    fn dataset_keeps_temporary_input_open_after_source_drops() {
+        let mut temp = Builder::new().suffix(".csv").tempfile().unwrap();
+        temp.write_all(b"id,value\n1,first\n2,second\n").unwrap();
+        temp.flush().unwrap();
+        let source = InputSource::from_temp(temp, "sample");
+        let mut dataset = open_delimited_dataset(source, FormatKind::Csv).unwrap();
+
+        assert!(dataset.move_record(1).unwrap());
+        assert_eq!(dataset.current_value(1), "second");
+    }
+}
diff --git a/crates/fmtview-core/src/load/open.rs b/crates/fmtview-core/src/load/open.rs
index 5de7edf..0f6ef72 100644
--- a/crates/fmtview-core/src/load/open.rs
+++ b/crates/fmtview-core/src/load/open.rs
@@ -45,6 +45,9 @@ pub fn open_view_file_with_fallback(
     allow_plain_fallback: bool,
 ) -> Result<OpenedViewFile> {
     match profile.load {
+        LoadPlan::LazyDelimitedRecords => {
+            anyhow::bail!("delimited inputs require the delimited viewer")
+        }
         LoadPlan::LazyTransformedRecords => Ok(OpenedViewFile {
             file: Box::new(LazyTransformedRecordsFile::new(input, *options)?),
             content: profile.content,
@@ -108,6 +111,9 @@ impl FormatKindLabel for FormatKind {
     fn label(self) -> &'static str {
         match self {
             FormatKind::Auto => "input",
+            FormatKind::Csv => "CSV",
+            FormatKind::Tsv => "TSV",
+            FormatKind::Xsv => "XSV",
             FormatKind::Json => "JSON",
             FormatKind::Jsonl => "JSONL",
             FormatKind::Xml => "XML",
diff --git a/crates/fmtview-core/src/load/plan.rs b/crates/fmtview-core/src/load/plan.rs
index 04477b4..367afbe 100644
--- a/crates/fmtview-core/src/load/plan.rs
+++ b/crates/fmtview-core/src/load/plan.rs
@@ -1,6 +1,7 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum LoadPlan {
     LazyTransformedRecords,
+    LazyDelimitedRecords,
     EagerTransformedDocument,
     EagerIndexedSource,
 }
diff --git a/crates/fmtview-core/src/perf/load.rs b/crates/fmtview-core/src/perf/load.rs
index fba2f11..37cc6ac 100644
--- a/crates/fmtview-core/src/perf/load.rs
+++ b/crates/fmtview-core/src/perf/load.rs
@@ -6,10 +6,14 @@ use std::{
 use tempfile::NamedTempFile;
 
 use crate::{
-    load::{IndexedTempFile, LazyTransformedRecordsFile, RecordTimelineViewFile, ViewFile},
+    InputSource,
+    load::{
+        IndexedTempFile, LazyTransformedRecordsFile, RecordTimelineViewFile, ViewFile,
+        open_delimited_dataset,
+    },
     timeline::{FileRecordTimeline, RecordLoadLimit},
     transform::{FormatKind, FormatOptions, format_source_to_temp},
-    viewer::FileViewer,
+    viewer::{DelimitedViewer, FileViewer, InputEvent, KeyCode, KeyModifiers},
 };
 use ratatui::layout::Size;
 
@@ -23,6 +27,12 @@ use super::{
 };
 
 pub(super) const CASES: &[BenchCase] = &[
+    BenchCase {
+        label: "wide delimited first-record open+render",
+        shape: "delimited-records/wide-row",
+        layer: "header+record-index+raw-cell-highlight+deep-viewport",
+        run: bench_wide_delimited_first_record,
+    },
     BenchCase {
         label: "raw indexed load",
         shape: "line-indexed",
@@ -108,6 +118,69 @@ pub(super) const CASES: &[BenchCase] = &[
         run: bench_xml_whole_document_index_readback,
     },
 ];
+
+fn bench_wide_delimited_first_record() -> BenchSample {
+    const FIELDS: usize = 20_000;
+    let mut temp = NamedTempFile::new().unwrap();
+    let headers = (1..FIELDS)
+        .map(|index| format!("field_{index}"))
+        .chain(std::iter::once("payload".to_owned()))
+        .collect::<Vec<_>>()
+        .join(",");
+    writeln!(temp, "{headers}").unwrap();
+    let payload = format!(r#"{{"message":"{}"}}"#, "long value ".repeat(200_000));
+    let escaped = payload.replace('"', "\"\"");
+    let values = std::iter::repeat_n("value".to_owned(), FIELDS - 1)
+        .chain(std::iter::once(format!("\"{escaped}\"")))
+        .collect::<Vec<_>>()
+        .join(",");
+    writeln!(temp, "{values}").unwrap();
+    temp.flush().unwrap();
+    let input_bytes = temp.as_file().metadata().unwrap().len() as usize;
+    let source = InputSource::from_temp(temp, "wide.csv");
+
+    let started = Instant::now();
+    let dataset = open_delimited_dataset(source, FormatKind::Csv).unwrap();
+    let mut viewer = DelimitedViewer::new(dataset);
+    let size = Size::new(120, 32);
+    viewer.handle_event(
+        InputEvent::Key {
+            code: KeyCode::End,
+            modifiers: KeyModifiers::NONE,
+        },
+        DelimitedViewer::page_for_size(size),
+    );
+    let _first = viewer.render(size);
+    viewer.handle_event(
+        InputEvent::Key {
+            code: KeyCode::Enter,
+            modifiers: KeyModifiers::NONE,
+        },
+        DelimitedViewer::page_for_size(size),
+    );
+    viewer.handle_event(
+        InputEvent::Key {
+            code: KeyCode::End,
+            modifiers: KeyModifiers::NONE,
+        },
+        DelimitedViewer::page_for_size(size),
+    );
+    let frame = viewer.render(size);
+    let elapsed = started.elapsed();
+
+    assert!(frame.title.contains(&format!("field {FIELDS}/{FIELDS}")));
+    BenchSample {
+        elapsed,
+        records: 1,
+        items: FIELDS,
+        string_bytes: payload.len(),
+        lines: frame.styled.len(),
+        indexed_lines: 0,
+        window_lines: 0,
+        input_bytes,
+        output_bytes: 0,
+    }
+}
 fn bench_raw_indexed_load() -> BenchSample {
     let mut temp = NamedTempFile::new().unwrap();
     let line = format!("{}\n", "x".repeat(240));
diff --git a/crates/fmtview-core/src/profile/tests.rs b/crates/fmtview-core/src/profile/tests.rs
index 509966a..68f2631 100644
--- a/crates/fmtview-core/src/profile/tests.rs
+++ b/crates/fmtview-core/src/profile/tests.rs
@@ -42,6 +42,30 @@ fn resolves_plain_extension_to_passthrough_profile() {
     assert_eq!(profile.transform, TransformStrategy::Passthrough);
 }
 
+#[test]
+fn resolves_delimited_extensions_to_lazy_table_profiles() {
+    for (suffix, expected) in [
+        (".csv", FormatKind::Csv),
+        (".tsv", FormatKind::Tsv),
+        (".xsv", FormatKind::Xsv),
+    ] {
+        let (_temp, source) = source_with_suffix(b"id,payload\n1,hello\n", suffix);
+        let profile = TypeProfile::resolve(
+            &source,
+            &FormatOptions {
+                kind: FormatKind::Auto,
+                indent: 2,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(profile.content, expected);
+        assert_eq!(profile.shape, ContentShape::DelimitedRecords);
+        assert_eq!(profile.load, LoadPlan::LazyDelimitedRecords);
+        assert_eq!(profile.transform, TransformStrategy::Passthrough);
+    }
+}
+
 #[test]
 fn resolves_jinja_extension_to_template_profile() {
     let (_temp, source) = source_with_suffix(b"<h1>{{ title }}</h1>\n", ".html.j2");
@@ -137,6 +161,12 @@ fn explicit_format_kinds_choose_profile_without_sniffing() {
     let (_temp, source) = source(b"{\"broken\":\n");
 
     let cases = [
+        (
+            FormatKind::Csv,
+            ContentShape::DelimitedRecords,
+            LoadPlan::LazyDelimitedRecords,
+            TransformStrategy::Passthrough,
+        ),
         (
             FormatKind::Jsonl,
             ContentShape::RecordStream,
diff --git a/crates/fmtview-core/src/transform.rs b/crates/fmtview-core/src/transform.rs
index 5f18635..027b944 100644
--- a/crates/fmtview-core/src/transform.rs
+++ b/crates/fmtview-core/src/transform.rs
@@ -10,7 +10,6 @@ pub(crate) const IO_BUFFER_BYTES: usize = 256 * 1024;
 #[cfg(test)]
 pub(crate) use engine::format_record_bytes;
 pub(crate) use engine::format_record_display_bytes;
-#[cfg(test)]
 pub(crate) use engine::format_record_to_string;
 #[cfg(test)]
 pub(crate) use engine::format_source_to_temp;
diff --git a/crates/fmtview-core/src/transform/engine.rs b/crates/fmtview-core/src/transform/engine.rs
index 673ec76..31c11b8 100644
--- a/crates/fmtview-core/src/transform/engine.rs
+++ b/crates/fmtview-core/src/transform/engine.rs
@@ -119,9 +119,13 @@ fn try_format_source_to_writer<W: Write>(
             options.indent,
         )
         .with_context(|| format!("failed to format {} as HTML", source.label()))?,
-        FormatKind::Toml | FormatKind::Markdown | FormatKind::Plain | FormatKind::Jinja => {
-            passthrough_source_to_writer(source, output)?
-        }
+        FormatKind::Csv
+        | FormatKind::Tsv
+        | FormatKind::Xsv
+        | FormatKind::Toml
+        | FormatKind::Markdown
+        | FormatKind::Plain
+        | FormatKind::Jinja => passthrough_source_to_writer(source, output)?,
     }
     Ok(())
 }
@@ -153,9 +157,13 @@ pub fn format_record_to_bytes(input: &[u8], kind: FormatKind, indent: usize) ->
                 output.pop();
             }
         }
-        FormatKind::Toml | FormatKind::Markdown | FormatKind::Plain | FormatKind::Jinja => {
-            output.extend_from_slice(input)
-        }
+        FormatKind::Csv
+        | FormatKind::Tsv
+        | FormatKind::Xsv
+        | FormatKind::Toml
+        | FormatKind::Markdown
+        | FormatKind::Plain
+        | FormatKind::Jinja => output.extend_from_slice(input),
     }
     Ok(output)
 }
@@ -219,7 +227,13 @@ pub(crate) fn format_record_bytes(line: &[u8], options: FormatOptions) -> Result
             FormatKind::Html,
             options.indent,
         )?),
-        FormatKind::Toml | FormatKind::Markdown | FormatKind::Plain | FormatKind::Jinja => None,
+        FormatKind::Csv
+        | FormatKind::Tsv
+        | FormatKind::Xsv
+        | FormatKind::Toml
+        | FormatKind::Markdown
+        | FormatKind::Plain
+        | FormatKind::Jinja => None,
     };
 
     Ok(formatted.unwrap_or_else(|| trimmed.to_vec()))
diff --git a/crates/fmtview-core/src/transform/types.rs b/crates/fmtview-core/src/transform/types.rs
index 490338d..b7a01f9 100644
--- a/crates/fmtview-core/src/transform/types.rs
+++ b/crates/fmtview-core/src/transform/types.rs
@@ -1,6 +1,9 @@
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum FormatKind {
     Auto,
+    Csv,
+    Tsv,
+    Xsv,
     Json,
     Jsonl,
     Xml,
@@ -11,6 +14,12 @@ pub enum FormatKind {
     Jinja,
 }
 
+impl FormatKind {
+    pub const fn is_delimited(self) -> bool {
+        matches!(self, Self::Csv | Self::Tsv | Self::Xsv)
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct FormatOptions {
     pub kind: FormatKind,
diff --git a/crates/fmtview-core/src/viewer.rs b/crates/fmtview-core/src/viewer.rs
index a6af0ca..8dfdf15 100644
--- a/crates/fmtview-core/src/viewer.rs
+++ b/crates/fmtview-core/src/viewer.rs
@@ -1,7 +1,9 @@
+mod delimited;
 mod diff;
 mod file;
 mod input;
 
+pub use delimited::DelimitedViewer;
 pub use diff::DiffViewer;
 pub use file::FileViewer;
 pub use input::{InputEvent, KeyCode, KeyModifiers, MouseEventKind, ViewerAction, ViewerCommand};
diff --git a/crates/fmtview-core/src/viewer/delimited.rs b/crates/fmtview-core/src/viewer/delimited.rs
new file mode 100644
index 0000000..62cd571
--- /dev/null
+++ b/crates/fmtview-core/src/viewer/delimited.rs
@@ -0,0 +1,397 @@
+mod render;
+
+use std::time::Duration;
+
+use anyhow::Result;
+use ratatui::layout::Size;
+
+use crate::{
+    load::DelimitedDataset,
+    tui::screen::{RenderFrame, ScrollPosition},
+    viewer::{InputEvent, KeyCode, KeyModifiers, MouseEventKind, ViewerAction},
+};
+
+use render::{CellDisplay, CellMatch};
+
+const PRELOAD_BUDGET: Duration = Duration::from_millis(6);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum Focus {
+    Fields,
+    Value,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum PromptKind {
+    Field,
+    Value,
+}
+
+struct Prompt {
+    kind: PromptKind,
+    buffer: String,
+    original_field: usize,
+}
+
+pub struct DelimitedViewer {
+    dataset: DelimitedDataset,
+    field: usize,
+    focus: Focus,
+    prompt: Option<Prompt>,
+    value_query: String,
+    value_search_match: Option<CellMatch>,
+    value_scroll: usize,
+    last_total_rows: usize,
+    last_value_height: usize,
+    last_value_width: usize,
+    cell: CellDisplay,
+    notice: Option<String>,
+}
+
+impl DelimitedViewer {
+    pub fn new(dataset: DelimitedDataset) -> Self {
+        let cell = CellDisplay::new(dataset.current_value(0));
+        Self {
+            dataset,
+            field: 0,
+            focus: Focus::Fields,
+            prompt: None,
+            value_query: String::new(),
+            value_search_match: None,
+            value_scroll: 0,
+            last_total_rows: 1,
+            last_value_height: 1,
+            last_value_width: 1,
+            cell,
+            notice: None,
+        }
+    }
+
+    pub fn handle_event(&mut self, event: InputEvent, page: usize) -> ViewerAction {
+        let result = match event {
+            InputEvent::Key { code, modifiers } => self.handle_key(code, modifiers, page),
+            InputEvent::Mouse { kind, .. } => self.handle_mouse(kind),
+            InputEvent::Resize => KeyResult::Dirty,
+            InputEvent::Command(_) | InputEvent::Ignore => KeyResult::Clean,
+        };
+        match result {
+            KeyResult::Dirty => ViewerAction {
+                dirty: true,
+                ..ViewerAction::default()
+            },
+            KeyResult::Quit => ViewerAction {
+                quit: true,
+                ..ViewerAction::default()
+            },
+            KeyResult::Clean => ViewerAction::default(),
+        }
+    }
+
+    pub fn render(&mut self, size: Size) -> RenderFrame {
+        let rendered = render::render(self, size);
+        self.last_total_rows = rendered.total_value_rows;
+        self.last_value_height = rendered.value_height;
+        self.last_value_width = rendered.value_width;
+        self.value_scroll = self
+            .value_scroll
+            .min(self.last_total_rows.saturating_sub(self.last_value_height));
+        RenderFrame {
+            area: ratatui::layout::Rect::new(0, 0, size.width, size.height),
+            styled: rendered.lines,
+            sticky: Vec::new(),
+            selection_mode: false,
+            title: rendered.title,
+            footer_text: rendered.footer,
+            footer_style: crate::tui::palette::gutter_style(),
+            position: ScrollPosition {
+                top: self.dataset.current_index().unwrap_or(0),
+                row_offset: self.value_scroll,
+            },
+            scroll_hint: None,
+        }
+    }
+
+    pub fn preload(&mut self) -> Result<bool> {
+        self.dataset.preload(PRELOAD_BUDGET)
+    }
+
+    pub const fn page_for_size(size: Size) -> usize {
+        size.height.saturating_sub(4) as usize
+    }
+
+    fn handle_key(&mut self, code: KeyCode, modifiers: KeyModifiers, page: usize) -> KeyResult {
+        if matches!(code, KeyCode::Char('c')) && modifiers.contains(KeyModifiers::CONTROL) {
+            return KeyResult::Quit;
+        }
+        if self.prompt.is_some() {
+            return self.handle_prompt_key(code, modifiers);
+        }
+        match code {
+            KeyCode::Char('q') => KeyResult::Quit,
+            KeyCode::Esc if self.focus == Focus::Value => {
+                self.focus = Focus::Fields;
+                KeyResult::Dirty
+            }
+            KeyCode::Esc => KeyResult::Quit,
+            KeyCode::Enter if self.focus == Focus::Fields => {
+                self.focus = Focus::Value;
+                KeyResult::Dirty
+            }
+            KeyCode::Enter => KeyResult::Clean,
+            KeyCode::Char('/') => {
+                self.prompt = Some(Prompt {
+                    kind: if self.focus == Focus::Fields {
+                        PromptKind::Field
+                    } else {
+                        PromptKind::Value
+                    },
+                    buffer: String::new(),
+                    original_field: self.field,
+                });
+                KeyResult::Dirty
+            }
+            KeyCode::Char('n') if self.focus == Focus::Value => self.repeat_value_search(true),
+            KeyCode::Char('N') if self.focus == Focus::Value => self.repeat_value_search(false),
+            KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::Fields => self.move_field(-1),
+            KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::Fields => self.move_field(1),
+            KeyCode::Left | KeyCode::Char('h') if self.focus == Focus::Fields => {
+                self.move_record(-1)
+            }
+            KeyCode::Right | KeyCode::Char('l') if self.focus == Focus::Fields => {
+                self.move_record(1)
+            }
+            KeyCode::PageUp if self.focus == Focus::Fields => self.move_record(-(page as isize)),
+            KeyCode::PageDown if self.focus == Focus::Fields => self.move_record(page as isize),
+            KeyCode::Home if self.focus == Focus::Fields => self.set_field(0),
+            KeyCode::End if self.focus == Focus::Fields => {
+                self.set_field(self.dataset.headers().len().saturating_sub(1))
+            }
+            KeyCode::Up | KeyCode::Char('k') if self.focus == Focus::Value => self.scroll_value(-1),
+            KeyCode::Down | KeyCode::Char('j') if self.focus == Focus::Value => {
+                self.scroll_value(1)
+            }
+            KeyCode::PageUp if self.focus == Focus::Value => self.scroll_value(-(page as isize)),
+            KeyCode::PageDown if self.focus == Focus::Value => self.scroll_value(page as isize),
+            KeyCode::Home if self.focus == Focus::Value => {
+                self.value_scroll = 0;
+                KeyResult::Dirty
+            }
+            KeyCode::End if self.focus == Focus::Value => {
+                self.value_scroll = self.last_total_rows.saturating_sub(self.last_value_height);
+                KeyResult::Dirty
+            }
+            _ => KeyResult::Clean,
+        }
+    }
+
+    fn handle_prompt_key(&mut self, code: KeyCode, modifiers: KeyModifiers) -> KeyResult {
+        let Some(prompt) = self.prompt.as_mut() else {
+            return KeyResult::Clean;
+        };
+        match code {
+            KeyCode::Esc => {
+                let original = prompt.original_field;
+                let kind = prompt.kind;
+                self.prompt = None;
+                if kind == PromptKind::Field {
+                    let _ = self.set_field(original);
+                    KeyResult::Dirty
+                } else {
+                    KeyResult::Dirty
+                }
+            }
+            KeyCode::Enter => {
+                let prompt = self.prompt.take().expect("prompt was present");
+                if prompt.kind == PromptKind::Value {
+                    self.value_query = prompt.buffer;
+                    self.value_search_match = None;
+                    self.repeat_value_search(true)
+                } else {
+                    KeyResult::Dirty
+                }
+            }
+            KeyCode::Backspace => {
+                prompt.buffer.pop();
+                if prompt.kind == PromptKind::Field {
+                    self.select_first_field_match();
+                }
+                KeyResult::Dirty
+            }
+            KeyCode::Char(ch)
+                if !modifiers.contains(KeyModifiers::CONTROL)
+                    && !modifiers.contains(KeyModifiers::ALT) =>
+            {
+                prompt.buffer.push(ch);
+                if prompt.kind == PromptKind::Field {
+                    self.select_first_field_match();
+                }
+                KeyResult::Dirty
+            }
+            _ => KeyResult::Clean,
+        }
+    }
+
+    fn handle_mouse(&mut self, kind: MouseEventKind) -> KeyResult {
+        match kind {
+            MouseEventKind::ScrollUp if self.focus == Focus::Value => self.scroll_value(-3),
+            MouseEventKind::ScrollDown if self.focus == Focus::Value => self.scroll_value(3),
+            MouseEventKind::ScrollUp => self.move_field(-1),
+            MouseEventKind::ScrollDown => self.move_field(1),
+            _ => KeyResult::Clean,
+        }
+    }
+
+    fn move_field(&mut self, delta: isize) -> KeyResult {
+        if self.dataset.headers().is_empty() {
+            return KeyResult::Clean;
+        }
+        let target = if delta >= 0 {
+            self.field.saturating_add(delta as usize)
+        } else {
+            self.field.saturating_sub(delta.unsigned_abs())
+        }
+        .min(self.dataset.headers().len() - 1);
+        self.set_field(target)
+    }
+
+    fn set_field(&mut self, field: usize) -> KeyResult {
+        if self.dataset.headers().is_empty() || self.field == field {
+            return KeyResult::Clean;
+        }
+        self.field = field.min(self.dataset.headers().len() - 1);
+        self.refresh_cell();
+        KeyResult::Dirty
+    }
+
+    fn move_record(&mut self, delta: isize) -> KeyResult {
+        match self.dataset.move_record(delta) {
+            Ok(true) => {
+                self.notice = None;
+                self.field = self
+                    .field
+                    .min(self.dataset.headers().len().saturating_sub(1));
+                self.refresh_cell();
+                KeyResult::Dirty
+            }
+            Ok(false) => KeyResult::Clean,
+            Err(error) => {
+                self.notice = Some(format!("record navigation failed: {error:#}"));
+                KeyResult::Dirty
+            }
+        }
+    }
+
+    fn scroll_value(&mut self, delta: isize) -> KeyResult {
+        let max = self.last_total_rows.saturating_sub(self.last_value_height);
+        let next = if delta >= 0 {
+            self.value_scroll.saturating_add(delta as usize).min(max)
+        } else {
+            self.value_scroll.saturating_sub(delta.unsigned_abs())
+        };
+        if next == self.value_scroll {
+            return KeyResult::Clean;
+        }
+        self.value_scroll = next;
+        KeyResult::Dirty
+    }
+
+    fn select_first_field_match(&mut self) {
+        let Some(prompt) = self.prompt.as_ref() else {
+            return;
+        };
+        let query = prompt.buffer.to_lowercase();
+        if query.is_empty() {
+            return;
+        }
+        if let Some(index) = self
+            .dataset
+            .headers()
+            .iter()
+            .position(|header| header.to_lowercase().contains(&query))
+            && index != self.field
+        {
+            self.field = index;
+            self.refresh_cell();
+        }
+    }
+
+    fn repeat_value_search(&mut self, forward: bool) -> KeyResult {
+        if self.value_query.is_empty() {
+            return KeyResult::Clean;
+        }
+        let found = self
+            .cell
+            .find_match(&self.value_query, self.value_search_match, forward);
+        let Some(found) = found else {
+            self.notice = Some(format!("not found: {}", self.value_query));
+            return KeyResult::Dirty;
+        };
+        let scroll = self.cell.visual_offset_for_match(found);
+        if self.value_search_match == Some(found) && self.value_scroll == scroll {
+            return KeyResult::Clean;
+        }
+        self.notice = None;
+        self.value_search_match = Some(found);
+        self.value_scroll = scroll;
+        KeyResult::Dirty
+    }
+
+    fn refresh_cell(&mut self) {
+        self.cell = CellDisplay::new(self.dataset.current_value(self.field));
+        self.cell.ensure_layout(self.last_value_width);
+        self.value_scroll = 0;
+        self.last_total_rows = 1;
+        self.value_query.clear();
+        self.value_search_match = None;
+        self.notice = None;
+    }
+
+    fn visible_fields(&self, height: usize) -> Vec<usize> {
+        if height == 0 || self.dataset.headers().is_empty() {
+            return Vec::new();
+        }
+        let query = self
+            .prompt
+            .as_ref()
+            .filter(|prompt| prompt.kind == PromptKind::Field)
+            .map(|prompt| prompt.buffer.to_lowercase())
+            .unwrap_or_default();
+        if query.is_empty() {
+            let start = self
+                .field
+                .saturating_sub(height / 2)
+                .min(self.dataset.headers().len().saturating_sub(height));
+            return (start..self.dataset.headers().len()).take(height).collect();
+        }
+        let mut match_count = 0_usize;
+        let mut selected = None;
+        for (index, header) in self.dataset.headers().iter().enumerate() {
+            if header.to_lowercase().contains(&query) {
+                if index == self.field {
+                    selected = Some(match_count);
+                }
+                match_count += 1;
+            }
+        }
+        let start = selected
+            .unwrap_or(0)
+            .saturating_sub(height / 2)
+            .min(match_count.saturating_sub(height));
+        self.dataset
+            .headers()
+            .iter()
+            .enumerate()
+            .filter(|(_, header)| header.to_lowercase().contains(&query))
+            .map(|(index, _)| index)
+            .skip(start)
+            .take(height)
+            .collect()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum KeyResult {
+    Clean,
+    Dirty,
+    Quit,
+}
diff --git a/crates/fmtview-core/src/viewer/delimited/render.rs b/crates/fmtview-core/src/viewer/delimited/render.rs
new file mode 100644
index 0000000..903ae85
--- /dev/null
+++ b/crates/fmtview-core/src/viewer/delimited/render.rs
@@ -0,0 +1,687 @@
+use std::ops::Range;
+
+use ratatui::{
+    layout::Size,
+    style::{Modifier, Style},
+    text::{Line, Span},
+};
+use unicode_width::UnicodeWidthChar;
+
+use crate::{
+    formats::{detect_markup_kind, highlight_content_window, highlight_large_content_window},
+    transform::{FormatKind, format_record_to_string},
+    tui::{
+        palette::{
+            bool_style, gutter_style, key_style, null_style, number_style, plain_style,
+            search_inactive_match_bg, string_style,
+        },
+        text::format_count,
+        wrap::{
+            WrapCheckpointIndex, continuation_indent, next_wrap_end, wrap_ranges_window_indexed,
+            wrapped_row_count,
+        },
+    },
+};
+
+use super::{DelimitedViewer, Focus, PromptKind};
+use crate::viewer::file::render::apply_search_ranges_to_spans;
+
+const MAX_FORMATTED_CELL_BYTES: usize = 1024 * 1024;
+
+pub(super) struct RenderedDelimitedView {
+    pub(super) lines: Vec<Line<'static>>,
+    pub(super) title: String,
+    pub(super) footer: String,
+    pub(super) total_value_rows: usize,
+    pub(super) value_height: usize,
+    pub(super) value_width: usize,
+}
+
+pub(super) struct CellDisplay {
+    text: String,
+    lines: Vec<Range<usize>>,
+    mode: FormatKind,
+    scalar_style: Option<Style>,
+    formatted: bool,
+    cached_width: usize,
+    row_counts: Vec<usize>,
+    wrap_indices: Vec<WrapCheckpointIndex>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(super) struct CellMatch {
+    pub(super) line: usize,
+    pub(super) start_byte: usize,
+}
+
+impl CellDisplay {
+    pub(super) fn new(value: String) -> Self {
+        let (text, mode, scalar_style, formatted) = display_value(value);
+        let lines = line_ranges(&text);
+        let count = lines.len();
+        Self {
+            text,
+            lines,
+            mode,
+            scalar_style,
+            formatted,
+            cached_width: 0,
+            row_counts: Vec::new(),
+            wrap_indices: (0..count).map(|_| WrapCheckpointIndex::default()).collect(),
+        }
+    }
+
+    pub(super) fn find_match(
+        &self,
+        query: &str,
+        current: Option<CellMatch>,
+        forward: bool,
+    ) -> Option<CellMatch> {
+        if query.is_empty() || self.lines.is_empty() {
+            return None;
+        }
+        if forward {
+            self.find_forward(query, current)
+        } else {
+            self.find_backward(query, current)
+        }
+    }
+
+    pub(super) fn visual_offset_for_match(&self, found: CellMatch) -> usize {
+        let preceding = self.row_counts.iter().take(found.line).sum::<usize>();
+        let line = self.line(found.line);
+        preceding.saturating_add(wrapped_row_for_byte(
+            line,
+            self.cached_width.max(1),
+            found.start_byte,
+        ))
+    }
+
+    pub(super) fn ensure_layout(&mut self, width: usize) {
+        let width = width.max(1);
+        if self.cached_width == width && self.row_counts.len() == self.lines.len() {
+            return;
+        }
+        self.cached_width = width;
+        self.row_counts = self
+            .lines
+            .iter()
+            .map(|range| {
+                let line = &self.text[range.clone()];
+                wrapped_row_count(line, width, continuation_indent(line, width))
+            })
+            .collect();
+        self.wrap_indices = (0..self.lines.len())
+            .map(|_| WrapCheckpointIndex::default())
+            .collect();
+    }
+
+    fn total_rows(&self) -> usize {
+        self.row_counts.iter().sum::<usize>().max(1)
+    }
+
+    fn visible_rows(
+        &mut self,
+        width: usize,
+        scroll: usize,
+        height: usize,
+        query: Option<&str>,
+        active: Option<CellMatch>,
+    ) -> Vec<Line<'static>> {
+        self.ensure_layout(width);
+        if height == 0 {
+            return Vec::new();
+        }
+        let mut skipped = scroll.min(self.total_rows().saturating_sub(1));
+        let mut logical = 0;
+        while logical < self.row_counts.len() && skipped >= self.row_counts[logical] {
+            skipped -= self.row_counts[logical];
+            logical += 1;
+        }
+
+        let mut rendered = Vec::with_capacity(height);
+        while logical < self.lines.len() && rendered.len() < height {
+            let line = &self.text[self.lines[logical].clone()];
+            let remaining = height - rendered.len();
+            let window = wrap_ranges_window_indexed(
+                line,
+                width,
+                continuation_indent(line, width),
+                skipped,
+                remaining,
+                self.wrap_indices.get_mut(logical),
+            );
+            for range in window.ranges {
+                let mut spans = Vec::new();
+                if range.continuation_indent > 0 {
+                    spans.push(Span::styled(
+                        " ".repeat(range.continuation_indent),
+                        plain_style(),
+                    ));
+                }
+                if let Some(style) = self.scalar_style {
+                    spans.push(Span::styled(
+                        line[range.start_byte..range.end_byte].to_owned(),
+                        style,
+                    ));
+                } else if !self.formatted && self.text.len() > MAX_FORMATTED_CELL_BYTES {
+                    spans.extend(highlight_large_content_window(
+                        line,
+                        self.mode,
+                        range.start_byte,
+                        range.end_byte,
+                    ));
+                } else {
+                    spans.extend(highlight_content_window(
+                        line,
+                        self.mode,
+                        range.start_byte,
+                        range.end_byte,
+                    ));
+                }
+                let (match_ranges, active_range) = row_search_ranges(
+                    line,
+                    query.filter(|query| !query.is_empty()),
+                    logical,
+                    active,
+                    range.start_byte,
+                    range.end_byte,
+                    range.continuation_indent,
+                );
+                rendered.push(Line::from(apply_search_ranges_to_spans(
+                    &spans,
+                    &match_ranges,
+                    active_range,
+                )));
+            }
+            logical += 1;
+            skipped = 0;
+        }
+        if rendered.is_empty() {
+            rendered.push(Line::from(Span::styled("", plain_style())));
+        }
+        rendered
+    }
+
+    fn label(&self) -> &'static str {
+        if self.scalar_style == Some(number_style()) {
+            "number"
+        } else if self.scalar_style == Some(bool_style()) {
+            "boolean"
+        } else if self.scalar_style == Some(null_style()) {
+            "null"
+        } else {
+            match self.mode {
+                FormatKind::Json if !self.formatted => "JSON raw",
+                FormatKind::Xml if !self.formatted => "XML raw",
+                FormatKind::Html if !self.formatted => "HTML raw",
+                FormatKind::Json => "JSON",
+                FormatKind::Xml => "XML",
+                FormatKind::Html => "HTML",
+                _ => "text",
+            }
+        }
+    }
+
+    fn line(&self, index: usize) -> &str {
+        self.lines
+            .get(index)
+            .map(|range| &self.text[range.clone()])
+            .unwrap_or("")
+    }
+
+    fn find_forward(&self, query: &str, current: Option<CellMatch>) -> Option<CellMatch> {
+        if let Some(current) = current {
+            let line = self.line(current.line);
+            let after = current
+                .start_byte
+                .saturating_add(query.len())
+                .min(line.len());
+            if let Some(offset) = line[after..].find(query) {
+                return Some(CellMatch {
+                    line: current.line,
+                    start_byte: after + offset,
+                });
+            }
+            for line_index in current.line.saturating_add(1)..self.lines.len() {
+                if let Some(found) = first_match(self.line(line_index), query, line_index) {
+                    return Some(found);
+                }
+            }
+            for line_index in 0..current.line {
+                if let Some(found) = first_match(self.line(line_index), query, line_index) {
+                    return Some(found);
+                }
+            }
+            return self.line(current.line)[..current.start_byte.min(line.len())]
+                .find(query)
+                .map(|start_byte| CellMatch {
+                    line: current.line,
+                    start_byte,
+                });
+        }
+        (0..self.lines.len())
+            .find_map(|line_index| first_match(self.line(line_index), query, line_index))
+    }
+
+    fn find_backward(&self, query: &str, current: Option<CellMatch>) -> Option<CellMatch> {
+        if let Some(current) = current {
+            let line = self.line(current.line);
+            if let Some(start_byte) = line[..current.start_byte.min(line.len())].rfind(query) {
+                return Some(CellMatch {
+                    line: current.line,
+                    start_byte,
+                });
+            }
+            for line_index in (0..current.line).rev() {
+                if let Some(found) = last_match(self.line(line_index), query, line_index) {
+                    return Some(found);
+                }
+            }
+            for line_index in (current.line.saturating_add(1)..self.lines.len()).rev() {
+                if let Some(found) = last_match(self.line(line_index), query, line_index) {
+                    return Some(found);
+                }
+            }
+            let after = current
+                .start_byte
+                .saturating_add(query.len())
+                .min(line.len());
+            return line[after..].rfind(query).map(|offset| CellMatch {
+                line: current.line,
+                start_byte: after + offset,
+            });
+        }
+        (0..self.lines.len())
+            .rev()
+            .find_map(|line_index| last_match(self.line(line_index), query, line_index))
+    }
+}
+
+pub(super) fn render(viewer: &mut DelimitedViewer, size: Size) -> RenderedDelimitedView {
+    let content_width = usize::from(size.width.saturating_sub(2));
+    let body_height = usize::from(size.height.saturating_sub(3));
+    let sidebar_width = sidebar_width(content_width);
+    let value_width = content_width
+        .saturating_sub(sidebar_width)
+        .saturating_sub(1);
+    let value_height = body_height.saturating_sub(1).max(1);
+
+    viewer.cell.ensure_layout(value_width);
+    let total_value_rows = viewer.cell.total_rows();
+    let max_scroll = total_value_rows.saturating_sub(value_height);
+    viewer.value_scroll = viewer.value_scroll.min(max_scroll);
+
+    let visible_fields = viewer.visible_fields(body_height);
+    let value_rows = viewer.cell.visible_rows(
+        value_width,
+        viewer.value_scroll,
+        value_height,
+        (viewer.focus == Focus::Value).then_some(viewer.value_query.as_str()),
+        (viewer.focus == Focus::Value)
+            .then_some(viewer.value_search_match)
+            .flatten(),
+    );
+
+    let mut lines = Vec::with_capacity(body_height);
+    for row in 0..body_height {
+        let sidebar = sidebar_line(viewer, visible_fields.get(row).copied(), sidebar_width);
+        let mut spans = sidebar.spans;
+        spans.push(Span::styled("│", gutter_style()));
+        if row == 0 {
+            let field_name = viewer
+                .dataset
+                .headers()
+                .get(viewer.field)
+                .map(String::as_str)
+                .unwrap_or("no fields");
+            spans.push(Span::styled(
+                fit_text(
+                    &format!(" {field_name}  · {}", viewer.cell.label()),
+                    value_width,
+                ),
+                key_style().add_modifier(Modifier::BOLD),
+            ));
+        } else if let Some(value) = value_rows.get(row - 1) {
+            spans.extend(value.spans.clone());
+        }
+        lines.push(Line::from(spans));
+    }
+
+    RenderedDelimitedView {
+        lines,
+        title: title(viewer),
+        footer: footer(viewer),
+        total_value_rows,
+        value_height,
+        value_width,
+    }
+}
+
+fn title(viewer: &DelimitedViewer) -> String {
+    let records = format_count(viewer.dataset.record_count());
+    let suffix = if viewer.dataset.record_count_exact() {
+        ""
+    } else {
+        "+"
+    };
+    let record = viewer
+        .dataset
+        .current_index()
+        .map(|index| format_count(index + 1))
+        .unwrap_or_else(|| "0".to_owned());
+    let field = if viewer.dataset.headers().is_empty() {
+        0
+    } else {
+        viewer.field + 1
+    };
+    let focus = if viewer.focus == Focus::Fields {
+        "fields"
+    } else {
+        "value"
+    };
+    format!(
+        " {} | {} {} | record {record}/{records}{suffix} | field {field}/{} | {focus} ",
+        viewer.dataset.label(),
+        format_kind_label(viewer.dataset.kind()),
+        viewer.dataset.dialect().display(),
+        viewer.dataset.headers().len(),
+    )
+}
+
+fn footer(viewer: &DelimitedViewer) -> String {
+    if let Some(prompt) = viewer.prompt.as_ref() {
+        let label = if prompt.kind == PromptKind::Field {
+            "find field"
+        } else {
+            "search value"
+        };
+        return format!(
+            " {label}: {} | Enter accept | Backspace edit | Esc cancel ",
+            prompt.buffer
+        );
+    }
+    if let Some(notice) = viewer.notice.as_deref() {
+        return format!(" {notice} | Esc/q close ");
+    }
+    if viewer.focus == Focus::Value {
+        let search = if viewer.value_query.is_empty() {
+            String::new()
+        } else {
+            format!("search: {} | n/N | ", viewer.value_query)
+        };
+        return format!(
+            " value {}/{} | {search}↑/↓ scroll | Space/Page | / search | Esc fields | q quit ",
+            viewer.value_scroll.saturating_add(1),
+            viewer.last_total_rows,
+        );
+    }
+    " ↑/↓ field | ←/→ record | / find field | Enter value | Page records | q quit ".to_owned()
+}
+
+fn sidebar_line(viewer: &DelimitedViewer, field: Option<usize>, width: usize) -> Line<'static> {
+    let Some(field) = field else {
+        return Line::from(Span::styled(" ".repeat(width), gutter_style()));
+    };
+    let name = viewer
+        .dataset
+        .headers()
+        .get(field)
+        .map(String::as_str)
+        .unwrap_or("");
+    let selected = field == viewer.field;
+    let marker = if selected { '›' } else { ' ' };
+    let text = fit_text(&format!("{marker} {:>4} {name}", field + 1), width);
+    let style = if selected {
+        key_style()
+            .bg(search_inactive_match_bg())
+            .add_modifier(Modifier::BOLD)
+    } else {
+        gutter_style()
+    };
+    Line::from(Span::styled(text, style))
+}
+
+fn sidebar_width(content_width: usize) -> usize {
+    if content_width < 32 {
+        return content_width.saturating_div(3).max(8);
+    }
+    content_width.saturating_div(3).clamp(18, 36)
+}
+
+fn fit_text(text: &str, width: usize) -> String {
+    let mut output = String::new();
+    let mut used = 0_usize;
+    for ch in text.chars() {
+        let ch_width = UnicodeWidthChar::width(ch).unwrap_or(1);
+        if used.saturating_add(ch_width) > width {
+            break;
+        }
+        output.push(ch);
+        used += ch_width;
+    }
+    output.push_str(&" ".repeat(width.saturating_sub(used)));
+    output
+}
+
+fn display_value(value: String) -> (String, FormatKind, Option<Style>, bool) {
+    let trimmed = value.trim();
+    if value.len() <= MAX_FORMATTED_CELL_BYTES
+        && matches!(trimmed.as_bytes().first(), Some(b'{' | b'['))
+        && let Ok(formatted) = format_record_to_string(trimmed.as_bytes(), FormatKind::Json, 2)
+    {
+        return (formatted, FormatKind::Json, None, true);
+    }
+    if trimmed.starts_with('<') {
+        let kind = detect_markup_kind(trimmed.as_bytes());
+        if value.len() <= MAX_FORMATTED_CELL_BYTES
+            && let Ok(formatted) = format_record_to_string(trimmed.as_bytes(), kind, 2)
+        {
+            return (formatted, kind, None, true);
+        }
+        return (value, kind, None, false);
+    }
+    if matches!(trimmed.as_bytes().first(), Some(b'{' | b'[')) {
+        return (value, FormatKind::Json, None, false);
+    }
+    let scalar_style = if trimmed.len() > 128 {
+        Some(string_style())
+    } else if trimmed.is_empty() {
+        Some(gutter_style())
+    } else {
+        let lower = trimmed.to_ascii_lowercase();
+        if lower == "true" || lower == "false" {
+            Some(bool_style())
+        } else if matches!(lower.as_str(), "null" | "nil" | "none" | "na" | "n/a") {
+            Some(null_style())
+        } else if trimmed.parse::<f64>().is_ok() {
+            Some(number_style())
+        } else {
+            Some(string_style())
+        }
+    };
+    (value, FormatKind::Plain, scalar_style, false)
+}
+
+fn line_ranges(value: &str) -> Vec<Range<usize>> {
+    let mut lines = Vec::new();
+    let mut start = 0;
+    for (index, byte) in value.bytes().enumerate() {
+        if byte != b'\n' {
+            continue;
+        }
+        let end = if index > start && value.as_bytes()[index - 1] == b'\r' {
+            index - 1
+        } else {
+            index
+        };
+        lines.push(start..end);
+        start = index + 1;
+    }
+    lines.push(start..value.len());
+    lines
+}
+
+fn first_match(line: &str, query: &str, line_index: usize) -> Option<CellMatch> {
+    line.find(query).map(|start_byte| CellMatch {
+        line: line_index,
+        start_byte,
+    })
+}
+
+fn last_match(line: &str, query: &str, line_index: usize) -> Option<CellMatch> {
+    line.rfind(query).map(|start_byte| CellMatch {
+        line: line_index,
+        start_byte,
+    })
+}
+
+fn wrapped_row_for_byte(line: &str, width: usize, byte: usize) -> usize {
+    if line.is_empty() {
+        return 0;
+    }
+    let target = byte.min(line.len().saturating_sub(1));
+    let indent = continuation_indent(line, width);
+    let mut row = 0;
+    let mut start_byte = 0;
+    let mut start_char = 0;
+    while start_byte < line.len() {
+        let row_width = if row == 0 {
+            width.max(1)
+        } else {
+            width
+                .saturating_sub(indent.min(width.saturating_sub(1)))
+                .max(1)
+        };
+        let (end_byte, end_char) = next_wrap_end(line, start_byte, start_char, row_width);
+        if target < end_byte || end_byte >= line.len() {
+            return row;
+        }
+        start_byte = end_byte.max(start_byte + 1).min(line.len());
+        start_char = end_char.max(start_char + 1);
+        row += 1;
+    }
+    row
+}
+
+fn row_search_ranges(
+    line: &str,
+    query: Option<&str>,
+    logical_line: usize,
+    active: Option<CellMatch>,
+    row_start_byte: usize,
+    row_end_byte: usize,
+    prefix_chars: usize,
+) -> (Vec<Range<usize>>, Option<Range<usize>>) {
+    let Some(query) = query else {
+        return (Vec::new(), None);
+    };
+    let overlap = query.len().saturating_sub(1);
+    let mut scan_start = row_start_byte.saturating_sub(overlap);
+    while scan_start > 0 && !line.is_char_boundary(scan_start) {
+        scan_start -= 1;
+    }
+    let mut scan_end = row_end_byte.saturating_add(overlap).min(line.len());
+    while scan_end < line.len() && !line.is_char_boundary(scan_end) {
+        scan_end += 1;
+    }
+    let ranges = line[scan_start..scan_end]
+        .match_indices(query)
+        .filter_map(|(offset, _)| {
+            let match_start = scan_start + offset;
+            let match_end = match_start + query.len();
+            let start = match_start.max(row_start_byte);
+            let end = match_end.min(row_end_byte);
+            (start < end).then(|| {
+                let local_start = line[row_start_byte..start].chars().count();
+                let local_end = local_start + line[start..end].chars().count();
+                prefix_chars + local_start..prefix_chars + local_end
+            })
+        })
+        .collect::<Vec<_>>();
+    let active = active
+        .filter(|active| active.line == logical_line)
+        .and_then(|active| {
+            let match_start = active.start_byte.min(line.len());
+            let match_end = match_start.saturating_add(query.len()).min(line.len());
+            let start = match_start.max(row_start_byte);
+            let end = match_end.min(row_end_byte);
+            (start < end).then(|| {
+                let local_start = line[row_start_byte..start].chars().count();
+                let local_end = local_start + line[start..end].chars().count();
+                prefix_chars + local_start..prefix_chars + local_end
+            })
+        });
+    (ranges, active)
+}
+
+fn format_kind_label(kind: FormatKind) -> &'static str {
+    match kind {
+        FormatKind::Csv => "CSV",
+        FormatKind::Tsv => "TSV",
+        FormatKind::Xsv => "XSV",
+        _ => "delimited",
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn structured_cells_reuse_existing_highlighters() {
+        let display = CellDisplay::new(r#"{"items":[1,true]}"#.to_owned());
+        assert_eq!(display.mode, FormatKind::Json);
+        assert!(display.text.contains("\"items\""));
+    }
+
+    #[test]
+    fn fit_text_uses_display_width_without_ellipsis() {
+        assert_eq!(fit_text("你好 payload", 8), "你好 pay");
+    }
+
+    #[test]
+    fn search_match_maps_to_its_actual_wrapped_row_and_repeats_within_a_line() {
+        let mut display = CellDisplay::new(format!(
+            "{}needle{}needle",
+            "x".repeat(5000),
+            "y".repeat(80)
+        ));
+        display.ensure_layout(40);
+
+        let first = display.find_match("needle", None, true).unwrap();
+        let second = display.find_match("needle", Some(first), true).unwrap();
+
+        assert!(display.visual_offset_for_match(first) >= 124);
+        assert!(display.visual_offset_for_match(second) > display.visual_offset_for_match(first));
+    }
+
+    #[test]
+    fn search_highlight_survives_a_soft_wrap_boundary() {
+        let mut display = CellDisplay::new("xxxxneedle".to_owned());
+        let found = display.find_match("needle", None, true).unwrap();
+        let rows = display.visible_rows(5, 0, 3, Some("needle"), Some(found));
+        let highlighted_rows = rows
+            .iter()
+            .filter(|row| {
+                row.spans
+                    .iter()
+                    .any(|span| span.style.bg == Some(crate::tui::palette::search_match_bg()))
+            })
+            .count();
+
+        assert_eq!(highlighted_rows, 2);
+    }
+
+    #[test]
+    fn oversized_structured_cell_stays_raw_to_bound_formatting_memory() {
+        let display = CellDisplay::new(format!(
+            "{{\"payload\":\"{}\"}}",
+            "x".repeat(MAX_FORMATTED_CELL_BYTES)
+        ));
+
+        assert_eq!(display.mode, FormatKind::Json);
+        assert!(!display.formatted);
+        assert_eq!(display.label(), "JSON raw");
+    }
+}
diff --git a/crates/fmtview-core/src/viewer/file/render.rs b/crates/fmtview-core/src/viewer/file/render.rs
index 731d146..0475053 100644
--- a/crates/fmtview-core/src/viewer/file/render.rs
+++ b/crates/fmtview-core/src/viewer/file/render.rs
@@ -19,6 +19,7 @@ pub(in crate::viewer) use layout::*;
 pub(in crate::viewer) use line::rendered_row_count;
 pub(in crate::viewer) use metrics::*;
 pub(in crate::viewer) use prewarm::*;
+pub(in crate::viewer) use search::*;
 pub(in crate::viewer) use tail::*;
 pub(in crate::viewer) use types::*;
 pub(in crate::viewer) use viewport::*;
@@ -27,5 +28,3 @@ pub(in crate::viewer) use viewport::*;
 pub(in crate::viewer) use crate::tui::wrap::*;
 #[cfg(test)]
 pub(in crate::viewer) use line::*;
-#[cfg(test)]
-pub(in crate::viewer) use search::*;
diff --git a/crates/fmtview-core/tests/headless_viewer.rs b/crates/fmtview-core/tests/headless_viewer.rs
index 732d305..e4b36a8 100644
--- a/crates/fmtview-core/tests/headless_viewer.rs
+++ b/crates/fmtview-core/tests/headless_viewer.rs
@@ -1,9 +1,9 @@
 use std::io::Write;
 
 use fmtview_core::{
-    ContentShape, DiffViewer, FileViewer, FormatKind, FormatOptions, InputEvent, InputSource,
-    KeyCode, KeyModifiers, LoadPlan, TypeProfile, diff_view, open_view_file,
-    render_frame_to_buffer,
+    ContentShape, DelimitedViewer, DiffViewer, FileViewer, FormatKind, FormatOptions, InputEvent,
+    InputSource, KeyCode, KeyModifiers, LoadPlan, TypeProfile, diff_view, open_delimited_dataset,
+    open_view_file, render_frame_to_buffer,
 };
 use ratatui::{
     buffer::Buffer,
@@ -356,6 +356,50 @@ fn diff_engine_renders_and_navigates_without_a_terminal() {
     assert!(!next.styled.is_empty());
 }
 
+#[test]
+fn delimited_engine_finds_fields_and_highlights_structured_values() {
+    let source = source(
+        "wide.csv",
+        concat!(
+            "id,status,payload,notes\n",
+            "1,ok,\"{\"\"role\"\":\"\"assistant\"\",\"\"items\"\":[1,true]}\",first\n",
+            "2,error,\"{\"\"role\"\":\"\"tool\"\",\"\"message\"\":\"\"failed\"\"}\",second\n",
+        ),
+    );
+    let dataset = open_delimited_dataset(source, FormatKind::Csv).unwrap();
+    let mut viewer = DelimitedViewer::new(dataset);
+    let size = Size::new(100, 18);
+
+    let first = viewer.render(size);
+    assert!(first.title.contains("CSV ,"), "{}", first.title);
+    assert!(buffer_text(first).contains("id"));
+
+    send_delimited_key(&mut viewer, size, KeyCode::Char('/'));
+    for ch in "payload".chars() {
+        send_delimited_key(&mut viewer, size, KeyCode::Char(ch));
+    }
+    send_delimited_key(&mut viewer, size, KeyCode::Enter);
+    let payload = viewer.render(size);
+    let text = buffer_text(payload);
+    assert!(text.contains("request_payload") || text.contains("payload"));
+    assert!(text.contains("\"role\": \"assistant\""), "{text}");
+
+    send_delimited_key(&mut viewer, size, KeyCode::Enter);
+    send_delimited_key(&mut viewer, size, KeyCode::Char('/'));
+    for ch in "assistant".chars() {
+        send_delimited_key(&mut viewer, size, KeyCode::Char(ch));
+    }
+    send_delimited_key(&mut viewer, size, KeyCode::Enter);
+    let searched = viewer.render(size);
+    assert!(searched.footer_text.contains("search: assistant"));
+
+    send_delimited_key(&mut viewer, size, KeyCode::Esc);
+    assert!(send_delimited_key(&mut viewer, size, KeyCode::Right).dirty);
+    let second = viewer.render(size);
+    assert_eq!(second.position.top, 1);
+    assert!(buffer_text(second).contains("\"role\": \"tool\""));
+}
+
 fn source(label: &str, text: &str) -> InputSource {
     let mut temp = NamedTempFile::new().unwrap();
     temp.write_all(text.as_bytes()).unwrap();
@@ -373,6 +417,20 @@ fn send_key(viewer: &mut FileViewer, size: Size, code: KeyCode) -> fmtview_core:
     )
 }
 
+fn send_delimited_key(
+    viewer: &mut DelimitedViewer,
+    size: Size,
+    code: KeyCode,
+) -> fmtview_core::ViewerAction {
+    viewer.handle_event(
+        InputEvent::Key {
+            code,
+            modifiers: KeyModifiers::NONE,
+        },
+        DelimitedViewer::page_for_size(size),
+    )
+}
+
 fn buffer_text(frame: fmtview_core::RenderFrame) -> String {
     let mut buffer = Buffer::empty(Rect::new(0, 0, frame.area.width, frame.area.height));
     render_frame_to_buffer(&mut buffer, frame);
diff --git a/docs/INDEX.md b/docs/INDEX.md
index ffb3df1..e857980 100644
--- a/docs/INDEX.md
+++ b/docs/INDEX.md
@@ -72,7 +72,8 @@ or navigation target should be displayed. Those decisions belong to core.
   redirected output, eager viewing, lazy record viewing, and diff input.
 - `load.rs` and `load/` own `ViewFile`, eager temp-file indexing, lazy record
   spooling, timeline raw/formatted spools, reset reconciliation, read windows,
-  progress, notices, and preload mechanics.
+  progress, notices, and preload mechanics. `load/delimited.rs` owns lazy CSV-
+  family logical-record positions and selected-record reads.
 - `timeline.rs` defines the public backend-neutral `RecordTimeline` contract,
   identities/snapshots/read/refresh outcomes, and the reverse-scanning growing
   file implementation.
@@ -82,6 +83,9 @@ or navigation target should be displayed. Those decisions belong to core.
   action types. The root package translates crossterm events into this vocabulary.
 - `viewer/file.rs` owns `FileViewer`: background search/structure work, lazy
   preload scheduling, viewer state transitions, frame rendering, and prewarming.
+- `viewer/delimited.rs` owns the CSV/TSV/XSV field/value explorer, contextual
+  field/value search, record navigation, and backend-neutral frames; its render
+  module owns the sidebar and complete highlighted value pane.
 - `viewer/file/` owns search, navigation, sticky breadcrumbs, conversation/tool
   context, Markdown checkpoints, viewport positioning, layout, gutters,
   highlighting, render caches, and tail clamping.
diff --git a/docs/architecture.md b/docs/architecture.md
index 99b09cd..f63af6e 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -100,6 +100,14 @@ unit of work that shared runtimes can rely on:
     in bounded record batches, and future ordered parallel transform can share
     the same runtime. JSONL and NDJSON use this shape today.
 
+  DelimitedRecords
+    Input is a delimiter-aware sequence whose logical records may span physical
+    lines. The explorer indexes record positions lazily, keeps header fields as
+    the navigation axis, and holds only the selected logical record for field
+    access. Embedded structured cells have a bounded 1 MiB pretty-format path;
+    larger values keep their complete raw layout and visible-window syntax
+    highlighting. CSV, TSV, and XSV use this shape today.
+
   WholeDocument
     Correct formatting depends on document-level parser state. The transformed
     document normally has to be produced before the viewer can index it. JSON,
@@ -115,6 +123,7 @@ behavior, temp-file indexing, highlight checkpoints, and viewer readback.
 
 | Type | Shape | Interactive view | Redirected output | Diff input | Format package |
 | --- | --- | --- | --- | --- | --- |
+| CSV/TSV/XSV | DelimitedRecords | Lazy record index with field sidebar and complete highlighted value pane | Exact passthrough | Passthrough | `formats/delimited` dialect rules plus shared embedded-value highlighters |
 | JSON | WholeDocument | Eager transformed document indexed from a temp file | Pretty-printed JSON | Pretty-printed JSON | `formats/json` |
 | JSONL/NDJSON | RecordStream | Lazy transformed records spooled and indexed on demand | Pretty-printed records | Pretty-printed records; TTY diff can open lazily | `formats/jsonl` profile plus JSON record behavior |
 | XML | WholeDocument | Eager transformed document indexed from a temp file | Pretty-printed XML-compatible markup | Pretty-printed XML-compatible markup | `formats/xml` |
diff --git a/docs/visual-verification.md b/docs/visual-verification.md
index 6362123..e29103f 100644
--- a/docs/visual-verification.md
+++ b/docs/visual-verification.md
@@ -63,6 +63,16 @@ FMTVIEW_EMULATOR_SCENARIO=conversation \
   target/debug/fmtview examples/conversation.jsonl
 ```
 
+For the wide delimited-record explorer, select the dedicated scenario. It
+records live field filtering, complete embedded JSON rendering, value focus and
+search, record navigation, and clean quit:
+
+```sh
+FMTVIEW_EMULATOR_SCENARIO=delimited \
+  scripts/record-emulator-demo.sh target/fmtview-emulator-recordings/delimited -- \
+  target/debug/fmtview examples/wide.csv
+```
+
 For release candidates, pass the release binary explicitly after building it:
 
 ```sh
diff --git a/examples/wide.csv b/examples/wide.csv
new file mode 100644
index 0000000..04c070f
--- /dev/null
+++ b/examples/wide.csv
@@ -0,0 +1,4 @@
+id,created_at,status,region,customer_name,request_id,model,latency_ms,input_tokens,output_tokens,request_payload,response_payload,error_message,notes
+req_1041,2026-08-04T11:22:31Z,ok,ap-southeast,Alice Chen,call_01,gpt-5,231,842,193,"{""role"":""user"",""content"":[{""type"":""text"",""text"":""Summarize the quarterly report and preserve every material qualification.""}],""metadata"":{""source"":""wide-csv-demo"",""tags"":[""finance"",""review""]}}","{""role"":""assistant"",""content"":[{""type"":""text"",""text"":""Revenue increased while operating margin remained under pressure; the complete answer stays visible and wraps inside the value pane without truncation.""}],""usage"":{""input_tokens"":842,""output_tokens"":193}}",,"normal request with long embedded JSON cells"
+req_1042,2026-08-04T11:23:10Z,error,eu-west,Bob Li,call_02,gpt-5,8421,1294,88,"{""role"":""user"",""content"":[{""type"":""text"",""text"":""Validate the deployment configuration across all production regions.""}],""metadata"":{""source"":""wide-csv-demo"",""attempt"":2}}","{""role"":""tool"",""tool_call_id"":""call_02"",""content"":""upstream returned an invalid response after 8421ms""}","upstream returned an invalid response after the configured retry budget was exhausted","this record demonstrates field search, record navigation, and complete error payload viewing"
+req_1043,2026-08-04T11:24:02Z,pending,us-east,Carla Ruiz,call_03,gpt-5,0,433,0,"<request><task priority=""high"">Inspect embedded XML highlighting inside a CSV field.</task><owner>platform</owner></request>",,waiting for approval,"XML payload is highlighted by the existing markup formatter"
diff --git a/npm/fmtview/README.md b/npm/fmtview/README.md
index e09cf1e..3bc6b21 100644
--- a/npm/fmtview/README.md
+++ b/npm/fmtview/README.md
@@ -1,7 +1,8 @@
 # fmtview
 
-Fast CLI viewing, highlighting, search, and diffing for JSON, JSONL,
-HTML, XML-compatible markup, Markdown, TOML, plain text, and Jinja templates.
+Fast CLI viewing, highlighting, search, and diffing for CSV/TSV/XSV, JSON,
+JSONL, HTML, XML-compatible markup, Markdown, TOML, plain text, and Jinja
+templates.
 
 This npm package installs the prebuilt static Linux x64 `fmtview` binary.
 
@@ -20,10 +21,12 @@ fmtview app.log
 `.jsonl`, `.html`, `.md`, `.toml`, `.txt`, and `.j2` are hints, and unknown
 extensions are sniffed from a bounded content prefix where possible.
 
-JSON, JSONL/NDJSON, XML-compatible markup, and HTML are formatted. Markdown,
-TOML, plain text, and Jinja templates are passthrough types: they are indexed
-and previewed without rewriting their content. Markdown fenced `json`, `toml`,
-`xml`/`html`, and `jinja` blocks reuse the matching viewer highlighter.
+CSV/TSV/XSV files open as a searchable field/value explorer in a TTY and keep
+exact source bytes when redirected. JSON, JSONL/NDJSON, XML-compatible markup,
+and HTML are formatted. Markdown, TOML, plain text, and Jinja templates are
+passthrough types: they are indexed and previewed without rewriting their
+content. Markdown fenced `json`, `toml`, `xml`/`html`, and `jinja` blocks reuse
+the matching viewer highlighter.
 
 The main product surface is the terminal viewer: fast lazy loading, useful
 highlighting, in-viewer search, and interactive diffs while redirected stdout
diff --git a/npm/fmtview/package.json b/npm/fmtview/package.json
index 1fe6d4b..d1d743e 100644
--- a/npm/fmtview/package.json
+++ b/npm/fmtview/package.json
@@ -1,7 +1,7 @@
 {
   "name": "fmtview",
-  "version": "0.6.2",
-  "description": "Fast CLI viewer for highlighting, search, and diffs across JSON, JSONL, HTML/XML, Markdown, TOML, text, and Jinja",
+  "version": "0.6.3",
+  "description": "Fast CLI viewer for CSV, JSON, JSONL, HTML/XML, Markdown, TOML, text, and Jinja",
   "license": "MIT",
   "homepage": "https://github.com/siriusctrl/fmtview#readme",
   "repository": {
@@ -12,6 +12,8 @@
     "url": "https://github.com/siriusctrl/fmtview/issues"
   },
   "keywords": [
+    "csv",
+    "tsv",
     "json",
     "jsonl",
     "xml",
diff --git a/scripts/record-emulator-demo.sh b/scripts/record-emulator-demo.sh
index ea4a9ab..58ab67e 100755
--- a/scripts/record-emulator-demo.sh
+++ b/scripts/record-emulator-demo.sh
@@ -29,6 +29,9 @@ command to record append, detach, reattach, and pause/resume actions.
 
 Set FMTVIEW_EMULATOR_SCENARIO=conversation to record nested tool-pair
 navigation, structured/raw record toggles, media collapse, search, and wrap.
+
+Set FMTVIEW_EMULATOR_SCENARIO=delimited to record field filtering, embedded
+value highlighting, value search, and record navigation for examples/wide.csv.
 EOF
 }
 
@@ -259,6 +262,29 @@ if [[ -n "$follow_file" ]]; then
   sleep 0.8
   send_key "resume_follow" "f"
   sleep 0.8
+elif [[ "$scenario" == "delimited" ]]; then
+  send_key "field_search_open" "slash"
+  sleep 0.2
+  send_type "field_search_query" "request_payload"
+  sleep 0.4
+  send_key "field_search_accept" "Return"
+  sleep 0.8
+  send_key "focus_value" "Return"
+  sleep 0.7
+  send_key "value_search_open" "slash"
+  sleep 0.2
+  send_type "value_search_query" "content"
+  sleep 0.2
+  send_key "value_search_accept" "Return"
+  sleep 0.8
+  send_key "value_page_down" "Page_Down"
+  sleep 0.7
+  send_key "return_to_fields" "Escape"
+  sleep 0.5
+  send_key "next_record" "Right"
+  sleep 0.8
+  send_key "focus_next_value" "Return"
+  sleep 0.8
 elif [[ "$scenario" == "conversation" ]]; then
   send_key "tool_search_open" "slash"
   sleep 0.2
diff --git a/src/cli.rs b/src/cli.rs
index fb0fbb8..fd8ec47 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -4,7 +4,8 @@ use anyhow::{Context, Result, bail};
 use clap::{Args, Parser, Subcommand, ValueEnum};
 use fmtview_core::{
     ContentShape, FormatKind, FormatOptions, TypeProfile, diff_sources, diff_view,
-    open_follow_view_file, open_view_file, open_view_file_with_fallback, transform_source_to_temp,
+    open_delimited_dataset, open_follow_view_file, open_view_file, open_view_file_with_fallback,
+    transform_source_to_temp,
 };
 
 use crate::{
@@ -17,7 +18,7 @@ use crate::{
 #[command(
     name = "fmtview",
     version,
-    about = "Fast formatter, diff tool, and terminal viewer for JSON, JSONL, XML, HTML, Markdown, TOML, plain text, and Jinja templates",
+    about = "Fast formatter, diff tool, and terminal viewer for CSV, TSV, XSV, JSON, JSONL, XML, HTML, Markdown, TOML, plain text, and Jinja templates",
     args_conflicts_with_subcommands = true,
     subcommand_precedence_over_arg = true
 )]
@@ -145,6 +146,11 @@ fn run_format(command: FormatCommand) -> Result<()> {
         return viewer::run(opened.file, opened.content, opened.notice);
     }
 
+    if profile.content_kind().is_delimited() && should_view() {
+        let dataset = open_delimited_dataset(input, profile.content_kind())?;
+        return viewer::run_delimited(dataset);
+    }
+
     if should_view() {
         let opened = if kind == FormatKind::Auto {
             open_view_file_with_fallback(&input, &resolved_options, profile, true)?
@@ -180,6 +186,9 @@ fn run_diff(command: DiffCommand) -> Result<()> {
 #[derive(Debug, Clone, Copy, ValueEnum)]
 enum CliFormatKind {
     Auto,
+    Csv,
+    Tsv,
+    Xsv,
     Json,
     Jsonl,
     Xml,
@@ -194,6 +203,9 @@ impl From<CliFormatKind> for FormatKind {
     fn from(kind: CliFormatKind) -> Self {
         match kind {
             CliFormatKind::Auto => Self::Auto,
+            CliFormatKind::Csv => Self::Csv,
+            CliFormatKind::Tsv => Self::Tsv,
+            CliFormatKind::Xsv => Self::Xsv,
             CliFormatKind::Json => Self::Json,
             CliFormatKind::Jsonl => Self::Jsonl,
             CliFormatKind::Xml => Self::Xml,
diff --git a/src/viewer.rs b/src/viewer.rs
index 8f59451..73cb98a 100644
--- a/src/viewer.rs
+++ b/src/viewer.rs
@@ -13,8 +13,8 @@ use crossterm::{
     terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
 use fmtview_core::{
-    DiffView, DiffViewer, FileViewer, FormatKind, InputEvent, KeyCode, KeyModifiers,
-    MouseEventKind, ViewFile, ViewerAction,
+    DelimitedDataset, DelimitedViewer, DiffView, DiffViewer, FileViewer, FormatKind, InputEvent,
+    KeyCode, KeyModifiers, MouseEventKind, ViewFile, ViewerAction,
 };
 use ratatui::backend::CrosstermBackend;
 
@@ -35,6 +35,10 @@ pub(crate) fn run_diff(view: DiffView) -> Result<()> {
     })
 }
 
+pub(crate) fn run_delimited(dataset: DelimitedDataset) -> Result<()> {
+    run_terminal(|terminal| run_delimited_loop(terminal, DelimitedViewer::new(dataset)))
+}
+
 fn run_file_loop(
     terminal: &mut ViewerTerminal<CrosstermBackend<io::Stdout>>,
     mut viewer: FileViewer,
@@ -112,6 +116,36 @@ fn run_diff_loop(
     Ok(())
 }
 
+fn run_delimited_loop(
+    terminal: &mut ViewerTerminal<CrosstermBackend<io::Stdout>>,
+    mut viewer: DelimitedViewer,
+) -> Result<()> {
+    let mut dirty = true;
+    loop {
+        if dirty {
+            let size = terminal.size().context("failed to read terminal size")?;
+            terminal
+                .draw(viewer.render(size))
+                .context("failed to draw delimited viewer frame")?;
+            dirty = false;
+        }
+
+        if !event::poll(EVENT_POLL_INTERVAL).context("failed to poll terminal event")? {
+            dirty |= viewer.preload()?;
+            continue;
+        }
+
+        let size = terminal.size().context("failed to read terminal size")?;
+        let page = DelimitedViewer::page_for_size(size);
+        let action = drain_events(|event| (viewer.handle_event(event, page), false))?;
+        if action.quit {
+            break;
+        }
+        dirty |= action.dirty;
+    }
+    Ok(())
+}
+
 fn drain_file_events(viewer: &mut FileViewer, page: usize) -> Result<ViewerAction> {
     drain_events(|event| {
         let action = viewer.handle_event(event, page);
diff --git a/tests/cli.rs b/tests/cli.rs
index a831f42..7f2e578 100644
--- a/tests/cli.rs
+++ b/tests/cli.rs
@@ -251,6 +251,30 @@ fn unknown_extension_plain_text_is_passthrough() {
         .stdout(predicate::eq("not json\n{{ still plain }}\nkey = value\n"));
 }
 
+#[test]
+fn csv_redirect_preserves_exact_source_bytes() {
+    let input = "id,payload\r\n1,\"line one\nline two\"\r\n";
+    let mut file = TempFileBuilder::new().suffix(".csv").tempfile().unwrap();
+    file.write_all(input.as_bytes()).unwrap();
+
+    let mut cmd = Command::cargo_bin("fmtview").unwrap();
+    cmd.arg(file.path())
+        .assert()
+        .success()
+        .stdout(predicate::eq(input));
+}
+
+#[test]
+fn explicit_tsv_stdin_stays_scriptable() {
+    let input = "id\tpayload\n1\t{\"ok\":true}\n";
+    let mut cmd = Command::cargo_bin("fmtview").unwrap();
+    cmd.args(["--type", "tsv"])
+        .write_stdin(input)
+        .assert()
+        .success()
+        .stdout(predicate::eq(input));
+}
+
 #[test]
 fn auto_detects_toml_as_passthrough() {
     let mut input = TempFileBuilder::new().suffix(".toml").tempfile().unwrap();