diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9eb0f53..c73e56b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -4,16 +4,15 @@ on:
   push:
     branches: [ main, work ]
   pull_request:
-    branches: [ main ]
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
-          node-version: 18
+          node-version: 20
       - run: npm ci
       - run: npm run lint
       - run: npm test
diff --git a/.vscodeignore b/.vscodeignore
index 7d3e5c7..4ac8a1a 100644
--- a/.vscodeignore
+++ b/.vscodeignore
@@ -9,3 +9,13 @@ vsc-extension-quickstart.md
 **/*.map
 **/*.ts
 **/.vscode-test.*
+
+dist/**
+out/test/**
+.github/**
+.agents/**
+.codex/**
+.mcp.json
+AGENTS.md
+scripts/**
+images/*-*.jpg
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 09902bc..e1f9293 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,8 +1,32 @@
 # Changelog
 
-All notable changes to the "CSV" extension will be documented in this file.
+## [1.4.2] - 2026-10-17
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+This release combines the editing, navigation, and table tools developed since the public 1.3 release.
+
+### Editing and file integrity
+
+- Preserve multiline drafts through repeated line breaks, blur, saves, tab changes, and table/text switches. Failed edits remain available for retry or explicit discard.
+- Preserve existing CSV quoting and line endings during cell edits, structural paste, and row/column moves. Copy and Cut quote each value only when necessary, retain real empty fields, and exclude the extra append row.
+- Add saved-file table/text replacement with unsaved-edit preservation and explicit Save As support for untitled CSV/TSV tables that retain their native owner.
+- Keep native Find in Files destinations in text after an explicit local-file Text choice, including restart and Off/On. Restore only owned routing preferences on return to Table and preserve intervening user choices.
+- Preserve the active document through multi-file Off/On changes. Serialize native handoffs and request a fresh acknowledgment for cell or filter activity made while waiting.
+- Improve encoding guidance without guessing or silently changing the source encoding.
+
+### Table navigation and views
+
+- Add contextual first-row header and serial-index actions, frozen leading rows/columns, remembered manual widths, and a configurable default for hidden leading metadata.
+- Fix column resize hit testing at fractional borders and frozen seams, retain usable narrow-column centers, and make dragged widths follow the pointer. Automatic sizing accounts for multiline values.
+- Show selection immediately on mouse-down. Support a second separate header click for header-only selection, anchored Ctrl/Cmd+Shift+Arrow ranges, and viewport following during held-arrow navigation.
+- Keep modified native Find/Replace shortcuts outside the table overlay. Position context menus using available viewport space, with scrolling in small panes.
+- Paint frozen-row divider seams without changing row geometry. Preserve the chosen datatype palette or theme foreground mode across light, dark, and high-contrast themes.
+
+### Filtering, preview, and comparison
+
+- Add inline live column filters with multiple AND conditions, including repeated conditions on one column; inferred number/date/boolean comparisons; Does Not Contain; and RE2 regular expressions. Preserve input focus, invalid drafts, source row identities, and the full source when saving.
+- Add a bounded, paginated read-only preview for large saved UTF-8 files. The direct Explorer/command path avoids opening a full text document first; malformed or oversized records produce errors instead of truncation.
+- Add explicit read-only table comparison with record alignment, changed-cell highlighting, synchronized panes, change navigation, and bounded display/alignment work. Native Git/PR custom-editor diff remains a separate limitation.
+- Document privacy and data handling, including remote extension hosts, clipboard/link actions, diagnostic logs, and saved filter values.
 
 ## [1.2.1] - 2025-08-20
 - Fixed: Scrolling freeze at 1000 rows when header was enabled by making chunking consistent across modes and using a safe JSON transport to the webview.
diff --git a/PRIVACY.md b/PRIVACY.md
new file mode 100644
index 0000000..bc2194b
--- /dev/null
+++ b/PRIVACY.md
@@ -0,0 +1,33 @@
+# Privacy and data handling
+
+CSV does not implement an upload service, analytics client, or extension-specific telemetry collection. Normal editable views parse, search, sort, and edit files through the VS Code document and the extension's bundled code. No account or external processing service is required by CSV.
+
+## Where processing happens
+
+Normal editable CSV views receive the file's decoded text from VS Code. The extension parses that text with the bundled Papa Parse library, sends table content to its VS Code webview, and applies edits through VS Code's document APIs. Saving in these views uses VS Code's normal file-saving behavior and the selected file encoding.
+
+The read-only large-file preview supports host-local UTF-8 files and reads bounded blocks directly from the saved file. It does not write the saved file.
+
+For a normal local workspace, these operations run on your computer. In Remote SSH, WSL, Dev Containers, or another remote workspace, the extension host and files can be on that remote environment. File contents travel through your existing VS Code connection to display and edit them in the webview. “No external processing service” does not mean that a remote workspace's data stays on your local computer.
+
+The font picker uses the bundled `font-list` package to enumerate fonts available to the extension host through operating-system helpers. It does not use an online font service.
+
+## Actions that share information outside the table
+
+- **Clipboard:** Copying writes the selected contents to the system clipboard; pasting reads clipboard contents supplied by the editor. Other applications, clipboard managers, and operating-system clipboard synchronization may have access to that clipboard.
+- **Links:** Ctrl/Cmd+click on a recognized link asks VS Code to open its URL using your configured browser or application. Supported schemes include HTTP, HTTPS, FTP, and email links. The destination receives the URL, including any information in its path or query, according to that application's behavior. CSV does not fetch a link merely to render its text. You can disable link interaction with `csv.clickableLinks`.
+- **Support:** If you attach a file, screenshot, or log to a GitHub issue, you are sharing it with that issue's audience. CSV does not submit these materials automatically.
+
+VS Code's Marketplace connections, updates, Settings Sync, remote services, other extensions, and the browser or application used for links have their own data-handling behavior. They are separate from CSV's runtime processing.
+
+## Logs and stored state
+
+The extension writes diagnostic messages to the extension host's console. Routine messages include file paths/URIs, row counts, and the row/column coordinates of an edit; routine edit messages omit the cell value. Errors can still contain document or operation details, and a failed external-link operation can log its URL. Treat extension host logs as potentially containing sensitive information, especially before sharing them for support. The log location and retention are controlled by VS Code and may be in a remote environment.
+
+CSV's code does not send those logs or cell contents to a telemetry endpoint. This statement does not describe or override VS Code's own telemetry, logging, crash reporting, or another extension's behavior. Consult your editor's privacy policy and settings for those services.
+
+CSV stores per-file view preferences in VS Code workspace state on the extension host, keyed by the file URI: header mode, serial-index visibility, separator overrides, hidden leading rows, manual column widths, frozen rows/columns, and column filters. Valid filter conditions are saved as you type in the filter details row and may contain sensitive CSV values; incomplete or invalid drafts are not saved. Clear all filters removes the saved conditions for that file. Its webview state remembers scroll/selection positions, column widths, row heights, and zoom. View preferences and saved state can themselves contain sensitive data and metadata; they are not intended as full-document backups. VS Code independently manages the document, undo history, unsaved-file backups, autosave, and any platform synchronization you enable.
+
+## Scope of these statements
+
+These statements describe this repository's extension and webview implementation. The main data paths are in [`src/CsvEditorProvider.ts`](src/CsvEditorProvider.ts), [`media/main.js`](media/main.js), [`src/commands.ts`](src/commands.ts), and [`src/extension.ts`](src/extension.ts); runtime dependencies are declared in [`package.json`](package.json). They are not a promise about every VS Code component, remote host, dependency version, or installed extension. Review the version you use and your environment's policies when deciding whether it fits your data requirements.
diff --git a/README.md b/README.md
index 7dec9d6..e7c9c10 100644
--- a/README.md
+++ b/README.md
@@ -1,203 +1,193 @@
-# **CSV**
+# CSV
 
-Experience a whole new way to work with CSV files right inside VS Code. CSV transforms your CSV files into an interactive, spreadsheet-like experience—making it effortless to view, edit, and navigate your data with precision and speed.
+View and edit `.csv`, `.tsv`, `.tab`, and `.psv` files as tables in VS Code. CSV supports multiline cells, selection and clipboard operations, column filters, frozen panes, and a text-view switch for working with the underlying file.
 
----
+Actual CSV table webview with example data, captured in Chromium.
 
-## Screenshots
+![CSV table in a dark theme](images/marketplace-dark.png)
+![CSV table in a light theme](images/marketplace-light.png)
 
-![Dark Theme Screenshot](images/Screenshot_dark.png)
-![Light Theme Screenshot](images/Screenshot_light.png)
+## Open and edit a file
 
----
+Install **CSV** by **ReprEng** from the Extensions view, then open a supported file. CSV opens it as a table unless your editor associations select another editor. The default separators are comma for `.csv`, tab for `.tsv` and `.tab`, and pipe for `.psv`.
 
-## Why CSV?
+1. Click a cell to select it. Type to start a quick edit, or press Enter or double-click for detail editing.
+2. Press Enter or Tab, click outside the cell, or move focus away to commit its text to the VS Code document. In quick edit, arrow keys also commit and move to the adjacent cell. In detail edit, arrows move the text caret; Shift+Enter inserts a line break.
+3. Press Ctrl/Cmd+S to commit the active cell and save the document. Committing a cell alone does **not** write the file to disk; VS Code's autosave can save committed document changes if enabled.
 
-Working with CSV files shouldn’t be a chore. With CSV, you get:
+Escape cancels the active cell draft. If VS Code rejects an edit, its draft stays available: retry it or press Escape to discard it before structural operations, switching views, or disabling the table. Changes remain unsaved until a save succeeds.
 
-- **Direct In-Place Editing:** Click on any cell to edit its content seamlessly. Your changes can be saved immediately to the CSV file, ensuring data integrity without extra steps.
-- **Smart Column Sizing & Dynamic Color Coding:** Columns automatically adjust to fit content while being visually distinguished by data type. Whether it’s boolean, date, integer, float, or text, each column gets its own adaptive color that adjusts for light and dark themes.
-- **Sticky Headers & Fluid Navigation:** Keep your header row always visible as you scroll. Effortlessly move through cells using intuitive keyboard shortcuts like `Tab`, `Shift + Tab`, and arrow keys—just like a full-featured spreadsheet.
-- **Efficient Multi-Cell Selection & Clipboard Integration:** Select a range of cells with click-and-drag and copy them as well-formatted CSV data using `Ctrl/Cmd + C`.
-- **Grid Paste Support:** Paste copied ranges directly into the selected cell/range with `Ctrl/Cmd + V` in selection mode.
-- **Robust Data Handling:** Leveraging the power of [Papa Parse](https://www.papaparse.com/), the extension handles complex CSV structures, special characters, and various data types gracefully.
-- **Theme-Optimized Interface:** Whether you prefer light or dark mode, CSV automatically adapts its styles for an optimal viewing experience.
+An empty file can be edited immediately. The extra bottom row is an append affordance; entering a value creates source data, while leaving it empty does not. Disable `csv.showTrailingEmptyRow` to hide it.
 
----
+CSV declares support for VS Code **1.70 or later**. Saved-file table/text replacement requires **1.100** for clean documents and **1.120** for documents with unsaved changes. Older hosts show update guidance for that action.
 
-## Features
+## Select, copy, paste, and arrange data
 
-- **Interactive Editing:** Two modes — type to start a quick edit, or press Enter/double‑click for detail edit. Saves on blur.
-- **Smart Resizing:** Automatic calculation of column widths for improved readability.
-- **Dynamic Color Coding:** Visual cues based on data type help you quickly identify numbers, dates, booleans, and more (with opt‑in cool palette and theme-foreground mode settings).
-- **Sticky Headers:** Keep column titles in view as you scroll through large datasets.
-- **Enhanced Keyboard Navigation:** Navigate cells with arrows and Tab/Shift+Tab; quick edits can commit with arrow keys; `Ctrl/Cmd + A` selects all; `Ctrl/Cmd + C` copies selection.
-- **Advanced Multi-Cell Selection:** Easily select and copy blocks of data, then paste them elsewhere as properly formatted CSV.
-- **Add/Delete Columns:** Right-click any cell to add a column left or right, or remove the selected column.
-- **Add/Delete Rows:** Insert above/below or remove the selected row via context menu.
-- **Edit Empty CSVs:** Create or open an empty CSV file and start typing immediately.
-- **Column Sorting:** Right-click a header and choose A–Z or Z–A.
-- **Custom Font Controls:** Choose a font family and optional font-size override, or inherit VS Code defaults.
-- **In-View Zoom:** Use `Ctrl/Cmd + Mouse Wheel` or `Ctrl/Cmd + +/-/0` to zoom the CSV view without changing global editor zoom.
-- **Find & Replace Overlay:** Built-in find/replace bar with match options (case, whole-word, regex), keyboard navigation, and single/all replace actions across the full file (including chunked rows).
-- **Multiline Cell Display:** Cells with embedded newlines render as wrapped multi-line content (with preserved line breaks and matching row height).
-- **Clickable Links:** URLs in cells are automatically detected and displayed as clickable links. Ctrl/Cmd+click to open them in your browser.
-- **Preserved CSV Integrity:** All modifications respect CSV formatting—no unwanted extra characters or formatting issues.
-- **Optimized for Performance:** Designed for medium-sized datasets, ensuring a smooth editing experience without compromising on functionality.
-- **Large File Support:** Loads big CSVs in chunks so even large datasets open quickly.
-- **CSV/TSV/TAB/PSV Support:** `.csv`, `.tsv`, `.tab`, and `.psv` files are recognized automatically. Defaults: comma for CSV, tab for TSV/TAB, pipe for PSV.
+Selection is visible as soon as you press the mouse button. Drag or Shift+click to select a range. Click a header to select its column; a second separate click on the same header selects only the header cell. Double-click edits the header. Click the serial index to select a row, or the top-left corner to select the table. Shift+click extends whole-row or whole-column selections.
 
----
+Use Ctrl/Cmd+C or X, or the selection's right-click **Copy** or **Cut** action. Clipboard data uses the active separator and quotes each value only when needed, preserving separators, line breaks, literal quotes, surrounding whitespace, and real empty cells. The serial index and extra append row are excluded. Selecting only the append row leaves the clipboard unchanged. Clipboard shortcuts inside cell edits, Find, Replace, and filter inputs keep their normal text-editing behavior.
 
-## Compatibility
+Paste with Ctrl/Cmd+V in selection mode or the right-click **Paste** action. A single value fills a selected rectangle; a copied matrix starts at the selection. With filters active, copying, cutting, filling, and matrix paste use matching source rows. Additional pasted rows append at the physical end of the file. Nonmatching rows stay intact, and saving includes the full file.
 
-This extension is built for VS Code **1.70.0** and later. It has been tested with
-Cursor (built on VS Code 1.99) and the latest VS Code releases (1.102).
+Right-click cells to insert or delete rows and columns. Multi-selection actions use the selected count. Drag selected headers or row indices to reorder a column/row or selected group. Right-click a header to sort ascending or descending; with filters active, sorting rearranges matching rows within their source positions and leaves hidden rows in place. These operations change the document and require saving like other edits. Unchanged field quoting and existing line endings are preserved; new values follow a consistent existing column quote style where available.
 
-## Getting Started
+Context menus open toward the available space, flip above or left when needed, and scroll in small panes. Resizing the editor or changing CSV zoom dismisses an open menu.
 
-### 1. Install the Extension
+## Headers, metadata rows, widths, and frozen panes
 
-- Open Visual Studio Code.
-- Go to the Extensions view (`Ctrl+Shift+X` or `Cmd+Shift+X` on macOS).
-- Search for **CSV** and click **Install**.
+- **Header:** Right-click a cell in the first visible source row and choose **Use first row as header** or **Treat first row as data**. Hidden leading metadata is skipped; filtering does not promote an arbitrary matching row to the header. The Command Palette also provides **CSV: Toggle First Row as Header**.
+- **Serial index:** Right-click an index cell or its top-left corner and choose **Hide serial index column**. Restore it with **CSV: Toggle Serial Index Column**. The numbers identify source rows and can have gaps while filtering.
+- **Metadata:** **CSV: Hide First N Rows** hides leading records without deleting them. Blank input inherits `csv.defaultIgnoreRows`; an explicit `0` shows them even if the configured default is nonzero.
+- **Widths:** Automatic column widths account for the longest line in multiline cells. Drag close to a column boundary to resize, including with headers off. Double-click the boundary to restore automatic sizing. Manual widths are remembered per file; narrow columns retain a selectable center. Drag the bottom edge of a serial-index cell to adjust its row height.
+- **Frozen panes:** Right-click to freeze through a visible row or data column, or use **CSV: Freeze Leading Rows/Columns**. Enter `0` to unfreeze an axis. Counts are remembered per file. By default, the header stays frozen; with headers off, no rows freeze until requested. Hidden metadata and the append row do not count. Frozen rows follow measured multiline/zoomed heights and paint their divider seams; the serial index stays alongside frozen data columns.
 
-### 2. Open a CSV, TSV, TAB, or PSV File
+Header, serial-index, separator, hidden-row, manual-width, and frozen-pane preferences do not change CSV contents and are stored per file URI in VS Code workspace state. Scroll, selection, row heights, and zoom use webview state. Column colors follow the selected datatype palette (`default`, `cool`, or `warm`) or the theme foreground mode. Light, dark, and high-contrast themes retain that choice. CSV's zoom changes the table's text size independently of global editor zoom.
 
-- Open any `.csv`, `.tsv`, `.tab`, or `.psv` file in VS Code.
-- The file will automatically load, presenting your data in an interactive grid view.
+## Live column filters
 
-### 3. Edit and Navigate
+Right-click a data column and choose **Filter this column** to add a condition above the table. Choose a column and operator, then type a value; results update as you type without replacing the focused input. **Add filter** and repeated context actions add conditions, including multiple conditions on the same column. All conditions combine with **AND**. Remove one condition or use **Clear all filters** to remove them all.
 
-- **Edit Modes:**
-  - Quick edit: start typing any character to edit the selected cell immediately. Press any Arrow key to save and move the selection to the next cell in that direction.
-  - Detail edit: press `Enter` on a selected cell or double‑click to enter a focused edit. Arrow Left/Right move the text caret; Arrow Up goes to start; Arrow Down goes to end. Click outside the cell (or blur) to save.
-- **Keyboard Navigation:** Use Arrow keys to move between cells when not editing. Use `Tab`/`Shift+Tab` to move horizontally (wrapping across rows as needed).
-- **Multi-Cell Selection:** Click and drag or use `Shift + Click` to select multiple cells, then copy them as CSV using `Ctrl/Cmd + C`.
-- **Find & Replace:** Press `Ctrl/Cmd + F` to open Find, or `Ctrl/Cmd + H` to open Find + Replace.
+![Two live column conditions combined with AND](images/marketplace-filters.png)
 
----
+Every column offers Contains, Does Not Contain, Regular Expression, Equals, Does Not Equal, Is Empty, and Is Not Empty. Number and date columns also offer `>`, `>=`, `<`, and `<=`. Types are inferred from the original body rows, excluding the effective header and hidden metadata, before any filters apply. A text column whose nonblank cells all parse as supported dates also offers date comparisons without changing its column colors.
 
-## Commands
+- Text comparisons ignore case. Numbers accept finite decimal/scientific values and consistent thousands grouping, and compare without rounding away significant digits.
+- Boolean equality accepts `true/false`, `t/f`, `yes/no`, `y/n`, `on/off`, and `1/0`.
+- Dates accept ISO/year-first forms, numeric dates with four-digit years, and English month names, with optional times and timezone offsets. Unzoned values use UTC. Ambiguous numeric dates use month/day/year: `03/04/2026` means March 4; `13/04/2026` is unambiguously April 13. Use ISO dates or month names to avoid ambiguity. Supported timestamps compare exactly, including sub-millisecond fractions.
+- Regular Expression uses [RE2 syntax](https://github.com/google/re2/wiki/Syntax). Plain patterns ignore case; `/pattern/flags` supports `i`, `m`, and `s`. An explicit empty flag list (`/pattern/`) is case-sensitive. Lookaround and backreferences are unsupported.
 
-Open the Command Palette and search for:
+A zero-length value leaves a draft condition inactive, except Is Empty/Is Not Empty, which need no value. Literal spaces are valid text searches. Invalid or incomplete values show an inline error and retain the last valid results. Blank or invalid cell values do not match typed comparisons, including Does Not Equal; use Is Empty for empty cells. Incomplete IME text is not applied automatically after a view refresh.
 
-- `CSV: Toggle Extension On/Off` (`csv.toggleExtension`)
-- `CSV: Toggle First Row as Header` (`csv.toggleHeader`)
-- `CSV: Toggle Serial Index Column` (`csv.toggleSerialIndex`)
-- `CSV: Change CSV Separator` (`csv.changeSeparator`)
-- `CSV: Reset CSV Separator (Inherit)` (`csv.resetSeparator`)
-- `CSV: Change Font Family` (`csv.changeFontFamily`)
-- `CSV: Hide First N Rows` (`csv.changeIgnoreRows`)
-- `CSV: Change File Encoding` (`csv.changeEncoding`)
-- `CSV: Toggle Clickable Links` (`csv.toggleClickableLinks`)
-  
+Filtering scans the full editable document, retains source row identities, and does not delete source rows. Valid conditions are remembered per file and can contain sensitive data; see [Privacy and data handling](PRIVACY.md). Blank or invalid drafts are not persisted.
 
-## Settings
+## Find, native search, and text view
+
+Ctrl/Cmd+F opens table Find; Ctrl/Cmd+H opens Find and Replace. Match case, whole-word, regular expression, selection-only search, and single/all replacement are available. Table Find includes later chunks. With filters active, Find and Replace All use matching displayed rows and the header; hidden metadata and nonmatching rows are excluded.
+
+Ctrl/Cmd+Shift+F and Ctrl/Cmd+Shift+H remain VS Code's native Find/Replace in Files shortcuts. Alt-modified variants also stay outside the table overlay.
 
-Global (Settings UI or `settings.json`):
-
-- `csv.enabled` (boolean, default `true`): Enable/disable the custom editor.
-- `csv.fontFamily` (string, default empty): Override font family; falls back to `editor.fontFamily`.
-- `csv.fontSize` (number, default `0`): Override font size in px; set to `0` to inherit `editor.fontSize`.
-- `csv.mouseWheelZoom` (boolean, default `true`): Enable `Ctrl/Cmd + Mouse Wheel` zooming in the CSV editor.
-- `csv.mouseWheelZoomInvert` (boolean, default `false`): Invert the `Ctrl/Cmd + Mouse Wheel` zoom direction.
-- `csv.cellPadding` (number, default `4`): Vertical cell padding in pixels.
-- `csv.columnColorMode` (string, default `type`): `type` keeps CSV’s type-based column colors; `theme` uses your theme foreground color for all columns.
-- `csv.columnColorPalette` (string, default `default`): Type-color palette when `csv.columnColorMode` is `type`. `cool` biases colors toward greens/blues; `warm` biases colors toward oranges/reds.
-- `csv.diffUseThemeForeground` (boolean, default `true`): In compare/diff views, use theme foreground color so diff highlighting remains readable.
-- `csv.clickableLinks` (boolean, default `true`): Make URLs in cells clickable. Ctrl/Cmd+click to open links.
-- `csv.showTrailingEmptyRow` (boolean, default `true`): Show the extra empty row at the end of the table. Turn this off to hide that visual append row.
-- `csv.separatorMode` (string, default `extension`): Separator selection mode when no per-file override exists. `extension` uses extension mapping, `auto` detects from content first, `default` always uses `csv.defaultSeparator`.
-- `csv.defaultSeparator` (string, default `,`): Fallback separator. Use `\\t` in `settings.json` for tabs.
-- `csv.separatorByExtension` (object): Extension-to-separator mapping (defaults include `.csv`→`,`, `.tsv`/`.tab`→tab, `.psv`→`|`).
-- `csv.maxFileSizeMB` (number, default `10`): Soft limit for opening files in CSV view. If exceeded, CSV prompts: `Cancel`, `Continue This Time`, or `Ignore Forever` (sets this setting to `0`).
-- Per-file encoding: use `CSV: Change File Encoding` to set a file's encoding (e.g., `utf8`, `utf16le`, `windows1250`, `gbk`). The extension will reopen the file using the chosen encoding.
+Use the toolbar switch or **CSV: Switch Between Table and Text** to edit the same document as source text. For saved files, the target opens before the source view is replaced, so one representation remains in that editor group. Live cell edits commit first, unsaved changes remain unsaved, and unrelated tabs/groups are retained. If the file already has a table in another group, switch from that group.
 
-Per-file (stored by the extension; set via commands):
+For a saved local `file:` URI without an authority, query, or fragment, choosing Text also installs a reversible file-path editor association. Native Find in Files can then open that file in text at the selected result while CSV remains enabled. The choice survives restart and Off/On; switching successfully back to Table restores only CSV's owned association. Other files keep their normal editor choice. Intervening user choices are preserved. Patterns use VS Code's case-insensitive matching, so case-distinct paths are not independently isolated. CSV reports longer/conflicting associations or settings restrictions that prevent native routing.
 
-- First row as header (default `true`) — `CSV: Toggle First Row as Header`
-- Serial index column (default `true`) — `CSV: Toggle Serial Index Column`
-- CSV separator override — `CSV: Change CSV Separator` (or clear it with `CSV: Reset CSV Separator (Inherit)`)
-- Hide first N rows (default `0`) — `CSV: Hide First N Rows`
+**Search boundary:** this does not add native search navigation inside a table. A cold search into a file still associated with the table may open the table without revealing the match. Remote/virtual URIs that cannot be isolated by these patterns can switch views, but need CSV turned off for native text search routing. **CSV: Toggle Extension On/Off** temporarily routes CSV's four selectors and explicit CSV associations to native text while off, then restores owned preferences when enabled again. It honors an explicit workspace `csv.enabled` value, otherwise it toggles the global value. Re-enabling upgrades the invoking saved text tab when its restored editor choice is CSV; other already-open text tabs keep their current view until reopened or explicitly switched.
 
----
+## Untitled CSV and TSV
 
-## Editing Modes and Shortcuts
+Choose CSV or TSV language mode in a new untitled text document to open a table before saving. The native text tab remains its unsaved owner. Switching the table to text commits the live cell and closes only the temporary table; switching back recreates a table against that same document. Language changes preserve pending edits before refreshing the table.
 
-- Quick edit:
-  - Start: type any character (not Enter) on a selected cell.
-  - Save and move: press Arrow Up/Down/Left/Right to save and select the adjacent cell; does not re-enter edit.
-- Detail edit:
-  - Start: press `Enter` on a selected cell or double‑click a cell.
-  - Caret navigation: Arrow Left/Right move one character; Arrow Up moves caret to start; Arrow Down moves caret to end.
-  - New line in cell: `Shift + Enter` inserts a line break inside the current cell.
-  - Exit/save: click outside the cell or move focus to commit changes.
-- Global:
-  - Copy selection: `Ctrl/Cmd + C`
-  - Paste selection: `Ctrl/Cmd + V` (selection mode). Pasting a single value into a selected rectangle fills that rectangle.
-  - Zoom in/out/reset: `Ctrl/Cmd + +`, `Ctrl/Cmd + -`, `Ctrl/Cmd + 0` (also `Ctrl/Cmd + Mouse Wheel`)
-  - Find: `Ctrl/Cmd + F`
-  - Replace: `Ctrl/Cmd + H`
-  - Next/Previous match: `F3` / `Shift + F3` (also `Enter` / `Shift + Enter` in the Find box)
-  - Select all: `Ctrl/Cmd + A`
+Use the table toolbar's **Save Untitled Document As…** action or Ctrl/Cmd+S in selection or editing mode. CSV commits the active cell, reveals the native owner, and invokes VS Code's normal Save As flow. The temporary table closes when the untitled document becomes a saved file. Cancelling Save As retains the unsaved owner and table. Native **File > Save** cannot directly target a standalone table panel; switch to text before using that native action.
 
----
+Separator, header, serial-index, metadata, and filter controls work before saving. File encoding can be changed after saving. Untitled documents are not switched with the saved-file native replacement operation because associated-path untitled buffers require their existing owner.
 
-## Release Notes
+## Large File Preview
 
-### v1.2.1
-- Fix scrolling freeze at ~1000 rows when header is enabled by unifying chunking behavior and safely transporting chunks to the webview.
-- Trim trailing empty lines to avoid phantom last rows; correct final virtual row numbering.
-- Preserve scroll position after edits/saves in later chunks by loading enough chunks before restoring scroll.
-- Add tests for separators (CSV/TSV overrides), strict date parsing, header heuristics, and chunking stability.
+The normal editable view uses a full VS Code text document; chunked rendering does not bound source-memory use. To inspect a very large saved file without first allocating that document, right-click it in Explorer and choose **CSV: Open Large File Preview (Read-only)**, or run that command and pick a file. Opening the preview after an editable tab does not undo memory already allocated by VS Code.
 
-### v1.2.0
-- Edit modes: Quick edit (type to start; arrows save and move) and Detail edit (Enter/double‑click; arrows move caret, Up/Down jump to start/end).
-- Virtual rows and cells: Always shows one extra empty row at the bottom; short rows display empty editable cells up to the widest column. Empty edits do not create real rows/columns.
-- State persistence: Keeps scroll position and selection across tab switches and configuration refreshes, including large files with chunked rendering.
-- Selection improvements: Shift+Click on headers selects column ranges; Shift+Click on the serial index selects row ranges; right‑click preserves current selection.
-- Batch actions: Context menu adapts to multi‑selection (Add/Delete X Rows/Columns) and performs exact counts in a single operation.
-- Delete to clear: Press Delete/Backspace to clear contents of selected cells (skips serial index column).
-- Copy fidelity: Copies with the active delimiter and skips the serial index column for full‑row copies.
-- Encoding: New command “CSV: Change File Encoding” integrates VS Code’s encoding picker and returns to the CSV view.
-- Enable/disable UX: Toggling the extension on instantly upgrades open CSV/TSV tabs to this view; toggling off reverts immediately to the default view.
+The preview reads bounded saved-file blocks and displays one page at a time. **Next**, **Previous**, and **Back to Start** navigate complete records, including quoted multiline fields. The first record is data. There is no editing, global search, sorting, or filtering, and unsaved edits in another view are not included.
 
-See full history in `CHANGELOG.md`.
+It supports valid **UTF-8**, an optional UTF-8 BOM, a single ASCII separator, and host-local `file:` URIs. It reads directly in the extension host; arbitrary remote filesystem-provider URIs and other encodings are unsupported. Use a per-file separator override or `extension`/`default` separator mode; automatic detection without an override produces an actionable error.
 
----
+`csv.largeFilePreviewRows` sets a maximum of 1–10,000 records per page (default 1,000). Independent limits are 512 KiB of source records and 20,000 cells per page, 256 KiB per record, and 1,000 columns. Pages may be smaller. Malformed/oversized records produce errors instead of truncated data. Only the current page and up to 32 page positions are retained; **Previous** reaches that retained history. If the saved file changes, use **Back to Start**.
 
-## Development
+## Compare two files as tables
 
-Clone the repository and run the following commands:
+Select two files in Explorer and choose **CSV: Compare Files as Table**, or run the command from an active CSV/text document and select the modified file. With no active source, choose original and modified files. Both panes are read-only and use VS Code's decoded document text, including unsaved edits; editing a source refreshes the comparison.
 
-```bash
-npm install
-npm run lint
-npm test
-```
+The comparison aligns records around insertions/deletions, highlights changed cells, and shows placeholders for missing records or fields. Both scroll axes stay synchronized and paired rows share their height. Use **Previous/Next Change** and **Previous/Next Page**. The first record is data; comparison uses parsed values and field presence, not quoting or line-ending formatting.
 
-To create a VS Code extension package, run:
+The existing `csv.maxFileSizeMB` limit applies. Hard per-input limits are 10 MiB of saved bytes before a new document opens, 5 MiB of decoded text, 10,000 records, 100,000 cells, and 1,000 columns; values are limited to 64 Ki characters and records to 256 Ki characters. A provider without size information must already have the document open. Pages are capped at 200 aligned records, 20,000 body cells, and 512 Ki characters. Oversized/malformed inputs show errors without truncation. Bounded alignment falls back to positional pairing with a visible notice when necessary.
 
-```bash
-npm run package
-```
+This command is a separate table comparison. It does not provide native Git/PR custom-editor diff navigation; stable APIs do not reliably expose both input URIs for that flow.
 
-To compile without running tests:
+## File encoding
 
-```bash
-npm run compile
-```
+Editable views use Unicode text decoded by VS Code. Run **CSV: Change File Encoding**, choose **Reopen with Encoding**, and select the original file's encoding to correct incorrectly displayed characters. Check the text before saving. Cancelling the unsaved-changes prompt stops the command without discarding your edits. **Save with Encoding** changes how the current text is written; it cannot repair characters already decoded incorrectly. Use the original file or a backup if a corrupted version was saved.
 
----
+A nonmodal warning appears once per opened document containing the replacement character `�`, offering the encoding action. This is a possible decoding mismatch, not automatic encoding detection: `�` can be legitimate text, and other incorrect decodings may not produce it. CSV does not guess, transcode, or repair bytes automatically. The read-only preview's UTF-8 restriction is separate from this editable-view workflow.
 
-## Support
+## Commands
+
+Run these from the Command Palette. Commands that change a view preference target the active CSV table unless noted.
+
+| Command | Purpose |
+| --- | --- |
+| **CSV: Switch Between Table and Text** (`csv.toggleEditor`) | Switch the active supported table/text view. |
+| **CSV: Save Untitled Document As…** (`csv.saveUntitled`) | Commit and save the active untitled table through the native owner. |
+| **CSV: Toggle Extension On/Off** (`csv.toggleExtension`) | Enable/disable CSV and synchronize native editor routing. |
+| **CSV: Toggle First Row as Header** (`csv.toggleHeader`) | Change the file's header preference. |
+| **CSV: Toggle Serial Index Column** (`csv.toggleSerialIndex`) | Show/hide the file's serial index. |
+| **CSV: Change CSV Separator** (`csv.changeSeparator`) | Override the separator; blank input inherits configured rules. Enter `\t` for tab. |
+| **CSV: Reset CSV Separator (Inherit)** (`csv.resetSeparator`) | Clear the file's separator override. |
+| **CSV: Hide First N Rows** (`csv.changeIgnoreRows`) | Override the metadata-row count; blank input inherits the default. |
+| **CSV: Freeze Leading Rows** (`csv.changeFrozenRows`) | Set the number of leading visible rows to freeze; `0` unfreezes. |
+| **CSV: Freeze Leading Columns** (`csv.changeFrozenColumns`) | Set leading data columns to freeze; `0` unfreezes. |
+| **CSV: Change File Encoding** (`csv.changeEncoding`) | Open VS Code's encoding picker for a saved file. |
+| **CSV: Change Font Family** (`csv.changeFontFamily`) | Pick an extension-host font or inherit `editor.fontFamily`. |
+| **CSV: Toggle Clickable Links** (`csv.toggleClickableLinks`) | Toggle link interaction globally. |
+| **CSV: Open Large File Preview (Read-only)** (`csv.openLargeFilePreview`) | Open a saved host-local file in the bounded preview. |
+| **CSV: Compare Files as Table** (`csv.compareFilesAsTable`) | Choose two source files for read-only table comparison. |
+
+## Settings
 
-Have questions, suggestions, or encountered an issue?
-- Open an issue on [GitHub](https://github.com/jonaraphael/csv/issues) and let us know how we can help!
-
----
-
-## License
-
-This extension is licensed under the [MIT License](LICENSE).
+All settings are under `csv.*` in VS Code Settings or `settings.json`. Font and mouse-wheel zoom settings are application-scoped. Per-file commands override the relevant inherited view defaults.
+
+| Setting | Default | Behavior |
+| --- | --- | --- |
+| `csv.enabled` | `true` | Enable the custom editor; the toggle command also manages reversible native routing. |
+| `csv.fontFamily` | `""` | Inherit `editor.fontFamily`, or use the specified font family. |
+| `csv.fontSize` | `0` | Inherit `editor.fontSize`, or use a positive pixel size. |
+| `csv.mouseWheelZoom` | `true` | Allow Ctrl/Cmd+mouse wheel table zoom. |
+| `csv.mouseWheelZoomInvert` | `false` | Reverse the table zoom direction. |
+| `csv.cellPadding` | `4` | Vertical cell padding in pixels. |
+| `csv.columnColorMode` | `"type"` | `type` uses datatype colors; `theme` uses theme foreground. |
+| `csv.columnColorPalette` | `"default"` | `default`, `cool`, or `warm` when color mode is `type`. |
+| `csv.diffUseThemeForeground` | `true` | Use theme foreground for CSV views recognized as diff contexts. |
+| `csv.clickableLinks` | `true` | Enable Ctrl/Cmd+click on recognized links. |
+| `csv.showTrailingEmptyRow` | `true` | Show the extra append row. |
+| `csv.separatorMode` | `"extension"` | `extension` uses extension mapping, `auto` detects from content first, `default` uses the configured default. Per-file overrides take precedence. |
+| `csv.defaultSeparator` | `","` | Fallback separator. Use `"\t"` in JSON for a tab character, or `"\\t"` for the supported literal escape. |
+| `csv.separatorByExtension` | CSV comma; TSV/TAB tab; PSV pipe | Extension mapping; keys accept `.ext` or `ext`. |
+| `csv.maxFileSizeMB` | `10` | Editable-view size prompt. `0` disables it; **Ignore Forever** sets it to `0`. This is not a memory cap. |
+| `csv.defaultIgnoreRows` | `0` | Hidden leading metadata records when no per-file override exists. |
+| `csv.largeFilePreviewRows` | `1000` | Preview records per page, from `1` to `10000`, subject to byte/cell caps. |
+
+Header mode, serial-index visibility, separator overrides, hidden rows, widths, frozen panes, and valid filter conditions are remembered per file. They change the view, except operations such as sorting, editing, and structural changes that explicitly modify document data.
+
+## Keyboard and mouse reference
+
+Ctrl/Cmd means Ctrl on Windows/Linux and Command on macOS. Table shortcuts apply outside text inputs unless noted.
+
+| Action | Shortcut or gesture |
+| --- | --- |
+| Select a cell/range | Click / drag / Shift+click |
+| Select a row or column | Click its serial index or header; Shift+click extends the range |
+| Select only a header cell | A second separate click on the same header |
+| Select the table | Ctrl/Cmd+A, or click the top-left corner |
+| Move selection | Arrow keys; holding a key keeps the target visible |
+| Extend selection | Shift+Arrow |
+| Jump to a table edge | Ctrl/Cmd+Arrow |
+| Extend to an edge | Ctrl/Cmd+Shift+Arrow, retaining the starting anchor and row/column shape |
+| Next/previous cell | Tab / Shift+Tab; wraps across data rows |
+| Quick edit | Type on a selected cell; arrows commit and move |
+| Detail edit | Enter or double-click; arrows move the caret |
+| Commit and move while editing | Enter moves down; Tab/Shift+Tab moves across |
+| Insert a cell line break | Shift+Enter |
+| Cancel a draft | Escape; a failed edit restores its current source value |
+| Save | Ctrl/Cmd+S commits the active cell, then saves (Save As for untitled) |
+| Copy / cut / paste | Ctrl/Cmd+C / X / V, or right-click actions |
+| Clear selected values | Delete / Backspace |
+| Table Find / Replace | Ctrl/Cmd+F / H |
+| Native Find / Replace in Files | Ctrl/Cmd+Shift+F / H |
+| Next/previous Find match | F3 / Shift+F3; Enter/Shift+Enter in Find; Ctrl/Cmd+G/Shift+G while Find is open |
+| Resize / reset a column | Drag / double-click near its boundary |
+| Resize a row | Drag the bottom edge of its serial-index cell |
+| Reorder rows/columns | Drag selected serial indices/headers |
+| Zoom in / out / reset | Ctrl/Cmd+plus / minus / 0; Ctrl/Cmd+mouse wheel if enabled |
+| Open a recognized link | Ctrl/Cmd+click |
+
+## Privacy and development
+
+See [Privacy and data handling](PRIVACY.md) for local/remote processing, clipboard and link actions, diagnostics, and saved preferences. CSV has no upload service or extension-specific analytics client. Remote workspaces can process files in the remote extension host.
+
+For development, use Node 20 and run `npm ci`, `npm test`, and `npm run lint`. `npm run package` creates the VSIX. See [the changelog](CHANGELOG.md) for release history and [REVIEW.md](REVIEW.md) for repository priorities.
diff --git a/images/context-menu-edge.jpg b/images/context-menu-edge.jpg
new file mode 100644
index 0000000..3e59353
Binary files /dev/null and b/images/context-menu-edge.jpg differ
diff --git a/images/frozen-row-dividers.jpg b/images/frozen-row-dividers.jpg
new file mode 100644
index 0000000..7ee7641
Binary files /dev/null and b/images/frozen-row-dividers.jpg differ
diff --git a/images/frozen-top-edge.jpg b/images/frozen-top-edge.jpg
new file mode 100644
index 0000000..d0ef25d
Binary files /dev/null and b/images/frozen-top-edge.jpg differ
diff --git a/images/header-menu-later.jpg b/images/header-menu-later.jpg
new file mode 100644
index 0000000..b4990f4
Binary files /dev/null and b/images/header-menu-later.jpg differ
diff --git a/images/header-menu-off.jpg b/images/header-menu-off.jpg
new file mode 100644
index 0000000..b9b2890
Binary files /dev/null and b/images/header-menu-off.jpg differ
diff --git a/images/header-menu-on.jpg b/images/header-menu-on.jpg
new file mode 100644
index 0000000..c0ffdf4
Binary files /dev/null and b/images/header-menu-on.jpg differ
diff --git a/images/held-arrow-scroll.jpg b/images/held-arrow-scroll.jpg
new file mode 100644
index 0000000..053e266
Binary files /dev/null and b/images/held-arrow-scroll.jpg differ
diff --git a/images/high-contrast-narrow.jpg b/images/high-contrast-narrow.jpg
new file mode 100644
index 0000000..0d71b1f
Binary files /dev/null and b/images/high-contrast-narrow.jpg differ
diff --git a/images/inline-column-filters.jpg b/images/inline-column-filters.jpg
new file mode 100644
index 0000000..ce1a86b
Binary files /dev/null and b/images/inline-column-filters.jpg differ
diff --git a/images/marketplace-dark.png b/images/marketplace-dark.png
new file mode 100644
index 0000000..37047c7
Binary files /dev/null and b/images/marketplace-dark.png differ
diff --git a/images/marketplace-filters.png b/images/marketplace-filters.png
new file mode 100644
index 0000000..b8989a0
Binary files /dev/null and b/images/marketplace-filters.png differ
diff --git a/images/marketplace-light.png b/images/marketplace-light.png
new file mode 100644
index 0000000..14765c6
Binary files /dev/null and b/images/marketplace-light.png differ
diff --git a/images/mouse-selection.jpg b/images/mouse-selection.jpg
new file mode 100644
index 0000000..6ee8a68
Binary files /dev/null and b/images/mouse-selection.jpg differ
diff --git a/images/range-selection.jpg b/images/range-selection.jpg
new file mode 100644
index 0000000..a89e9e6
Binary files /dev/null and b/images/range-selection.jpg differ
diff --git a/images/resize-hit-area.jpg b/images/resize-hit-area.jpg
new file mode 100644
index 0000000..43bfb24
Binary files /dev/null and b/images/resize-hit-area.jpg differ
diff --git a/images/serial-index-menu.jpg b/images/serial-index-menu.jpg
new file mode 100644
index 0000000..8ebd0c0
Binary files /dev/null and b/images/serial-index-menu.jpg differ
diff --git a/media/column-filters.js b/media/column-filters.js
new file mode 100644
index 0000000..b77b851
--- /dev/null
+++ b/media/column-filters.js
@@ -0,0 +1,246 @@
+// Inline filter drafts live in this webview; only complete conditions reach the host.
+window.createColumnFilterControls = ({ root, metadata, onChange, onLayout, onPending, onActivity }) => {
+  const columns = Array.isArray(metadata.columns) ? metadata.columns : [];
+  const maxFilters = Number.isSafeInteger(metadata.maxFilters) ? metadata.maxFilters : 20;
+  let revision = Number.isSafeInteger(metadata.revision) ? metadata.revision : 0;
+  let timer = null;
+  let nextId = 0;
+  let snapshotRows = [];
+  let pending = false;
+  const rows = [];
+  const make = (tag, text) => {
+    const element = document.createElement(tag);
+    if (text !== undefined) element.textContent = text;
+    return element;
+  };
+  const toolbar = make('div');
+  toolbar.className = 'column-filter-toolbar';
+  const summary = make('span');
+  summary.dataset.filterSummary = '';
+  summary.setAttribute('aria-live', 'polite');
+  const addButton = make('button', 'Add filter');
+  addButton.id = 'addColumnFilter';
+  addButton.type = 'button';
+  const clearButton = make('button', 'Clear all filters');
+  clearButton.id = 'clearAllFilters';
+  clearButton.type = 'button';
+  const globalError = make('span');
+  globalError.dataset.filterError = '';
+  globalError.setAttribute('role', 'alert');
+  toolbar.append(summary, addButton, clearButton, globalError);
+  const list = make('div');
+  list.className = 'column-filter-conditions';
+  root.replaceChildren(toolbar, list);
+  root.setAttribute('aria-label', 'Column filters');
+  const isUnary = operator => operator === 'empty' || operator === 'notEmpty';
+  const typedOperator = operator => !['contains', 'notContains', 'regex', 'empty', 'notEmpty'].includes(operator);
+  const columnFor = column => columns.find(item => item.column === column) || columns[0];
+  const setSummary = data => { summary.textContent = `Filtered: ${data.matchedRows ?? 0} of ${data.totalRows ?? 0} rows`; };
+  setSummary(metadata);
+  const updateLayout = () => {
+    root.hidden = rows.length === 0;
+    addButton.disabled = !columns.length || rows.length >= maxFilters;
+    clearButton.disabled = rows.length === 0;
+    rows.forEach((row, index) => { row.and.textContent = index ? 'AND' : ''; });
+    onLayout?.();
+  };
+  const clearErrors = () => {
+    globalError.textContent = '';
+    rows.forEach(row => {
+      row.error.textContent = row.incomplete ? 'Finish editing this condition to apply filters.' : row.invalidOperator ? 'Choose an operator supported by this column type.' : '';
+      row.value.toggleAttribute('aria-invalid', !!row.invalidOperator);
+      if (row.invalidOperator) row.value.setAttribute('aria-invalid', 'true');
+    });
+  };
+  const condition = row => {
+    const column = columnFor(Number(row.column.value));
+    const operator = row.operator.value;
+    if (!column || (!isUnary(operator) && row.value.value.length === 0)) return null;
+    const filter = { column: column.column, operator, value: isUnary(operator) ? '' : row.value.value };
+    if (typedOperator(operator) && column.dataType !== 'string') filter.dataType = column.dataType;
+    return filter;
+  };
+  const send = () => {
+    timer = null;
+    if (rows.some(row => row.composing || row.incomplete)) return;
+    snapshotRows = rows.filter(row => condition(row));
+    onChange({ revision, filters: snapshotRows.map(condition) });
+  };
+  const changed = () => {
+    onActivity?.();
+    // Invalidate older replies immediately, even before debounce/composition ends.
+    revision += 1;
+    pending = !rows.some(row => row.incomplete);
+    onPending?.(pending);
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+    clearErrors();
+    if (pending && !rows.some(row => row.composing)) timer = setTimeout(send, 100);
+    updateLayout();
+  };
+  const fillOperators = (row, preferred) => {
+    const column = columnFor(Number(row.column.value));
+    row.operator.replaceChildren();
+    for (const choice of column?.operators || []) {
+      const option = make('option', choice.label);
+      option.value = choice.operator;
+      row.operator.append(option);
+    }
+    row.error.textContent = row.incomplete ? 'Finish editing this condition to apply filters.' : '';
+    row.value.removeAttribute('aria-invalid');
+    row.invalidOperator = !!preferred && !Array.from(row.operator.options).some(option => option.value === preferred);
+    if (row.invalidOperator) {
+      const unavailable = make('option', `${preferred} (unsupported for ${column?.dataType === 'string' ? 'text' : column?.dataType || 'text'})`);
+      unavailable.value = preferred;
+      unavailable.disabled = true;
+      row.operator.append(unavailable);
+      row.error.textContent = 'Choose an operator supported by this column type.';
+      row.value.setAttribute('aria-invalid', 'true');
+    }
+    if (preferred) row.operator.value = preferred;
+    row.value.hidden = isUnary(row.operator.value);
+    row.value.disabled = isUnary(row.operator.value);
+    row.type.textContent = column?.dataType === 'string' ? 'text' : column?.dataType || 'text';
+  };
+  const append = filter => {
+    const column = columnFor(filter?.column);
+    if (!column || rows.length >= maxFilters) return null;
+    const id = ++nextId;
+    const element = make('div');
+    element.className = 'column-filter-row';
+    const and = make('span');
+    and.className = 'column-filter-and';
+    const columnSelect = make('select');
+    columnSelect.dataset.filterColumn = '';
+    columnSelect.setAttribute('aria-label', `Filter ${id} column`);
+    for (const item of columns) {
+      const option = make('option', item.label);
+      option.value = String(item.column);
+      columnSelect.append(option);
+    }
+    columnSelect.value = String(column.column);
+    const type = make('span');
+    type.className = 'column-filter-type';
+    const operator = make('select');
+    operator.dataset.filterOperator = '';
+    operator.setAttribute('aria-label', `Filter ${id} operator`);
+    const value = make('input');
+    value.type = 'text';
+    value.dataset.filterValue = '';
+    value.setAttribute('aria-label', `Filter ${id} value`);
+    value.value = filter?.value || '';
+    const remove = make('button', 'Remove');
+    remove.type = 'button';
+    remove.dataset.removeFilter = '';
+    remove.setAttribute('aria-label', `Remove filter ${id}`);
+    const error = make('span');
+    error.id = `column-filter-error-${id}`;
+    error.className = 'column-filter-error';
+    error.setAttribute('role', 'alert');
+    value.setAttribute('aria-describedby', error.id);
+    const row = { element, and, column: columnSelect, type, operator, value, remove, error, composing: false, incomplete: filter?.composing === true };
+    fillOperators(row, filter?.operator || 'contains');
+    element.append(and, columnSelect, type, operator, value, remove, error);
+    list.append(element);
+    rows.push(row);
+    columnSelect.addEventListener('change', () => { row.incomplete = false; fillOperators(row, operator.value); changed(); });
+    operator.addEventListener('change', () => { row.incomplete = false; row.invalidOperator = false; value.hidden = isUnary(operator.value); value.disabled = isUnary(operator.value); changed(); });
+    value.addEventListener('input', () => { row.incomplete = false; changed(); });
+    value.addEventListener('compositionstart', () => { row.incomplete = false; row.composing = true; changed(); });
+    value.addEventListener('compositionend', () => { row.incomplete = false; row.composing = false; changed(); });
+    remove.addEventListener('click', () => {
+      rows.splice(rows.indexOf(row), 1);
+      element.remove();
+      changed();
+    });
+    return row;
+  };
+  const add = column => {
+    const row = append({ column, operator: 'contains', value: '' });
+    if (!row) return;
+    changed();
+    row.value.focus();
+  };
+  addButton.addEventListener('click', () => add(Number(rows[rows.length - 1]?.column.value ?? columns[0]?.column)));
+  clearButton.addEventListener('click', () => {
+    rows.splice(0).forEach(row => row.element.remove());
+    changed();
+  });
+  const restored = metadata.filterDraft;
+  for (const filter of restored?.rows || metadata.filters || []) append(filter);
+  updateLayout();
+  if (restored) {
+    // This state arrived through one controller's refresh ACK, never VS Code storage.
+    changed();
+    setTimeout(() => {
+      const focus = restored.focus;
+      const field = rows[focus?.row]?.[focus?.field];
+      if (!field || !['column', 'operator', 'value', 'remove'].includes(focus?.field)) return;
+      field.focus({ preventScroll: true });
+      if (focus.field === 'value' && Number.isInteger(focus.selectionStart) && Number.isInteger(focus.selectionEnd)) {
+        field.setSelectionRange(focus.selectionStart, focus.selectionEnd, focus.selectionDirection || 'none');
+      }
+    }, 0);
+  }
+  const captureDraft = () => {
+    if (!rows.length && !pending) return undefined;
+    const draft = {
+      rows: rows.map(row => ({ column: Number(row.column.value), operator: row.operator.value, value: row.value.value, ...((row.composing || row.incomplete) ? { composing: true } : {}) })),
+      session: metadata.session,
+      filterColumnsRevision: metadata.filterColumnsRevision,
+      columns: columns.map(column => ({ column: column.column, label: column.label }))
+    };
+    rows.some((row, index) => {
+      for (const field of ['column', 'operator', 'value', 'remove']) {
+        if (row[field] !== document.activeElement) continue;
+        draft.focus = { row: index, field };
+        if (field === 'value') Object.assign(draft.focus, {
+          selectionStart: row.value.selectionStart,
+          selectionEnd: row.value.selectionEnd,
+          selectionDirection: row.value.selectionDirection
+        });
+        return true;
+      }
+      return false;
+    });
+    return draft;
+  };
+  return {
+    add,
+    captureDraft,
+    retry: changed,
+    get latestRevision() { return revision; },
+    receive(message) {
+      if (message.session !== metadata.session || message.revision !== revision) return false;
+      pending = false;
+      clearErrors();
+      if (Array.isArray(message.columns) && JSON.stringify(message.columns) !== JSON.stringify(columns)) {
+        columns.length = 0;
+        for (const column of message.columns) columns.push(column);
+        for (const row of rows) {
+          const selected = row.column.value;
+          row.column.replaceChildren();
+          for (const column of columns) {
+            const option = make('option', column.label);
+            option.value = String(column.column);
+            row.column.append(option);
+          }
+          row.column.value = selected;
+          fillOperators(row, row.operator.value);
+        }
+      }
+      if (message.error) globalError.textContent = message.error;
+      else if (message.errors?.length) globalError.textContent = 'Showing the last valid results.';
+      for (const item of message.errors || []) {
+        const row = snapshotRows[item.index];
+        if (!row) continue;
+        row.error.textContent = item.message;
+        row.value.setAttribute('aria-invalid', 'true');
+      }
+      if (message.error || message.errors?.length) { setSummary(message); onLayout?.(); return true; }
+      setSummary(message);
+      onLayout?.();
+      return true;
+    }
+  };
+};
diff --git a/media/frozen-panes.js b/media/frozen-panes.js
new file mode 100644
index 0000000..24db08e
--- /dev/null
+++ b/media/frozen-panes.js
@@ -0,0 +1,90 @@
+// Layout uses measured dimensions so multiline cells, manual sizes and zoom agree.
+window.createFrozenPaneManager = ({ table, firstRow, realRowCount, rowOrder, topInset, onNeedRows }) => {
+  let rows = 0;
+  let columns = 0;
+  let scheduled = false;
+  let disposed = false;
+  const count = value => Number.isSafeInteger(Number(value)) && Number(value) >= 0 ? Number(value) : 0;
+  const renderedRows = () => Array.from(table.rows).map(row => {
+    const dataCell = Array.from(row.cells).find(cell => cell.hasAttribute('data-row'));
+    return { element: row, index: Number(dataCell?.getAttribute('data-row')) };
+  }).filter(row => Number.isInteger(row.index));
+  const schedule = () => {
+    if (scheduled || disposed) return;
+    scheduled = true;
+    requestAnimationFrame(() => { scheduled = false; if (!disposed) layout(); });
+  };
+  const observer = typeof ResizeObserver === 'function' ? new ResizeObserver(schedule) : null;
+  const observedRows = new WeakSet();
+  const layout = () => {
+    const rendered = renderedRows();
+    for (const { element } of rendered) {
+      if (!observedRows.has(element)) {
+        observedRows.add(element);
+        observer?.observe(element);
+      }
+    }
+    table.querySelectorAll('.csv-frozen-row, .csv-frozen-column').forEach(cell => {
+      cell.classList.remove('csv-frozen-row', 'csv-frozen-column');
+      cell.style.top = '';
+      cell.style.left = '';
+      cell.style.zIndex = '';
+    });
+    const representative = rendered[0]?.element;
+    const leftByColumn = new Map();
+    let left = 0;
+    if (columns && representative) {
+      for (const cell of Array.from(representative.cells)) {
+        const attr = cell.getAttribute('data-col');
+        const col = attr === null ? -1 : Number(attr);
+        if (col >= columns) break;
+        leftByColumn.set(col, left);
+        left += cell.getBoundingClientRect().width;
+      }
+    }
+    const visibleRows = rowOrder?.length ? rowOrder.filter(row => row < realRowCount) : null;
+    const frozenRows = visibleRows ? new Set(visibleRows.slice(0, rows)) : null;
+    const lastFrozenRow = visibleRows ? (visibleRows[Math.min(rows, visibleRows.length) - 1] ?? -1) : Math.min(firstRow + rows, realRowCount) - 1;
+    const firstFrozenCell = rendered.find(({ index }) => frozenRows ? frozenRows.has(index) : index >= firstRow && index <= lastFrozenRow)?.element.cells[0];
+    // A collapsed border straddles the sticky edge. Cover its inner half once,
+    // keeping the measured spacing between frozen rows unchanged.
+    const topBorder = firstFrozenCell && getComputedStyle(table).borderCollapse === 'collapse'
+      ? parseFloat(getComputedStyle(firstFrozenCell).borderTopWidth) || 0
+      : 0;
+    let top = (topInset?.() || 0) - topBorder / 2;
+    for (const { element, index } of rendered) {
+      const frozenRow = frozenRows ? frozenRows.has(index) : index >= firstRow && index <= lastFrozenRow;
+      const height = element.getBoundingClientRect().height || Math.max(0, ...Array.from(element.cells).map(cell => cell.getBoundingClientRect().height));
+      for (const cell of Array.from(element.cells)) {
+        const attr = cell.getAttribute('data-col');
+        const col = attr === null ? -1 : Number(attr);
+        const frozenColumn = leftByColumn.has(col);
+        if (frozenRow) {
+          cell.classList.add('csv-frozen-row');
+          cell.style.top = `${top}px`;
+        }
+        if (frozenColumn) {
+          cell.classList.add('csv-frozen-column');
+          cell.style.left = `${leftByColumn.get(col)}px`;
+        }
+        if (frozenRow || frozenColumn) {
+          cell.style.zIndex = frozenRow && frozenColumn ? '4' : (frozenRow ? '3' : '2');
+        }
+      }
+      if (frozenRow) top += height;
+    }
+    if (lastFrozenRow >= firstRow && (rendered[rendered.length - 1]?.index ?? -1) < lastFrozenRow) {
+      onNeedRows?.(lastFrozenRow);
+    }
+  };
+  return {
+    schedule,
+    layout,
+    update(nextRows, nextColumns) {
+      rows = count(nextRows);
+      columns = count(nextColumns);
+      schedule();
+    },
+    dispose() { disposed = true; observer?.disconnect(); }
+  };
+};
diff --git a/media/high-contrast.css b/media/high-contrast.css
new file mode 100644
index 0000000..c2c5ee7
--- /dev/null
+++ b/media/high-contrast.css
@@ -0,0 +1,116 @@
+/* Accessibility chrome is limited to high-contrast themes. Cell foregrounds
+   continue to follow the selected datatype palette or explicit theme mode. */
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) {
+  color: var(--vscode-editor-foreground);
+  background-color: var(--vscode-editor-background);
+  --csv-contrast-border: var(--vscode-contrastBorder, var(--vscode-editorWidget-border, var(--vscode-panel-border, var(--vscode-editor-foreground))));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) :is(td, th) {
+  border-color: var(--csv-contrast-border) !important;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) th {
+  background-color: var(--vscode-editor-background) !important;
+}
+
+/* Outlines identify state without covering datatype colors with a bright fill.
+   Reset background images as well, including the opaque frozen-pane layers. */
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) :is(td, th).selected {
+  background: var(--vscode-editor-background) !important;
+  outline: 1px solid var(--vscode-focusBorder, var(--csv-contrast-border));
+  outline-offset: -1px;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) :is(td, th).highlight {
+  background: var(--vscode-editor-background) !important;
+  outline: 1px solid var(--vscode-editor-findMatchHighlightBorder, var(--csv-contrast-border));
+  outline-offset: -1px;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) :is(td, th).active-match {
+  background: var(--vscode-editor-background) !important;
+  outline: 2px solid var(--vscode-editor-findMatchBorder, var(--vscode-focusBorder));
+  outline-offset: -2px;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) .csv-link {
+  color: var(--vscode-textLink-foreground, var(--vscode-editor-foreground));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) .csv-link:hover {
+  color: var(--vscode-textLink-activeForeground, var(--vscode-textLink-foreground));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) .selected .csv-link {
+  color: inherit;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #contextMenu {
+  color: var(--vscode-menu-foreground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-menu-background, var(--vscode-editor-background));
+  border-color: var(--csv-contrast-border);
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #contextMenu div {
+  border-color: var(--csv-contrast-border) !important;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #contextMenu div:hover {
+  color: var(--vscode-menu-selectionForeground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-menu-selectionBackground, var(--vscode-editor-background));
+  outline: 1px solid var(--vscode-menu-selectionBorder, var(--csv-contrast-border));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget {
+  color: var(--vscode-editorWidget-foreground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-editorWidget-background, var(--vscode-editor-background));
+  border-color: var(--csv-contrast-border);
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget :is(.fr-gutter, .fr-overflow-menu) {
+  background-color: var(--vscode-editorWidget-background, var(--vscode-editor-background));
+  border-color: var(--csv-contrast-border);
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget .fr-input {
+  color: var(--vscode-input-foreground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-input-background, var(--vscode-editor-background));
+  border-color: var(--vscode-input-border, var(--csv-contrast-border));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget .fr-input::placeholder {
+  color: var(--vscode-input-placeholderForeground, var(--vscode-editor-foreground));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget :is(.fr-status, button) {
+  color: var(--vscode-editorWidget-foreground, var(--vscode-editor-foreground));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget button:hover {
+  color: var(--vscode-toolbar-hoverForeground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-toolbar-hoverBackground, var(--vscode-editor-background));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget .fr-toggle-btn[aria-pressed="true"] {
+  color: var(--vscode-inputOption-activeForeground, var(--vscode-editor-foreground));
+  background-color: var(--vscode-inputOption-activeBackground, var(--vscode-editor-background));
+  box-shadow: inset 0 -2px 0 var(--vscode-inputOption-activeBorder, var(--csv-contrast-border));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget button[disabled] {
+  color: var(--vscode-disabledForeground, var(--vscode-editor-foreground));
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget :is(button, input):focus-visible {
+  outline: 2px solid var(--vscode-focusBorder, var(--csv-contrast-border));
+  outline-offset: -2px;
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget .fr-divider {
+  background-color: var(--csv-contrast-border);
+}
+
+body:is(.vscode-high-contrast, .vscode-high-contrast-light) #findReplaceWidget .fr-inline-toggles {
+  border-color: var(--csv-contrast-border);
+}
diff --git a/media/large-preview.js b/media/large-preview.js
new file mode 100644
index 0000000..d758553
--- /dev/null
+++ b/media/large-preview.js
@@ -0,0 +1,30 @@
+const vscode = acquireVsCodeApi();
+const status = document.getElementById('status');
+const records = document.getElementById('records');
+const error = document.getElementById('error');
+const buttons = ['start', 'previous', 'next'].map(id => document.getElementById(id));
+const busy = () => {
+  buttons.forEach(button => { button.disabled = true; });
+  status.textContent = 'Loading saved file…';
+};
+buttons.forEach(button => {
+  button.addEventListener('click', () => {
+    busy();
+    vscode.postMessage({ type: button.id });
+  });
+});
+window.addEventListener('message', event => {
+  if (event.data.type !== 'page') return;
+  const message = event.data;
+  // Markup is built by the extension from escaped cell values. Replacing the
+  // page bounds DOM growth regardless of how many pages have been visited.
+  records.innerHTML = message.html;
+  records.scrollTop = records.scrollLeft = 0;
+  status.textContent = message.status;
+  error.textContent = message.error || '';
+  buttons[0].disabled = false;
+  buttons[1].disabled = !message.canBack;
+  buttons[2].disabled = !message.canNext;
+});
+busy();
+vscode.postMessage({ type: 'ready' });
diff --git a/media/main.js b/media/main.js
index 58079a4..525f3fe 100644
--- a/media/main.js
+++ b/media/main.js
@@ -6,7 +6,21 @@ try { document.body.focus({ preventScroll: true }); } catch { try { document.bod
 const vscode = acquireVsCodeApi();
 
 const root = document.getElementById('csv-root');
-const CSV_SEPARATOR = String.fromCodePoint(parseInt(root?.dataset?.sepcode || '44', 10)); // default ','
+let filterMetadata = {};
+try { filterMetadata = JSON.parse(document.getElementById('__csvFilters')?.textContent || '{}'); } catch {}
+const filterSession = filterMetadata.session;
+let visibleRowOrder = [];
+try { visibleRowOrder = JSON.parse(root?.dataset?.roworder || '[]'); } catch {}
+let headerSourceRow = Number(root?.dataset?.firstrow || '0');
+let filterEpoch = 0;
+let filterSnapshotPending = false;
+const adjacentVisibleRow = (row, direction) => {
+  if (!visibleRowOrder.length) return row + direction;
+  const index = visibleRowOrder.indexOf(row);
+  return visibleRowOrder[index + direction] ?? (row >= Number(root?.dataset?.realrowcount || '0') ? row + direction : row);
+};
+let frozenRowCount = Number(root?.dataset?.frozenrows || '0');
+let frozenColumnCount = Number(root?.dataset?.frozencolumns || '0');
 const parsePositiveNumber = value => {
   const parsed = typeof value === 'string' ? Number.parseFloat(value) : Number(value);
   if (!Number.isFinite(parsed) || parsed <= 0) return undefined;
@@ -28,12 +42,15 @@ let lastContextIsHeader = false;   // remembers whether we right-clicked a <th>
 let isUpdating = false, isSelecting = false, anchorCell = null, rangeEndCell = null, currentSelection = [];
 let startCell = null, endCell = null, selectionMode = "cell";
 let editingCell = null, originalCellValue = "";
+const failedCellDrafts = new Set();
+let discardingFailedDraft = false;
 // Edit mode:
 //  - 'quick': started by typing a character (not Enter)
 //  - 'detail': started by Enter or double-click
 let editMode = null; // 'quick' | 'detail' | null
 const DRAG_THRESHOLD_PX = 4;
 const RESIZE_HANDLE_PX = 6;
+const COLUMN_RESIZE_HANDLE_PX = 4;
 let resizeState = null;
 let reorderState = null;
 
@@ -46,6 +63,9 @@ dragIndicator.style.zIndex = '20000';
 dragIndicator.style.background = '#0a84ff';
 dragIndicator.style.display = 'none';
 document.body.appendChild(dragIndicator);
+const automaticColumnSizes = new WeakMap();
+let persistedColumnSizes = {};
+try { persistedColumnSizes = JSON.parse(root?.dataset?.columnsizes || '{}'); } catch {}
 let columnSizeState = {};
 let rowSizeState = {};
 
@@ -62,13 +82,24 @@ const normalizeSizeState = (raw, minSize) => {
   return out;
 };
 
+const setRenderedColumnWidth = (cell, px) => {
+  if (!automaticColumnSizes.has(cell)) {
+    automaticColumnSizes.set(cell, { width: cell.style.width, minWidth: cell.style.minWidth, maxWidth: cell.style.maxWidth, boxSizing: cell.style.boxSizing });
+  }
+  cell.style.boxSizing = 'border-box';
+  cell.style.width = `${px}px`;
+  cell.style.minWidth = `${px}px`;
+  cell.style.maxWidth = `${px}px`;
+};
+const persistColumnSizes = () => {
+  vscode.postMessage({ type: 'columnSizesChanged', columnSizes: { ...columnSizeState } });
+};
 const applySizeStateToRenderedCells = () => {
+  window.csvFrozenPanes?.schedule();
   for (const [col, width] of Object.entries(columnSizeState)) {
     const px = Math.max(40, Math.round(Number(width)));
     table.querySelectorAll(`[data-col="${col}"]`).forEach(cell => {
-      cell.style.width = `${px}px`;
-      cell.style.minWidth = `${px}px`;
-      cell.style.maxWidth = `${px}px`;
+      setRenderedColumnWidth(cell, px);
     });
   }
   for (const [row, height] of Object.entries(rowSizeState)) {
@@ -96,6 +127,8 @@ const setZoomScale = (nextScale, persist = true) => {
     return false;
   }
   zoomScale = normalized;
+  const menu = document.getElementById('contextMenu');
+  if (menu) { menu.style.display = 'none'; }
   document.body.style.fontSize = `${Math.max(1, BASE_FONT_SIZE_PX * zoomScale)}px`;
   applySizeStateToRenderedCells();
   if (persist) {
@@ -149,12 +182,79 @@ const persistState = () => {
   } catch {}
 };
 
+// Coalesce repeated navigation to the latest cell before paint. Native smooth
+// scrolling restarts on every key repeat and can leave selection offscreen.
+let pendingCellReveal = null;
+let cellRevealScheduled = false;
+const scheduleCellReveal = (cell, center = false) => {
+  pendingCellReveal = { cell, center };
+  if (cellRevealScheduled) return;
+  cellRevealScheduled = true;
+  requestAnimationFrame(() => {
+    cellRevealScheduled = false;
+    const request = pendingCellReveal;
+    pendingCellReveal = null;
+    if (!request?.cell?.isConnected || !scrollContainer) return;
+    const width = scrollContainer.clientWidth;
+    const height = scrollContainer.clientHeight;
+    if (width <= 0 || height <= 0) return;
+    const viewport = scrollContainer.getBoundingClientRect();
+    const viewportLeft = viewport.left + scrollContainer.clientLeft;
+    const viewportTop = viewport.top + scrollContainer.clientTop;
+    let left = Math.max(0, viewportLeft);
+    let top = Math.max(0, viewportTop);
+    const right = Math.min(window.innerWidth, viewportLeft + width);
+    const bottom = Math.min(window.innerHeight, viewportTop + height);
+    const target = request.cell;
+    let fixedTop = target.classList.contains('csv-frozen-row');
+    const fixedLeft = target.classList.contains('csv-frozen-column');
+
+    const filterBar = document.getElementById('filterStatus');
+    if (filterBar) top = Math.max(top, filterBar.getBoundingClientRect().bottom);
+    const headerCell = table.tHead?.rows[0]?.cells[0];
+    if (headerCell) {
+      const style = getComputedStyle(headerCell);
+      if (style.position === 'sticky' && style.top && style.top !== 'auto') {
+        top = Math.max(top, headerCell.getBoundingClientRect().bottom);
+        fixedTop = fixedTop || table.tHead.contains(target);
+      }
+    }
+    // Frozen panes are leading rows/columns. Read one representative per
+    // boundary, rather than scanning every rendered cell on each repeat.
+    for (const row of table.rows) {
+      const first = row.cells[0];
+      if (!first?.classList.contains('csv-frozen-row')) break;
+      top = Math.max(top, first.getBoundingClientRect().bottom);
+    }
+    for (const cell of table.rows[0]?.cells || []) {
+      if (!cell.classList.contains('csv-frozen-column')) break;
+      left = Math.max(left, cell.getBoundingClientRect().right);
+    }
+
+    const rect = target.getBoundingClientRect();
+    const revealDelta = (start, end, min, max) => {
+      if (max <= min) return 0;
+      // A cell larger than the available pane cannot fit; keep its leading
+      // edge usable instead of alternating between opposite edges.
+      if (end - start > max - min) return start - min;
+      if (request.center) return (start + end - min - max) / 2;
+      return start < min ? start - min : end > max ? end - max : 0;
+    };
+    const x = fixedLeft ? 0 : revealDelta(rect.left, rect.right, left, right);
+    const y = fixedTop ? 0 : revealDelta(rect.top, rect.bottom, top, bottom);
+    // Even zero delta cancels any native animation already in flight.
+    scrollContainer.scrollTo({ left: scrollContainer.scrollLeft + x, top: scrollContainer.scrollTop + y, behavior: 'instant' });
+    persistState();
+  });
+};
+
 const restoreState = () => {
+  if (document.activeElement?.closest?.('#filterStatus')) return;
   try {
     const st = vscode.getState() || {};
     const restoredZoom = parsePositiveNumber(st.zoomScale);
     setZoomScale(restoredZoom ?? 1, false);
-    columnSizeState = normalizeSizeState(st.columnSizes, 40);
+    columnSizeState = normalizeSizeState(st.columnSizes ?? persistedColumnSizes, 40);
     rowSizeState = normalizeSizeState(st.rowSizes, getMinRowHeight());
     applySizeStateToRenderedCells();
     if (typeof st.scrollX === 'number' && scrollContainer) {
@@ -179,14 +279,14 @@ const restoreState = () => {
       }
     }
     if (typeof st.anchorRow === 'number' && typeof st.anchorCol === 'number') {
-      const tag = (hasHeader && st.anchorRow === 0 ? 'th' : 'td');
-      let sel = table.querySelector(`${tag}[data-row="${st.anchorRow}"][data-col="${st.anchorCol}"]`);
+      const selector = `td[data-row="${st.anchorRow}"][data-col="${st.anchorCol}"], th[data-row="${st.anchorRow}"][data-col="${st.anchorCol}"]`;
+      let sel = table.querySelector(selector);
       // If not present yet (due to chunking), load chunks until available or exhausted
       if (!sel && typeof window.__csvLoadNextChunk === 'function') {
         let guard = 100; // prevent infinite loops
         while (!sel && typeof window.__csvLoadNextChunk === 'function' && guard-- > 0) {
           if (!window.__csvLoadNextChunk()) break;
-          sel = table.querySelector(`${tag}[data-row="${st.anchorRow}"][data-col="${st.anchorCol}"]`);
+          sel = table.querySelector(selector);
         }
       }
       applySizeStateToRenderedCells();
@@ -237,73 +337,46 @@ const requestRemoteChunk = () => {
   remoteChunkRequestInFlight = true;
   remoteChunkRequestedStart = remoteNextChunkStart;
   remoteChunkRequestSeq += 1;
-  vscode.postMessage({ type: 'requestChunk', start: remoteNextChunkStart, requestId: remoteChunkRequestSeq });
+  vscode.postMessage({ type: 'requestChunk', start: remoteNextChunkStart, requestId: remoteChunkRequestSeq, filterEpoch, session: filterSession });
 };
 
-if (csvChunks.length || remoteHasMoreChunks) {
+let chunkObserver = null;
+let chunkLoading = false;
+const primeChunks = () => {
+  chunkObserver?.disconnect();
+  const last = table.tBodies[0]?.querySelector('tr:last-child');
+  if (last && (csvChunks.length || remoteHasMoreChunks)) chunkObserver?.observe(last);
+};
+loadNextChunk = () => {
   const tbody = table.tBodies[0];
-  let loading = false;
-
-  loadNextChunk = () => {
-    if (loading || !tbody) return false;
-    if (!csvChunks.length) {
-      requestRemoteChunk();
-      return false;
-    }
-    loading = true;
-    try {
-      const html = csvChunks.shift();
-      if (html) {
-        tbody.insertAdjacentHTML('beforeend', html);
-        applySizeStateToRenderedCells();
-        window.dispatchEvent(new Event('csvChunkLoaded'));
-      }
-      if (!csvChunks.length) {
-        requestRemoteChunk();
-      }
-      return !!html;
-    } finally {
-      loading = false;
-    }
-  };
-  // Expose for restoration logic
-  window.__csvLoadNextChunk = loadNextChunk;
-
-  nearBottom = () => {
-    if (!scrollContainer) return false;
-    const remain = scrollContainer.scrollHeight - scrollContainer.scrollTop - scrollContainer.clientHeight;
-    return remain < 300; // px threshold
-  };
-
-  const io = new IntersectionObserver((entries)=>{
-    if (entries[0] && entries[0].isIntersecting) {
-      loadNextChunk();
-      const last = tbody && tbody.querySelector('tr:last-child');
-      if (last) io.observe(last);
-    }
-  }, { root: scrollContainer || null, rootMargin: '0px 0px 300px 0px' });
-
-  const prime = () => {
-    const last = tbody && tbody.querySelector('tr:last-child');
-    if (last) { io.observe(last); }
-  };
-  prime();
-
-  // Fallback: scroll-driven loader to ensure progress even if IO misses
-  const scrollHandler = () => {
-    if (!csvChunks.length && !remoteHasMoreChunks) return;
-    if (nearBottom()) {
-      // Load until we create headroom or exhaust currently available chunks
-      let guard = 10;
-      while (nearBottom() && guard-- > 0) {
-        if (!loadNextChunk()) break;
-      }
-      prime();
+  if (chunkLoading || !tbody) return false;
+  if (!csvChunks.length) { requestRemoteChunk(); return false; }
+  chunkLoading = true;
+  try {
+    const html = csvChunks.shift();
+    if (html) {
+      tbody.insertAdjacentHTML('beforeend', html);
+      applySizeStateToRenderedCells();
+      window.dispatchEvent(new Event('csvChunkLoaded'));
     }
-  };
-  if (scrollContainer) scrollContainer.addEventListener('scroll', scrollHandler, { passive: true });
-  else window.addEventListener('scroll', scrollHandler, { passive: true });
-}
+    if (!csvChunks.length) requestRemoteChunk();
+    primeChunks();
+    return !!html;
+  } finally { chunkLoading = false; }
+};
+window.__csvLoadNextChunk = loadNextChunk;
+nearBottom = () => !!scrollContainer && scrollContainer.scrollHeight - scrollContainer.scrollTop - scrollContainer.clientHeight < 300;
+chunkObserver = new IntersectionObserver(entries => {
+  if (entries[0]?.isIntersecting) loadNextChunk();
+}, { root: scrollContainer || null, rootMargin: '0px 0px 300px 0px' });
+primeChunks();
+const scrollChunkLoader = () => {
+  if (!csvChunks.length && !remoteHasMoreChunks) return;
+  let guard = 10;
+  while (nearBottom() && guard-- > 0) { if (!loadNextChunk()) break; }
+  primeChunks();
+};
+(scrollContainer || window).addEventListener('scroll', scrollChunkLoader, { passive: true });
 
 const ensureTargetStep = () => {
   if (!pendingEnsureTarget) return;
@@ -367,18 +440,28 @@ const handleZoomWheel = e => {
 };
 window.addEventListener('wheel', handleZoomWheel, { passive: false });
 
-const hasHeader = document.querySelector('thead') !== null;
+let hasHeader = document.querySelector('thead') !== null;
+let headerEnabled = root?.dataset?.headerenabled === '1';
 const getCellCoords = cell => ({ row: parseInt(cell.getAttribute('data-row')), col: parseInt(cell.getAttribute('data-col')) });
 const clearSelection = () => { currentSelection.forEach(c => c.classList.remove('selected')); currentSelection = []; };
 const contextMenu = document.getElementById('contextMenu');
 
 /* ──────── UPDATED showContextMenu ──────── */
+const changeFrozenPanes = change => {
+  frozenRowCount = change.rows ?? frozenRowCount;
+  frozenColumnCount = change.columns ?? frozenColumnCount;
+  window.csvFrozenPanes?.update(frozenRowCount, frozenColumnCount);
+  vscode.postMessage({ type: 'freezePanesChanged', rows: frozenRowCount, columns: frozenColumnCount });
+};
 const showContextMenu = (x, y, row, col) => {
   contextMenu.innerHTML = '';
   const item = (label, cb) => {
     const d = document.createElement('div');
     d.textContent = label;
-    d.addEventListener('click', () => { cb(); contextMenu.style.display = 'none'; });
+    d.addEventListener('click', () => {
+      if (!filterSnapshotPending) cb();
+      contextMenu.style.display = 'none';
+    });
     contextMenu.appendChild(d);
   };
   const divider = () => {
@@ -387,6 +470,49 @@ const showContextMenu = (x, y, row, col) => {
     d.style.margin = '1px 0';
     contextMenu.appendChild(d);
   };
+  if (col === -1) {
+    item('Hide serial index column', () => {
+      const anchor = anchorCell ? getCellCoords(anchorCell) : null;
+      if (!anchor || !Number.isFinite(anchor.col) || anchor.col < 0) {
+        const row = anchor && Number.isFinite(anchor.row) ? anchor.row : Number(root?.dataset?.firstrow || '0');
+        const surviving = table.querySelector(`td[data-row="${row}"][data-col="0"], th[data-row="${row}"][data-col="0"]`);
+        if (surviving) {
+          clearSelection();
+          surviving.classList.add('selected');
+          currentSelection.push(surviving);
+          anchorCell = surviving;
+          rangeEndCell = surviving;
+        }
+      }
+      persistState();
+      vscode.postMessage({ type: 'setSerialIndex', enabled: false });
+    });
+    divider();
+  }
+  if (row === Number(root?.dataset?.firstrow)) {
+    item(headerEnabled ? 'Treat first row as data' : 'Use first row as header', () => {
+      persistState();
+      vscode.postMessage({ type: 'setHeader', enabled: !headerEnabled });
+    });
+    divider();
+  }
+  if (Number.isInteger(col) && col >= 0) {
+    item('Filter this column…', () => window.csvColumnFilters?.add(col));
+    divider();
+  }
+  item('Cut', () => copySelectionToClipboard(true));
+  item('Copy', () => copySelectionToClipboard());
+  item('Paste', () => pasteFromClipboard());
+  divider();
+  if (Number.isInteger(row) && row >= Number(root?.dataset?.firstrow || '0') && row < Number(root?.dataset?.realrowcount || '0')) {
+    item('Freeze rows through this row', () => changeFrozenPanes({ rows: row - Number(root?.dataset?.firstrow || '0') + 1 }));
+  }
+  if (Number.isInteger(col) && col >= 0) {
+    item('Freeze columns through this column', () => changeFrozenPanes({ columns: col + 1 }));
+  }
+  if (frozenRowCount > 0) item('Unfreeze rows', () => changeFrozenPanes({ rows: 0 }));
+  if (frozenColumnCount > 0) item('Unfreeze columns', () => changeFrozenPanes({ columns: 0 }));
+  divider();
   // Derive multi-row/column selection counts
   const selectedIndexCells = currentSelection.filter(el => el && el.getAttribute && el.getAttribute('data-col') === '-1');
   const selectedRowIds = Array.from(new Set(selectedIndexCells.map(el => parseInt(el.getAttribute('data-row') || '-1', 10)).filter(n => !isNaN(n)))).sort((a,b)=>a-b);
@@ -400,9 +526,9 @@ const showContextMenu = (x, y, row, col) => {
 
   /* Header-only: SORT functionality */
   if (lastContextIsHeader) {
-    item('Sort: A-Z', () =>
+    item(root?.dataset?.filtered === '1' ? 'Sort matching rows: A-Z' : 'Sort: A-Z', () =>
       vscode.postMessage({ type: 'sortColumn', index: col, ascending: true }));
-    item('Sort: Z-A', () =>
+    item(root?.dataset?.filtered === '1' ? 'Sort matching rows: Z-A' : 'Sort: Z-A', () =>
       vscode.postMessage({ type: 'sortColumn', index: col, ascending: false }));
   }        
 
@@ -457,10 +583,25 @@ const showContextMenu = (x, y, row, col) => {
     });
   }
 
-  contextMenu.style.left = x + 'px';
-  contextMenu.style.top = y + 'px';
+  const viewportWidth = window.innerWidth;
+  const viewportHeight = window.innerHeight;
+  const marginX = Math.min(8, viewportWidth / 4);
+  const marginY = Math.min(8, viewportHeight / 4);
+  contextMenu.style.maxWidth = `${Math.max(0, viewportWidth - 2 * marginX)}px`;
+  contextMenu.style.maxHeight = `${Math.max(0, viewportHeight - 2 * marginY)}px`;
+  // Measure all actions at their natural width, bounded by the viewport, before placing.
+  contextMenu.style.left = `${marginX}px`;
+  contextMenu.style.top = `${marginY}px`;
   contextMenu.style.display = 'block';
+  contextMenu.scrollTop = 0;
+  contextMenu.scrollLeft = 0;
+  const { width, height } = contextMenu.getBoundingClientRect();
+  const left = x + width <= viewportWidth - marginX ? x : x - width;
+  const top = y + height <= viewportHeight - marginY ? y : y - height;
+  contextMenu.style.left = `${clamp(left, marginX, Math.max(marginX, viewportWidth - marginX - width))}px`;
+  contextMenu.style.top = `${clamp(top, marginY, Math.max(marginY, viewportHeight - marginY - height))}px`;
 };
+window.addEventListener('resize', () => { contextMenu.style.display = 'none'; });
 
 const getElementTarget = target => {
   if (target instanceof Element) return target;
@@ -557,17 +698,60 @@ const getRowDropTarget = clientY => {
   return { beforeIndex, indicatorY };
 };
 const getResizeEdgeInfo = (target, e) => {
-  if (!target) return null;
-  if (isColumnHeaderCell(target)) {
-    const col = parseInt(target.getAttribute('data-col') || 'NaN', 10);
-    if (!Number.isNaN(col)) {
-      const rect = target.getBoundingClientRect();
-      const edgeDelta = rect.right - e.clientX;
-      if (edgeDelta >= 0 && edgeDelta <= RESIZE_HANDLE_PX) {
-        return { axis: 'column', index: col, rect };
-      }
+  if (editingCell || !Number.isFinite(e.clientX) || !Number.isFinite(e.clientY)) return null;
+  const element = getElementTarget(e.target);
+  if (element?.closest('a, .csv-link, input, textarea, select, button, [contenteditable="true"], [role="button"]')) return null;
+  const paintedCellAt = (x, y) => {
+    const hit = document.elementFromPoint(x, y);
+    return hit && table.contains(hit) ? getCellTarget(hit) : null;
+  };
+  const candidates = new Set();
+  const add = cell => { if (cell && table.contains(cell)) candidates.add(cell); };
+  if (target) {
+    add(target);
+    // A sticky seam can lie inside a partially covered scrolling cell's rect.
+    add(paintedCellAt(e.clientX - COLUMN_RESIZE_HANDLE_PX - 0.5, e.clientY));
+    const rect = target.getBoundingClientRect();
+    if (rect.width > 0 && Math.abs(e.clientX - rect.left) <= COLUMN_RESIZE_HANDLE_PX) {
+      // Hit the painted neighbor, which can differ from col-1 at a frozen seam.
+      add(paintedCellAt(rect.left - 0.5, e.clientY));
+      add(paintedCellAt(rect.left - 1, e.clientY));
+      add(target.previousElementSibling);
+    }
+  } else {
+    // Collapsed/fractional borders can target TR/TABLE rather than either cell.
+    for (const delta of [0, -0.5, 0.5, -1, 1]) {
+      add(paintedCellAt(e.clientX + delta, e.clientY));
     }
   }
+  let closest = null;
+  let closestDistance = Infinity;
+  for (const cell of candidates) {
+    const coords = getDataCellCoords(cell);
+    if (!coords) continue;
+    const rect = cell.getBoundingClientRect();
+    if (rect.width <= 0 || rect.height <= 0 || e.clientY < rect.top - 0.5 || e.clientY > rect.bottom + 0.5 || Math.abs(e.clientX - rect.right) > COLUMN_RESIZE_HANDLE_PX + 0.75) continue;
+    const sampleY = clamp(e.clientY, rect.top + Math.min(0.5, rect.height / 4), rect.bottom - Math.min(0.5, rect.height / 4));
+    // A scrolled cell can share the frozen column's x coordinate while covered.
+    if (paintedCellAt(rect.right - Math.min(0.5, rect.width / 4), sampleY) !== cell) continue;
+    const neighbor = paintedCellAt(rect.right + 0.5, sampleY);
+    const next = neighbor && neighbor !== cell && neighbor.parentElement === cell.parentElement ? neighbor : cell.nextElementSibling;
+    const nextRect = next && getDataCellCoords(next) ? next.getBoundingClientRect() : null;
+    const adjacent = nextRect && nextRect.width > 0 && nextRect.left <= rect.right + 1.5 && nextRect.right > rect.right;
+    const contiguous = adjacent && Math.abs(nextRect.left - rect.right) <= 1.5;
+    const boundary = contiguous ? (rect.right + nextRect.left) / 2 : rect.right;
+    const leftCover = paintedCellAt(rect.left + Math.min(0.5, rect.width / 4), sampleY);
+    const visibleLeft = leftCover && leftCover !== cell ? Math.min(rect.right, Math.max(rect.left, leftCover.getBoundingClientRect().right)) : rect.left;
+    const nextWidth = adjacent ? nextRect.right - Math.max(nextRect.left, rect.right) : Infinity;
+    // Use the painted span at sticky seams so even partially covered cells retain a center.
+    const band = Math.min(COLUMN_RESIZE_HANDLE_PX, (rect.right - visibleLeft) / 4, nextWidth / 4);
+    const distance = Math.abs(e.clientX - boundary);
+    if (distance <= band && distance < closestDistance) {
+      closestDistance = distance;
+      closest = { axis: 'column', index: coords.col, rect };
+    }
+  }
+  if (closest) return closest;
   if (isRowIndexCell(target)) {
     const row = parseInt(target.getAttribute('data-row') || 'NaN', 10);
     if (!Number.isNaN(row)) {
@@ -581,23 +765,23 @@ const getResizeEdgeInfo = (target, e) => {
   return null;
 };
 const applyColumnWidth = (col, widthPx) => {
+  window.csvFrozenPanes?.schedule();
   const width = Math.max(40, Math.round(widthPx));
   columnSizeState[String(col)] = width;
   table.querySelectorAll(`[data-col="${col}"]`).forEach(cell => {
-    cell.style.width = `${width}px`;
-    cell.style.minWidth = `${width}px`;
-    cell.style.maxWidth = `${width}px`;
+    setRenderedColumnWidth(cell, width);
   });
 };
 const resetColumnWidth = col => {
+  window.csvFrozenPanes?.schedule();
   delete columnSizeState[String(col)];
   table.querySelectorAll(`[data-col="${col}"]`).forEach(cell => {
-    cell.style.width = '';
-    cell.style.minWidth = '';
-    cell.style.maxWidth = '';
+    const automatic = automaticColumnSizes.get(cell);
+    if (automatic) Object.assign(cell.style, automatic);
   });
 };
 const applyRowHeight = (row, heightPx) => {
+  window.csvFrozenPanes?.schedule();
   const height = Math.max(getMinRowHeight(), Math.round(heightPx));
   rowSizeState[String(row)] = height;
   table.querySelectorAll(`[data-row="${row}"]`).forEach(cell => {
@@ -606,6 +790,7 @@ const applyRowHeight = (row, heightPx) => {
   });
 };
 const resetRowHeight = row => {
+  window.csvFrozenPanes?.schedule();
   delete rowSizeState[String(row)];
   table.querySelectorAll(`[data-row="${row}"]`).forEach(cell => {
     cell.style.height = '';
@@ -640,7 +825,8 @@ const startReorderDrag = (target, e) => {
       startX: e.clientX,
       startY: e.clientY,
       active: false,
-      beforeIndex: null
+      beforeIndex: null,
+      headerOnlyOnClick: e.detail === 1 && selectionMode === 'column' && anchorCell === target && selected.length === 1 ? target : null
     };
     return true;
   }
@@ -695,20 +881,32 @@ const onGlobalDragMove = e => {
     showRowDropIndicator(target.indicatorY);
   }
 };
-const onGlobalDragEnd = () => {
+const onGlobalDragEnd = e => {
   if (resizeState) {
+    if (resizeState.axis === 'column') persistColumnSizes();
     resizeState = null;
     table.style.cursor = '';
     persistState();
+    window.csvFrozenPanes?.schedule();
   }
   if (!reorderState) return;
 
-  const { axis, indices, active, beforeIndex } = reorderState;
+  const { axis, indices, active, beforeIndex, headerOnlyOnClick } = reorderState;
   reorderState = null;
   hideDragIndicator();
   table.style.cursor = '';
 
-  if (!active || !Number.isFinite(beforeIndex)) return;
+  if (!active) {
+    // Keep selected columns available for dragging until an ordinary click ends.
+    // A real double-click has detail 2 and keeps the existing edit gesture.
+    if (headerOnlyOnClick && e.button === 0 && getCellTarget(e.target) === headerOnlyOnClick) {
+      selectionMode = 'cell';
+      startCell = endCell = headerOnlyOnClick;
+      setSingleSelection(headerOnlyOnClick);
+    }
+    return;
+  }
+  if (!Number.isFinite(beforeIndex)) return;
   if (axis === 'column') {
     vscode.postMessage({ type: 'reorderColumns', indices, beforeIndex });
   } else {
@@ -747,15 +945,16 @@ document.addEventListener('click', (e) => {
 /* ──────── UPDATED contextmenu listener ──────── */
 table.addEventListener('contextmenu', e => {
   const target = getCellTarget(e.target);
-  if (!target) return;
+  if (!target || editingCell) return;
   const colAttr = target.getAttribute('data-col');
   const rowAttr = target.getAttribute('data-row');
-  const col = parseInt(colAttr);
+  const serialCorner = target.hasAttribute('data-serial-index');
+  const col = serialCorner ? -1 : parseInt(colAttr);
   const row = parseInt(rowAttr);
-  if ((isNaN(col) || col === -1) && (isNaN(row) || row === -1)) return;
+  if (!serialCorner && (isNaN(col) || col === -1) && (isNaN(row) || row === -1)) return;
   e.preventDefault();
-  lastContextIsHeader = target.tagName === 'TH';
-  showContextMenu(e.pageX, e.pageY, row, col);
+  lastContextIsHeader = target.tagName === 'TH' && !serialCorner;
+  showContextMenu(e.clientX, e.clientY, row, col);
 });
 
 table.addEventListener('mousedown', e => {
@@ -766,6 +965,10 @@ table.addEventListener('mousedown', e => {
     return;
   }
   const target = getCellTarget(e.target);
+  if (e.button === 0 && startResizeDrag(target, e)) {
+    e.preventDefault();
+    return;
+  }
   if (!target) return;
 
   // Preserve selection on right-click; select target if outside current selection
@@ -784,10 +987,6 @@ table.addEventListener('mousedown', e => {
     return; // do not start drag selection on right-click
   }
   if (e.button !== 0) return;
-  if (!editingCell && startResizeDrag(target, e)) {
-    e.preventDefault();
-    return;
-  }
   if (!editingCell && !e.shiftKey && !e.ctrlKey && !e.metaKey && !e.altKey && startReorderDrag(target, e)) {
     e.preventDefault();
     return;
@@ -855,6 +1054,16 @@ table.addEventListener('mousedown', e => {
   
   selectionMode = (target.tagName === 'TH') ? "column" : (target.getAttribute('data-col') === '-1' ? "row" : "cell");
   startCell = target; endCell = target; rangeEndCell = target; isSelecting = true; e.preventDefault();
+  if (selectionMode === "column") {
+    const col = Number(target.getAttribute('data-col'));
+    selectFullColumnRange(col, col);
+  } else if (selectionMode === "row") {
+    const row = Number(target.getAttribute('data-row'));
+    selectFullRowRange(row, row);
+  } else {
+    const coords = getCellCoords(target);
+    selectRange(coords, coords);
+  }
   target.focus();
 });
 
@@ -894,10 +1103,6 @@ table.addEventListener('mousemove', e => {
     return;
   }
   const target = getCellTarget(e.target);
-  if (!target) {
-    table.style.cursor = '';
-    return;
-  }
   const edge = getResizeEdgeInfo(target, e);
   if (edge) {
     table.style.cursor = edge.axis === 'column' ? 'col-resize' : 'row-resize';
@@ -916,11 +1121,6 @@ table.addEventListener('mouseup', e => {
   if(!isSelecting) return;
   isSelecting = false;
   if(selectionMode === "cell"){
-    if(startCell === endCell){
-      clearSelection();
-      startCell.classList.add('selected');
-      currentSelection.push(startCell);
-    }
     anchorCell = startCell;
     rangeEndCell = endCell;
     persistState();
@@ -939,9 +1139,10 @@ const selectRange = (start, end) => {
   clearSelection();
   const minRow = Math.min(start.row, end.row), maxRow = Math.max(start.row, end.row);
   const minCol = Math.min(start.col, end.col), maxCol = Math.max(start.col, end.col);
-  for(let r = minRow; r <= maxRow; r++){
+  const selectedRows = visibleRowOrder.length ? visibleRowOrder.filter(row => row >= minRow && row <= maxRow) : Array.from({ length: maxRow - minRow + 1 }, (_, index) => minRow + index);
+  for (const r of selectedRows) {
     for(let c = minCol; c <= maxCol; c++){
-      const selector = (hasHeader && r === 0 ? 'th' : 'td') + '[data-row="'+r+'"][data-col="'+c+'"]';
+      const selector = (hasHeader && r === headerSourceRow ? 'th' : 'td') + '[data-row="'+r+'"][data-col="'+c+'"]';
       const selCell = table.querySelector(selector);
       if(selCell){ selCell.classList.add('selected'); currentSelection.push(selCell); }
     }
@@ -974,6 +1175,19 @@ const selectFullRowRange = (row1, row2) => {
   });
 };
 
+const extendSelectionTo = target => {
+  rangeEndCell = target;
+  const start = getCellCoords(anchorCell);
+  const end = getCellCoords(target);
+  if (isColumnHeaderCell(anchorCell)) {
+    selectFullColumnRange(start.col, end.col);
+  } else if (isRowIndexCell(anchorCell)) {
+    selectFullRowRange(start.row, end.row);
+  } else {
+    selectRange(start, end);
+  }
+};
+
 const getDataCellCoords = cell => {
   if (!cell || typeof cell.getAttribute !== 'function') return null;
   const coords = getCellCoords(cell);
@@ -994,7 +1208,8 @@ const getDataSelectionBounds = () => {
   const maxRow = Math.max(...rows);
   const minCol = Math.min(...cols);
   const maxCol = Math.max(...cols);
-  const expectedCount = (maxRow - minRow + 1) * (maxCol - minCol + 1);
+  const rowIds = [...new Set(rows)].sort((a, b) => a - b);
+  const expectedCount = rowIds.length * (maxCol - minCol + 1);
   const rectangular = keys.size === expectedCount;
   return { minRow, maxRow, minCol, maxCol, rectangular };
 };
@@ -1052,6 +1267,19 @@ const isFindWidgetTarget = target => {
   const el = getElementTarget(target);
   return !!(el && el.closest('#findReplaceWidget'));
 };
+const isGridControlTarget = target => isFindWidgetTarget(target) || !!getElementTarget(target)?.closest('#filterStatus');
+const preventPendingGridAction = event => {
+  if (!filterSnapshotPending || isGridControlTarget(event.target)) return;
+  event.preventDefault();
+  event.stopImmediatePropagation();
+};
+for (const type of ['keydown', 'copy', 'cut', 'paste']) {
+  document.addEventListener(type, preventPendingGridAction, true);
+}
+for (const type of ['mousedown', 'mouseup', 'dblclick', 'contextmenu', 'beforeinput']) {
+  table.addEventListener(type, preventPendingGridAction, true);
+}
+
 const clearFindHighlights = () => {
   document.querySelectorAll('.highlight, .active-match').forEach(el => {
     el.classList.remove('highlight');
@@ -1165,7 +1393,7 @@ const setActiveFindMatch = (index, shouldScroll = true) => {
     cell.classList.add('highlight');
     cell.classList.add('active-match');
     if (shouldScroll) {
-      cell.scrollIntoView({ block: 'center', inline: 'center', behavior: 'smooth' });
+      scheduleCellReveal(cell, true);
     }
   }
   updateFindStatus();
@@ -1234,6 +1462,7 @@ const replaceInText = (text, replaceAllMatches) => {
   return text.replace(regex, matched => preserveReplacementCase(replacementText, matched));
 };
 const replaceCurrentMatch = () => {
+  if (filterSnapshotPending) return;
   if (!findMatches.length || findReplaceState.invalidRegex) return;
   const match = findMatches[currentMatchIndex];
   if (!match) {
@@ -1254,6 +1483,7 @@ const replaceCurrentMatch = () => {
   runFind(true);
 };
 const replaceAllMatches = () => {
+  if (filterSnapshotPending) return;
   if (findReplaceState.invalidRegex || !findInput.value || !findMatches.length) return;
   const seen = new Set();
   if (!findMatches.length) return;
@@ -1313,41 +1543,46 @@ const closeFindReplace = () => {
 
 findInput.addEventListener('input', () => scheduleFind(false));
 findInput.addEventListener('keydown', e => {
-  e.stopPropagation();
   if (e.key === 'Escape') {
     e.preventDefault();
+    e.stopPropagation();
     closeFindReplace();
     return;
   }
   if (e.key === 'Enter') {
     e.preventDefault();
+    e.stopPropagation();
     navigateFind(e.shiftKey);
     return;
   }
   if (e.key === 'F3') {
     e.preventDefault();
+    e.stopPropagation();
     navigateFind(e.shiftKey);
     return;
   }
   if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'g') {
     e.preventDefault();
+    e.stopPropagation();
     navigateFind(e.shiftKey);
   }
 });
 replaceInput.addEventListener('keydown', e => {
-  e.stopPropagation();
   if (e.key === 'Escape') {
     e.preventDefault();
+    e.stopPropagation();
     closeFindReplace();
     return;
   }
   if (e.key === 'F3') {
     e.preventDefault();
+    e.stopPropagation();
     navigateFind(e.shiftKey);
     return;
   }
   if (e.key === 'Enter') {
     e.preventDefault();
+    e.stopPropagation();
     replaceCurrentMatch();
   }
 });
@@ -1414,9 +1649,9 @@ window.addEventListener('csvChunkLoaded', () => {
   }
 });
 
-// Capture-phase handler to intercept Cmd/Ctrl + Arrow and move to extremes
+// Handle modified arrow jumps once; Shift extends the existing selection.
 document.addEventListener('keydown', e => {
-  if (isFindWidgetTarget(e.target)) {
+  if (isGridControlTarget(e.target) || isTextInputTarget(e.target)) {
     return;
   }
   const isArrowKey = (k) => ['ArrowUp','ArrowDown','ArrowLeft','ArrowRight','Up','Down','Left','Right','Home','End'].includes(k);
@@ -1425,38 +1660,26 @@ document.addEventListener('keydown', e => {
     e.stopImmediatePropagation();
     e.stopPropagation();
 
-    const sc = document.querySelector('.table-container');
-    if (sc) {
-      if (['ArrowLeft','Left','Home'].includes(e.key))  sc.scrollTo({ left: 0, behavior: 'smooth' });
-      if (['ArrowRight','Right','End'].includes(e.key)) sc.scrollTo({ left: sc.scrollWidth, behavior: 'smooth' });
-      if (['ArrowUp','Up'].includes(e.key))    sc.scrollTo({ top: 0, behavior: 'smooth' });
-      if (['ArrowDown','Down'].includes(e.key))  sc.scrollTo({ top: sc.scrollHeight, behavior: 'smooth' });
-    } else {
-      if (['ArrowUp','Up'].includes(e.key)) {
-        window.scrollTo({ top: 0, behavior: 'smooth' });
-      }
-      if (['ArrowDown','Down'].includes(e.key)) {
-        const h = Math.max(
-          document.body.scrollHeight,
-          document.documentElement.scrollHeight
-        );
-        window.scrollTo({ top: h, behavior: 'smooth' });
-      }
+    // Select All has no fixed cell anchor; preserve the complete selection.
+    if (e.shiftKey && !anchorCell && currentSelection.length > 1) {
+      return;
     }
 
-    const ref = anchorCell || currentSelection[0] || document.querySelector('td.selected, th.selected') || document.querySelector('td, th');
+    const fixedAnchor = anchorCell || currentSelection.find(cell => {
+      const { row, col } = getCellCoords(cell);
+      return Number.isInteger(row) && Number.isInteger(col);
+    }) || table.querySelector('td[data-row][data-col], th[data-row][data-col]');
+    const ref = e.shiftKey && anchorCell ? (rangeEndCell || fixedAnchor) : fixedAnchor;
     let target = null;
     if (ref) {
       const { row, col } = getCellCoords(ref);
       if (['ArrowLeft','Left','Home'].includes(e.key)) {
-        const tag = (hasHeader && row === 0 ? 'th' : 'td');
-        const rowCells = Array.from(table.querySelectorAll(tag + '[data-row="'+row+'"]'))
+        const rowCells = Array.from(table.querySelectorAll('td[data-row="'+row+'"], th[data-row="'+row+'"]'))
           .filter(el => el.getAttribute('data-col') !== null && el.getAttribute('data-col') !== '-1');
         const min = rowCells.reduce((acc, el) => Math.min(acc, parseInt(el.getAttribute('data-col'))), Infinity);
         target = rowCells.find(el => parseInt(el.getAttribute('data-col')) === min) || ref;
       } else if (['ArrowRight','Right','End'].includes(e.key)) {
-        const tag = (hasHeader && row === 0 ? 'th' : 'td');
-        const rowCells = Array.from(table.querySelectorAll(tag + '[data-row="'+row+'"]'))
+        const rowCells = Array.from(table.querySelectorAll('td[data-row="'+row+'"], th[data-row="'+row+'"]'))
           .filter(el => el.getAttribute('data-col') !== null && el.getAttribute('data-col') !== '-1');
         const max = rowCells.reduce((acc, el) => Math.max(acc, parseInt(el.getAttribute('data-col'))), -1);
         target = rowCells.find(el => parseInt(el.getAttribute('data-col')) === max) || ref;
@@ -1470,39 +1693,41 @@ document.addEventListener('keydown', e => {
     }
 
     if (target) {
-      clearSelection();
-      target.classList.add('selected');
-      currentSelection.push(target);
-      anchorCell = target;
-      rangeEndCell = target;
-      persistState();
-      target.focus({preventScroll:true});
-      if (['ArrowUp','Up'].includes(e.key)) {
-        const topRow = getFirstDataRow();
-        const below = table.querySelector('td[data-row="'+topRow+'"][data-col="'+getCellCoords(target).col+'"]');
-        if (below) {
-          below.scrollIntoView({ block: 'center', inline: 'nearest', behavior: 'smooth' });
-        } else {
-          target.scrollIntoView({ block: 'center', inline: 'nearest', behavior: 'smooth' });
-        }
+      if (e.shiftKey && fixedAnchor) {
+        anchorCell = fixedAnchor;
+        extendSelectionTo(target);
       } else {
-        target.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
+        clearSelection();
+        target.classList.add('selected');
+        currentSelection.push(target);
+        anchorCell = target;
+        rangeEndCell = target;
       }
+      persistState();
+      (e.shiftKey ? anchorCell : target).focus({preventScroll:true});
+      scheduleCellReveal(target);
     }
   }
 }, true);
 
 document.addEventListener('keydown', e => {
+  if (getElementTarget(e.target)?.closest('#filterStatus')) return;
   if (maybeHandleZoomShortcut(e)) {
     return;
   }
   const key = typeof e.key === 'string' ? e.key.toLowerCase() : '';
-  if ((e.ctrlKey || e.metaKey) && key === 'f') {
+  if ((e.ctrlKey || e.metaKey) && !e.altKey && !e.shiftKey && key === 's') {
+    e.preventDefault();
+    if (editingCell) { editingCell.blur(); }
+    vscode.postMessage({ type: 'save' });
+    return;
+  }
+  if ((e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey && key === 'f') {
     e.preventDefault();
     openFindReplace(false);
     return;
   }
-  if ((e.ctrlKey || e.metaKey) && key === 'h') {
+  if ((e.ctrlKey || e.metaKey) && !e.shiftKey && !e.altKey && key === 'h') {
     e.preventDefault();
     openFindReplace(true);
     return;
@@ -1522,14 +1747,15 @@ document.addEventListener('keydown', e => {
     closeFindReplace();
     return;
   }
-  if (isFindWidgetTarget(e.target)) {
+  if (isGridControlTarget(e.target)) {
     return;
   }
   if ((e.ctrlKey || e.metaKey) && e.key === 'a' && !editingCell) {
     e.preventDefault(); selectAllCells(); return;
   }
-  if ((e.ctrlKey || e.metaKey) && e.key === 'c' && currentSelection.length > 0) {
-    e.preventDefault(); copySelectionToClipboard(); return;
+  if ((e.ctrlKey || e.metaKey) && !editingCell && !isTextInputTarget(e.target) &&
+      (key === 'c' || key === 'x') && currentSelection.length > 0) {
+    e.preventDefault(); copySelectionToClipboard(key === 'x'); return;
   }
 
   // Clear contents of selected cells when not editing
@@ -1548,61 +1774,6 @@ document.addEventListener('keydown', e => {
     return;
   }
 
-  const isArrowKey = (k) => ['ArrowUp','ArrowDown','ArrowLeft','ArrowRight','Up','Down','Left','Right','Home','End'].includes(k);
-  if (!editingCell && (e.ctrlKey || e.metaKey) && isArrowKey(e.key)) {
-    e.preventDefault();
-    const sc = document.querySelector('.table-container');
-    if (sc) {
-      if (['ArrowLeft','Left','Home'].includes(e.key))  sc.scrollTo({ left: 0, behavior: 'smooth' });
-      if (['ArrowRight','Right','End'].includes(e.key)) sc.scrollTo({ left: sc.scrollWidth, behavior: 'smooth' });
-      if (['ArrowUp','Up'].includes(e.key))    sc.scrollTo({ top: 0, behavior: 'smooth' });
-      if (['ArrowDown','Down'].includes(e.key))  sc.scrollTo({ top: sc.scrollHeight, behavior: 'smooth' });
-    }
-
-    let refCell = anchorCell;
-    if (!refCell) {
-      refCell = currentSelection[0] || document.querySelector('td.selected, th.selected');
-    }
-    let target = null;
-    if (refCell) {
-      const { row, col } = getCellCoords(refCell);
-      if (['ArrowLeft','Left','Home'].includes(e.key)) {
-        const tag = (hasHeader && row === 0 ? 'th' : 'td');
-        const rowCells = Array.from(table.querySelectorAll(tag + '[data-row="'+row+'"]'))
-          .filter(el => el.getAttribute('data-col') !== null && el.getAttribute('data-col') !== '-1');
-        const min = rowCells.reduce((acc, el) => Math.min(acc, parseInt(el.getAttribute('data-col'))), Infinity);
-        target = rowCells.find(el => parseInt(el.getAttribute('data-col')) === min) || refCell;
-      } else if (['ArrowRight','Right','End'].includes(e.key)) {
-        const tag = (hasHeader && row === 0 ? 'th' : 'td');
-        const rowCells = Array.from(table.querySelectorAll(tag + '[data-row="'+row+'"]'))
-          .filter(el => el.getAttribute('data-col') !== null && el.getAttribute('data-col') !== '-1');
-        const max = rowCells.reduce((acc, el) => Math.max(acc, parseInt(el.getAttribute('data-col'))), -1);
-        target = rowCells.find(el => parseInt(el.getAttribute('data-col')) === max) || refCell;
-      } else if (['ArrowUp','Up'].includes(e.key)) {
-        if (hasHeader) {
-          target = table.querySelector('th[data-row="0"][data-col="'+col+'"]') || refCell;
-        } else {
-          target = table.querySelector('td[data-row="0"][data-col="'+col+'"]') || refCell;
-        }
-      } else if (['ArrowDown','Down'].includes(e.key)) {
-        const colCells = Array.from(table.querySelectorAll('td[data-col="'+col+'"]'));
-        target = (colCells.length ? colCells[colCells.length - 1] : null) || refCell;
-      }
-    }
-
-    if (target) {
-      clearSelection();
-      target.classList.add('selected');
-      currentSelection.push(target);
-      anchorCell = target;
-      rangeEndCell = target;
-      persistState();
-      target.focus({preventScroll:true});
-      target.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
-    }
-    return;
-  }
-
   if (!editingCell && e.key === 'Tab' && !e.ctrlKey && !e.metaKey && !e.altKey) {
     e.preventDefault();
     const refCell = anchorCell || getCellTarget(document.activeElement) || currentSelection[0] || document.querySelector('td.selected, th.selected');
@@ -1619,13 +1790,13 @@ document.addEventListener('keydown', e => {
     let targetRow = coords.row;
     let targetCol = coords.col + (isBackward ? -1 : 1);
     if (!isBackward && targetCol > maxCol) {
-      targetRow += 1;
+      targetRow = adjacentVisibleRow(targetRow, 1);
       targetCol = minCol;
     } else if (isBackward && targetCol < minCol) {
       if (targetRow <= firstDataRow) {
         return;
       }
-      targetRow -= 1;
+      targetRow = adjacentVisibleRow(targetRow, -1);
       targetCol = maxCol;
     }
     const nextCell = ensureRenderedCellByCoords(targetRow, targetCol);
@@ -1666,21 +1837,19 @@ document.addEventListener('keydown', e => {
     const { row, col } = getCellCoords(rangeEndCell || anchorCell);
     let targetRow = row, targetCol = col;
     switch(e.key){
-      case 'ArrowUp':   targetRow = row - 1; break;
-      case 'ArrowDown': targetRow = row + 1; break;
+      case 'ArrowUp':   targetRow = adjacentVisibleRow(row, -1); break;
+      case 'ArrowDown': targetRow = adjacentVisibleRow(row, 1); break;
       case 'ArrowLeft': targetCol = col - 1; break;
       case 'ArrowRight':targetCol = col + 1; break;
     }
-    if(targetRow < 0 || targetCol < 0) return;
-    const tag = (hasHeader && targetRow === 0 ? 'th' : 'td');
-    const nextCell = table.querySelector(`${tag}[data-row="${targetRow}"][data-col="${targetCol}"]`);
+    if(targetRow < 0 || targetCol < (isRowIndexCell(anchorCell) ? -1 : 0)) return;
+    const nextCell = ensureRenderedCellByCoords(targetRow, targetCol);
     if(nextCell){
       e.preventDefault();
-      rangeEndCell = nextCell;
-      selectRange(getCellCoords(anchorCell), getCellCoords(rangeEndCell));
+      extendSelectionTo(nextCell);
       persistState();
       anchorCell.focus({preventScroll:true});
-      rangeEndCell.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
+      scheduleCellReveal(rangeEndCell);
     }
     return;
   }
@@ -1689,14 +1858,14 @@ document.addEventListener('keydown', e => {
     const { row, col } = getCellCoords(anchorCell);
     let targetRow = row, targetCol = col;
     switch(e.key){
-      case 'ArrowUp':   targetRow = row - 1; break;
-      case 'ArrowDown': targetRow = row + 1; break;
+      case 'ArrowUp':   targetRow = adjacentVisibleRow(row, -1); break;
+      case 'ArrowDown': targetRow = adjacentVisibleRow(row, 1); break;
       case 'ArrowLeft': targetCol = col - 1; break;
       case 'ArrowRight':targetCol = col + 1; break;
     }
     if(targetRow < 0 || targetCol < 0) return;
-    const tag = (hasHeader && targetRow === 0 ? 'th' : 'td');
-    const nextCell = table.querySelector(`${tag}[data-row="${targetRow}"][data-col="${targetCol}"]`);
+    const tag = (hasHeader && targetRow === headerSourceRow ? 'th' : 'td');
+    const nextCell = ensureRenderedCellByCoords(targetRow, targetCol);
     if(nextCell){
       e.preventDefault();
       clearSelection();
@@ -1706,7 +1875,7 @@ document.addEventListener('keydown', e => {
       rangeEndCell = nextCell;
       persistState();
       nextCell.focus({preventScroll:true});
-      nextCell.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
+      scheduleCellReveal(nextCell);
     }
     return;
   }
@@ -1717,14 +1886,14 @@ document.addEventListener('keydown', e => {
     const { row, col } = getCellCoords(editingCell);
     let targetRow = row, targetCol = col;
     switch(e.key){
-      case 'ArrowUp':   targetRow = row - 1; break;
-      case 'ArrowDown': targetRow = row + 1; break;
+      case 'ArrowUp':   targetRow = adjacentVisibleRow(row, -1); break;
+      case 'ArrowDown': targetRow = adjacentVisibleRow(row, 1); break;
       case 'ArrowLeft': targetCol = col - 1; break;
       case 'ArrowRight':targetCol = col + 1; break;
     }
     if (targetRow >= 0 && targetCol >= 0) {
-      const tag = (hasHeader && targetRow === 0 ? 'th' : 'td');
-      const nextCell = table.querySelector(`${tag}[data-row="${targetRow}"][data-col="${targetCol}"]`);
+      const tag = (hasHeader && targetRow === headerSourceRow ? 'th' : 'td');
+      const nextCell = ensureRenderedCellByCoords(targetRow, targetCol);
       if (nextCell) {
         const commitAndMove = () => {
           clearSelection();
@@ -1734,7 +1903,7 @@ document.addEventListener('keydown', e => {
           rangeEndCell = nextCell;
           persistState();
           nextCell.focus({preventScroll:true});
-          nextCell.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
+          scheduleCellReveal(nextCell);
         };
         const cellRef = editingCell;
         cellRef && cellRef.blur();
@@ -1758,11 +1927,6 @@ document.addEventListener('keydown', e => {
     return;
   }
 
-  if (editingCell && ((e.ctrlKey || e.metaKey) && e.key === 's')) {
-    e.preventDefault();
-    editingCell.blur();
-    vscode.postMessage({ type: 'save' });
-  }
   if (editingCell && e.key === 'Enter') {
     e.preventDefault();
     if (e.shiftKey) {
@@ -1773,7 +1937,7 @@ document.addEventListener('keydown', e => {
     }
     const { row, col } = getCellCoords(editingCell);
     editingCell.blur();
-    const targetRow = row + 1;
+    const targetRow = adjacentVisibleRow(row, 1);
     // Editing Enter commits and moves selection down (no auto-edit).
     const nextCell = ensureRenderedCellByCoords(targetRow, col);
     if (nextCell) {
@@ -1798,13 +1962,13 @@ document.addEventListener('keydown', e => {
     if (bounds) {
       targetCol = col + (isBackward ? -1 : 1);
       if (!isBackward && targetCol > bounds.maxCol) {
-        targetRow += 1;
+        targetRow = adjacentVisibleRow(targetRow, 1);
         targetCol = bounds.minCol;
       } else if (isBackward && targetCol < bounds.minCol) {
         if (targetRow <= firstDataRow) {
           canMove = false;
         } else {
-          targetRow -= 1;
+          targetRow = adjacentVisibleRow(targetRow, -1);
           targetCol = bounds.maxCol;
         }
       }
@@ -1819,15 +1983,46 @@ document.addEventListener('keydown', e => {
     }
   }
   if (editingCell && e.key === 'Escape') {
-    e.preventDefault(); editingCell.innerText = originalCellValue; editingCell.blur();
+    e.preventDefault();
+    const { row, col } = getCellCoords(editingCell);
+    if (failedCellDrafts.has(`${row}:${col}`)) {
+      discardingFailedDraft = true;
+      editingCell.blur();
+      discardingFailedDraft = false;
+      vscode.postMessage({ type: 'discardCellDraft', row, col });
+    } else {
+      editingCell.textContent = originalCellValue;
+      editingCell.blur();
+    }
   }
   if (!editingCell && e.key === 'Escape') {
     clearSelection();
   }
 });
 
+const isTextInputTarget = target => {
+  const el = getElementTarget(target);
+  return !!(el && (el.closest('input, textarea, select') || el.isContentEditable));
+};
+const pasteFromClipboard = () => {
+  if (editingCell) return;
+  const anchor = getPasteAnchorCoords();
+  if (!anchor) return;
+  vscode.postMessage({
+    type: 'pasteFromClipboard',
+    anchorRow: anchor.row,
+    anchorCol: anchor.col,
+    selection: getDataSelectionBounds() || undefined
+  });
+};
+for (const type of ['copy', 'cut']) {
+  document.addEventListener(type, e => {
+    if (editingCell || isTextInputTarget(e.target) || isGridControlTarget(e.target)) return;
+    if (copySelectionToClipboard(type === 'cut')) e.preventDefault();
+  });
+}
 document.addEventListener('paste', e => {
-  if (isFindWidgetTarget(e.target)) {
+  if (isTextInputTarget(e.target) || isGridControlTarget(e.target)) {
     return;
   }
   if (editingCell) {
@@ -1858,10 +2053,10 @@ document.addEventListener('paste', e => {
 
 const selectAllCells = () => { clearSelection(); document.querySelectorAll('td, th').forEach(cell => { cell.classList.add('selected'); currentSelection.push(cell); }); };
 
-const setCursorToEnd = cell => { setTimeout(() => { 
+const setCursorToEnd = cell => {
   const range = document.createRange(); range.selectNodeContents(cell); range.collapse(false);
   const sel = window.getSelection(); sel.removeAllRanges(); sel.addRange(range);
-}, 10); };
+};
 
 const setCursorToStart = cell => { setTimeout(() => {
   const range = document.createRange(); range.selectNodeContents(cell); range.collapse(true);
@@ -1894,7 +2089,7 @@ const setSingleSelection = cell => {
   rangeEndCell = cell;
   persistState();
   try { cell.focus({ preventScroll: true }); } catch { try { cell.focus(); } catch {} }
-  cell.scrollIntoView({ block: 'nearest', inline: 'nearest', behavior: 'smooth' });
+  scheduleCellReveal(cell);
 };
 
 const NEWLINE_SENTINEL_ATTR = 'data-csv-newline-sentinel';
@@ -1907,11 +2102,9 @@ const placeCaretBeforeSentinel = sentinel => {
   const sel = window.getSelection();
   if (!sel) return;
   const range = document.createRange();
-  if (sentinel.firstChild) {
-    range.setStart(sentinel.firstChild, 0);
-  } else {
-    range.setStartBefore(sentinel);
-  }
+  // Keep typed text outside the disposable placeholder. A text-bearing span
+  // would absorb new input and delete that input when the placeholder is removed.
+  range.setStartBefore(sentinel);
   range.collapse(true);
   sel.removeAllRanges();
   sel.addRange(range);
@@ -1919,9 +2112,8 @@ const placeCaretBeforeSentinel = sentinel => {
 
 const appendVisibleNewlineAtEnd = cell => {
   removeNewlineSentinels(cell);
-  const sentinel = document.createElement('span');
+  const sentinel = document.createElement('br');
   sentinel.setAttribute(NEWLINE_SENTINEL_ATTR, 'true');
-  sentinel.textContent = '\u200B';
   cell.appendChild(document.createTextNode('\n'));
   cell.appendChild(sentinel);
   placeCaretBeforeSentinel(sentinel);
@@ -1944,9 +2136,8 @@ const insertNewlineAtCaret = cell => {
   const atEnd = range.collapsed && isRangeAtEndOfCell(cell, range);
   range.deleteContents();
   if (atEnd) {
-    const sentinel = document.createElement('span');
+    const sentinel = document.createElement('br');
     sentinel.setAttribute(NEWLINE_SENTINEL_ATTR, 'true');
-    sentinel.textContent = '\u200B';
     const fragment = document.createDocumentFragment();
     fragment.appendChild(document.createTextNode('\n'));
     fragment.appendChild(sentinel);
@@ -1969,6 +2160,7 @@ const editCell = (cell, event, mode = 'detail') => {
   cell.classList.remove('selected');
   originalCellValue = cell.textContent;
   editingCell = cell;
+  vscode.postMessage({ type: 'cellEditStarted' });
   editMode = mode;
   cell.classList.add('editing');
   cell.setAttribute('contenteditable', 'true');
@@ -1977,7 +2169,9 @@ const editCell = (cell, event, mode = 'detail') => {
     removeNewlineSentinels(cell);
     const value = cell.textContent;
     const coords = getCellCoords(cell);
-    vscode.postMessage({ type: 'editCell', row: coords.row, col: coords.col, value: value });
+    if (!discardingFailedDraft) {
+      vscode.postMessage({ type: 'editCell', row: coords.row, col: coords.col, value: value });
+    }
     cell.removeAttribute('contenteditable');
     cell.classList.remove('editing');
     editingCell = null;
@@ -1996,6 +2190,7 @@ table.addEventListener('dblclick', e => {
     e.stopPropagation();
     if (edge.axis === 'column') {
       resetColumnWidth(edge.index);
+      persistColumnSizes();
     } else {
       resetRowHeight(edge.index);
     }
@@ -2017,32 +2212,48 @@ table.addEventListener('dblclick', e => {
   editCell(target, e);
 });
 
-const copySelectionToClipboard = () => {
-  if (currentSelection.length === 0) return;
-
-  // Only copy real data/header columns; skip serial index column (col === -1)
-  const coords = currentSelection
-    .map(cell => getCellCoords(cell))
-    .filter(c => !isNaN(c.row) && !isNaN(c.col) && c.col >= 0);
-  if (coords.length === 0) return;
-  const minRow = Math.min(...coords.map(c => c.row)), maxRow = Math.max(...coords.map(c => c.row));
-  const minCol = Math.min(...coords.map(c => c.col)), maxCol = Math.max(...coords.map(c => c.col));
-  let csv = '';
-  for(let r = minRow; r <= maxRow; r++){
-    let rowVals = [];
-    for(let c = minCol; c <= maxCol; c++){
-      const selector = (hasHeader && r === 0 ? 'th' : 'td') + '[data-row="'+r+'"][data-col="'+c+'"]';
-      const cell = table.querySelector(selector);
-      rowVals.push(cell ? cell.innerText : '');
+const copySelectionToClipboard = (cut = false) => {
+  const bounds = getDataSelectionBounds();
+  if (!bounds) return false;
+  const { minCol, maxCol } = bounds;
+  const realRowCount = Number(root.dataset.realrowcount);
+  // The append row is an editor affordance, never clipboard data. Consume an
+  // append-only gesture without a host write or native empty clipboard copy.
+  if (!Number.isSafeInteger(realRowCount) || realRowCount < 0) { return true; }
+  const matrix = [];
+  const rowIds = [...new Set(currentSelection.map(getDataCellCoords).filter(Boolean).map(coords => coords.row))]
+    .filter(row => row < realRowCount).sort((a, b) => a - b);
+  if (!rowIds.length) { return true; }
+  for (const row of rowIds) {
+    const values = [];
+    for (let col = minCol; col <= maxCol; col++) {
+      const cell = getRenderedCellByCoords(row, col);
+      values.push(cell ? cell.textContent : '');
     }
-    csv += rowVals.join(CSV_SEPARATOR) + '\n';
+    matrix.push(values);
   }
-  vscode.postMessage({ type: 'copyToClipboard', text: csv.trimEnd() });
+  vscode.postMessage({ type: 'copyCells', matrix, rowIds, startCol: minCol, cut });
+  return true;
 };
 
 window.addEventListener('message', event => {
   const message = event.data;
-  if(message.type === 'focus'){
+  if (message.type === 'prepareViewRefresh') {
+    if (editingCell) { editingCell.blur(); }
+    persistState();
+    vscode.postMessage({ type: 'viewRefreshReady', requestId: message.requestId, session: filterSession, filterDraft: window.csvColumnFilters?.captureDraft() });
+  } else if (message.type === 'columnFiltersResult') {
+    applyColumnFiltersResult(message);
+  } else if (message.type === 'frozenPanes') {
+    frozenRowCount = Number(message.rows);
+    frozenColumnCount = Number(message.columns);
+    window.csvFrozenPanes?.update(frozenRowCount, frozenColumnCount);
+  } else if (message.type === 'editCellFailed') {
+    failedCellDrafts.add(`${message.row}:${message.col}`);
+    const cell = table.querySelector(`[data-row="${message.row}"][data-col="${message.col}"]`);
+    if (message.retry && cell && !editingCell) { editCell(cell, undefined, 'detail'); }
+  } else if(message.type === 'focus'){
+    if (document.activeElement?.closest?.('#filterStatus')) return;
     if (anchorCell) {
       try { anchorCell.focus({ preventScroll: true }); } catch { try { anchorCell.focus(); } catch {} }
     } else {
@@ -2051,6 +2262,7 @@ window.addEventListener('message', event => {
   } else if (message.type === 'chunkData') {
     const requestId = Number(message.requestId);
     const start = Number(message.start);
+    if (message.session !== filterSession || Number(message.filterEpoch) !== filterEpoch) return;
     if (remoteChunkRequestInFlight) {
       if (!Number.isInteger(requestId) || requestId !== remoteChunkRequestSeq) {
         return;
@@ -2074,6 +2286,7 @@ window.addEventListener('message', event => {
       remoteNextChunkStart = -1;
       remoteHasMoreChunks = false;
     }
+    window.csvFrozenPanes?.schedule();
     if (csvChunks.length && pendingEnsureTarget) {
       ensureTargetStep();
     } else if (csvChunks.length && nearBottom()) {
@@ -2082,8 +2295,9 @@ window.addEventListener('message', event => {
   } else if(message.type === 'updateCell'){
     isUpdating = true;
     const { row, col, value, rendered } = message;
+    failedCellDrafts.delete(`${row}:${col}`);
     const cell = table.querySelector('td[data-row="'+row+'"][data-col="'+col+'"], th[data-row="'+row+'"][data-col="'+col+'"]');
-    if (cell) {
+    if (cell && cell !== editingCell) {
       if (typeof rendered === 'string') {
         cell.innerHTML = rendered;
       } else {
@@ -2095,6 +2309,7 @@ window.addEventListener('message', event => {
       scheduleFind(true);
     }
   } else if (message.type === 'pasteApplied') {
+    if (filterSnapshotPending || document.activeElement?.closest?.('#filterStatus')) return;
     const startRow = Number(message.startRow);
     const startCol = Number(message.startCol);
     const endRow = Number(message.endRow);
@@ -2116,7 +2331,7 @@ window.addEventListener('message', event => {
     selectRange({ row: startRow, col: startCol }, { row: endRow, col: endCol });
     persistState();
     try { startCell.focus({ preventScroll: true }); } catch { try { startCell.focus(); } catch {} }
-    endCell.scrollIntoView({ block:'nearest', inline:'nearest', behavior:'smooth' });
+    scheduleCellReveal(endCell);
   } else if (message.type === 'findMatchesResult') {
     if (!findReplaceState.open) {
       return;
@@ -2162,10 +2377,11 @@ window.addEventListener('message', event => {
 
 // After initial restoreState, if there's a pending edit request, perform it
 const maybeResumePendingEdit = () => {
+  if (document.activeElement?.closest?.('#filterStatus')) return;
   try {
     const st = vscode.getState() || {};
     if (st && typeof st.anchorRow === 'number' && typeof st.anchorCol === 'number' && st.pendingEdit === 'detail') {
-      const tag = (hasHeader && st.anchorRow === 0 ? 'th' : 'td');
+      const tag = (hasHeader && st.anchorRow === headerSourceRow ? 'th' : 'td');
       const sel = table.querySelector(`${tag}[data-row="${st.anchorRow}"][data-col="${st.anchorCol}"]`);
       if (sel) {
         editCell(sel, undefined, 'detail');
@@ -2180,14 +2396,149 @@ const maybeResumePendingEdit = () => {
 
 // Try after load and after visibility/focus restores
 setTimeout(maybeResumePendingEdit, 0);
-document.addEventListener('visibilitychange', () => { if (document.visibilityState === 'visible') setTimeout(maybeResumePendingEdit, 0); });
+document.addEventListener('visibilitychange', () => {
+  if (document.visibilityState === 'visible') {
+    setTimeout(maybeResumePendingEdit, 0);
+  } else if (editingCell) {
+    editingCell.blur();
+  }
+});
+window.addEventListener('blur', () => {
+  if (editingCell) editingCell.blur();
+});
 window.addEventListener('focus', () => { setTimeout(maybeResumePendingEdit, 0); }, { passive: true });
 
 document.addEventListener('keydown', e => {
-  if (findReplaceState.open) {
+  if (findReplaceState.open || isGridControlTarget(e.target)) {
     return;
   }
   if(!editingCell && e.key === 'Escape'){
     clearSelection();
   }
 });
+
+// A partial filter redraw keeps the delegated table and focused controls alive.
+const initializeFrozenPanes = () => {
+  window.csvFrozenPanes?.dispose();
+  if (typeof window.createFrozenPaneManager !== 'function') return;
+  window.csvFrozenPanes = window.createFrozenPaneManager({
+    table,
+    firstRow: Number(root?.dataset?.firstrow || '0'),
+    realRowCount: Number(root?.dataset?.realrowcount || '0'),
+    rowOrder: visibleRowOrder,
+    topInset: () => document.getElementById('filterStatus')?.getBoundingClientRect().height || 0,
+    onNeedRows: () => loadNextChunk()
+  });
+  window.csvFrozenPanes.update(frozenRowCount, frozenColumnCount);
+};
+initializeFrozenPanes();
+window.addEventListener('csvChunkLoaded', () => window.csvFrozenPanes?.schedule());
+window.addEventListener('resize', () => window.csvFrozenPanes?.schedule());
+window.addEventListener('pagehide', () => window.csvFrozenPanes?.dispose(), { once: true });
+const invalidateFilterFind = () => {
+  clearTimeout(findDebounce);
+  latestFindRequestId = ++findRequestSeq;
+  pendingFindRequests.clear();
+  clearFindHighlights();
+  findMatches = [];
+  findMatchKeySet = new Set();
+  currentMatchIndex = -1;
+  updateFindStatus();
+  updateFindControls();
+};
+const setFilterPending = pending => {
+  filterSnapshotPending = pending;
+  table.toggleAttribute('inert', pending);
+  table.setAttribute('aria-busy', String(pending));
+  if (pending) {
+    pendingCellReveal = null;
+    if (editingCell) editingCell.blur();
+    invalidateFilterFind();
+  }
+};
+const submitColumnFilters = snapshot => {
+  if (editingCell) editingCell.blur();
+  vscode.postMessage({ type: 'updateColumnFilters', ...snapshot, session: filterSession });
+};
+const applyColumnFiltersResult = message => {
+  if (message.session !== filterSession || !window.csvColumnFilters || message.revision !== window.csvColumnFilters.latestRevision) return;
+  // A newly started draft must reach the host before any replacement render.
+  if (editingCell) {
+    editingCell.blur();
+    window.csvColumnFilters.retry();
+    return;
+  }
+  if (!window.csvColumnFilters.receive(message)) return;
+  if (failedCellDrafts.size) { setFilterPending(false); return; }
+  const epoch = Number(message.filterEpoch);
+  if (typeof message.tableHtml === 'string' && Number.isSafeInteger(epoch) && epoch >= 0 &&
+      (!(message.error || message.errors?.length) || epoch !== filterEpoch)) {
+    const parsed = document.createElement('template');
+    parsed.innerHTML = message.tableHtml;
+    const replacement = parsed.content.querySelector('table');
+    if (!replacement) return;
+    const priorAnchor = anchorCell ? getCellCoords(anchorCell) : null;
+    clearSelection();
+    anchorCell = rangeEndCell = startCell = endCell = null;
+    isSelecting = false;
+    selectionMode = 'cell';
+    resizeState = reorderState = null;
+    table.style.cursor = '';
+    hideDragIndicator();
+    pendingEnsureTarget = null;
+    pendingCellReveal = null;
+    invalidateFilterFind();
+    chunkObserver?.disconnect();
+    remoteChunkRequestInFlight = false;
+    remoteChunkRequestedStart = -1;
+    remoteChunkRequestSeq += 1;
+    filterEpoch = epoch;
+    table.replaceChildren(...Array.from(replacement.childNodes));
+    hasHeader = !!table.tHead;
+    headerEnabled = message.headerEnabled === true;
+    root.dataset.headerenabled = headerEnabled ? '1' : '0';
+    headerSourceRow = Number(message.firstVisibleRow);
+    root.dataset.firstrow = String(message.firstVisibleRow);
+    root.dataset.realrowcount = String(message.realRowCount);
+    visibleRowOrder.length = 0;
+    for (const row of Array.isArray(message.visibleRowIds) ? message.visibleRowIds : []) visibleRowOrder.push(row);
+    root.dataset.roworder = JSON.stringify(visibleRowOrder);
+    root.dataset.filtered = message.filters?.length ? '1' : '0';
+    try { csvChunks = JSON.parse(message.chunksJson || '[]'); } catch { csvChunks = []; }
+    remoteNextChunkStart = Number.isInteger(message.nextChunkStart) ? message.nextChunkStart : -1;
+    remoteHasMoreChunks = !!message.hasRemoteChunks && remoteNextChunkStart >= 0;
+    root.dataset.nextchunkstart = remoteNextChunkStart >= 0 ? String(remoteNextChunkStart) : '';
+    root.dataset.hasmorechunks = remoteHasMoreChunks ? '1' : '0';
+    if (chunkTemplate) chunkTemplate.textContent = JSON.stringify(csvChunks);
+    const colors = document.getElementById('__csvColumnColors');
+    if (colors && typeof message.colorCss === 'string') colors.textContent = message.colorCss;
+    if (priorAnchor) {
+      const cell = getRenderedCellByCoords(priorAnchor.row, priorAnchor.col);
+      if (cell) { cell.classList.add('selected'); currentSelection.push(cell); anchorCell = rangeEndCell = cell; }
+    }
+    applySizeStateToRenderedCells();
+    initializeFrozenPanes();
+    primeChunks();
+    persistState();
+    replaceAll.title = message.filters?.length ? 'Replace All in matching filtered rows' : 'Replace All';
+  }
+  setFilterPending(false);
+  if (findReplaceState.open && findInput.value) runFind(true);
+};
+const filterStatus = document.getElementById('filterStatus');
+if (filterStatus && typeof window.createColumnFilterControls === 'function') {
+  window.csvColumnFilters = window.createColumnFilterControls({
+    root: filterStatus,
+    metadata: filterMetadata,
+    onChange: submitColumnFilters,
+    onActivity: () => vscode.postMessage({ type: 'filterDraftChanged', session: filterSession }),
+    onPending: setFilterPending,
+    onLayout: () => window.csvFrozenPanes?.schedule()
+  });
+  if (typeof ResizeObserver === 'function') new ResizeObserver(() => window.csvFrozenPanes?.schedule()).observe(filterStatus);
+}
+for (const button of [replaceOne, replaceAll]) button.addEventListener('click', event => {
+  if (filterSnapshotPending) { event.preventDefault(); event.stopImmediatePropagation(); }
+}, true);
+// The host may be waiting to commit a draft while this webview initializes.
+vscode.postMessage({ type: 'webviewReady' });
diff --git a/media/table-comparison.js b/media/table-comparison.js
new file mode 100644
index 0000000..bbd0607
--- /dev/null
+++ b/media/table-comparison.js
@@ -0,0 +1,89 @@
+const vscode = acquireVsCodeApi();
+const original = document.getElementById('original');
+const modified = document.getElementById('modified');
+let page = 0;
+let pendingFocus;
+let alignFrame;
+let synchronizing = false;
+const expectedScroll = new WeakMap();
+
+const alignRows = () => {
+  const left = Array.from(original.querySelectorAll('tbody tr'));
+  const right = Array.from(modified.querySelectorAll('tbody tr'));
+  [...left, ...right].forEach(row => { row.style.height = ''; });
+  left.forEach((row, index) => {
+    if (!right[index]) return;
+    const height = Math.ceil(Math.max(row.getBoundingClientRect().height, right[index].getBoundingClientRect().height));
+    row.style.height = right[index].style.height = `${height}px`;
+  });
+  if (Number.isInteger(pendingFocus)) {
+    [original, modified].forEach(pane => {
+      const row = pane.querySelector(`[data-align="${pendingFocus}"]`);
+      if (row) {
+        row.classList.add('focused');
+        const header = pane.querySelector('thead');
+        pane.scrollTop = Math.max(0, pane.scrollTop + row.getBoundingClientRect().top - pane.getBoundingClientRect().top - pane.clientTop - (header?.getBoundingClientRect().height || 0));
+      }
+    });
+    pendingFocus = undefined;
+  }
+};
+const queueAlignment = () => {
+  if (alignFrame) cancelAnimationFrame(alignFrame);
+  alignFrame = requestAnimationFrame(alignRows);
+};
+
+[[original, modified], [modified, original]].forEach(([source, target]) => {
+  source.addEventListener('scroll', () => {
+    if (synchronizing) return;
+    const expected = expectedScroll.get(source);
+    if (expected && Math.abs(source.scrollTop - expected.top) < 1 && Math.abs(source.scrollLeft - expected.left) < 1) {
+      expectedScroll.delete(source);
+      return;
+    }
+    expectedScroll.set(target, { top: source.scrollTop, left: source.scrollLeft });
+    synchronizing = true;
+    target.scrollTop = source.scrollTop;
+    target.scrollLeft = source.scrollLeft;
+    synchronizing = false;
+  }, { passive: true });
+});
+
+const buttons = ['previousPage', 'nextPage', 'previousChange', 'nextChange'].map(id => document.getElementById(id));
+const request = message => {
+  buttons.forEach(button => { button.disabled = true; });
+  vscode.postMessage(message);
+};
+buttons[0].addEventListener('click', () => request({ type: 'page', index: page - 1 }));
+buttons[1].addEventListener('click', () => request({ type: 'page', index: page + 1 }));
+buttons[2].addEventListener('click', () => request({ type: 'change', direction: -1 }));
+buttons[3].addEventListener('click', () => request({ type: 'change', direction: 1 }));
+window.addEventListener('message', event => {
+  const message = event.data;
+  if (message.type !== 'comparison') return;
+  original.innerHTML = message.originalHtml;
+  modified.innerHTML = message.modifiedHtml;
+  [original, modified].forEach(pane => {
+    const table = pane.querySelector('table');
+    if (table) table.style.width = `${60 + Number(table.dataset.columns) * 180}px`;
+    pane.scrollTop = pane.scrollLeft = 0;
+    expectedScroll.delete(pane);
+  });
+  page = message.page;
+  document.getElementById('status').textContent = message.status;
+  document.getElementById('error').textContent = message.error || '';
+  document.getElementById('notice').textContent = message.notice || '';
+  buttons[0].disabled = page <= 0;
+  buttons[1].disabled = page >= message.pageCount - 1;
+  buttons[2].disabled = !message.canPreviousChange;
+  buttons[3].disabled = !message.canNextChange;
+  pendingFocus = message.focusRecord;
+  queueAlignment();
+});
+if (typeof ResizeObserver === 'function') {
+  const observer = new ResizeObserver(queueAlignment);
+  observer.observe(original);
+  observer.observe(modified);
+}
+window.addEventListener('resize', queueAlignment);
+request({ type: 'ready' });
diff --git a/package-lock.json b/package-lock.json
index fe4da3a..fa94b49 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,15 +1,16 @@
 {
   "name": "csv",
-  "version": "1.3.0",
+  "version": "1.4.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "csv",
-      "version": "1.3.0",
+      "version": "1.4.2",
       "dependencies": {
         "font-list": "^1.5.1",
-        "papaparse": "^5.5.3"
+        "papaparse": "^5.5.3",
+        "re2js": "1.3.3"
       },
       "devDependencies": {
         "@types/node": "^20.11.19",
@@ -19,6 +20,8 @@
         "@typescript-eslint/parser": "^7.9.0",
         "@vscode/vsce": "^3.7.1",
         "eslint": "^8.57.0",
+        "iconv-lite": "^0.6.3",
+        "jsdom": "^26.1.0",
         "typescript": "^4.4.3",
         "vscode": "^1.1.37"
       },
@@ -27,6 +30,27 @@
         "vscode": "^1.70.0"
       }
     },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
+      "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.3",
+        "@csstools/css-color-parser": "^3.0.9",
+        "@csstools/css-parser-algorithms": "^3.0.4",
+        "@csstools/css-tokenizer": "^3.0.3",
+        "lru-cache": "^10.4.3"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color/node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/@azu/format-text": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/@azu/format-text/-/format-text-1.0.2.tgz",
@@ -238,6 +262,121 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.4.1",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.1.tgz",
@@ -1806,6 +1945,34 @@
         "url": "https://github.com/sponsors/fb55"
       }
     },
+    "node_modules/cssstyle": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",
+      "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^3.2.0",
+        "rrweb-cssom": "^0.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/data-urls": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",
+      "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/debug": {
       "version": "4.4.3",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -1824,6 +1991,13 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/decompress-response": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
@@ -2869,6 +3043,19 @@
         "node": ">=10"
       }
     },
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/htmlparser2": {
       "version": "10.1.0",
       "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
@@ -3131,6 +3318,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/is-wsl": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/is-wsl/-/is-wsl-3.1.0.tgz",
@@ -3208,6 +3402,84 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/jsdom": {
+      "version": "26.1.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
+      "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssstyle": "^4.2.1",
+        "data-urls": "^5.0.0",
+        "decimal.js": "^10.5.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "nwsapi": "^2.2.16",
+        "parse5": "^7.2.1",
+        "rrweb-cssom": "^0.8.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^5.1.1",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^7.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.1.1",
+        "ws": "^8.18.0",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/jsdom/node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/jsdom/node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/jsdom/node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/json-buffer": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
@@ -3741,6 +4013,13 @@
         "url": "https://github.com/fb55/nth-check?sponsor=1"
       }
     },
+    "node_modules/nwsapi": {
+      "version": "2.2.28",
+      "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.28.tgz",
+      "integrity": "sha512-IlVB7OS7qrOsVYlpnFIkETjMwT9jwvmocJmmM+GZU/PAB3uGi9Ezd7vcWhWBUnSc0ya4ppmQITOyP1ez9gg8cg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/object-inspect": {
       "version": "1.13.4",
       "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.4.tgz",
@@ -4250,6 +4529,12 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/re2js": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/re2js/-/re2js-1.3.3.tgz",
+      "integrity": "sha512-s/I5zEAo79SUK0Qw4dpZKpiMwbQ6Gz0KU2NRr7eaO4x/p2g7Vvmn3hdeXDg8VsaUjfj/ora+e9oi27LX/C9+mw==",
+      "license": "MIT"
+    },
     "node_modules/read": {
       "version": "1.0.7",
       "resolved": "https://registry.npmjs.org/read/-/read-1.0.7.tgz",
@@ -4406,6 +4691,13 @@
         "node": "*"
       }
     },
+    "node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/run-applescript": {
       "version": "7.1.0",
       "resolved": "https://registry.npmjs.org/run-applescript/-/run-applescript-7.1.0.tgz",
@@ -4481,6 +4773,19 @@
         "node": ">=11.0.0"
       }
     },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/secretlint": {
       "version": "10.2.2",
       "resolved": "https://registry.npmjs.org/secretlint/-/secretlint-10.2.2.tgz",
@@ -4950,6 +5255,13 @@
         "url": "https://github.com/chalk/supports-hyperlinks?sponsor=1"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/table": {
       "version": "6.9.0",
       "resolved": "https://registry.npmjs.org/table/-/table-6.9.0.tgz",
@@ -5086,6 +5398,26 @@
         "url": "https://bevry.me/fund"
       }
     },
+    "node_modules/tldts": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",
+      "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^6.1.86"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",
+      "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tmp": {
       "version": "0.2.5",
       "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
@@ -5109,6 +5441,32 @@
         "node": ">=8.0"
       }
     },
+    "node_modules/tough-cookie": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
+      "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^6.1.32"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/ts-api-utils": {
       "version": "1.4.3",
       "resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-1.4.3.tgz",
@@ -5599,6 +5957,29 @@
         "node": ">=4"
       }
     },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/whatwg-encoding": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
@@ -5623,6 +6004,20 @@
         "node": ">=18"
       }
     },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -5656,6 +6051,28 @@
       "dev": true,
       "license": "ISC"
     },
+    "node_modules/ws": {
+      "version": "8.22.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.0.tgz",
+      "integrity": "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/wsl-utils": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/wsl-utils/-/wsl-utils-0.1.0.tgz",
@@ -5672,6 +6089,16 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/xml2js": {
       "version": "0.5.0",
       "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.5.0.tgz",
@@ -5696,6 +6123,13 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/yallist": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
diff --git a/package.json b/package.json
index 31d2bda..8b82a6c 100644
--- a/package.json
+++ b/package.json
@@ -2,13 +2,13 @@
   "name": "csv",
   "displayName": "CSV",
   "publisher": "ReprEng",
-  "description": "Seamlessly Display and Edit CSVs",
+  "description": "View and edit CSV, TSV, TAB, and PSV files as tables.",
   "icon": "images/icon.jpg",
   "repository": {
     "type": "git",
     "url": "https://github.com/jonaraphael/csv.git"
   },
-  "version": "1.3.0",
+  "version": "1.4.2",
   "engines": {
     "vscode": "^1.70.0",
     "node": ">=14"
@@ -19,9 +19,15 @@
     "Other"
   ],
   "activationEvents": [
+    "onStartupFinished",
     "onLanguage:csv",
     "onLanguage:tsv",
     "onCommand:csv.toggleExtension",
+    "onCommand:csv.openLargeFilePreview",
+    "onCommand:csv.compareFilesAsTable",
+    "onCustomEditor:csv.largeFilePreview",
+    "onCommand:csv.toggleEditor",
+    "onCommand:csv.saveUntitled",
     "onCommand:csv.toggleHeader",
     "onCommand:csv.toggleSerialIndex",
     "onCommand:csv.changeSeparator",
@@ -29,7 +35,9 @@
     "onCommand:csv.changeFontFamily",
     "onCommand:csv.changeIgnoreRows",
     "onCommand:csv.changeEncoding",
-    "onCommand:csv.toggleClickableLinks"
+    "onCommand:csv.toggleClickableLinks",
+    "onCommand:csv.changeFrozenRows",
+    "onCommand:csv.changeFrozenColumns"
   ],
   "main": "./out/extension.js",
   "contributes": {
@@ -64,6 +72,25 @@
       }
     ],
     "commands": [
+      {
+        "command": "csv.openLargeFilePreview",
+        "title": "CSV: Open Large File Preview (Read-only)"
+      },
+      {
+        "command": "csv.toggleEditor",
+        "title": "CSV: Switch Between Table and Text",
+        "icon": "$(arrow-swap)"
+      },
+      {
+        "command": "csv.compareFilesAsTable",
+        "title": "CSV: Compare Files as Table"
+      },
+      {
+        "command": "csv.saveUntitled",
+        "title": "CSV: Save Untitled Document As\u2026",
+        "icon": "$(save)",
+        "enablement": "activeWebviewPanelId == csv.untitledEditor"
+      },
       {
         "command": "csv.toggleExtension",
         "title": "CSV: Toggle Extension On/Off"
@@ -99,8 +126,48 @@
       {
         "command": "csv.toggleClickableLinks",
         "title": "CSV: Toggle Clickable Links"
+      },
+      {
+        "command": "csv.changeFrozenRows",
+        "title": "CSV: Freeze Leading Rows"
+      },
+      {
+        "command": "csv.changeFrozenColumns",
+        "title": "CSV: Freeze Leading Columns"
       }
     ],
+    "menus": {
+      "editor/title": [
+        {
+          "command": "csv.toggleEditor",
+          "when": "!isInDiffEditor && (activeCustomEditorId == csv.editor || activeWebviewPanelId == csv.untitledEditor || (activeEditor == workbench.editors.files.textFileEditor && resourceScheme != untitled && resourceExtname =~ /\\.(csv|tsv|tab|psv)$/i) || (activeEditor == workbench.editors.textResourceEditor && resourceScheme == untitled && editorLangId =~ /^(csv|tsv)$/))",
+          "group": "navigation"
+        },
+        {
+          "command": "csv.saveUntitled",
+          "when": "activeWebviewPanelId == csv.untitledEditor",
+          "group": "navigation@1"
+        }
+      ],
+      "commandPalette": [
+        {
+          "command": "csv.saveUntitled",
+          "when": "activeWebviewPanelId == csv.untitledEditor"
+        }
+      ],
+      "explorer/context": [
+        {
+          "command": "csv.compareFilesAsTable",
+          "when": "resourceExtname =~ /\\.(csv|tsv|tab|psv)$/i && config.csv.enabled",
+          "group": "navigation"
+        },
+        {
+          "command": "csv.openLargeFilePreview",
+          "when": "resourceScheme == file && resourceExtname =~ /\\.(csv|tsv|tab|psv)$/i && config.csv.enabled",
+          "group": "navigation"
+        }
+      ]
+    },
     "configuration": {
       "type": "object",
       "title": "CSV Extension Configuration",
@@ -113,7 +180,7 @@
         "csv.fontFamily": {
           "type": "string",
           "default": "",
-          "description": "Font family used by the CSV custom editor. Leave empty to inherit ‘editor.fontFamily’.",
+          "description": "Font family used by the CSV custom editor. Leave empty to inherit \u2018editor.fontFamily\u2019.",
           "scope": "application"
         },
         "csv.fontSize": {
@@ -207,10 +274,36 @@
           "default": 10,
           "minimum": 0,
           "description": "Soft max size in MB for opening files in CSV view. 0 disables the limit. When exceeded, CSV prompts to cancel, continue this time, or disable the limit."
+        },
+        "csv.defaultIgnoreRows": {
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "scope": "resource",
+          "description": "Default number of initial metadata rows to hide without deleting them. Per-file Hide First N Rows values override this default; leave that command blank to inherit again."
+        },
+        "csv.largeFilePreviewRows": {
+          "type": "integer",
+          "default": 1000,
+          "minimum": 1,
+          "maximum": 10000,
+          "scope": "resource",
+          "description": "Maximum records per read-only Large File Preview page. Byte/cell safety limits can produce smaller pages."
         }
       }
     },
     "customEditors": [
+      {
+        "viewType": "csv.largeFilePreview",
+        "displayName": "CSV Large File Preview (Read-only)",
+        "priority": "option",
+        "selector": [
+          { "filenamePattern": "*.csv" },
+          { "filenamePattern": "*.tsv" },
+          { "filenamePattern": "*.tab" },
+          { "filenamePattern": "*.psv" }
+        ]
+      },
       {
         "viewType": "csv.editor",
         "displayName": "CSV",
@@ -240,7 +333,8 @@
   },
   "dependencies": {
     "font-list": "^1.5.1",
-    "papaparse": "^5.5.3"
+    "papaparse": "^5.5.3",
+    "re2js": "1.3.3"
   },
   "devDependencies": {
     "@types/node": "^20.11.19",
@@ -250,6 +344,8 @@
     "@typescript-eslint/parser": "^7.9.0",
     "@vscode/vsce": "^3.7.1",
     "eslint": "^8.57.0",
+    "iconv-lite": "^0.6.3",
+    "jsdom": "^26.1.0",
     "typescript": "^4.4.3",
     "vscode": "^1.1.37"
   }
diff --git a/scripts/editor-switch-smoke.cjs b/scripts/editor-switch-smoke.cjs
new file mode 100644
index 0000000..3cd8964
--- /dev/null
+++ b/scripts/editor-switch-smoke.cjs
@@ -0,0 +1,99 @@
+// Run in an isolated VS Code development host using --extensionTestsPath.
+const assert = require('assert').strict;
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vscode = require('vscode');
+const { CsvEditorProvider } = require('../out/CsvEditorProvider');
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+function tabsFor(uri, column) {
+  return vscode.window.tabGroups.all.find(group => group.viewColumn === column).tabs.filter(tab => tab.input.uri?.toString() === uri.toString());
+}
+function snapshotOtherGroups(column) {
+  return vscode.window.tabGroups.all.filter(group => group.viewColumn !== column).map(group => ({
+    column: group.viewColumn,
+    tabs: group.tabs.map(tab => ({ uri: tab.input.uri?.toString(), type: tab.input.viewType || 'text', dirty: tab.isDirty }))
+  }));
+}
+exports.run = async function () {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'csv-editor-switch-'));
+  await vscode.extensions.getExtension('ReprEng.csv').activate();
+  try {
+    const unrelatedPath = path.join(directory, 'unrelated.csv');
+    const otherPath = path.join(directory, 'other-group.csv');
+    fs.writeFileSync(unrelatedPath, 'leave,this\nalone,1');
+    fs.writeFileSync(otherPath, 'other,group\nkeep,2');
+    const unrelated = vscode.Uri.file(unrelatedPath);
+    await vscode.commands.executeCommand('vscode.openWith', unrelated, 'default', { preview: false });
+    const sourceColumn = vscode.window.tabGroups.activeTabGroup.viewColumn;
+    await vscode.commands.executeCommand('vscode.openWith', vscode.Uri.file(otherPath), 'default', { viewColumn: vscode.ViewColumn.Beside, preview: false });
+    const otherSnapshot = snapshotOtherGroups(sourceColumn);
+
+    for (const [suffix, separator] of [['csv', ','], ['tsv', '\t'], ['tab', '\t'], ['psv', '|']]) {
+      const filename = path.join(directory, `data.${suffix}`);
+      const contents = `name${separator}value\nfirst${separator}1`;
+      let expected = contents.replace('first', 'unsaved-first');
+      fs.writeFileSync(filename, contents);
+      const uri = vscode.Uri.file(filename);
+      await vscode.commands.executeCommand('vscode.openWith', uri, 'default', { viewColumn: sourceColumn, preview: false });
+      const edit = new vscode.WorkspaceEdit(); edit.insert(uri, new vscode.Position(1, 0), 'unsaved-');
+      assert.equal(await vscode.workspace.applyEdit(edit), true);
+      for (let round = 0; round < 2; round++) {
+        for (const viewType of ['csv.editor', 'default']) {
+          await vscode.commands.executeCommand('csv.toggleEditor');
+          const group = vscode.window.tabGroups.activeTabGroup;
+          const tabs = tabsFor(uri, sourceColumn);
+          assert.equal(group.viewColumn, sourceColumn);
+          assert.equal(tabs.length, 1, 'only one representation may remain after a switch');
+          if (viewType === 'csv.editor') { assert.equal(group.activeTab.input.viewType, viewType); }
+          else { assert.ok(group.activeTab.input instanceof vscode.TabInputText); }
+          const live = vscode.workspace.textDocuments.find(document => document.uri.toString() === uri.toString());
+          assert.ok(live); assert.equal(live.isDirty, true); assert.equal(live.getText(), expected);
+          assert.equal(fs.readFileSync(filename, 'utf8'), contents, 'switching must not save');
+          assert.deepEqual(snapshotOtherGroups(sourceColumn), otherSnapshot);
+          const untouched = tabsFor(unrelated, sourceColumn);
+          assert.equal(untouched.length, 1); assert.ok(untouched[0].input instanceof vscode.TabInputText, 'normalization must leave unrelated tabs alone');
+          if (viewType === 'csv.editor' && round === 0) {
+            const controller = CsvEditorProvider.getActiveProvider();
+            void controller.enqueueOperation(() => controller.updateDocument(1, 1, '1\nqueued draft'));
+            expected = `name${separator}value\nunsaved-first${separator}"1\nqueued draft"`;
+          }
+        }
+      }
+      if (suffix === 'csv') {
+        // Recreate the previous draft's two-view state, then ensure replacement
+        // reuses its existing counterpart and removes only the original source.
+        await vscode.commands.executeCommand('vscode.openWith', uri, 'csv.editor', { viewColumn: sourceColumn, preview: false });
+        await vscode.commands.executeCommand('vscode.openWith', uri, 'default', { viewColumn: sourceColumn, preview: false });
+        assert.equal(tabsFor(uri, sourceColumn).length, 2);
+        await vscode.commands.executeCommand('csv.toggleEditor');
+        assert.equal(tabsFor(uri, sourceColumn).length, 1);
+        assert.equal(vscode.workspace.textDocuments.find(document => document.uri.toString() === uri.toString()).getText(), expected);
+        assert.equal(fs.readFileSync(filename, 'utf8'), contents);
+        assert.deepEqual(snapshotOtherGroups(sourceColumn), otherSnapshot);
+      }
+    }
+
+    const cancelPath = path.join(directory, 'cancel.csv');
+    fs.writeFileSync(cancelPath, 'name,value\noriginal,1');
+    const cancelUri = vscode.Uri.file(cancelPath);
+    await vscode.commands.executeCommand('vscode.openWith', cancelUri, 'default', { viewColumn: sourceColumn, preview: false });
+    const edit = new vscode.WorkspaceEdit(); edit.insert(cancelUri, new vscode.Position(1, 0), 'unsaved-');
+    await vscode.workspace.applyEdit(edit);
+    await vscode.workspace.getConfiguration('csv').update('maxFileSizeMB', 0.000001, vscode.ConfigurationTarget.Global);
+    // Return the same result as pressing Cancel in the large-file prompt; the
+    // extension-test host refuses modal dialogs instead of displaying them.
+    const showWarning = vscode.window.showWarningMessage;
+    vscode.window.showWarningMessage = async () => undefined;
+    try { await vscode.commands.executeCommand('csv.toggleEditor'); }
+    finally { vscode.window.showWarningMessage = showWarning; }
+    await sleep(200);
+    const live = vscode.workspace.textDocuments.find(document => document.uri.toString() === cancelUri.toString());
+    assert.ok(live && live.isDirty, 'cancelled target initialization must retain the dirty owner');
+    assert.equal(live.getText(), 'name,value\nunsaved-original,1');
+    assert.equal(tabsFor(cancelUri, sourceColumn).length, 1);
+    assert.ok(tabsFor(cancelUri, sourceColumn)[0].input instanceof vscode.TabInputText, 'cancellation keeps the source');
+    assert.equal(fs.readFileSync(cancelPath, 'utf8'), 'name,value\noriginal,1');
+    console.log('CSV_SWITCH_SMOKE_OK: dirty CSV/TSV/TAB/PSV, queued multiline edits, one representation, counterpart reuse, unrelated tabs unchanged, other groups unchanged, target cancellation retained');
+  } finally { fs.rmSync(directory, { recursive: true, force: true }); }
+};
diff --git a/scripts/untitled-editor-smoke.cjs b/scripts/untitled-editor-smoke.cjs
new file mode 100644
index 0000000..e86888b
--- /dev/null
+++ b/scripts/untitled-editor-smoke.cjs
@@ -0,0 +1,119 @@
+// Run in an isolated VS Code development host using --extensionTestsPath.
+const assert = require('assert').strict;
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const vscode = require('vscode');
+const { CsvEditorProvider } = require('../out/CsvEditorProvider');
+const { getActiveUntitledCsvEditor } = require('../out/untitled-editors');
+
+async function waitUntil(predicate, message) {
+  const deadline = Date.now() + 5000;
+  while (!predicate()) {
+    if (Date.now() > deadline) { throw new Error(message); }
+    await new Promise(resolve => setTimeout(resolve, 20));
+  }
+}
+async function prepare(document, language, content) {
+  await vscode.window.showTextDocument(document, { preview: false });
+  const edit = new vscode.WorkspaceEdit();
+  edit.insert(document.uri, new vscode.Position(0, 0), content);
+  assert.equal(await vscode.workspace.applyEdit(edit), true);
+  const live = await vscode.languages.setTextDocumentLanguage(document, language);
+  await waitUntil(() => getActiveUntitledCsvEditor()?.document === live, 'language mode should open the untitled table');
+  assert.equal(live.getText(), content);
+  assert.ok(vscode.window.tabGroups.all.flatMap(group => group.tabs).some(tab => tab.input.uri?.toString() === live.uri.toString() && tab.isDirty), 'native source must retain its unsaved state');
+  return live;
+}
+
+exports.run = async function () {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'csv-untitled-'));
+  await vscode.extensions.getExtension('ReprEng.csv').activate();
+  try {
+    for (const language of ['csv', 'tsv']) {
+      const separator = language === 'tsv' ? '\t' : ',';
+      const filename = path.join(directory, `saved.${language}`);
+      const uri = vscode.Uri.file(filename).with({ scheme: 'untitled' });
+      const document = await vscode.workspace.openTextDocument(uri);
+      await vscode.languages.setTextDocumentLanguage(document, 'plaintext');
+      const contents = `name${separator}value\nnew${separator}42`;
+      let live = await prepare(document, language, contents);
+      await new Promise(resolve => setTimeout(resolve, 200));
+      await vscode.workspace.getConfiguration('csv').update('enabled', false, vscode.ConfigurationTarget.Global);
+      await waitUntil(() => vscode.window.activeTextEditor?.document.uri.toString() === live.uri.toString() && !getActiveUntitledCsvEditor(), 'disabling should reveal the native untitled owner');
+      assert.equal(live.getText(), contents);
+      assert.equal(fs.existsSync(filename), false, 'disabling must not save');
+      await vscode.workspace.getConfiguration('csv').update('enabled', true, vscode.ConfigurationTarget.Global);
+      await waitUntil(() => getActiveUntitledCsvEditor()?.document === live, 'enabling should safely reopen associated-path untitled buffers');
+      assert.equal(live.getText(), contents);
+      let controller = CsvEditorProvider.getActiveProvider();
+      assert.ok(controller);
+      assert.equal(controller.getCurrentSeparator(), separator);
+      const oppositeLanguage = language === 'csv' ? 'tsv' : 'csv';
+      live = await vscode.languages.setTextDocumentLanguage(live, oppositeLanguage);
+      await waitUntil(() => getActiveUntitledCsvEditor()?.document === live && controller.getCurrentSeparator() === (oppositeLanguage === 'tsv' ? '\t' : ','), 'native language rebind should use its logical extension');
+      assert.equal(live.getText(), contents, 'language change must not convert source data');
+      live = await vscode.languages.setTextDocumentLanguage(live, language);
+      await waitUntil(() => getActiveUntitledCsvEditor()?.document === live && controller.getCurrentSeparator() === separator, 'native language roundtrip should restore its logical extension');
+      assert.equal(live.getText(), contents);
+      await controller.updateDocument(1, 1, '43');
+      const expected = `name${separator}value\nnew${separator}43`;
+      assert.equal(live.getText(), expected);
+      const previousPanel = getActiveUntitledCsvEditor().panel;
+      await vscode.commands.executeCommand('csv.toggleEditor');
+      assert.equal(vscode.window.activeTextEditor.document.uri.toString(), live.uri.toString());
+      assert.equal(vscode.window.activeTextEditor.document.getText(), expected);
+      assert.equal(getActiveUntitledCsvEditor(), undefined, 'source switch closes only the standalone table');
+      assert.equal(live.isClosed, false, 'native unsaved owner remains live');
+      assert.equal(fs.existsSync(filename), false, 'source switching must not save');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      assert.ok(vscode.window.activeTextEditor, 'explicit source switch must stay in source');
+      await vscode.commands.executeCommand('csv.toggleEditor');
+      await waitUntil(() => getActiveUntitledCsvEditor()?.document === live, 'switch should recreate the untitled grid against the same owner');
+      assert.notEqual(getActiveUntitledCsvEditor().panel, previousPanel);
+      controller = CsvEditorProvider.getActiveProvider();
+      const savedExpected = `name${separator}value\nnew${separator}"43\nqueued"`;
+      void controller.enqueueOperation(() => controller.updateDocument(1, 1, '43\nqueued'));
+      await vscode.commands.executeCommand('csv.saveUntitled');
+      await waitUntil(() => live.isClosed && fs.existsSync(filename) && fs.readFileSync(filename, 'utf8') === savedExpected && !CsvEditorProvider.editors.some(candidate => candidate.getDocumentUri().toString() === live.uri.toString()), 'registered native save should finish writing exact bytes and close the temporary grid');
+      assert.equal(fs.readFileSync(filename, 'utf8'), savedExpected);
+      await vscode.commands.executeCommand('vscode.openWith', vscode.Uri.file(filename), 'csv.editor', { preview: false });
+      assert.equal(CsvEditorProvider.getActiveProvider().getCurrentSeparator(), separator);
+    }
+
+    const document = await vscode.workspace.openTextDocument({ language: 'plaintext' });
+    const live = await prepare(document, 'csv', 'name,value\ncancel,42');
+    const panel = getActiveUntitledCsvEditor().panel;
+    const controller = CsvEditorProvider.getActiveProvider();
+    // Exercise the cancellation result without opening an interactive native picker.
+    // Associated-path documents above exercise actual native saving and disk bytes.
+    const executeCommand = vscode.commands.executeCommand;
+    let cancelledSaveCalls = 0;
+    vscode.commands.executeCommand = (command, ...args) => {
+      if (command === 'workbench.action.files.save') {
+        cancelledSaveCalls += 1;
+        return Promise.resolve();
+      }
+      return executeCommand(command, ...args);
+    };
+    try {
+      await vscode.commands.executeCommand('csv.saveUntitled');
+      await waitUntil(() => vscode.window.activeTextEditor?.document.uri.toString() === live.uri.toString() && !panel.active, 'registered Save As command should reveal the native owner and finish its view-state transition');
+      await controller.enqueueOperation(() => {});
+    } finally {
+      vscode.commands.executeCommand = executeCommand;
+    }
+    assert.equal(cancelledSaveCalls, 1);
+    assert.equal(live.isClosed, false);
+    assert.ok(vscode.window.tabGroups.all.flatMap(group => group.tabs).some(tab => tab.input.uri?.toString() === live.uri.toString() && tab.isDirty), 'cancel must retain the dirty native source');
+    assert.equal(live.getText(), 'name,value\ncancel,42');
+    await vscode.commands.executeCommand('csv.toggleEditor');
+    await waitUntil(() => getActiveUntitledCsvEditor()?.panel === panel, 'cancelled Save As must retain and reuse the grid');
+    panel.dispose();
+    assert.equal(live.getText(), 'name,value\ncancel,42');
+    assert.equal(CsvEditorProvider.currentActive, undefined);
+    console.log('CSV_UNTITLED_SMOKE_OK: pretyped CSV+TSV, language roundtrips, shared edits, source switching, disable/re-enable, registered Save As exact native saves, controlled Save As cancellation retained');
+  } finally {
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+};
diff --git a/src/CsvEditorProvider.ts b/src/CsvEditorProvider.ts
index 9135ca8..965e5ff 100644
--- a/src/CsvEditorProvider.ts
+++ b/src/CsvEditorProvider.ts
@@ -1,6 +1,11 @@
 import Papa from 'papaparse';
 import * as vscode from 'vscode';
 import * as path from 'path';
+import { parseClipboardMatrix, serializeClipboardMatrix } from './clipboard';
+import { ColumnFilter, normalizeColumnFilters, compileColumnFilters, visibleSourceRows, remapColumnFilters, getFilterOperatorChoices, validateColumnFilterInput, MAX_COLUMN_FILTERS, MAX_FILTER_VALUE_LENGTH } from './column-filters';
+import { FilterDataType, parseFilterDate } from './filter-values';
+
+type FrozenPanes = { rows: number; columns: number };
 
 type SeparatorMode = 'extension' | 'auto' | 'default';
 type SeparatorSettings = {
@@ -34,7 +39,9 @@ type PasteApplyResult = {
   plan: PastePlan;
 };
 type ChunkRenderState = {
-  startAbs: number;
+  rowIds: number[];
+  bodyStart: number;
+  virtualRow: number;
   allRows: string[][];
   allRowsCount: number;
   chunkRows: number;
@@ -47,6 +54,25 @@ type ChunkRenderState = {
   isDark: boolean;
   serialIndexWidthCh: number;
 };
+type FilterColumn = { column: number; label: string; dataType: FilterDataType; operators: ReturnType<typeof getFilterOperatorChoices> };
+type FilterDraft = {
+  session: string;
+  filterColumnsRevision: number;
+  rows: Array<{ column: number; operator: ColumnFilter['operator']; value: string; composing?: boolean }>;
+  columns: Array<{ column: number; label: string }>;
+  focus?: {
+    row: number;
+    field: 'column' | 'operator' | 'value' | 'remove';
+    selectionStart?: number;
+    selectionEnd?: number;
+    selectionDirection?: 'forward' | 'backward' | 'none';
+  };
+};
+type FilterRender = {
+  tableHtml: string; chunksJson: string; colorCss: string; nextChunkStart: number; hasRemoteChunks: boolean;
+  visibleRowIds: number[]; matchedRows: number; totalRows: number; filters: ColumnFilter[]; columns: FilterColumn[];
+  firstVisibleRow: number; realRowCount: number; headerEnabled: boolean; chunkState: ChunkRenderState | undefined;
+};
 type ChunkResponse = {
   html: string;
   nextStart: number;
@@ -61,14 +87,39 @@ class CsvEditorController {
   private static readonly DEFAULT_MAX_FILE_SIZE_MB = 10;
   private static readonly LARGE_FILE_CONTINUE_THIS_TIME = 'Continue This Time';
   private static readonly LARGE_FILE_IGNORE_FOREVER = 'Ignore Forever';
+  private static readonly encodingWarnings = new WeakSet<vscode.TextDocument>();
+  private static readonly DRAFT_COMMIT_TIMEOUT_MS = 5000;
+  private static nativeHandoffQueue: Promise<void> = Promise.resolve();
 
   private isUpdatingDocument = false;
   private isSaving = false;
+  private disposed = false;
+  private defaultEditorHandoff: Promise<void> | undefined;
+  private pendingViewAction: (() => Promise<void>) | undefined;
+  private pendingDocumentReference: { document: vscode.TextDocument; separator: string } | undefined;
+  private renderedSeparator: string | undefined;
+  private viewCommitRequested = false;
+  private viewCommitSequence = 0;
+  private viewCommitNeedsFreshAck = false;
+  private draftActivityRevision = 0;
+  private pendingClose = false;
+  private pendingOperation: Promise<void> = Promise.resolve();
+  private readonly failedCellEdits = new Map<string, { row: number; col: number }>();
+  private refreshAfterDraftCommit = false;
+  private readonly draftCommitWaiters = new Set<{ resolve: (success: boolean) => void; timer: ReturnType<typeof setTimeout> }>();
   private currentWebviewPanel: vscode.WebviewPanel | undefined;
   private document!: vscode.TextDocument;
   private separatorCache: { version: number; configKey: string; separator: string } | undefined;
   private isDiffContext = false;
+  private currentHeader = false;
   private chunkRenderState: ChunkRenderState | undefined;
+  private currentFilterView: FilterRender | undefined;
+  private latestFilterRevision = 0;
+  private filterEpoch = 0;
+  private filterSession = '';
+  private filterSessionUri = '';
+  private filterColumnsRevision = 0;
+  private pendingFilterDraft: { uri: string; draft: FilterDraft } | undefined;
 
   constructor(private readonly context: vscode.ExtensionContext) {}
 
@@ -80,6 +131,26 @@ class CsvEditorController {
     _token: vscode.CancellationToken
   ): Promise<void> {
     this.document = document;
+    this.currentWebviewPanel = webviewPanel;
+    let changeDocumentSubscription: vscode.Disposable | undefined;
+    let saveDocumentSubscription: vscode.Disposable | undefined;
+    // Register before remote stat/prompt awaits: a closed panel stays closed.
+    webviewPanel.onDidDispose(() => {
+      this.disposed = true;
+      changeDocumentSubscription?.dispose();
+      saveDocumentSubscription?.dispose();
+      CsvEditorProvider.editors = CsvEditorProvider.editors.filter(ed => ed !== this);
+      this.currentWebviewPanel = undefined;
+      this.pendingFilterDraft = undefined;
+      this.pendingViewAction = undefined;
+      this.pendingDocumentReference = undefined;
+      this.viewCommitRequested = false;
+      this.resolveDraftCommitWaiters(false);
+      if (CsvEditorProvider.currentActive === this) {
+        CsvEditorProvider.currentActive = undefined;
+      }
+    });
+    if (_token.isCancellationRequested) { return; }
 
     const config = vscode.workspace.getConfiguration('csv', this.document.uri);
     if (!config.get<boolean>('enabled', true)) {
@@ -89,17 +160,19 @@ class CsvEditorController {
     }
 
     const proceed = await this.confirmLargeFileOpen(config, webviewPanel, _token);
-    if (!proceed) {
+    if (!proceed || this.disposed || _token.isCancellationRequested || document.isClosed) {
       return;
     }
 
-    this.currentWebviewPanel = webviewPanel;
+    if (!vscode.workspace.getConfiguration('csv', document.uri).get<boolean>('enabled', true)) {
+      await this.openWithDefaultEditorAndClose(webviewPanel, document.uri);
+      return;
+    }
     CsvEditorProvider.editors.push(this);
 
     webviewPanel.webview.options = {
       enableScripts: true,
-      // Use file path for compatibility with older VS Code types (no Uri.joinPath)
-      localResourceRoots: [vscode.Uri.file(path.join(this.context.extensionPath, 'media'))]
+      localResourceRoots: [this.getMediaUri()]
     };
 
     this.refreshDiffContext(webviewPanel);
@@ -108,23 +181,82 @@ class CsvEditorController {
     if (webviewPanel.active) {
       CsvEditorProvider.currentActive = this;
     }
+    void this.warnAboutPossibleDecoding().catch(error => {
+      console.warn('CSV: Encoding warning action failed', error);
+    });
 
     webviewPanel.webview.postMessage({ type: 'focus' });
+    let wasVisible = webviewPanel.visible;
     webviewPanel.onDidChangeViewState(e => {
+      const becameVisible = e.webviewPanel.visible && !wasVisible;
+      wasVisible = e.webviewPanel.visible;
       if (e.webviewPanel.active) {
         const diffChanged = this.refreshDiffContext(e.webviewPanel);
-        if (diffChanged) {
-          this.updateWebviewContent();
+        if (diffChanged || becameVisible) {
+          // A hidden webview can be recreated from its original HTML snapshot.
+          // Rebuild from the current (possibly unsaved) document after pending edits.
+          void this.enqueueOperation(() => this.updateWebviewContent());
         }
         e.webviewPanel.webview.postMessage({ type: 'focus' });
         CsvEditorProvider.currentActive = this;
+      } else if (CsvEditorProvider.currentActive === this) {
+        CsvEditorProvider.currentActive = undefined;
       }
     });
 
-    webviewPanel.webview.onDidReceiveMessage(async e => {
+    webviewPanel.webview.onDidReceiveMessage(e => {
+      if (e.type === 'filterDraftChanged') {
+        if (e.session === this.filterSession) { this.draftActivityRevision += 1; }
+        return;
+      }
+      if (e.type === 'updateColumnFilters' && e.session === this.filterSession && Number.isSafeInteger(e.revision) && e.revision > this.latestFilterRevision) {
+        this.latestFilterRevision = e.revision;
+      }
+      const mutatesTable = ['replaceCells', 'pasteCells', 'insertColumn', 'insertColumns', 'deleteColumn', 'deleteColumns',
+        'insertRow', 'insertRows', 'deleteRow', 'deleteRows', 'reorderColumns', 'reorderRows', 'sortColumn', 'pasteFromClipboard'].includes(e.type) || (e.type === 'copyCells' && e.cut === true);
+      // Observe new drafts immediately, even while an earlier queued edit awaits
+      // applyEdit. An ACK received before that activity cannot authorize reload.
+      if (mutatesTable || ['cellEditStarted', 'editCell', 'discardCellDraft'].includes(e.type)) {
+        this.draftActivityRevision += 1;
+      }
+      const receivedRevision = this.draftActivityRevision;
+      return this.enqueueOperation(async () => {
+      if (mutatesTable && this.failedCellEdits.size) {
+        const failed = this.failedCellEdits.values().next().value!;
+        void webviewPanel.webview.postMessage({ type: 'editCellFailed', row: failed.row, col: failed.col, retry: true });
+        void vscode.window.showErrorMessage('CSV: Retry the failed cell edit or press Escape to discard it before changing the table.');
+        return;
+      }
       switch (e.type) {
+        case 'webviewReady': {
+          if (this.viewCommitRequested) {
+            this.postViewCommitRequest();
+          }
+          break;
+        }
+        case 'viewRefreshReady': {
+          if (e.session !== this.filterSession) { break; }
+          if (this.viewCommitRequested && e.requestId !== this.viewCommitSequence) {
+            break;
+          }
+          if (!this.viewCommitRequested && e.requestId !== undefined) {
+            break;
+          }
+          if (this.viewCommitRequested && (this.viewCommitNeedsFreshAck || receivedRevision !== this.draftActivityRevision)) {
+            this.viewCommitNeedsFreshAck = false;
+            this.viewCommitSequence += 1;
+            this.postViewCommitRequest();
+            break;
+          }
+          this.captureFilterDraft(e.filterDraft);
+          await this.finishViewCommit();
+          break;
+        }
         case 'editCell':
-          this.updateDocument(e.row, e.col, e.value);
+          await this.updateDocument(e.row, e.col, e.value);
+          break;
+        case 'discardCellDraft':
+          this.discardFailedCellDraft(e.row, e.col);
           break;
         case 'replaceCells':
           await this.replaceCells(e.replacements);
@@ -133,17 +265,54 @@ class CsvEditorController {
           await this.pasteCells(e.text, e.anchorRow, e.anchorCol, e.selection);
           break;
         case 'requestChunk':
-          await this.requestChunk(e.start, e.requestId);
+          await this.requestChunk(e.start, e.requestId, e.filterEpoch, e.session);
           break;
         case 'findMatches':
           await this.findMatches(e.requestId, e.query, e.options);
           break;
         case 'save':
-          await this.handleSave();
+          if (this.viewCommitRequested) {
+            this.saveAfterCommit();
+          } else {
+            await this.handleSave();
+          }
+          break;
+        case 'updateColumnFilters':
+          await this.updateColumnFilters(e.revision, e.filters, e.session);
           break;
-        case 'copyToClipboard':
-          await vscode.env.clipboard.writeText(e.text);
-          console.log('CSV: Copied to clipboard');
+        case 'freezePanesChanged':
+          await this.setFrozenPanes({ rows: e.rows, columns: e.columns });
+          break;
+        case 'columnSizesChanged':
+          await CsvEditorProvider.setColumnSizesForUri(this.context, this.document.uri, e.columnSizes);
+          break;
+        case 'setHeader': {
+          if (typeof e.enabled === 'boolean') {
+            const uri = this.document.uri;
+            await CsvEditorProvider.setHeaderForUri(this.context, uri, e.enabled);
+            CsvEditorProvider.editors
+              .filter(editor => editor.getDocumentUri().toString() === uri.toString())
+              .forEach(editor => editor.refresh());
+          }
+          break;
+        }
+        case 'setSerialIndex': {
+          if (typeof e.enabled === 'boolean') {
+            const uri = this.getDocumentUri();
+            if (CsvEditorProvider.getSerialIndexForUri(this.context, uri) !== e.enabled) {
+              await CsvEditorProvider.setSerialIndexForUri(this.context, uri, e.enabled);
+              CsvEditorProvider.editors
+                .filter(editor => editor.getDocumentUri().toString() === uri.toString())
+                .forEach(editor => editor.refreshViewSafely());
+            }
+          }
+          break;
+        }
+        case 'copyCells':
+          await this.copyCells(e.matrix, e.rowIds, e.startCol, e.cut === true);
+          break;
+        case 'pasteFromClipboard':
+          await this.pasteCells(await vscode.env.clipboard.readText(), e.anchorRow, e.anchorCol, e.selection);
           break;
         case 'insertColumn':
           await this.insertColumn(e.index);
@@ -182,9 +351,10 @@ class CsvEditorController {
           await this.openLinkExternally(e.url);
           break;
       }
+      });
     });
 
-    const changeDocumentSubscription = vscode.workspace.onDidChangeTextDocument(e => {
+    changeDocumentSubscription = vscode.workspace.onDidChangeTextDocument(e => {
       if (
         e.document.uri.toString() === document.uri.toString() &&
         !this.isUpdatingDocument &&
@@ -194,11 +364,38 @@ class CsvEditorController {
       }
     });
 
-    webviewPanel.onDidDispose(() => {
-      changeDocumentSubscription.dispose();
-      CsvEditorProvider.editors = CsvEditorProvider.editors.filter(ed => ed !== this);
-      this.currentWebviewPanel = undefined;
+    saveDocumentSubscription = vscode.workspace.onWillSaveTextDocument(e => {
+      if (e.document.uri.toString() === document.uri.toString() && !this.isSaving) {
+        // Native File > Save can run while the webview's blur edit is applying.
+        // The custom save command is already in this queue and must not await itself.
+        e.waitUntil(this.pendingOperation);
+      }
+    });
+  }
+
+  private enqueueOperation(operation: () => void | Promise<void>): Promise<void> {
+    // Event listeners are not awaited by VS Code. Serialize mutations, reads and
+    // saves so every command sees the result of the preceding document edit.
+    this.pendingOperation = this.pendingOperation.then(operation).catch(error => {
+      console.error('CSV: Editor operation failed', error);
     });
+    return this.pendingOperation;
+  }
+
+  private async warnAboutPossibleDecoding(): Promise<void> {
+    if (this.document.uri.scheme === 'untitled' || !this.document.getText().includes('\uFFFD') || CsvEditorController.encodingWarnings.has(this.document)) {
+      return;
+    }
+    CsvEditorController.encodingWarnings.add(this.document);
+    const action = 'Change File Encoding';
+    const selected = await vscode.window.showWarningMessage(
+      'CSV: This file contains replacement characters (�), which can indicate a decoding mismatch. Check the source encoding before saving.',
+      action
+    );
+    if (selected === action && !this.disposed) {
+      // Bind the action to this document even if another tab becomes active.
+      await vscode.commands.executeCommand('csv.changeEncoding', this.document.uri);
+    }
   }
 
   private getMaxFileSizeLimitMb(config: vscode.WorkspaceConfiguration): number {
@@ -227,17 +424,118 @@ class CsvEditorController {
     return (fileSizeBytes / CsvEditorController.BYTES_PER_MB).toFixed(1);
   }
 
-  private async openWithDefaultEditorAndClose(webviewPanel: vscode.WebviewPanel, uri: vscode.Uri): Promise<void> {
-    try {
-      const opts: any = {
-        viewColumn: webviewPanel.viewColumn,
-        preserveFocus: !webviewPanel.active,
-        preview: webviewPanel.active ? webviewPanel.active : false
+  private captureOtherEditorOwner(uri: vscode.Uri, viewColumn: vscode.ViewColumn | undefined): (() => Promise<void>) | undefined {
+    const group = vscode.window.tabGroups.activeTabGroup;
+    if (!group) { return; }
+    const tab = group.activeTab;
+    const input: any = tab?.input;
+    const stillOpen = () => vscode.window.tabGroups.all.includes(group) && !!tab && group.tabs.includes(tab);
+    const activeController = CsvEditorProvider.editors.find(editor => editor !== this && editor.isActive() && editor.getViewColumn() === group.viewColumn);
+    const panel = activeController?.currentWebviewPanel;
+    if (panel) {
+      const document = activeController.document;
+      return async () => {
+        if (!vscode.window.tabGroups.all.includes(group)) { return; }
+        if (activeController.currentWebviewPanel === panel && panel.viewColumn === group.viewColumn && stillOpen()) {
+          panel.reveal(group.viewColumn, false);
+        } else if (!activeController.currentWebviewPanel && !document.isClosed && group.tabs.some(candidate => {
+          const native: any = candidate.input;
+          return !native?.viewType && native?.uri?.toString() === document.uri.toString();
+        })) {
+          // Another Off handoff can replace the captured grid first. Reuse
+          // its native owner only while that owner still has a live tab here.
+          await vscode.window.showTextDocument(document, { viewColumn: group.viewColumn, preview: false });
+        }
       };
-      await vscode.commands.executeCommand('vscode.openWith', uri, 'default', opts);
-    } finally {
-      try { webviewPanel.dispose(); } catch {}
     }
+    const activeUri: vscode.Uri | undefined = input?.uri;
+    if (!activeUri || (group.viewColumn === viewColumn && activeUri.toString() === uri.toString())) { return; }
+    if (input.viewType === CsvEditorProvider.viewType) { return; }
+    if (input.viewType) {
+      return async () => { if (stillOpen()) { await vscode.commands.executeCommand('vscode.openWith', activeUri, input.viewType, { viewColumn: group.viewColumn, preserveFocus: false }); } };
+    }
+    const editor = vscode.window.visibleTextEditors.find(candidate => candidate.viewColumn === group.viewColumn && candidate.document.uri.toString() === activeUri.toString());
+    if (editor) {
+      return async () => {
+        if (!stillOpen()) { return; }
+        // The owner may have acquired its standalone table while the saved-file
+        // handoff was pending. Reveal that live view instead of promoting text.
+        const controller = CsvEditorProvider.editors.find(candidate => candidate !== this && candidate.getViewColumn() === group.viewColumn && candidate.getDocumentUri().toString() === activeUri.toString());
+        if (controller?.currentWebviewPanel) { controller.currentWebviewPanel.reveal(group.viewColumn, false); }
+        else if (!editor.document.isClosed) { await vscode.window.showTextDocument(editor.document, { viewColumn: group.viewColumn, preview: false }); }
+      };
+    }
+  }
+
+  private async openWithDefaultEditorAndClose(webviewPanel: vscode.WebviewPanel, uri: vscode.Uri, reason?: 'disabled' | 'language'): Promise<void> {
+    if (this.disposed) { return; }
+    if (!this.defaultEditorHandoff) {
+      const authorization = reason ? {
+        activity: this.draftActivityRevision, document: this.document, version: this.document.version,
+        language: this.document.languageId, session: this.filterSession, filterRevision: this.latestFilterRevision,
+        columnsRevision: this.filterColumnsRevision
+      } : undefined;
+      let reprepare = false;
+      const pending = CsvEditorController.nativeHandoffQueue.then(async () => {
+        if (this.disposed || this.document.isClosed) { return; }
+        const supported = uri.scheme !== 'untitled' || this.document.languageId === 'csv' || this.document.languageId === 'tsv';
+        if (supported && CsvEditorProvider.editors.includes(this) && vscode.workspace.getConfiguration('csv', uri).get<boolean>('enabled', true)) { return; }
+        if (authorization && (authorization.activity !== this.draftActivityRevision || authorization.document !== this.document ||
+            authorization.version !== this.document.version || authorization.language !== this.document.languageId ||
+            authorization.session !== this.filterSession || authorization.filterRevision !== this.latestFilterRevision ||
+            authorization.columnsRevision !== this.filterColumnsRevision || this.pendingDocumentReference)) {
+          // A different handoff held the native queue after this view's ACK.
+          // Release this slot and request a new ACK without blocking its own
+          // message queue, where the final cell/filter edits must be applied.
+          reprepare = true;
+          return;
+        }
+        let restoreOwner = this.captureOtherEditorOwner(uri, webviewPanel.viewColumn);
+        const focusSubscription = vscode.window.onDidChangeActiveTextEditor(() => {
+          const next = this.captureOtherEditorOwner(uri, webviewPanel.viewColumn);
+          if (next) { restoreOwner = next; }
+        });
+        const wasActive = webviewPanel.active;
+        try {
+          const opts = { viewColumn: webviewPanel.viewColumn, preserveFocus: !wasActive };
+          if (uri.scheme === 'untitled') {
+            await vscode.window.showTextDocument(this.document, { ...opts, preview: false });
+          } else {
+            const existing = vscode.window.visibleTextEditors.find(editor =>
+              editor.document.uri.toString() === uri.toString() && editor.viewColumn === webviewPanel.viewColumn);
+            if (!existing) {
+              await vscode.commands.executeCommand('vscode.openWith', uri, 'default', opts);
+            }
+          }
+        } finally {
+          focusSubscription.dispose();
+          const supported = uri.scheme !== 'untitled' || this.document.languageId === 'csv' || this.document.languageId === 'tsv';
+          const retainTable = supported && !this.disposed && CsvEditorProvider.editors.includes(this) &&
+            vscode.workspace.getConfiguration('csv', uri).get<boolean>('enabled', true);
+          const group = vscode.window.tabGroups.activeTabGroup;
+          const input: any = group?.activeTab?.input;
+          const nativeHandoffIsActive = group?.viewColumn === webviewPanel.viewColumn && !input?.viewType && input?.uri?.toString() === uri.toString();
+          if (!retainTable) { try { webviewPanel.dispose(); } catch {} }
+          // Only undo activation caused by this handoff. A later user choice in
+          // another tab/group always keeps focus and its live document owner.
+          if (nativeHandoffIsActive) {
+            if (restoreOwner) { await restoreOwner(); }
+            else if (retainTable && wasActive) { webviewPanel.reveal(webviewPanel.viewColumn, false); }
+          }
+        }
+      });
+      // Only native opens/disposal/restoration serialize; draft ACKs remain
+      // independent, so a failed edit in one file cannot block other files.
+      CsvEditorController.nativeHandoffQueue = pending.then(() => {}, () => {});
+      this.defaultEditorHandoff = pending;
+      void pending.then(() => {
+        if (this.defaultEditorHandoff === pending) { this.defaultEditorHandoff = undefined; }
+        if (reprepare && !this.disposed && reason) { this.revealSourceAfterCommit(reason); }
+      }, () => {
+        if (this.defaultEditorHandoff === pending) { this.defaultEditorHandoff = undefined; }
+      });
+    }
+    await this.defaultEditorHandoff;
   }
 
   private async confirmLargeFileOpen(
@@ -245,6 +543,9 @@ class CsvEditorController {
     webviewPanel: vscode.WebviewPanel,
     token: vscode.CancellationToken
   ): Promise<boolean> {
+    if (this.document.uri.scheme === 'untitled') {
+      return true;
+    }
     const maxFileSizeMB = this.getMaxFileSizeLimitMb(config);
     if (maxFileSizeMB <= 0) {
       return true;
@@ -293,19 +594,176 @@ class CsvEditorController {
   }
 
   public refresh() {
+    if (this.disposed) { return; }
     const config = vscode.workspace.getConfiguration('csv', this.document.uri);
-    if (!config.get<boolean>('enabled', true)) {
-      this.currentWebviewPanel?.dispose();
-      vscode.commands.executeCommand('vscode.openWith', this.document.uri, 'default');
+    const enabled = config.get<boolean>('enabled', true);
+    if (this.failedCellEdits.size) {
+      this.refreshAfterDraftCommit = true;
+      if (!enabled) {
+        void vscode.window.showErrorMessage('CSV: Retry the failed cell edit or press Escape to discard it before disabling the table view.');
+      }
+      return;
+    }
+    if (!enabled) {
+      this.revealSourceAfterCommit();
     } else {
-      if (this.currentWebviewPanel) {
+      if (this.defaultEditorHandoff) { return; }
+      if (this.viewCommitRequested || this.failedCellEdits.size) {
+        this.refreshAfterDraftCommit = true;
+        return;
+      }
+      if (this.currentWebviewPanel && !this.viewCommitRequested && !this.failedCellEdits.size) {
         this.forceReload();
       }
     }
   }
 
+  public getViewColumn(): vscode.ViewColumn | undefined {
+    return this.currentWebviewPanel?.viewColumn;
+  }
+
+  public commitPendingDraft(): Promise<boolean> {
+    const panel = this.currentWebviewPanel;
+    if (!panel) {
+      return Promise.resolve(false);
+    }
+    return new Promise(resolve => {
+      const waiter = {
+        resolve,
+        timer: setTimeout(() => {
+          this.draftCommitWaiters.delete(waiter);
+          resolve(false);
+        }, CsvEditorController.DRAFT_COMMIT_TIMEOUT_MS)
+      };
+      this.draftCommitWaiters.add(waiter);
+      const alreadyRequested = this.viewCommitRequested;
+      this.requestViewCommit();
+      if (alreadyRequested && panel.visible) {
+        this.postViewCommitRequest();
+      }
+    });
+  }
+
+  private resolveDraftCommitWaiters(success: boolean): void {
+    for (const waiter of this.draftCommitWaiters) {
+      clearTimeout(waiter.timer);
+      waiter.resolve(success);
+    }
+    this.draftCommitWaiters.clear();
+  }
+
+  public revealSourceAfterCommit(reason: 'disabled' | 'language' = 'disabled'): void {
+    const panel = this.currentWebviewPanel;
+    if (!panel) {
+      return;
+    }
+    // A deliberate close takes priority over a pending Save As or re-render.
+    this.pendingClose = true;
+    this.pendingViewAction = async () => {
+      const enabled = vscode.workspace.getConfiguration('csv', this.document.uri).get<boolean>('enabled', true);
+      const supportedLanguage = this.document.languageId === 'csv' || this.document.languageId === 'tsv';
+      if (enabled && (reason === 'disabled' || supportedLanguage)) {
+        // A quick re-enable/language roundtrip still commits the active draft.
+        this.updateWebviewContent();
+        return;
+      }
+      await this.openWithDefaultEditorAndClose(panel, this.document.uri, reason);
+    };
+    this.requestViewCommit();
+  }
+
+  public saveUntitledAfterCommit(): void {
+    if (this.document.uri.scheme === 'untitled') {
+      this.saveAfterCommit();
+    }
+  }
+
+  private saveAfterCommit(): void {
+    if (!this.currentWebviewPanel || this.pendingClose) {
+      return;
+    }
+    this.pendingViewAction = async () => {
+      await this.handleSave();
+      this.updateWebviewContent();
+    };
+    this.requestViewCommit();
+  }
+
+  private postViewCommitRequest(): void {
+    const panel = this.currentWebviewPanel;
+    if (!panel) {
+      this.resolveDraftCommitWaiters(false);
+      return;
+    }
+    try {
+      void Promise.resolve(panel.webview.postMessage({
+        type: 'prepareViewRefresh', requestId: this.viewCommitSequence
+      })).then(delivered => {
+        if (!delivered) { this.resolveDraftCommitWaiters(false); }
+      }, () => this.resolveDraftCommitWaiters(false));
+    } catch {
+      this.resolveDraftCommitWaiters(false);
+    }
+  }
+
+  private requestViewCommit(): void {
+    const panel = this.currentWebviewPanel;
+    if (!panel || this.viewCommitRequested) {
+      return;
+    }
+    this.viewCommitRequested = true;
+    this.viewCommitNeedsFreshAck = false;
+    this.viewCommitSequence += 1;
+    if (panel.visible) {
+      // The final edit arrives before the acknowledgment in the ordered queue.
+      // webviewReady resends this request if the first script is still loading.
+      this.postViewCommitRequest();
+    } else {
+      void this.enqueueOperation(() => this.finishViewCommit());
+    }
+  }
+
+  private requestRecoveryRefresh(): void {
+    this.refreshAfterDraftCommit = true;
+    if (this.viewCommitRequested) {
+      // A recovery cannot reuse the snapshot taken before its queued edit.
+      this.viewCommitNeedsFreshAck = true;
+      return;
+    }
+    // The acknowledgment itself runs on the ordered queue, so never await it here.
+    this.requestViewCommit();
+  }
+
+  private async finishViewCommit(): Promise<void> {
+    this.viewCommitRequested = false;
+    if (this.failedCellEdits.size) {
+      // Keep the live DOM and any pending action until its failed cell can be retried.
+      this.resolveDraftCommitWaiters(false);
+      return;
+    }
+    const hadWaiters = this.draftCommitWaiters.size > 0;
+    if (this.pendingDocumentReference) {
+      this.document = this.pendingDocumentReference.document;
+      this.pendingDocumentReference = undefined;
+      this.separatorCache = undefined;
+    }
+    const action = this.pendingViewAction;
+    this.pendingViewAction = undefined;
+    this.pendingClose = false;
+    const refreshNeeded = this.refreshAfterDraftCommit;
+    this.refreshAfterDraftCommit = false;
+    if (action) {
+      await action();
+    } else if (!hadWaiters || refreshNeeded) {
+      this.updateWebviewContent();
+    }
+    // An awaited action can leave a newer request pending. Its waiters need
+    // that request's own ACK, even when this older action just completed.
+    if (!this.viewCommitRequested) { this.resolveDraftCommitWaiters(!!this.currentWebviewPanel && !this.failedCellEdits.size); }
+  }
+
   private forceReload() {
-    if (!this.currentWebviewPanel) return;
+    if (!this.currentWebviewPanel || this.failedCellEdits.size) return;
     const panel = this.currentWebviewPanel;
     // First, blank the DOM to ensure a full script/style reinit on next set
     panel.webview.html = '<!DOCTYPE html><html><head><meta charset="UTF-8"></head><body></body></html>';
@@ -386,6 +844,198 @@ class CsvEditorController {
     );
   }
 
+  private getFilterColumns(data: string[][]): FilterColumn[] {
+    const offset = Math.min(Math.max(0, this.getHiddenRows()), data.length);
+    const header = this.getEffectiveHeader(data, offset);
+    const body = data.slice(offset + (header ? 1 : 0));
+    const count = Math.max(1, data.reduce((max, row) => Math.max(max, row.length), 0));
+    return Array.from({ length: count }, (_, column) => {
+      const values = body.map(row => row[column] ?? '');
+      const inferred = this.estimateColumnDataType(values);
+      let dataType: FilterDataType = inferred === 'integer' || inferred === 'float' ? 'number'
+        : inferred === 'date' || inferred === 'boolean' ? inferred : 'string';
+      if (inferred === 'string') {
+        const nonblank = values.filter(value => value.trim() !== '');
+        if (nonblank.length && nonblank.every(value => parseFilterDate(value) !== undefined)) {
+          dataType = 'date';
+        }
+      }
+      return { column, label: (header ? data[offset]?.[column] : '') || `Column ${column + 1}`, dataType, operators: getFilterOperatorChoices(dataType) };
+    });
+  }
+
+  private filterResponse(): Record<string, unknown> {
+    if (!this.currentFilterView) { return { filterEpoch: this.filterEpoch }; }
+    const { chunkState, ...payload } = this.currentFilterView;
+    return { ...payload, filterEpoch: this.filterEpoch };
+  }
+
+  private async updateColumnFilters(rawRevision: unknown, rawFilters: unknown, session: unknown): Promise<void> {
+    const panel = this.currentWebviewPanel;
+    if (!panel || session !== this.filterSession) { return; }
+    const reply = (extra: Record<string, unknown>) => {
+      if (session !== this.filterSession || panel !== this.currentWebviewPanel) { return; }
+      void panel.webview.postMessage({ type: 'columnFiltersResult', session: this.filterSession, revision: rawRevision, ...this.filterResponse(), ...extra });
+    };
+    if (typeof rawRevision !== 'number' || !Number.isSafeInteger(rawRevision) || rawRevision <= 0) {
+      reply({ error: 'Filter revisions must be positive safe integers.' });
+      return;
+    }
+    if (rawRevision !== this.latestFilterRevision || rawRevision <= this.filterEpoch) { return; }
+    if (this.failedCellEdits.size) {
+      reply({ error: 'Retry the failed cell edit before changing filters.' });
+      return;
+    }
+    if (this.pendingDocumentReference || this.viewCommitRequested) {
+      reply({ error: 'Finish the current editor change before changing filters.' });
+      return;
+    }
+    if (!Array.isArray(rawFilters) || rawFilters.length > MAX_COLUMN_FILTERS) {
+      reply({ error: `Provide at most ${MAX_COLUMN_FILTERS} filter conditions.` });
+      return;
+    }
+    const data = this.trimTrailingEmptyRows(Papa.parse<string[]>(this.document.getText(), { delimiter: this.getSeparator() }).data);
+    const columns = this.getFilterColumns(data);
+    const filters: ColumnFilter[] = [];
+    const errors: Array<{ index: number; message: string }> = [];
+    rawFilters.forEach((raw: unknown, index: number) => {
+      if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+        errors.push({ index, message: 'Provide a valid filter condition.' });
+        return;
+      }
+      const item = raw as Record<string, unknown>;
+      if (Object.keys(item).some(key => !['column', 'operator', 'value', 'dataType'].includes(key)) ||
+          typeof item.column !== 'number' || !Number.isSafeInteger(item.column) || item.column < 0 || item.column >= columns.length ||
+          typeof item.operator !== 'string' || typeof item.value !== 'string' || item.value.length > MAX_FILTER_VALUE_LENGTH ||
+          (item.dataType !== undefined && (typeof item.dataType !== 'string' || !['string', 'number', 'date', 'boolean'].includes(item.dataType)))) {
+        errors.push({ index, message: 'Provide a valid column, operator, type and filter value.' });
+        return;
+      }
+      const column = columns[item.column];
+      const choice = column.operators.find(operator => operator.operator === item.operator);
+      if (!choice) {
+        errors.push({ index, message: `Choose an operator supported by this ${column.dataType} column.` });
+        return;
+      }
+      const typed = !['contains', 'notContains', 'regex', 'empty', 'notEmpty'].includes(choice.operator);
+      const dataType = typed && column.dataType !== 'string' ? column.dataType : undefined;
+      // Empty text boxes remain local drafts, including incomplete typed queries.
+      if (choice.operator !== 'empty' && choice.operator !== 'notEmpty' && item.value.length === 0) { return; }
+      const error = validateColumnFilterInput(choice.operator, item.value, dataType);
+      if (error) { errors.push({ index, message: error }); return; }
+      filters.push({ column: item.column, operator: choice.operator, value: item.value, ...(dataType ? { dataType } : {}) });
+    });
+    if (errors.length) { reply({ errors, columns }); return; }
+    const view = this.buildFilterView(data, filters);
+    if (session !== this.filterSession || rawRevision !== this.latestFilterRevision) { return; }
+    const previous = CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri);
+    try {
+      await CsvEditorProvider.setColumnFiltersForUri(this.context, this.document.uri, filters);
+      if (session !== this.filterSession || rawRevision !== this.latestFilterRevision) {
+        await CsvEditorProvider.setColumnFiltersForUri(this.context, this.document.uri, previous);
+        return;
+      }
+    } catch {
+      reply({ error: 'The filter conditions could not be saved. Try again.' });
+      return;
+    }
+    this.chunkRenderState = view.chunkState;
+    this.currentFilterView = view;
+    this.currentHeader = view.headerEnabled;
+    this.filterEpoch = rawRevision;
+    reply({});
+  }
+
+  private captureFilterDraft(raw: unknown): void {
+    this.pendingFilterDraft = undefined;
+    const columns = this.currentFilterView?.columns;
+    if (!columns || !raw || typeof raw !== 'object' || Array.isArray(raw)) { return; }
+    const item = raw as Record<string, unknown>;
+    if (item.session !== this.filterSession || item.filterColumnsRevision !== this.filterColumnsRevision ||
+        !Array.isArray(item.rows) || item.rows.length > MAX_COLUMN_FILTERS ||
+        !Array.isArray(item.columns) || item.columns.length !== columns.length) { return; }
+    if (!item.columns.every((column: unknown, index: number) => {
+      if (!column || typeof column !== 'object' || Array.isArray(column)) { return false; }
+      const identity = column as Record<string, unknown>;
+      return identity.column === columns[index].column && identity.label === columns[index].label;
+    })) { return; }
+    const rows: FilterDraft['rows'] = [];
+    for (const rawRow of item.rows as unknown[]) {
+      if (!rawRow || typeof rawRow !== 'object' || Array.isArray(rawRow)) { return; }
+      const row = rawRow as Record<string, unknown>;
+      const operator = getFilterOperatorChoices('number').find(choice => choice.operator === row.operator)?.operator;
+      if (typeof row.column !== 'number' || !Number.isSafeInteger(row.column) || row.column < 0 || row.column >= columns.length ||
+          !operator || typeof row.value !== 'string' || row.value.length > MAX_FILTER_VALUE_LENGTH ||
+          (row.composing !== undefined && typeof row.composing !== 'boolean')) { return; }
+      // Preserve blank and invalid queries as drafts; only submission validates their meaning.
+      rows.push({ column: row.column, operator, value: row.value, ...(row.composing ? { composing: true } : {}) });
+    }
+    const draft: FilterDraft = {
+      session: this.filterSession,
+      filterColumnsRevision: this.filterColumnsRevision,
+      rows,
+      columns: columns.map(column => ({ column: column.column, label: column.label }))
+    };
+    if (item.focus !== undefined) {
+      if (!item.focus || typeof item.focus !== 'object' || Array.isArray(item.focus)) { return; }
+      const focus = item.focus as Record<string, unknown>;
+      if (typeof focus.row !== 'number' || !Number.isSafeInteger(focus.row) || focus.row < 0 || focus.row >= rows.length ||
+          (focus.field !== 'column' && focus.field !== 'operator' && focus.field !== 'value' && focus.field !== 'remove')) { return; }
+      draft.focus = { row: focus.row, field: focus.field };
+      if (focus.selectionStart !== undefined || focus.selectionEnd !== undefined || focus.selectionDirection !== undefined) {
+        if (focus.field !== 'value' || typeof focus.selectionStart !== 'number' || typeof focus.selectionEnd !== 'number' ||
+            !Number.isSafeInteger(focus.selectionStart) || !Number.isSafeInteger(focus.selectionEnd) ||
+            focus.selectionStart < 0 || focus.selectionEnd < focus.selectionStart || focus.selectionEnd > rows[focus.row].value.length ||
+            (focus.selectionDirection !== 'forward' && focus.selectionDirection !== 'backward' && focus.selectionDirection !== 'none')) { return; }
+        Object.assign(draft.focus, { selectionStart: focus.selectionStart, selectionEnd: focus.selectionEnd, selectionDirection: focus.selectionDirection });
+      }
+    }
+    this.pendingFilterDraft = { uri: this.filterSessionUri, draft };
+  }
+
+  private consumeFilterDraft(columns: FilterColumn[]): FilterDraft | undefined {
+    const pending = this.pendingFilterDraft;
+    this.pendingFilterDraft = undefined;
+    if (!pending || pending.uri !== this.document.uri.toString() || pending.draft.filterColumnsRevision !== this.filterColumnsRevision ||
+        pending.draft.columns.length !== columns.length || pending.draft.columns.some((column, index) =>
+          column.column !== columns[index].column || column.label !== columns[index].label)) { return undefined; }
+    return pending.draft;
+  }
+
+  private async remapFilters(columnOrder: number[]): Promise<void> {
+    if (columnOrder.length !== this.currentFilterView?.columns.length || columnOrder.some((column, index) => column !== index)) {
+      this.filterColumnsRevision++;
+      this.pendingFilterDraft = undefined;
+    }
+    await CsvEditorProvider.setColumnFiltersForUri(this.context, this.document.uri,
+      remapColumnFilters(CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri), columnOrder));
+  }
+
+  public refreshViewSafely(): void {
+    this.refreshAfterDraftCommit = true;
+    this.requestViewCommit();
+  }
+
+  public getCurrentFrozenPanes(): FrozenPanes {
+    return CsvEditorProvider.getFrozenPanesForUri(this.context, this.document.uri, this.currentHeader);
+  }
+
+  public async setFrozenPanes(change: Partial<FrozenPanes>): Promise<void> {
+    await CsvEditorProvider.setFrozenPanesForUri(this.context, this.document.uri, change);
+    this.currentWebviewPanel?.webview.postMessage({ type: 'frozenPanes', ...this.getCurrentFrozenPanes() });
+  }
+
+  public updateDocumentReference(document: vscode.TextDocument): void {
+    if (document.uri.toString() === this.document.uri.toString()) {
+      this.pendingDocumentReference = {
+        document,
+        separator: this.pendingDocumentReference?.separator ?? this.renderedSeparator ?? this.getSeparator()
+      };
+      this.refreshAfterDraftCommit = true;
+      this.requestViewCommit();
+    }
+  }
+
   public getDocumentUri(): vscode.Uri {
     return this.document.uri;
   }
@@ -396,13 +1046,50 @@ class CsvEditorController {
 
   // ───────────── Document Editing Methods ─────────────
 
+  private reportFailedCellEdit(row: number, col: number): void {
+    this.failedCellEdits.set(`${row}:${col}`, { row, col });
+    void this.currentWebviewPanel?.webview.postMessage({
+      type: 'editCellFailed', row, col, retry: !!this.viewCommitRequested
+    });
+  }
+
+  private postCommittedCell(row: number, col: number, value: string): void {
+    const clickableLinks = vscode.workspace.getConfiguration('csv', this.document.uri).get<boolean>('clickableLinks', true);
+    void this.currentWebviewPanel?.webview.postMessage({
+      type: 'updateCell', row, col, value, rendered: this.formatCellContent(value, clickableLinks)
+    });
+  }
+
+  private clearFailedCellEdit(row: number, col: number, value: string): void {
+    if (this.failedCellEdits.delete(`${row}:${col}`)) {
+      this.postCommittedCell(row, col, value);
+      if (!this.failedCellEdits.size) { this.requestRecoveryRefresh(); }
+    }
+  }
+
+  private discardFailedCellDraft(row: number, col: number): void {
+    const failed = this.failedCellEdits.get(`${row}:${col}`);
+    if (!failed) {
+      return;
+    }
+    // Escape discards the failed DOM draft, never overwrites the current owner.
+    const document = this.pendingDocumentReference?.document ?? this.document;
+    const data = Papa.parse<string[]>(document.getText(), { delimiter: this.getSeparator() }).data;
+    this.clearFailedCellEdit(row, col, String(data[row]?.[col] ?? ''));
+
+  }
+
   private async updateDocument(row: number, col: number, value: string) {
+    // The old document may be closed during a language change. Apply its final
+    // draft to the live shared URI using the delimiter of the still-visible grid.
+    const document = this.pendingDocumentReference?.document ?? this.document;
     this.isUpdatingDocument = true;
     let structuralChange = false;
+    let filterMembershipChanged = false;
     let applied = false;
     try {
       const separator = this.getSeparator();
-      const oldText = this.document.getText();
+      const oldText = document.getText();
       const result = Papa.parse(oldText, { dynamicTyping: false, delimiter: separator });
       const data = result.data as string[][];
       const hadRows = data.length;
@@ -412,10 +1099,15 @@ class CsvEditorController {
           ? String(data[row][col] ?? '')
           : undefined;
 
+      const filters = CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri);
+      const matches = compileColumnFilters(filters);
+      const previouslyMatched = matches(data[row] ?? []);
       const { data: nextData, trimmed, createdRow, createdCol } = this.mutateDataForEdit(data, row, col, value);
+      filterMembershipChanged = filters.length > 0 && previouslyMatched !== matches(nextData[row] ?? []);
       structuralChange = !!(trimmed || createdRow || createdCol || row >= hadRows || col >= hadColsAtRow);
 
       if (!structuralChange && previousValue === value) {
+        this.clearFailedCellEdit(row, col, value);
         return;
       }
 
@@ -426,40 +1118,52 @@ class CsvEditorController {
           separator,
           [{ row, col, value: String(value ?? '') }]
         );
+      } else {
+        newCsvText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(oldText, separator, nextData);
       }
       if (newCsvText === undefined) {
         newCsvText = Papa.unparse(nextData, { delimiter: separator });
       }
 
       if (newCsvText === oldText) {
+        this.clearFailedCellEdit(row, col, value);
         return;
       }
 
       const fullRange = new vscode.Range(
         0, 0,
-        this.document.lineCount,
-        this.document.lineCount ? this.document.lineAt(this.document.lineCount - 1).text.length : 0
+        document.lineCount,
+        document.lineCount ? document.lineAt(document.lineCount - 1).text.length : 0
       );
       const edit = new vscode.WorkspaceEdit();
-      edit.replace(this.document.uri, fullRange, newCsvText);
-      await vscode.workspace.applyEdit(edit);
-      applied = true;
+      edit.replace(document.uri, fullRange, newCsvText);
+      applied = await vscode.workspace.applyEdit(edit);
+    } catch (error) {
+      this.reportFailedCellEdit(row, col);
+      throw error;
     } finally {
       this.isUpdatingDocument = false;
     }
 
     if (!applied) {
+      this.reportFailedCellEdit(row, col);
       return;
     }
+    const recoveredDraft = this.failedCellEdits.delete(`${row}:${col}`);
 
-    console.log(`CSV: Updated row ${row + 1}, column ${col + 1} to "${value}"`);
-    const config = vscode.workspace.getConfiguration('csv', this.document.uri);
+    console.log(`CSV: Updated row ${row + 1}, column ${col + 1}`);
+    const config = vscode.workspace.getConfiguration('csv', document.uri);
     const clickableLinks = config.get<boolean>('clickableLinks', true);
     const rendered = this.formatCellContent(value ?? '', clickableLinks);
     this.currentWebviewPanel?.webview.postMessage({ type: 'updateCell', row, col, value, rendered });
 
     // Trigger a full re-render if structure may have changed (new row/col created)
-    if (structuralChange) {
+    if (recoveredDraft && !this.failedCellEdits.size) {
+      this.requestRecoveryRefresh();
+    }
+    if (filterMembershipChanged) {
+      this.refreshViewSafely();
+    } else if (structuralChange && !this.pendingDocumentReference) {
       try { this.updateWebviewContent(); } catch (e) { console.error('CSV: refresh failed after structural edit', e); }
     }
   }
@@ -528,34 +1232,32 @@ class CsvEditorController {
     }
   }
 
-  private parseClipboardMatrix(text: string): string[][] {
-    if (!text || text.length === 0) {
-      return [];
+  private async copyCells(rawMatrix: unknown, rawRowIds: unknown, rawStartCol: unknown, cut: boolean): Promise<void> {
+    if (!Array.isArray(rawMatrix) || rawMatrix.length === 0 || !rawMatrix.every(row =>
+      Array.isArray(row) && row.length > 0 && row.every(value => typeof value === 'string')
+    )) {
+      return;
     }
-    const parsed = Papa.parse(text, { dynamicTyping: false, delimiter: '' });
-    const rowsRaw = Array.isArray(parsed.data) ? parsed.data : [];
-    const matrix: string[][] = rowsRaw.map(rawRow => {
-      if (Array.isArray(rawRow)) {
-        return rawRow.map(cell => String(cell ?? ''));
-      }
-      return [String(rawRow ?? '')];
-    });
-    while (matrix.length > 0 && matrix[matrix.length - 1].every(value => value === '')) {
-      matrix.pop();
+    const matrix = rawMatrix as string[][];
+    const rowIds = Array.isArray(rawRowIds) ? rawRowIds : [];
+    const startCol = Number(rawStartCol);
+    if (rowIds.length !== matrix.length || new Set(rowIds).size !== rowIds.length || !rowIds.every(row => Number.isInteger(row) && row >= 0) || !Number.isInteger(startCol) || startCol < 0) {
+      return;
     }
-    if (matrix.length === 0) {
-      return [];
+    const documentVersion = this.document.version;
+    try {
+      await vscode.env.clipboard.writeText(serializeClipboardMatrix(matrix, this.getSeparator()));
+    } catch {
+      void vscode.window.showErrorMessage('CSV: Unable to write to the clipboard. The selected cells were kept.');
+      return;
     }
-    const width = matrix.reduce((max, row) => Math.max(max, row.length), 0);
-    if (width <= 0) {
-      return [];
+    if (cut && this.document.version === documentVersion) {
+      await this.replaceCells(matrix.flatMap((row, rowOffset) => row.map((_value, colOffset) => ({
+        row: rowIds[rowOffset],
+        col: startCol + colOffset,
+        value: ''
+      }))));
     }
-    matrix.forEach(row => {
-      while (row.length < width) {
-        row.push('');
-      }
-    });
-    return matrix;
   }
 
   private static parsePasteSelectionBounds(raw: unknown): PasteSelectionBounds | undefined {
@@ -622,7 +1324,8 @@ class CsvEditorController {
     matrix: string[][],
     anchorRow: number,
     anchorCol: number,
-    selection: PasteSelectionBounds | undefined
+    selection: PasteSelectionBounds | undefined,
+    targetRows?: number[]
   ): PasteApplyResult {
     const plan = CsvEditorController.computePastePlan(matrix, anchorRow, anchorCol, selection);
     if (!plan) {
@@ -640,6 +1343,11 @@ class CsvEditorController {
       };
     }
 
+    const rowsToWrite = targetRows ?? Array.from({ length: plan.endRow - plan.startRow + 1 }, (_, index) => plan.startRow + index);
+    if (rowsToWrite.length) {
+      plan.startRow = rowsToWrite[0];
+      plan.endRow = rowsToWrite[rowsToWrite.length - 1];
+    }
     const updates: Array<{ row: number; col: number; value: string }> = [];
     let changed = false;
     let structuralChange = false;
@@ -667,7 +1375,7 @@ class CsvEditorController {
 
     if (plan.fillSelection) {
       const value = String(matrix[0][0] ?? '');
-      for (let row = plan.startRow; row <= plan.endRow; row++) {
+      for (const row of rowsToWrite) {
         for (let col = plan.startCol; col <= plan.endCol; col++) {
           setCellValue(row, col, value);
         }
@@ -675,7 +1383,7 @@ class CsvEditorController {
     } else {
       for (let r = 0; r < matrix.length; r++) {
         for (let c = 0; c < matrix[r].length; c++) {
-          setCellValue(plan.startRow + r, plan.startCol + c, String(matrix[r][c] ?? ''));
+          setCellValue(rowsToWrite[r], plan.startCol + c, String(matrix[r][c] ?? ''));
         }
       }
     }
@@ -698,7 +1406,7 @@ class CsvEditorController {
     if (!Number.isInteger(anchorRow) || anchorRow < 0 || !Number.isInteger(anchorCol) || anchorCol < 0) {
       return;
     }
-    const matrix = this.parseClipboardMatrix(text);
+    const matrix = parseClipboardMatrix(text, this.getSeparator());
     if (!matrix.length || !matrix[0].length) {
       return;
     }
@@ -709,9 +1417,21 @@ class CsvEditorController {
       const separator = this.getSeparator();
       const oldText = this.document.getText();
       const result = Papa.parse(oldText, { dynamicTyping: false, delimiter: separator });
-      const data = result.data as string[][];
-
-      const pasteResult = CsvEditorController.applyPasteMatrixToData(data, matrix, anchorRow, anchorCol, selection);
+      const data = this.trimTrailingEmptyRows(result.data as string[][]);
+
+      const realData = this.trimTrailingEmptyRows(data);
+      const filters = normalizeColumnFilters(CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri), data.reduce((max, row) => Math.max(max, row.length), 0));
+      const visibleRows = [...visibleSourceRows(realData, this.getHiddenRows(), this.getEffectiveHeader(realData, this.getHiddenRows()), filters), realData.length];
+      const anchorIndex = visibleRows.indexOf(anchorRow);
+      if (anchorIndex < 0) {
+        void vscode.window.showInformationMessage('CSV: Select a visible cell and paste again.');
+        return;
+      }
+      const plan = CsvEditorController.computePastePlan(matrix, anchorRow, anchorCol, selection);
+      const targetRows = plan?.fillSelection
+        ? visibleRows.filter(row => row >= plan.startRow && row <= plan.endRow)
+        : matrix.map((_row, index) => visibleRows[anchorIndex + index] ?? realData.length + anchorIndex + index - visibleRows.length + 1);
+      const pasteResult = CsvEditorController.applyPasteMatrixToData(data, matrix, anchorRow, anchorCol, selection, targetRows);
       if (!pasteResult.changed) {
         return;
       }
@@ -719,6 +1439,8 @@ class CsvEditorController {
       let newCsvText: string | undefined;
       if (!pasteResult.structuralChange) {
         newCsvText = CsvEditorProvider.applyFieldUpdatesPreservingFormat(oldText, separator, pasteResult.updates);
+      } else {
+        newCsvText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(oldText, separator, this.trimTrailingEmptyRows(data));
       }
       if (newCsvText === undefined) {
         newCsvText = Papa.unparse(data, { delimiter: separator });
@@ -757,17 +1479,17 @@ class CsvEditorController {
     if (start < state.allRowsCount) {
       const end = Math.min(start + state.chunkRows, state.allRowsCount);
       const html = state.allRows.slice(start, end).map((row, localR) => {
-        const absRow = state.startAbs + start + localR;
-        const displayIdx = start + localR + 1;
+        const absRow = state.rowIds[start + localR];
+        const displayIdx = absRow - state.bodyStart + 1;
         let cells = '';
         for (let cIdx = 0; cIdx < state.numColumns; cIdx++) {
           const rawValue = row[cIdx] || '';
           const safe = this.formatCellContent(rawValue, state.clickableLinks);
           const titleAttr = this.getMultilineCellTitleAttr(rawValue);
-          cells += `<td tabindex="0" style="min-width:${Math.min(state.columnWidths[cIdx] || 0, 100)}ch;max-width:100ch;border:1px solid ${state.isDark ? '#555' : '#ccc'};color:${state.columnColors[cIdx]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;"${titleAttr} data-row="${absRow}" data-col="${cIdx}">${safe}</td>`;
+          cells += `<td tabindex="0" style="min-width:${Math.min(state.columnWidths[cIdx] || 0, 100)}ch;max-width:100ch;border:1px solid var(--csv-table-border, ${state.isDark ? '#555' : '#ccc'});color:${state.columnColors[cIdx]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;"${titleAttr} data-row="${absRow}" data-col="${cIdx}">${safe}</td>`;
         }
         const idxCell = state.addSerialIndex
-          ? `<td tabindex="0" style="min-width:${state.serialIndexWidthCh}ch;max-width:${state.serialIndexWidthCh}ch;border:1px solid ${state.isDark ? '#555' : '#ccc'};color:#888;" data-row="${absRow}" data-col="-1">${displayIdx}</td>`
+          ? `<td tabindex="0" style="min-width:${state.serialIndexWidthCh}ch;max-width:${state.serialIndexWidthCh}ch;border:1px solid var(--csv-table-border, ${state.isDark ? '#555' : '#ccc'});color:#888;" data-row="${absRow}" data-col="-1">${displayIdx}</td>`
           : '';
         return `<tr>${idxCell}${cells}</tr>`;
       }).join('');
@@ -782,26 +1504,28 @@ class CsvEditorController {
     }
 
     if (start === state.allRowsCount && state.includeTrailingEmptyRow) {
-      const virtualAbs = state.startAbs + state.allRowsCount;
-      const displayIdx = state.allRowsCount + 1;
+      const virtualAbs = state.virtualRow;
+      const displayIdx = virtualAbs - state.bodyStart + 1;
       const idxCell = state.addSerialIndex
-        ? `<td tabindex="0" style="min-width:${state.serialIndexWidthCh}ch;max-width:${state.serialIndexWidthCh}ch;border:1px solid ${state.isDark ? '#555' : '#ccc'};color:#888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>`
+        ? `<td tabindex="0" style="min-width:${state.serialIndexWidthCh}ch;max-width:${state.serialIndexWidthCh}ch;border:1px solid var(--csv-table-border, ${state.isDark ? '#555' : '#ccc'});color:#888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>`
         : '';
-      const dataCells = Array.from({ length: state.numColumns }, (_, i) => `<td tabindex="0" style="min-width:${Math.min(state.columnWidths[i] || 0, 100)}ch;max-width:100ch;border:1px solid ${state.isDark ? '#555' : '#ccc'};color:${state.columnColors[i]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
+      const dataCells = Array.from({ length: state.numColumns }, (_, i) => `<td tabindex="0" style="min-width:${Math.min(state.columnWidths[i] || 0, 100)}ch;max-width:100ch;border:1px solid var(--csv-table-border, ${state.isDark ? '#555' : '#ccc'});color:${state.columnColors[i]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
       return { html: `<tr>${idxCell}${dataCells}</tr>`, nextStart: -1, done: true };
     }
 
     return { html: '', nextStart: -1, done: true };
   }
 
-  private async requestChunk(rawStart: unknown, requestId: unknown): Promise<void> {
-    if (!this.currentWebviewPanel || !this.chunkRenderState) {
+  private async requestChunk(rawStart: unknown, requestId: unknown, filterEpoch: unknown, session: unknown): Promise<void> {
+    if (!this.currentWebviewPanel || !this.chunkRenderState || filterEpoch !== this.filterEpoch || session !== this.filterSession) {
       return;
     }
     const start = Number(rawStart);
     if (!Number.isInteger(start) || start < 0) {
       this.currentWebviewPanel.webview.postMessage({
         type: 'chunkData',
+        session: this.filterSession,
+        filterEpoch: this.filterEpoch,
         requestId,
         start: -1,
         html: '',
@@ -813,6 +1537,8 @@ class CsvEditorController {
     const response = this.renderChunkFromState(this.chunkRenderState, start);
     this.currentWebviewPanel.webview.postMessage({
       type: 'chunkData',
+      session: this.filterSession,
+      filterEpoch: this.filterEpoch,
       requestId,
       start,
       html: response.html,
@@ -882,7 +1608,8 @@ class CsvEditorController {
     const offset = Math.min(Math.max(0, hiddenRows), data.length);
     const matches: Array<{ row: number; col: number; value: string }> = [];
 
-    for (let row = offset; row < data.length; row++) {
+    const filters = normalizeColumnFilters(CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri), data.reduce((max, row) => Math.max(max, row.length), 0));
+    for (const row of visibleSourceRows(data, offset, this.getEffectiveHeader(data, hiddenRows), filters)) {
       const current = data[row] || [];
       for (let col = 0; col < current.length; col++) {
         const value = String(current[col] ?? '');
@@ -949,6 +1676,13 @@ class CsvEditorController {
   private async handleSave() {
     this.isSaving = true;
     try {
+      if (this.document.uri.scheme === 'untitled') {
+        // Native Save owns the actual Save As transition. The temporary grid
+        // closes when VS Code closes the original untitled document.
+        await vscode.window.showTextDocument(this.document, { viewColumn: this.currentWebviewPanel?.viewColumn, preview: false });
+        await vscode.commands.executeCommand('workbench.action.files.save');
+        return;
+      }
       const success = await this.document.save();
       console.log(success ? 'CSV: Document saved' : 'CSV: Failed to save document');
     } catch (error) {
@@ -963,14 +1697,17 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = Array.from({ length: data.reduce((max, row) => Math.max(max, row.length), 0) }, (_, column) => column);
     for (const row of data) {
       if (index > row.length) {
         while (row.length < index) row.push('');
       }
       row.splice(index, 0, '');
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 0, -1);
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, undefined, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -980,6 +1717,7 @@ class CsvEditorController {
     edit.replace(this.document.uri, fullRange, newText);
     await vscode.workspace.applyEdit(edit);
     this.isUpdatingDocument = false;
+    await this.remapFilters(order);
     this.updateWebviewContent();
   }
 
@@ -989,7 +1727,8 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = Array.from({ length: data.reduce((max, row) => Math.max(max, row.length), 0) }, (_, column) => column);
     for (let k = 0; k < count; k++) {
       for (const row of data) {
         if (index > row.length) {
@@ -998,7 +1737,9 @@ class CsvEditorController {
         row.splice(index, 0, '');
       }
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 0, ...Array(count).fill(-1));
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, undefined, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1008,6 +1749,7 @@ class CsvEditorController {
     edit.replace(this.document.uri, fullRange, newText);
     await vscode.workspace.applyEdit(edit);
     this.isUpdatingDocument = false;
+    await this.remapFilters(order);
     this.updateWebviewContent();
   }
 
@@ -1016,13 +1758,16 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = Array.from({ length: data.reduce((max, row) => Math.max(max, row.length), 0) }, (_, column) => column);
     for (const row of data) {
       if (index < row.length) {
         row.splice(index, 1);
       }
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 1);
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, undefined, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1032,6 +1777,7 @@ class CsvEditorController {
     edit.replace(this.document.uri, fullRange, newText);
     await vscode.workspace.applyEdit(edit);
     this.isUpdatingDocument = false;
+    await this.remapFilters(order);
     this.updateWebviewContent();
   }
 
@@ -1041,7 +1787,8 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = Array.from({ length: data.reduce((max, row) => Math.max(max, row.length), 0) }, (_, column) => column);
     const sorted = [...indices].sort((a,b)=>b-a);
     for (const idx of sorted) {
       for (const row of data) {
@@ -1050,7 +1797,9 @@ class CsvEditorController {
         }
       }
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    for (const column of sorted) { order.splice(column, 1); }
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, undefined, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1060,6 +1809,7 @@ class CsvEditorController {
     edit.replace(this.document.uri, fullRange, newText);
     await vscode.workspace.applyEdit(edit);
     this.isUpdatingDocument = false;
+    await this.remapFilters(order);
     this.updateWebviewContent();
   }
 
@@ -1110,26 +1860,22 @@ class CsvEditorController {
       return sa.localeCompare(sb, undefined, { sensitivity: 'base' });
     };
 
-    body.sort((r1, r2) => {
+    const filters = normalizeColumnFilters(CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri), rows.reduce((max, row) => Math.max(max, row.length), 0));
+    const matches = compileColumnFilters(filters);
+    const matchingSlots = body.map((_row, slot) => slot).filter(slot => matches(body[slot]));
+    const sortedMatches = matchingSlots.map(slot => body[slot]).sort((r1, r2) => {
       const diff = cmp(r1[index] ?? '', r2[index] ?? '');
       return ascending ? diff : -diff;
     });
+    matchingSlots.forEach((slot, order) => { body[slot] = sortedMatches[order]; });
 
     const prefix = rows.slice(0, offset);
     const combined = treatHeader ? [...prefix, header, ...body] : [...prefix, ...body];
 
-    // Sanitize before unparse: ensure undefined/null/NaN become empty strings
-    const sanitized: string[][] = combined.map(r => r.map((v: any) => {
-      if (v === undefined || v === null) return '';
-      const t = typeof v;
-      if (t === 'number') {
-        return Number.isNaN(v) ? '' : String(v);
-      }
-      const s = String(v);
-      return s.toLowerCase() === 'nan' ? '' : s;
-    }));
-
-    const newCsv = Papa.unparse(sanitized, { delimiter: separator });
+    const originalIndex = new Map(rows.map((row, position) => [row, position]));
+    const rowOrder = combined.map(row => originalIndex.get(row)!);
+    const newCsv = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, combined, rowOrder)
+      ?? Papa.unparse(combined, { delimiter: separator });
 
     const fullRange = new vscode.Range(
       0, 0,
@@ -1151,14 +1897,17 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = data.map((_row, position) => position);
     const numColumns = data.reduce((max, r) => Math.max(max, r.length), 0);
     const newRow = Array(numColumns).fill('');
     if (index > data.length) {
       while (data.length < index) data.push(Array(numColumns).fill(''));
     }
     data.splice(index, 0, newRow);
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 0, -1);
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1177,7 +1926,8 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = data.map((_row, position) => position);
     const numColumns = data.reduce((max, r) => Math.max(max, r.length), 0);
     for (let k = 0; k < count; k++) {
       const newRow = Array(numColumns).fill('');
@@ -1186,7 +1936,9 @@ class CsvEditorController {
       }
       data.splice(index, 0, newRow);
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 0, ...Array(count).fill(-1));
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1204,11 +1956,14 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = data.map((_row, position) => position);
     if (index < data.length) {
       data.splice(index, 1);
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    order.splice(index, 1);
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1227,14 +1982,17 @@ class CsvEditorController {
     const separator = this.getSeparator();
     const text = this.document.getText();
     const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-    const data = result.data as string[][];
+    const data = this.trimTrailingEmptyRows(result.data as string[][]);
+    const order = data.map((_row, position) => position);
     const sorted = [...indices].sort((a,b)=>b-a);
     for (const idx of sorted) {
       if (idx < data.length) {
         data.splice(idx, 1);
       }
     }
-    const newText = Papa.unparse(data, { delimiter: separator });
+    for (const row of sorted) { order.splice(row, 1); }
+    const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, data, order)
+      ?? Papa.unparse(data, { delimiter: separator });
     const fullRange = new vscode.Range(
       0, 0,
       this.document.lineCount,
@@ -1296,7 +2054,7 @@ class CsvEditorController {
       const separator = this.getSeparator();
       const text = this.document.getText();
       const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-      const data = result.data as string[][];
+      const data = this.trimTrailingEmptyRows(result.data as string[][]);
       const numColumns = data.reduce((max, row) => Math.max(max, row.length), 0);
       if (numColumns <= 0) return;
 
@@ -1307,13 +2065,13 @@ class CsvEditorController {
       const reorderedData = data.map(row => {
         const normalized = Array.from({ length: numColumns }, (_, i) => row[i] ?? '');
         const next = columnOrder.map(colIdx => normalized[colIdx] ?? '');
-        while (next.length > 0 && next[next.length - 1] === '') {
-          next.pop();
-        }
-        return next;
+        // Keep explicit empty fields; omit only positions absent from the source row.
+        const lastPresent = columnOrder.reduce((last, colIdx, index) => colIdx < row.length ? index : last, -1);
+        return next.slice(0, lastPresent + 1);
       });
 
-      const newText = Papa.unparse(reorderedData, { delimiter: separator });
+      const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, reorderedData, undefined, columnOrder)
+        ?? Papa.unparse(reorderedData, { delimiter: separator });
       const fullRange = new vscode.Range(
         0, 0,
         this.document.lineCount,
@@ -1322,6 +2080,7 @@ class CsvEditorController {
       const edit = new vscode.WorkspaceEdit();
       edit.replace(this.document.uri, fullRange, newText);
       await vscode.workspace.applyEdit(edit);
+      await this.remapFilters(columnOrder);
       this.updateWebviewContent();
     } finally {
       this.isUpdatingDocument = false;
@@ -1334,13 +2093,15 @@ class CsvEditorController {
       const separator = this.getSeparator();
       const text = this.document.getText();
       const result = Papa.parse(text, { dynamicTyping: false, delimiter: separator });
-      const data = result.data as string[][];
+      const data = this.trimTrailingEmptyRows(result.data as string[][]);
       if (!data.length) return;
 
-      const { reordered, changed } = this.reorderByIndices(data, indices, beforeIndex);
+      const { reordered: rowOrder, changed } = this.reorderByIndices(data.map((_, index) => index), indices, beforeIndex);
       if (!changed) return;
 
-      const newText = Papa.unparse(reordered, { delimiter: separator });
+      const reordered = rowOrder.map(index => data[index]);
+      const newText = CsvEditorProvider.applyStructuralUpdatesPreservingFormat(text, separator, reordered, rowOrder)
+        ?? Papa.unparse(reordered, { delimiter: separator });
       const fullRange = new vscode.Range(
         0, 0,
         this.document.lineCount,
@@ -1358,13 +2119,16 @@ class CsvEditorController {
   // ───────────── Webview Rendering ─────────────
 
   private updateWebviewContent() {
-    if (!this.currentWebviewPanel) return;
+    if (!this.currentWebviewPanel || this.failedCellEdits.size || this.pendingDocumentReference) return;
+    if (this.viewCommitRequested) {
+      this.refreshAfterDraftCommit = true;
+      return;
+    }
 
     const webview = this.currentWebviewPanel.webview;
     const config = vscode.workspace.getConfiguration('csv', this.document.uri);
-    const addSerialIndex = CsvEditorProvider.getSerialIndexForUri(this.context, this.document.uri);
     const separator = this.getSeparator();
-    const hiddenRows = this.getHiddenRows();
+    this.renderedSeparator = separator;
 
     let parsed;
     try {
@@ -1385,33 +2149,19 @@ class CsvEditorController {
 
     const cellPadding = config.get<number>('cellPadding', 4);
     const data = this.trimTrailingEmptyRows((parsed.data || []) as string[][]);
-    const treatHeader = this.getEffectiveHeader(data, hiddenRows);
-    const clickableLinks = config.get<boolean>('clickableLinks', true);
-    const configuredColumnColorMode = config.get<string>('columnColorMode', 'type');
-    const diffUseThemeForeground = config.get<boolean>('diffUseThemeForeground', true);
-    const columnColorMode = CsvEditorController.resolveEffectiveColumnColorMode(
-      configuredColumnColorMode,
-      this.isDiffContext,
-      diffUseThemeForeground
-    );
-    const columnColorPalette = config.get<string>('columnColorPalette', 'default');
-    const showTrailingEmptyRow = config.get<boolean>('showTrailingEmptyRow', true);
+    const filters = normalizeColumnFilters(CsvEditorProvider.getColumnFiltersForUri(this.context, this.document.uri), data.reduce((max, row) => Math.max(max, row.length), 0));
+    const view = this.buildFilterView(data, filters);
+    const filterDraft = this.consumeFilterDraft(view.columns);
+    this.currentHeader = view.headerEnabled;
+    this.chunkRenderState = view.chunkState;
+    this.currentFilterView = view;
+    this.latestFilterRevision = 0;
+    this.filterEpoch = 0;
+    this.filterSession = this.getNonce();
+    this.filterSessionUri = this.document.uri.toString();
     const mouseWheelZoomEnabled = config.get<boolean>('mouseWheelZoom', true);
     const mouseWheelZoomInvert = config.get<boolean>('mouseWheelZoomInvert', false);
-
-    const { tableHtml, chunksJson, colorCss, nextChunkStart, hasRemoteChunks, chunkState } =
-      this.generateTableAndChunks(
-        data,
-        treatHeader,
-        addSerialIndex,
-        hiddenRows,
-        clickableLinks,
-        columnColorMode,
-        columnColorPalette,
-        showTrailingEmptyRow,
-        /* maxSerializedChunks */ 0
-      );
-    this.chunkRenderState = chunkState;
+    const { tableHtml, chunksJson, colorCss, nextChunkStart, hasRemoteChunks } = view;
 
     const nonce = this.getNonce();
 
@@ -1427,11 +2177,36 @@ class CsvEditorController {
       extraColumnColorCss: colorCss,
       nextChunkStart,
       hasRemoteChunks,
+      headerEnabled: view.headerEnabled,
+      firstVisibleRow: view.firstVisibleRow,
       mouseWheelZoomEnabled,
-      mouseWheelZoomInvert
+      mouseWheelZoomInvert,
+      columnSizes: CsvEditorProvider.getColumnSizesForUri(this.context, this.document.uri),
+      frozenPanes: this.getCurrentFrozenPanes(),
+      realRowCount: data.length,
+      visibleRowIds: view.visibleRowIds,
+      filterMetadata: { session: this.filterSession, filterColumnsRevision: this.filterColumnsRevision, filters, columns: view.columns, matchedRows: view.matchedRows, totalRows: view.totalRows, maxFilters: MAX_COLUMN_FILTERS, revision: 0, ...(filterDraft ? { filterDraft } : {}) }
     });
   }
 
+  private buildFilterView(data: string[][], filters: ColumnFilter[]): FilterRender {
+    const config = vscode.workspace.getConfiguration('csv', this.document.uri);
+    const hiddenRows = Math.min(Math.max(0, this.getHiddenRows()), data.length);
+    const headerEnabled = this.getEffectiveHeader(data, hiddenRows);
+    const columnColorMode = CsvEditorController.resolveEffectiveColumnColorMode(
+      config.get<string>('columnColorMode', 'type'), this.isDiffContext, config.get<boolean>('diffUseThemeForeground', true));
+    const render = this.generateTableAndChunks(data, headerEnabled,
+      CsvEditorProvider.getSerialIndexForUri(this.context, this.document.uri), hiddenRows,
+      config.get<boolean>('clickableLinks', true), columnColorMode, config.get<string>('columnColorPalette', 'default'),
+      config.get<boolean>('showTrailingEmptyRow', true), 0, filters);
+    const visible = visibleSourceRows(data, hiddenRows, headerEnabled, filters);
+    return { ...render, filters, columns: this.getFilterColumns(data), headerEnabled,
+      firstVisibleRow: hiddenRows, realRowCount: data.length,
+      visibleRowIds: filters.length ? [...visible, data.length] : [],
+      matchedRows: visible.filter(row => !(headerEnabled && row === hiddenRows)).length,
+      totalRows: Math.max(0, data.length - hiddenRows - (headerEnabled ? 1 : 0)) };
+  }
+
   private generateTableAndChunks(
     data: string[][],
     treatHeader: boolean,
@@ -1441,7 +2216,8 @@ class CsvEditorController {
     columnColorMode: string,
     columnColorPalette: string,
     showTrailingEmptyRow: boolean,
-    maxSerializedChunks: number = Number.MAX_SAFE_INTEGER
+    maxSerializedChunks: number = Number.MAX_SAFE_INTEGER,
+    filters: ColumnFilter[] = []
   ): {
     tableHtml: string;
     chunksJson: string;
@@ -1454,7 +2230,8 @@ class CsvEditorController {
     const totalRows = data.length;
     const offset = Math.min(Math.max(0, hiddenRows), totalRows);
 
-    const isDark = vscode.window.activeColorTheme.kind === vscode.ColorThemeKind.Dark;
+    const themeKind = vscode.window.activeColorTheme.kind;
+    const isDark = themeKind === vscode.ColorThemeKind.Dark || themeKind === vscode.ColorThemeKind.HighContrast;
     let headerRow: string[] = [];
     let bodyData: string[][] = [];
     if (totalRows === 0 || offset >= totalRows) {
@@ -1466,8 +2243,12 @@ class CsvEditorController {
     } else {
       bodyData = data.slice(offset);
     }
+    const bodyStart = headerFlag ? offset + 1 : offset;
+    const matches = compileColumnFilters(filters);
+    const rowIds = bodyData.map((_row, index) => bodyStart + index).filter(row => matches(data[row]));
+    bodyData = rowIds.map(row => data[row]);
     const visibleForWidth = headerFlag ? [headerRow, ...bodyData] : bodyData;
-    let numColumns = visibleForWidth.reduce((max, row) => Math.max(max, row.length), 0);
+    let numColumns = data.reduce((max, row) => Math.max(max, row.length), 0);
     if (numColumns === 0) numColumns = 1; // ensure at least 1 column for the virtual row
 
     const columnData = Array.from({ length: numColumns }, (_, i) => bodyData.map(row => row[i] || ''));
@@ -1478,13 +2259,13 @@ class CsvEditorController {
       : (columnColorPalette === 'warm' ? 'warm' : 'default');
     const columnColors = useThemeForeground
       ? Array.from({ length: numColumns }, () => 'var(--vscode-editor-foreground)')
-      : columnTypes.map((type, i) => this.getColumnColor(type, isDark, i, palette));
+      : columnTypes.map((type, i) => `var(--csv-column-${i}, ${this.getColumnColor(type, isDark, i, palette)})`);
     const columnWidths = this.computeColumnWidths(visibleForWidth);
 
     const BASE_CHUNK_ROWS = 1000;
     const MAX_CELLS_PER_CHUNK = 20000;
     const MIN_CHUNK_ROWS = 10;
-    const allRows = headerFlag ? data.slice(offset + 1) : data.slice(offset);
+    const allRows = bodyData;
     const allRowsCount = allRows.length; // preserve total before any truncation
     const chunkRows = Math.max(
       MIN_CHUNK_ROWS,
@@ -1493,7 +2274,7 @@ class CsvEditorController {
     // Always keep one editable row for fully empty views; otherwise allow disabling the
     // trailing virtual row via settings.
     const includeTrailingEmptyRow = showTrailingEmptyRow || allRowsCount === 0;
-    const serialIndexMaxDisplay = includeTrailingEmptyRow ? allRowsCount + 1 : allRowsCount;
+    const serialIndexMaxDisplay = data.length - bodyStart + (includeTrailingEmptyRow ? 1 : 0);
     const serialIndexWidthCh = Math.max(4, String(Math.max(1, serialIndexMaxDisplay)).length + 1);
     const chunks: string[] = [];
     const chunked = allRowsCount > chunkRows;
@@ -1510,19 +2291,18 @@ class CsvEditorController {
           break;
         }
         const htmlChunk = allRows.slice(i, i + chunkRows).map((row, localR) => {
-          const startAbs = headerFlag ? offset + 1 : offset;
-          const absRow = startAbs + i + localR;
-          const displayIdx = i + localR + 1; // numbering relative to first visible data row
+          const absRow = rowIds[i + localR];
+          const displayIdx = absRow - bodyStart + 1; // retain source numbering across filtered gaps
           let cells = '';
           for (let cIdx = 0; cIdx < numColumns; cIdx++) {
             const rawValue = row[cIdx] || '';
             const safe = this.formatCellContent(rawValue, clickableLinks);
             const titleAttr = this.getMultilineCellTitleAttr(rawValue);
-            cells += `<td tabindex="0" style="min-width:${Math.min(columnWidths[cIdx]||0,100)}ch;max-width:100ch;border:1px solid ${isDark?'#555':'#ccc'};color:${columnColors[cIdx]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;"${titleAttr} data-row="${absRow}" data-col="${cIdx}">${safe}</td>`;
+            cells += `<td tabindex="0" style="min-width:${Math.min(columnWidths[cIdx]||0,100)}ch;max-width:100ch;border:1px solid var(--csv-table-border, ${isDark?'#555':'#ccc'});color:${columnColors[cIdx]};overflow:visible;white-space: pre-wrap;overflow-wrap:anywhere;"${titleAttr} data-row="${absRow}" data-col="${cIdx}">${safe}</td>`;
           }
 
           return `<tr>${
-            addSerialIndex ? `<td tabindex="0" style="min-width:${serialIndexWidthCh}ch;max-width:${serialIndexWidthCh}ch;border:1px solid ${isDark?'#555':'#ccc'};color:#888;" data-row="${absRow}" data-col="-1">${displayIdx}</td>` : ''
+            addSerialIndex ? `<td tabindex="0" style="min-width:${serialIndexWidthCh}ch;max-width:${serialIndexWidthCh}ch;border:1px solid var(--csv-table-border, ${isDark?'#555':'#ccc'});color:#888;" data-row="${absRow}" data-col="-1">${displayIdx}</td>` : ''
           }${cells}</tr>`;
         }).join('');
 
@@ -1531,41 +2311,44 @@ class CsvEditorController {
       }
     }
 
+    // Body classes change in place; inherited variables update every mounted or
+    // later-loaded cell without overriding the user's mode or reloading a draft.
     const colorCss = useThemeForeground
       ? ''
-      : columnColors.map((hex, i) => `td[data-col="${i}"], th[data-col="${i}"] { color: ${hex}; }`).join('');
+      : `body:is(.vscode-light, .vscode-high-contrast-light) { ${columnTypes.map((type, i) => `--csv-column-${i}: ${this.getColumnColor(type, false, i, palette)};`).join('')} }` +
+        `body:is(.vscode-dark, .vscode-high-contrast) { ${columnTypes.map((type, i) => `--csv-column-${i}: ${this.getColumnColor(type, true, i, palette)};`).join('')} }`;
 
     let tableHtml = `<table>`;
     if (headerFlag) {
       tableHtml += `<thead><tr>${
         addSerialIndex
-          ? `<th tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; background-color: ${isDark ? '#1e1e1e' : '#ffffff'}; color: #888;"></th>`
+          ? `<th tabindex="0" data-serial-index="1" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); background-color: var(--csv-header-background, ${isDark ? '#1e1e1e' : '#ffffff'}); color: #888;"></th>`
           : ''
       }`;
       for (let i = 0; i < numColumns; i++) {
         const safe = this.formatCellContent(headerRow[i] || '', clickableLinks);
-        tableHtml += `<th tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; background-color: ${isDark ? '#1e1e1e' : '#ffffff'}; color: ${columnColors[i]}; overflow: hidden; white-space: nowrap; text-overflow: ellipsis;" data-row="${offset}" data-col="${i}">${safe}</th>`;
+        tableHtml += `<th tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); background-color: var(--csv-header-background, ${isDark ? '#1e1e1e' : '#ffffff'}); color: ${columnColors[i]}; overflow: hidden; white-space: nowrap; text-overflow: ellipsis;" data-row="${offset}" data-col="${i}" data-filter-column="${filters.some(filter => filter.column === i) ? 'active' : 'none'}">${safe}</th>`;
       }
       tableHtml += `</tr></thead><tbody>`;
       const initialBodyRows = chunked ? allRows.slice(0, chunkRows) : allRows;
       initialBodyRows.forEach((row, r) => {
         tableHtml += `<tr>${
           addSerialIndex
-            ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: #888;" data-row="${offset + 1 + r}" data-col="-1">${r + 1}</td>`
+            ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: #888;" data-row="${rowIds[r]}" data-col="-1">${rowIds[r] - bodyStart + 1}</td>`
             : ''
         }`;
         for (let i = 0; i < numColumns; i++) {
           const rawValue = row[i] || '';
           const safe = this.formatCellContent(rawValue, clickableLinks);
           const titleAttr = this.getMultilineCellTitleAttr(rawValue);
-          tableHtml += `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;"${titleAttr} data-row="${offset + 1 + r}" data-col="${i}">${safe}</td>`;
+          tableHtml += `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;"${titleAttr} data-row="${rowIds[r]}" data-col="${i}">${safe}</td>`;
         }
         tableHtml += `</tr>`;
       });
       if (!chunked && includeTrailingEmptyRow) {
-        const virtualAbs = offset + 1 + initialBodyRows.length;
-        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: #888;" data-row="${virtualAbs}" data-col="-1">${initialBodyRows.length + 1}</td>` : '';
-        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
+        const virtualAbs = data.length;
+        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: #888;" data-row="${virtualAbs}" data-col="-1">${virtualAbs - bodyStart + 1}</td>` : '';
+        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
         tableHtml += `<tr>${idxCell}${dataCells}</tr>`;
       }
       tableHtml += `</tbody>`;
@@ -1575,22 +2358,22 @@ class CsvEditorController {
       nonHeaderRows.forEach((row, r) => {
         tableHtml += `<tr>${
           addSerialIndex
-            ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: #888;" data-row="${offset + r}" data-col="-1">${r + 1}</td>`
+            ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: #888;" data-row="${rowIds[r]}" data-col="-1">${rowIds[r] - bodyStart + 1}</td>`
             : ''
         }`;
         for (let i = 0; i < numColumns; i++) {
           const rawValue = row[i] || '';
           const safe = this.formatCellContent(rawValue, clickableLinks);
           const titleAttr = this.getMultilineCellTitleAttr(rawValue);
-          tableHtml += `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;"${titleAttr} data-row="${offset + r}" data-col="${i}">${safe}</td>`;
+          tableHtml += `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;"${titleAttr} data-row="${rowIds[r]}" data-col="${i}">${safe}</td>`;
         }
         tableHtml += `</tr>`;
       });
       if (!chunked && includeTrailingEmptyRow) {
-        const virtualAbs = offset + nonHeaderRows.length;
-        const displayIdx = nonHeaderRows.length + 1;
-        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: #888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>` : '';
-        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
+        const virtualAbs = data.length;
+        const displayIdx = virtualAbs - bodyStart + 1;
+        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: #888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>` : '';
+        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
         tableHtml += `<tr>${idxCell}${dataCells}</tr>`;
       }
       tableHtml += `</tbody>`;
@@ -1599,11 +2382,10 @@ class CsvEditorController {
     // If chunked, append a final chunk with the virtual row so it appears at the end.
     if (chunked && includeTrailingEmptyRow) {
       if (nextChunkStart === -1 && serializedChunkCount < safeMaxSerializedChunks) {
-        const startAbs = headerFlag ? offset + 1 : offset;
-        const virtualAbs = startAbs + allRowsCount;
-        const displayIdx = allRowsCount + 1;
-        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: #888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>` : '';
-        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid ${isDark ? '#555' : '#ccc'}; color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
+        const virtualAbs = data.length;
+        const displayIdx = virtualAbs - bodyStart + 1;
+        const idxCell = addSerialIndex ? `<td tabindex="0" style="min-width: ${serialIndexWidthCh}ch; max-width: ${serialIndexWidthCh}ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: #888;" data-row="${virtualAbs}" data-col="-1">${displayIdx}</td>` : '';
+        const dataCells = Array.from({ length: numColumns }, (_, i) => `<td tabindex="0" style="min-width: ${Math.min(columnWidths[i] || 0, 100)}ch; max-width: 100ch; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); color: ${columnColors[i]}; overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere;" data-row="${virtualAbs}" data-col="${i}"></td>`).join('');
         const vrow = `<tr>${idxCell}${dataCells}</tr>`;
         chunks.push(vrow);
       } else if (nextChunkStart === -1) {
@@ -1614,7 +2396,9 @@ class CsvEditorController {
     const hasRemoteChunks = nextChunkStart >= 0;
     const chunkState: ChunkRenderState | undefined = chunked
       ? {
-          startAbs: headerFlag ? offset + 1 : offset,
+          rowIds,
+          bodyStart,
+          virtualRow: data.length,
           allRows,
           allRowsCount,
           chunkRows,
@@ -1667,6 +2451,12 @@ class CsvEditorController {
     return !matches;
   }
 
+  private getMediaUri(...segments: string[]): vscode.Uri {
+    return this.context.extensionUri.with({
+      path: path.posix.join(this.context.extensionUri.path, 'media', ...segments)
+    });
+  }
+
   private wrapHtml(args: {
     webview: vscode.Webview;
     nonce: string;
@@ -1679,14 +2469,30 @@ class CsvEditorController {
     extraColumnColorCss: string;
     nextChunkStart: number;
     hasRemoteChunks: boolean;
+    headerEnabled: boolean;
     mouseWheelZoomEnabled: boolean;
     mouseWheelZoomInvert: boolean;
+    columnSizes: Record<string, number>;
+    frozenPanes: FrozenPanes;
+    firstVisibleRow: number;
+    realRowCount: number;
+    visibleRowIds: number[];
+    filterMetadata: { session: string; filterColumnsRevision: number; filters: ColumnFilter[]; columns: FilterColumn[]; matchedRows: number; totalRows: number; maxFilters: number; revision: number; filterDraft?: FilterDraft };
   }): string {
-    const { webview, nonce, fontFamily, fontSize, cellPadding, separator, tableHtml, chunksJson, extraColumnColorCss, nextChunkStart, hasRemoteChunks, mouseWheelZoomEnabled, mouseWheelZoomInvert } = args;
-    const isDark = vscode.window.activeColorTheme.kind === vscode.ColorThemeKind.Dark;
-    // Build script URI using file path for compatibility (older APIs may lack Uri.joinPath)
+    const { webview, nonce, fontFamily, fontSize, cellPadding, separator, tableHtml, chunksJson, extraColumnColorCss, nextChunkStart, hasRemoteChunks, headerEnabled, mouseWheelZoomEnabled, mouseWheelZoomInvert, columnSizes, frozenPanes, firstVisibleRow, realRowCount, visibleRowIds, filterMetadata } = args;
+    const themeKind = vscode.window.activeColorTheme.kind;
+    const isDark = themeKind === vscode.ColorThemeKind.Dark || themeKind === vscode.ColorThemeKind.HighContrast;
     const scriptUri = webview.asWebviewUri(
-      vscode.Uri.file(path.join(this.context.extensionPath, 'media', 'main.js'))
+      this.getMediaUri('main.js')
+    );
+
+    const filterScriptUri = webview.asWebviewUri(this.getMediaUri('column-filters.js'));
+    const filterMetadataJson = JSON.stringify(filterMetadata).replace(/[<>&\u2028\u2029]/g, character => '\\u' + character.charCodeAt(0).toString(16).padStart(4, '0'));
+    const frozenPanesScriptUri = webview.asWebviewUri(
+      this.getMediaUri('frozen-panes.js')
+    );
+    const contrastStyleUri = webview.asWebviewUri(
+      this.getMediaUri('high-contrast.css')
     );
 
     // Safe separator transport (assumes single character; see assumptions)
@@ -1701,18 +2507,41 @@ class CsvEditorController {
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>CSV</title>
     <style nonce="${nonce}">
+      /* Preserve the existing light/dark colors as theme classes change. */
+      body:is(.vscode-light, .vscode-high-contrast-light) {
+        --csv-table-border: #ccc;
+        --csv-header-background: #ffffff;
+        --csv-selection-background: #cce0ff;
+        --csv-find-highlight-background: #fefefe;
+        --csv-find-active-background: #ffffcc;
+        --csv-link-color: #0066cc;
+        --csv-link-hover-color: #0044aa;
+        --csv-menu-background: #ffffff;
+        --csv-menu-hover-background: #eeeeee;
+      }
+      body:is(.vscode-dark, .vscode-high-contrast) {
+        --csv-table-border: #555;
+        --csv-header-background: #1e1e1e;
+        --csv-selection-background: #333333;
+        --csv-find-highlight-background: #2a2a2a;
+        --csv-find-active-background: #444444;
+        --csv-link-color: #6cb6ff;
+        --csv-link-hover-color: #8ecfff;
+        --csv-menu-background: #2d2d2d;
+        --csv-menu-hover-background: #3d3d3d;
+      }
       body { font-family: ${this.escapeCss(fontFamily)}; font-size: ${fontSize}px; margin: 0; padding: 0; user-select: none; }
       .table-container { overflow: auto; height: 100vh; }
       table { border-collapse: collapse; width: max-content; }
-      th, td { padding: ${cellPadding}px 8px; border: 1px solid ${isDark ? '#555' : '#ccc'}; font-size: inherit; }
-      th { position: sticky; top: 0; background-color: ${isDark ? '#1e1e1e' : '#ffffff'}; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
+      th, td { padding: ${cellPadding}px 8px; border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); font-size: inherit; }
+      th { position: static; background-color: var(--csv-header-background, ${isDark ? '#1e1e1e' : '#ffffff'}); overflow: hidden; white-space: nowrap; text-overflow: ellipsis; }
       td { overflow: visible; white-space: pre-wrap; overflow-wrap: anywhere; }
-      td.selected, th.selected { background-color: ${isDark ? '#333333' : '#cce0ff'} !important; }
+      td.selected, th.selected { background-color: var(--csv-selection-background, ${isDark ? '#333333' : '#cce0ff'}) !important; }
       td.editing, th.editing { overflow: visible !important; white-space: pre-wrap !important; overflow-wrap: anywhere !important; max-width: none !important; }
-      .highlight { background-color: ${isDark ? '#2a2a2a' : '#fefefe'} !important; }
-      .active-match { background-color: ${isDark ? '#444444' : '#ffffcc'} !important; }
-      .csv-link { color: ${isDark ? '#6cb6ff' : '#0066cc'}; text-decoration: underline; cursor: pointer; }
-      .csv-link:hover { color: ${isDark ? '#8ecfff' : '#0044aa'}; }
+      .highlight { background-color: var(--csv-find-highlight-background, ${isDark ? '#2a2a2a' : '#fefefe'}) !important; }
+      .active-match { background-color: var(--csv-find-active-background, ${isDark ? '#444444' : '#ffffcc'}) !important; }
+      .csv-link { color: var(--csv-link-color, ${isDark ? '#6cb6ff' : '#0066cc'}); text-decoration: underline; cursor: pointer; }
+      .csv-link:hover { color: var(--csv-link-hover-color, ${isDark ? '#8ecfff' : '#0044aa'}); }
       #findReplaceWidget {
         position: fixed;
         top: 12px;
@@ -1885,19 +2714,55 @@ class CsvEditorController {
         font-size: inherit;
       }
       #findReplaceWidget .fr-overflow-item:hover { background: rgba(255,255,255,0.05); }
-      #contextMenu { position: absolute; display: none; background: ${isDark ? '#2d2d2d' : '#ffffff'}; border: 1px solid ${isDark ? '#555' : '#ccc'}; z-index: 10000; font-family: ${this.escapeCss(fontFamily)}; font-size: inherit; }
+      #contextMenu { position: fixed; display: none; width: max-content; box-sizing: border-box; overflow: auto; overflow-wrap: anywhere; background: var(--csv-menu-background, ${isDark ? '#2d2d2d' : '#ffffff'}); border: 1px solid var(--csv-table-border, ${isDark ? '#555' : '#ccc'}); z-index: 10000; font-family: ${this.escapeCss(fontFamily)}; font-size: inherit; }
       #contextMenu div { padding: 4px 12px; cursor: pointer; }
-      #contextMenu div:hover { background: ${isDark ? '#3d3d3d' : '#eeeeee'}; }
+      #contextMenu div:hover { background: var(--csv-menu-hover-background, ${isDark ? '#3d3d3d' : '#eeeeee'}); }
 
+      #csv-root .csv-frozen-row, #csv-root .csv-frozen-column {
+        position: sticky;
+        background-color: var(--vscode-editor-background, ${isDark ? '#1e1e1e' : '#ffffff'}) !important;
+      }
+      /* Paint collapsed divider seams with the sticky cells instead of the scrolling table. */
+      #csv-root .csv-frozen-row::before {
+        content: "";
+        position: absolute;
+        inset: -0.5px 0;
+        border-block: 1px solid var(--csv-contrast-border, var(--csv-table-border, ${isDark ? '#555' : '#ccc'}));
+        box-sizing: border-box;
+        pointer-events: none;
+      }
+      #csv-root .csv-frozen-row.selected, #csv-root .csv-frozen-column.selected {
+        background-image: linear-gradient(var(--vscode-editor-selectionBackground, ${isDark ? '#333333' : '#cce0ff'}), var(--vscode-editor-selectionBackground, ${isDark ? '#333333' : '#cce0ff'}));
+      }
+      #csv-root .csv-frozen-row.highlight, #csv-root .csv-frozen-column.highlight {
+        background-image: linear-gradient(var(--vscode-editor-findMatchHighlightBackground, transparent), var(--vscode-editor-findMatchHighlightBackground, transparent));
+      }
+      #csv-root .csv-frozen-row.active-match, #csv-root .csv-frozen-column.active-match {
+        background-image: linear-gradient(var(--vscode-editor-findMatchBackground, transparent), var(--vscode-editor-findMatchBackground, transparent));
+      }
+      #filterStatus { position: sticky; top: 0; left: 0; z-index: 6; display: flex; flex-direction: column; gap: 8px; align-items: stretch; max-height: 25vh; overflow: auto; padding: 6px; background: var(--vscode-editorWidget-background, ${isDark ? '#252526' : '#ffffff'}); color: var(--vscode-editorWidget-foreground, inherit); border-bottom: 1px solid var(--vscode-editorWidget-border, ${isDark ? '#555' : '#ccc'}); }
+      #filterStatus[hidden] { display: none; }
+      #filterStatus button { color: inherit; background: transparent; border: 1px solid var(--vscode-button-border, currentColor); border-radius: 3px; cursor: pointer; }
+      .column-filter-toolbar, .column-filter-row { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; }
+      .column-filter-conditions { display: flex; flex-direction: column; gap: 6px; }
+      .column-filter-row select, .column-filter-row input { max-width: 100%; min-width: 0; box-sizing: border-box; font: inherit; color: var(--vscode-input-foreground, inherit); background: var(--vscode-input-background, transparent); border: 1px solid var(--vscode-input-border, var(--vscode-editorWidget-border, currentColor)); }
+      .column-filter-row input { flex: 1 1 18ch; }
+      .column-filter-error { color: var(--vscode-errorForeground, inherit); flex-basis: 100%; }
+      .column-filter-type, .column-filter-and { font-size: 0.9em; }
+      th[data-filter-column="active"]::after { content: " ⏷"; }
+      #filterStatus button:focus-visible { outline: 2px solid var(--vscode-focusBorder); }
       /* Per-column computed colors */
-      ${extraColumnColorCss}
     </style>
+    <style id="__csvColumnColors" nonce="${nonce}">${extraColumnColorCss}</style>
+    <link rel="stylesheet" href="${contrastStyleUri}">
   </head>
   <body>
-    <div id="csv-root" class="table-container" data-sepcode="${sepCode}" data-fontsize="${fontSize}" data-wheelzoomenabled="${mouseWheelZoomEnabled ? '1' : '0'}" data-wheelzoominvert="${mouseWheelZoomInvert ? '1' : '0'}" data-nextchunkstart="${nextChunkStart >= 0 ? nextChunkStart : ''}" data-hasmorechunks="${hasRemoteChunks ? '1' : '0'}">
+    <div id="csv-root" data-headerenabled="${headerEnabled ? '1' : '0'}" data-roworder="${this.escapeHtml(JSON.stringify(visibleRowIds))}" data-filtered="${filterMetadata.filters.length ? '1' : '0'}" data-filterepoch="0" data-frozenrows="${frozenPanes.rows}" data-frozencolumns="${frozenPanes.columns}" data-firstrow="${firstVisibleRow}" data-realrowcount="${realRowCount}" data-columnsizes="${this.escapeHtml(JSON.stringify(columnSizes))}" class="table-container" data-sepcode="${sepCode}" data-fontsize="${fontSize}" data-wheelzoomenabled="${mouseWheelZoomEnabled ? '1' : '0'}" data-wheelzoominvert="${mouseWheelZoomInvert ? '1' : '0'}" data-nextchunkstart="${nextChunkStart >= 0 ? nextChunkStart : ''}" data-hasmorechunks="${hasRemoteChunks ? '1' : '0'}">
+      <div id="filterStatus" aria-label="Column filters"${filterMetadata.filters.length ? '' : ' hidden'}></div>
       ${tableHtml}
     </div>
 
+    <script id="__csvFilters" type="application/json" nonce="${nonce}">${filterMetadataJson}</script>
     <script id="__csvChunks" type="application/json" nonce="${nonce}">${chunksJson}</script>
 
     <div id="findReplaceWidget" class="replace-collapsed" role="group" aria-label="Find and Replace">
@@ -1930,7 +2795,7 @@ class CsvEditorController {
           </div>
           <div class="fr-actions">
             <button id="replaceOne" class="fr-action-btn" type="button" aria-label="Replace" title="Replace" disabled>↵</button>
-            <button id="replaceAll" class="fr-action-btn" type="button" aria-label="Replace All" title="Replace All" disabled>⇅</button>
+            <button id="replaceAll" class="fr-action-btn" type="button" aria-label="Replace All" title="${filterMetadata.filters.length ? 'Replace All in matching filtered rows' : 'Replace All'}" disabled>⇅</button>
           </div>
         </div>
         <div id="findOverflowMenu" class="fr-overflow-menu" role="menu" aria-label="Find Options">
@@ -1942,6 +2807,8 @@ class CsvEditorController {
     </div>
     <div id="contextMenu"></div>
 
+    <script nonce="${nonce}" src="${frozenPanesScriptUri}"></script>
+    <script nonce="${nonce}" src="${filterScriptUri}"></script>
     <script nonce="${nonce}" src="${scriptUri}"></script>
   </body>
 </html>`;
@@ -1954,7 +2821,9 @@ class CsvEditorController {
     const widths = Array(numColumns).fill(0);
     for (const row of data) {
       for (let i = 0; i < numColumns; i++){
-        widths[i] = Math.max(widths[i], (row[i] || '').length);
+        for (const line of (row[i] || '').split(/\r\n|[\r\n]/)) {
+          widths[i] = Math.max(widths[i], line.length);
+        }
       }
     }
     console.log(`CSV: Column widths: ${widths}`);
@@ -1962,6 +2831,12 @@ class CsvEditorController {
   }
 
   private getSeparator(): string {
+    if (this.pendingDocumentReference) {
+      return this.pendingDocumentReference.separator;
+    }
+    if ((this.failedCellEdits.size || this.refreshAfterDraftCommit) && this.renderedSeparator !== undefined) {
+      return this.renderedSeparator;
+    }
     const stored = CsvEditorProvider.getSeparatorForUri(this.context, this.document.uri);
     if (stored && stored.length) return stored;
 
@@ -1976,7 +2851,9 @@ class CsvEditorController {
       return this.separatorCache.separator;
     }
 
-    const filePath = this.document?.uri.fsPath || this.document?.uri.path || '';
+    const filePath = this.document.uri.scheme === 'untitled'
+      ? this.document.languageId === 'tsv' ? 'untitled.tsv' : 'untitled.csv'
+      : this.document?.uri.fsPath || this.document?.uri.path || '';
     const text = this.document.getText();
     const separator = CsvEditorProvider.resolveInheritedSeparator(filePath, text, settings);
     this.separatorCache = { version, configKey, separator };
@@ -2202,6 +3079,9 @@ export class CsvEditorProvider implements vscode.CustomTextEditorProvider {
   public static readonly headerKey     = 'csv.headerByUri';
   public static readonly serialKey     = 'csv.serialIndexByUri';
   public static readonly sepKey        = 'csv.separatorByUri';
+  public static readonly columnSizesKey = 'csv.columnSizesByUri';
+  public static readonly frozenPanesKey = 'csv.frozenPanesByUri';
+  public static readonly columnFiltersKey = 'csv.columnFiltersByUri';
   private static readonly DEFAULT_SEPARATOR = ',';
   private static readonly DEFAULT_SEPARATOR_MODE: SeparatorMode = 'extension';
   private static readonly BUILTIN_SEPARATORS_BY_EXTENSION: Record<string, string> = {
@@ -2386,8 +3266,8 @@ export class CsvEditorProvider implements vscode.CustomTextEditorProvider {
     const sep = delimiter && delimiter.length ? delimiter : CsvEditorProvider.DEFAULT_SEPARATOR;
     const rows: CsvFieldSpan[][] = [];
     let row: CsvFieldSpan[] = [];
-    let fieldStart = 0;
-    let i = 0;
+    let fieldStart = text.startsWith('\uFEFF') ? 1 : 0;
+    let i = fieldStart;
     let inQuotes = false;
     let quoted = false;
 
@@ -2507,6 +3387,90 @@ export class CsvEditorProvider implements vscode.CustomTextEditorProvider {
     return output;
   }
 
+  public static applyStructuralUpdatesPreservingFormat(
+    text: string,
+    delimiter: string,
+    data: string[][],
+    rowOrder?: number[],
+    columnOrder?: number[]
+  ): string | undefined {
+    const parsed = Papa.parse<string[]>(text, { delimiter, dynamicTyping: false });
+    if (parsed.errors.some(error => error.type === 'Quotes')) {
+      return undefined;
+    }
+    const original = parsed.data;
+    let contentRowCount = original.length;
+    while (contentRowCount > 0 && original[contentRowCount - 1].every(value => value === '')) {
+      contentRowCount--;
+    }
+    const spans = CsvEditorProvider.parseCsvFieldSpans(text, delimiter);
+    // Pasting into the displayed append row can fill an existing empty source
+    // record. Consume that record rather than retaining it again as a suffix.
+    for (let row = 0; row < data.length; row++) {
+      const sourceRow = rowOrder?.[row] ?? row;
+      const sourceEnd = spans[sourceRow]?.slice(-1)[0]?.end;
+      const sourceStart = spans[sourceRow]?.[0]?.start;
+      if (sourceEnd !== undefined && (sourceEnd < text.length || (sourceStart ?? sourceEnd) < sourceEnd) && data[row].some(value => value !== '')) {
+        contentRowCount = Math.max(contentRowCount, sourceRow + 1);
+      }
+    }
+    const bom = text.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const lastSpan = contentRowCount > 0 ? spans[contentRowCount - 1]?.slice(-1)[0] : undefined;
+    const suffix = text.slice(lastSpan?.end ?? bom.length);
+    const rowBreak = (row: number): string | undefined => {
+      const end = spans[row]?.slice(-1)[0]?.end;
+      if (end === undefined) {
+        return undefined;
+      }
+      return /^(\r\n|\n|\r)/.exec(text.slice(end))?.[0];
+    };
+    const defaultBreak = parsed.meta.linebreak || '\n';
+    const columnPrefersQuotes = (col: number): boolean => {
+      // The body supplies the convention when a header uses a different style.
+      const sample = spans.slice(contentRowCount > 1 ? 1 : 0, contentRowCount)
+        .map(row => row[col]).filter((span): span is CsvFieldSpan => !!span);
+      return sample.length > 0 && sample.every(span => span.quoted);
+    };
+    const quotedColumns = new Map<number, boolean>();
+    let output = bom;
+    for (let row = 0; row < data.length; row++) {
+      const sourceRow = rowOrder?.[row] ?? row;
+      const fields: string[] = [];
+      for (let col = 0; col < data[row].length; col++) {
+        const sourceCol = columnOrder?.[col] ?? col;
+        const span = sourceRow < contentRowCount ? spans[sourceRow]?.[sourceCol] : undefined;
+        const value = data[row][col] ?? '';
+        if (span && original[sourceRow]?.[sourceCol] === value) {
+          fields.push(text.slice(span.start, span.end));
+        } else {
+          if (!quotedColumns.has(sourceCol)) {
+            quotedColumns.set(sourceCol, columnPrefersQuotes(sourceCol));
+          }
+          fields.push(CsvEditorProvider.encodeCsvField(value, delimiter, span?.quoted ?? quotedColumns.get(sourceCol) ?? false));
+        }
+      }
+      output += fields.join(delimiter);
+      if (row < data.length - 1) {
+        output += rowBreak(sourceRow) ?? defaultBreak;
+      }
+    }
+    output += suffix;
+    // Papa Parse remains authoritative: never reuse source tokens if their
+    // reconstruction would change the requested values or field boundaries.
+    const actual = Papa.parse<string[]>(output, { delimiter, dynamicTyping: false });
+    const trimEmpty = (rows: string[][]) => {
+      const result = [...rows];
+      while (result.length > 0 && result[result.length - 1].every(value => value === '')) {
+        result.pop();
+      }
+      return result;
+    };
+    if (actual.errors.some(error => error.type === 'Quotes') || JSON.stringify(trimEmpty(actual.data)) !== JSON.stringify(trimEmpty(data))) {
+      return undefined;
+    }
+    return output;
+  }
+
   constructor(private readonly context: vscode.ExtensionContext) {}
 
   public async resolveCustomTextEditor(
@@ -2516,31 +3480,36 @@ export class CsvEditorProvider implements vscode.CustomTextEditorProvider {
   ): Promise<void> {
     console.log(`CSV(reg): creating controller for ${document.uri.toString()}`);
     const controller = new CsvEditorController(this.context);
-    // Track active controller
-    webviewPanel.onDidChangeViewState(e => {
-      if (e.webviewPanel.active) {
-        CsvEditorProvider.currentActive = controller;
-      }
-    });
     await controller.resolveCustomTextEditor(document, webviewPanel, _token);
   }
 
   public static getActiveProvider(): CsvEditorController | undefined {
-    return CsvEditorProvider.currentActive || CsvEditorProvider.editors.find(ed => ed.isActive());
+    const current = CsvEditorProvider.currentActive;
+    return current?.isActive() ? current : CsvEditorProvider.editors.find(ed => ed.isActive());
+  }
+
+  public static hasHiddenRowsOverride(context: vscode.ExtensionContext, uri: vscode.Uri): boolean {
+    const map = context.workspaceState.get<Record<string, number>>(CsvEditorProvider.hiddenRowsKey, {});
+    const saved = map[uri.toString()];
+    return Object.prototype.hasOwnProperty.call(map, uri.toString()) && typeof saved === 'number' && Number.isFinite(saved);
   }
 
   public static getHiddenRowsForUri(context: vscode.ExtensionContext, uri: vscode.Uri): number {
     const map = context.workspaceState.get<Record<string, number>>(CsvEditorProvider.hiddenRowsKey, {});
-    const n = map[uri.toString()] ?? 0;
-    return Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+    const saved = map[uri.toString()];
+    if (Object.prototype.hasOwnProperty.call(map, uri.toString()) && typeof saved === 'number' && Number.isFinite(saved)) {
+      return Math.max(0, Math.floor(saved));
+    }
+    const configured = vscode.workspace.getConfiguration('csv', uri).get<number>('defaultIgnoreRows', 0);
+    return typeof configured === 'number' && Number.isFinite(configured) ? Math.max(0, Math.floor(configured)) : 0;
   }
 
-  public static async setHiddenRowsForUri(context: vscode.ExtensionContext, uri: vscode.Uri, n: number): Promise<void> {
-    const map = { ...(context.workspaceState.get<Record<string, number>>(CsvEditorProvider.hiddenRowsKey, {})) };
-    if (!Number.isFinite(n) || n <= 0) {
+  public static async setHiddenRowsForUri(context: vscode.ExtensionContext, uri: vscode.Uri, n: number | undefined): Promise<void> {
+    const map = { ...context.workspaceState.get<Record<string, number>>(CsvEditorProvider.hiddenRowsKey, {}) };
+    if (n === undefined || !Number.isFinite(n)) {
       delete map[uri.toString()];
     } else {
-      map[uri.toString()] = Math.floor(n);
+      map[uri.toString()] = Math.max(0, Math.floor(n));
     }
     await context.workspaceState.update(CsvEditorProvider.hiddenRowsKey, map);
   }
@@ -2572,6 +3541,74 @@ export class CsvEditorProvider implements vscode.CustomTextEditorProvider {
     await context.workspaceState.update(CsvEditorProvider.serialKey, map);
   }
 
+  public static getColumnFiltersForUri(context: vscode.ExtensionContext, uri: vscode.Uri): ColumnFilter[] {
+    const map = context.workspaceState.get<Record<string, unknown>>(CsvEditorProvider.columnFiltersKey, {});
+    return normalizeColumnFilters(map[uri.toString()]);
+  }
+
+  public static async setColumnFiltersForUri(context: vscode.ExtensionContext, uri: vscode.Uri, filters: unknown): Promise<void> {
+    const map = { ...context.workspaceState.get<Record<string, unknown>>(CsvEditorProvider.columnFiltersKey, {}) };
+    const normalized = normalizeColumnFilters(filters);
+    if (normalized.length) {
+      map[uri.toString()] = normalized;
+    } else {
+      delete map[uri.toString()];
+    }
+    await context.workspaceState.update(CsvEditorProvider.columnFiltersKey, map);
+  }
+
+  public static getFrozenPanesForUri(context: vscode.ExtensionContext, uri: vscode.Uri, header: boolean): FrozenPanes {
+    const map = context.workspaceState.get<Record<string, Partial<FrozenPanes>>>(CsvEditorProvider.frozenPanesKey, {});
+    const saved = map[uri.toString()] ?? {};
+    const valid = (value: unknown): value is number => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+    return { rows: valid(saved.rows) ? saved.rows : (header ? 1 : 0), columns: valid(saved.columns) ? saved.columns : 0 };
+  }
+
+  public static async setFrozenPanesForUri(context: vscode.ExtensionContext, uri: vscode.Uri, change: Partial<FrozenPanes>): Promise<void> {
+    const map = { ...context.workspaceState.get<Record<string, Partial<FrozenPanes>>>(CsvEditorProvider.frozenPanesKey, {}) };
+    const saved = { ...map[uri.toString()] };
+    for (const axis of ['rows', 'columns'] as const) {
+      const value = change[axis];
+      if (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0) {
+        saved[axis] = value;
+      }
+    }
+    map[uri.toString()] = saved;
+    await context.workspaceState.update(CsvEditorProvider.frozenPanesKey, map);
+  }
+
+  public static normalizeColumnSizes(raw: unknown): Record<string, number> {
+    const sizes: Record<string, number> = {};
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+      return sizes;
+    }
+    for (const [key, value] of Object.entries(raw)) {
+      const col = Number(key);
+      const width = Number(value);
+      if (!Number.isInteger(col) || col < 0 || !Number.isFinite(width) || width < 40) {
+        continue;
+      }
+      sizes[String(col)] = Math.round(width);
+    }
+    return sizes;
+  }
+
+  public static getColumnSizesForUri(context: vscode.ExtensionContext, uri: vscode.Uri): Record<string, number> {
+    const map = context.workspaceState.get<Record<string, unknown>>(CsvEditorProvider.columnSizesKey, {});
+    return CsvEditorProvider.normalizeColumnSizes(map[uri.toString()]);
+  }
+
+  public static async setColumnSizesForUri(context: vscode.ExtensionContext, uri: vscode.Uri, raw: unknown): Promise<void> {
+    const map = { ...context.workspaceState.get<Record<string, unknown>>(CsvEditorProvider.columnSizesKey, {}) };
+    const sizes = CsvEditorProvider.normalizeColumnSizes(raw);
+    if (Object.keys(sizes).length) {
+      map[uri.toString()] = sizes;
+    } else {
+      delete map[uri.toString()];
+    }
+    await context.workspaceState.update(CsvEditorProvider.columnSizesKey, map);
+  }
+
   public static getSeparatorForUri(context: vscode.ExtensionContext, uri: vscode.Uri): string | undefined {
     const map = context.workspaceState.get<Record<string, string>>(CsvEditorProvider.sepKey, {});
     return map[uri.toString()];
diff --git a/src/bounded-csv-reader.ts b/src/bounded-csv-reader.ts
new file mode 100644
index 0000000..494c5a8
--- /dev/null
+++ b/src/bounded-csv-reader.ts
@@ -0,0 +1,220 @@
+import { promises as fs } from 'fs';
+import { TextDecoder } from 'util';
+import Papa from 'papaparse';
+
+export const previewLimits = {
+  readBytes: 64 * 1024,
+  pageBytes: 512 * 1024,
+  recordBytes: 256 * 1024,
+  pageCells: 20000,
+  columns: 1000,
+  history: 32
+};
+
+export type CsvPreviewPage = {
+  rows: string[][];
+  offset: number;
+  nextOffset: number;
+  done: boolean;
+  version: string;
+  bytesRead: number;
+};
+
+export type CsvPreviewReadOptions = {
+  delimiter: string;
+  offset?: number;
+  maxRows?: number;
+  expectedVersion?: string;
+  cancelled?: () => boolean;
+  // Smaller read buffers make boundary handling deterministic in unit tests.
+  readBytes?: number;
+};
+
+function version(stat: { dev: number; ino: number; size: number; mtimeMs: number }): string {
+  return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeMs}`;
+}
+
+export async function readCsvPreviewPage(filePath: string, options: CsvPreviewReadOptions): Promise<CsvPreviewPage> {
+  if (options.delimiter.length !== 1 || options.delimiter.charCodeAt(0) > 127 || /[\r\n"\0]/.test(options.delimiter)) {
+    throw new Error('Large File Preview requires a single ASCII separator. Set a separator override or use the editable CSV view.');
+  }
+  const checkCancelled = () => {
+    if (options.cancelled?.()) {
+      throw new Error('Large File Preview was cancelled.');
+    }
+  };
+  checkCancelled();
+  const handle = await fs.open(filePath, 'r');
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile()) {
+      throw new Error('Large File Preview can only read regular files.');
+    }
+    const fileVersion = version(stat);
+    if (options.expectedVersion && options.expectedVersion !== fileVersion) {
+      throw new Error('The file changed. Choose Back to Start to reload it.');
+    }
+    const offset = options.offset ?? 0;
+    if (!Number.isSafeInteger(offset) || offset < 0 || offset > stat.size) {
+      throw new Error('Invalid preview position. Choose Back to Start.');
+    }
+    const requestedRows = Math.trunc(Number(options.maxRows ?? 1000));
+    const maxRows = Number.isFinite(requestedRows) ? Math.min(10000, Math.max(1, requestedRows)) : 1000;
+    const readSize = Math.min(previewLimits.readBytes, Math.max(1, Math.trunc(options.readBytes ?? previewLimits.readBytes)));
+    const readBuffer = Buffer.alloc(readSize);
+    const recordBuffer = Buffer.alloc(previewLimits.recordBytes);
+    const rows: string[][] = [];
+    const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+    const delimiter = options.delimiter.charCodeAt(0);
+    let position = offset;
+    let recordStart = offset;
+    let recordLength = 0;
+    let recordFields = 1;
+    let usedBytes = 0;
+    let usedCells = 0;
+    let bytesRead = 0;
+    let state: 'start' | 'plain' | 'quoted' | 'closed' = 'start';
+    let pendingCr = false;
+    let stopped = false;
+    let nextOffset = offset;
+
+    if (offset === 0) {
+      const signature = Buffer.alloc(3);
+      const first = await handle.read(signature, 0, 3, 0);
+      bytesRead += first.bytesRead;
+      if ((signature[0] === 0xFF && signature[1] === 0xFE) || (signature[0] === 0xFE && signature[1] === 0xFF)) {
+        throw new Error('Large File Preview supports UTF-8 files only. Use the normal editor and Reopen with Encoding for this file.');
+      }
+      if (first.bytesRead === 3 && signature.equals(Buffer.from([0xEF, 0xBB, 0xBF]))) {
+        position = recordStart = 3;
+      }
+    }
+
+    const finishRecord = (end: number, terminatorBytes: number) => {
+      if (usedBytes + recordLength > previewLimits.pageBytes && rows.length > 0) {
+        stopped = true;
+        nextOffset = recordStart;
+        return;
+      }
+      let text: string;
+      try {
+        text = decoder.decode(recordBuffer.subarray(0, recordLength - terminatorBytes));
+      } catch {
+        throw new Error('Large File Preview supports valid UTF-8 only. Reopen the original file with its source encoding in the normal editor.');
+      }
+      if (text.includes('\0')) {
+        throw new Error('The file contains NUL bytes. Large File Preview supports UTF-8 text files only.');
+      }
+      // Prefix an empty field so Papa does not strip an intentional U+FEFF at
+      // the start of a later record when parsing records independently.
+      const parsed = Papa.parse<string[]>(`${options.delimiter}${text}`, { delimiter: options.delimiter, dynamicTyping: false });
+      if (parsed.errors.some(error => error.type === 'Quotes') || parsed.data.length !== 1) {
+        throw new Error(`Malformed CSV record at byte ${recordStart}. No partial record was displayed.`);
+      }
+      const row = parsed.data[0].slice(1);
+      if (row.length > previewLimits.columns) {
+        throw new Error(`A record exceeds the ${previewLimits.columns}-column preview limit. No fields were truncated.`);
+      }
+      if (usedCells + row.length > previewLimits.pageCells && rows.length > 0) {
+        stopped = true;
+        nextOffset = recordStart;
+        return;
+      }
+      rows.push(row);
+      usedBytes += recordLength;
+      usedCells += row.length;
+      nextOffset = recordStart = end;
+      recordLength = 0;
+      recordFields = 1;
+      state = 'start';
+      pendingCr = false;
+      stopped = rows.length >= maxRows || usedBytes >= previewLimits.pageBytes || usedCells >= previewLimits.pageCells;
+    };
+
+    while (!stopped && position < stat.size) {
+      checkCancelled();
+      const read = await handle.read(readBuffer, 0, readBuffer.length, position);
+      bytesRead += read.bytesRead;
+      if (read.bytesRead === 0) {
+        break;
+      }
+      for (let index = 0; index < read.bytesRead && !stopped; index++) {
+        const byte = readBuffer[index];
+        if (pendingCr && byte !== 10) {
+          finishRecord(position, 1);
+          if (stopped) {
+            break;
+          }
+        }
+        if (recordLength >= recordBuffer.length) {
+          throw new Error(`A record exceeds the ${previewLimits.recordBytes / 1024} KiB preview limit. No partial record was displayed.`);
+        }
+        recordBuffer[recordLength++] = byte;
+        position++;
+        if (pendingCr) {
+          finishRecord(position, 2);
+        } else if (state === 'quoted') {
+          if (byte === 34) {
+            state = 'closed';
+          }
+        } else if (state === 'closed' && byte === 34) {
+          state = 'quoted';
+        } else if (byte === 13) {
+          pendingCr = true;
+        } else if (byte === 10) {
+          finishRecord(position, 1);
+        } else if (byte === delimiter) {
+          recordFields++;
+          if (recordFields > previewLimits.columns) {
+            throw new Error(`A record exceeds the ${previewLimits.columns}-column preview limit. No fields were truncated.`);
+          }
+          state = 'start';
+        } else if (state === 'start' && byte === 34) {
+          state = 'quoted';
+        } else if (state === 'closed') {
+          if (byte !== 32 && byte !== 9) {
+            throw new Error(`Malformed quoted field at byte ${position - 1}. No partial record was displayed.`);
+          }
+        } else {
+          state = 'plain';
+        }
+      }
+    }
+    if (!stopped && recordLength > 0) {
+      if (state === 'quoted') {
+        throw new Error(`Unterminated quoted record at byte ${recordStart}. No partial record was displayed.`);
+      }
+      finishRecord(position, pendingCr ? 1 : 0);
+    }
+    if (rows.length === 0) {
+      nextOffset = position;
+    }
+    checkCancelled();
+    if (version(await fs.stat(filePath)) !== fileVersion || version(await handle.stat()) !== fileVersion) {
+      throw new Error('The file changed while reading. Choose Back to Start to reload it.');
+    }
+    return { rows, offset, nextOffset, done: nextOffset >= stat.size, version: fileVersion, bytesRead };
+  } finally {
+    await handle.close();
+  }
+}
+
+export type PreviewPosition = { offset: number; record: number };
+
+export class PreviewHistory {
+  private positions: PreviewPosition[] = [{ offset: 0, record: 0 }];
+  private index = 0;
+  get current(): PreviewPosition { return this.positions[this.index]; }
+  get canGoBack(): boolean { return this.index > 0; }
+  get size(): number { return this.positions.length; }
+  reset(): void { this.positions = [{ offset: 0, record: 0 }]; this.index = 0; }
+  previous(): void { if (this.canGoBack) { this.index--; } }
+  next(position: PreviewPosition): void {
+    this.positions.splice(this.index + 1);
+    this.positions.push(position);
+    if (this.positions.length > previewLimits.history) {
+      this.positions.shift();
+    }
+    this.index = this.positions.length - 1;
+  }
+}
diff --git a/src/clipboard.ts b/src/clipboard.ts
new file mode 100644
index 0000000..3c934ae
--- /dev/null
+++ b/src/clipboard.ts
@@ -0,0 +1,86 @@
+import Papa from 'papaparse';
+
+const clipboardDelimiterCandidates = ['\t', ',', ';', '|'];
+
+export function serializeClipboardMatrix(matrix: string[][], delimiter: string): string {
+  const escapedCharacters = [delimiter, ...clipboardDelimiterCandidates, '"', '\r', '\n', '\uFEFF'];
+  // Quote each value independently: a complex neighbor must not wrap plain text.
+  return Papa.unparse(matrix, {
+    delimiter,
+    quotes: value => value === '' || value.startsWith(' ') || value.endsWith(' ') ||
+      escapedCharacters.some(character => value.includes(character)),
+    newline: '\r\n'
+  });
+}
+
+// Papa's candidate parsers can mistake separators inside a later quoted field
+// for delimiters when the first field is unquoted. Remove candidates that occur
+// only inside complete quoted fields, then leave parsing/scoring to Papa.
+function clipboardDelimitersOutsideQuotes(text: string, candidates: string[]): string[] {
+  const tokens = [...candidates].sort((a, b) => b.length - a.length);
+  const found = new Set<string>();
+  let quoted = new Set<string>();
+  let inQuotes = false;
+  let fieldStart = true;
+  const at = (index: number) => tokens.find(token => text.startsWith(token, index));
+  for (let i = 0; i < text.length;) {
+    const character = text[i];
+    if (inQuotes) {
+      if (character === '"') {
+        if (text[i + 1] === '"') { i += 2; continue; }
+        const next = text[i + 1];
+        if (next !== undefined && next !== '\r' && next !== '\n' && !at(i + 1)) {
+          // An incomplete/malformed quoted prefix is ordinary external text.
+          for (const token of quoted) { found.add(token); }
+        }
+        inQuotes = false;
+        quoted = new Set();
+        fieldStart = false;
+        i++;
+      } else {
+        const token = at(i);
+        if (token) { quoted.add(token); i += token.length; }
+        else { i++; }
+      }
+      continue;
+    }
+    if (character === '"' && fieldStart) {
+      inQuotes = true;
+      i++;
+      continue;
+    }
+    const token = at(i);
+    if (token) {
+      found.add(token);
+      fieldStart = true;
+      i += token.length;
+    } else {
+      fieldStart = character === '\r' || character === '\n';
+      i++;
+    }
+  }
+  // Do not hide genuine separators behind an unterminated literal quote.
+  if (inQuotes) { for (const token of quoted) { found.add(token); } }
+  return candidates.filter(candidate => found.has(candidate));
+}
+
+export function parseClipboardMatrix(text: string, fallbackDelimiter: string): string[][] {
+  if (!text) {
+    return [];
+  }
+  const candidates = [fallbackDelimiter, ...clipboardDelimiterCandidates].filter((value, index, all) => value.length > 0 && all.indexOf(value) === index);
+  const available = clipboardDelimitersOutsideQuotes(text, candidates);
+  const parsed = Papa.parse<string[]>(text, {
+    dynamicTyping: false,
+    delimiter: available.length > 1 ? '' : available[0] || fallbackDelimiter,
+    delimitersToGuess: available
+  });
+  const matrix = parsed.data.map(row => row.map(value => String(value ?? '')));
+  // A terminal record separator creates one parser sentinel, not an extra record.
+  // Preserve explicit blank records, including quoted empty fields.
+  if (/[\r\n]$/.test(text) && matrix.length > 1 && matrix[matrix.length - 1].length === 1 && matrix[matrix.length - 1][0] === '') {
+    matrix.pop();
+  }
+  const width = matrix.reduce((max, row) => Math.max(max, row.length), 0);
+  return matrix.map(row => [...row, ...Array(width - row.length).fill('')]);
+}
diff --git a/src/column-filters.ts b/src/column-filters.ts
new file mode 100644
index 0000000..26221d7
--- /dev/null
+++ b/src/column-filters.ts
@@ -0,0 +1,197 @@
+import { RE2JS } from 're2js';
+import { FilterDataType, compileFilterDateComparison, compileFilterNumberComparison, parseFilterBoolean } from './filter-values';
+
+export type { FilterDataType } from './filter-values';
+export type ColumnFilterOperator = 'contains' | 'notContains' | 'regex' | 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'empty' | 'notEmpty';
+export type ColumnFilter = { column: number; operator: ColumnFilterOperator; value: string; dataType?: FilterDataType };
+export type ColumnFilterOperatorChoice = { operator: ColumnFilterOperator; label: string };
+export type CompiledColumnFilters = (row: readonly string[]) => boolean;
+export const MAX_FILTER_VALUE_LENGTH = 4096;
+export const MAX_COLUMN_FILTERS = 256;
+
+const operatorChoices: readonly ColumnFilterOperatorChoice[] = [
+  { operator: 'contains', label: 'Contains' },
+  { operator: 'notContains', label: 'Does Not Contain' },
+  { operator: 'regex', label: 'Regular Expression' },
+  { operator: 'equals', label: 'Equals' },
+  { operator: 'notEquals', label: 'Does Not Equal' },
+  { operator: 'greaterThan', label: 'Greater Than' },
+  { operator: 'greaterThanOrEqual', label: 'Greater Than or Equal' },
+  { operator: 'lessThan', label: 'Less Than' },
+  { operator: 'lessThanOrEqual', label: 'Less Than or Equal' },
+  { operator: 'empty', label: 'Is Empty' },
+  { operator: 'notEmpty', label: 'Is Not Empty' }
+];
+const operators = new Set(operatorChoices.map(choice => choice.operator));
+const dataTypes = new Set<FilterDataType>(['string', 'number', 'date', 'boolean']);
+const orderedOperators = new Set<ColumnFilterOperator>(['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual']);
+
+export function getFilterOperatorChoices(dataType: FilterDataType): readonly ColumnFilterOperatorChoice[] {
+  return operatorChoices.filter(choice => !orderedOperators.has(choice.operator) || dataType === 'number' || dataType === 'date');
+}
+
+function compileFilterRegex(value: string): RE2JS {
+  let pattern = value;
+  let flags = RE2JS.CASE_INSENSITIVE;
+  if (value.startsWith('/')) {
+    let closingSlash = -1;
+    for (let i = value.length - 1; i > 0; i--) {
+      if (value[i] !== '/') {
+        continue;
+      }
+      let backslashes = 0;
+      for (let j = i - 1; j >= 0 && value[j] === '\\'; j--) {
+        backslashes++;
+      }
+      if (backslashes % 2 === 0) {
+        closingSlash = i;
+        break;
+      }
+    }
+    if (closingSlash > 0) {
+      pattern = value.slice(1, closingSlash);
+      flags = 0;
+      const seen = new Set<string>();
+      for (const flag of value.slice(closingSlash + 1)) {
+        if (seen.has(flag) || (flag !== 'i' && flag !== 'm' && flag !== 's')) {
+          throw new Error('Only the i, m, and s flags are supported, without duplicates.');
+        }
+        seen.add(flag);
+        flags |= flag === 'i' ? RE2JS.CASE_INSENSITIVE : flag === 'm' ? RE2JS.MULTILINE : RE2JS.DOTALL;
+      }
+    }
+  }
+  return RE2JS.compile(pattern, flags);
+}
+
+function compileValuePredicate(operator: ColumnFilterOperator, query: string, dataType: FilterDataType): (value: string) => boolean {
+  if (operator === 'empty') {
+    return value => value === '';
+  }
+  if (operator === 'notEmpty') {
+    return value => value !== '';
+  }
+  if (operator === 'regex') {
+    const regex = compileFilterRegex(query);
+    return value => regex.matcher(value).find();
+  }
+  if (operator === 'contains' || operator === 'notContains') {
+    const lowerQuery = query.toLowerCase();
+    return operator === 'contains' ? value => value.toLowerCase().includes(lowerQuery) : value => !value.toLowerCase().includes(lowerQuery);
+  }
+  if (orderedOperators.has(operator) && dataType !== 'number' && dataType !== 'date') {
+    throw new Error('Ordered comparisons require a number or date column.');
+  }
+  if (dataType === 'string') {
+    const lowerQuery = query.toLowerCase();
+    return operator === 'equals' ? value => value.toLowerCase() === lowerQuery : value => value.toLowerCase() !== lowerQuery;
+  }
+  if (dataType === 'number' || dataType === 'date') {
+    const compare = dataType === 'number' ? compileFilterNumberComparison(query) : compileFilterDateComparison(query);
+    if (!compare) {
+      throw new Error(`Enter a valid ${dataType} value.`);
+    }
+    return value => {
+      const comparison = compare(value);
+      if (comparison === undefined) {
+        return false;
+      }
+      switch (operator) {
+        case 'equals': return comparison === 0;
+        case 'notEquals': return comparison !== 0;
+        case 'greaterThan': return comparison > 0;
+        case 'greaterThanOrEqual': return comparison >= 0;
+        case 'lessThan': return comparison < 0;
+        case 'lessThanOrEqual': return comparison <= 0;
+        default: return false;
+      }
+    };
+  }
+  const threshold = parseFilterBoolean(query);
+  if (threshold === undefined) {
+    throw new Error(`Enter a valid ${dataType} value.`);
+  }
+  return value => {
+    const scalar = parseFilterBoolean(value);
+    if (scalar === undefined) {
+      return false;
+    }
+    return operator === 'equals' ? scalar === threshold : scalar !== threshold;
+  };
+}
+
+export function validateColumnFilterInput(operator: ColumnFilterOperator, value: string, dataType: FilterDataType = 'string'): string | undefined {
+  if (!operators.has(operator) || !dataTypes.has(dataType)) {
+    return 'Choose a valid filter operator and data type.';
+  }
+  if (typeof value !== 'string' || value.length > MAX_FILTER_VALUE_LENGTH) {
+    return `Filter values must contain at most ${MAX_FILTER_VALUE_LENGTH} characters.`;
+  }
+  try {
+    compileValuePredicate(operator, value, dataType);
+    return undefined;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return operator === 'regex' ? `Enter a valid RE2 regular expression: ${detail}` : detail;
+  }
+}
+
+export function normalizeColumnFilters(raw: unknown, columnCount = Infinity): ColumnFilter[] {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const normalized: ColumnFilter[] = [];
+  for (const item of raw.slice(0, MAX_COLUMN_FILTERS)) {
+    if (!item || typeof item !== 'object') {
+      continue;
+    }
+    const { column, operator, value, dataType } = item as Partial<ColumnFilter>;
+    if (typeof column !== 'number' || !Number.isSafeInteger(column) || column < 0 || column >= columnCount || !operators.has(operator as ColumnFilterOperator) || typeof value !== 'string' || value.length > MAX_FILTER_VALUE_LENGTH || (dataType !== undefined && !dataTypes.has(dataType))) {
+      continue;
+    }
+    // Invalid query syntax remains visible and removable; compilation fails closed.
+    normalized.push({ column, operator: operator!, value, ...(dataType === undefined ? {} : { dataType }) });
+  }
+  return normalized;
+}
+
+export function compileColumnFilters(filters: readonly ColumnFilter[]): CompiledColumnFilters {
+  if (filters.length > MAX_COLUMN_FILTERS) {
+    return () => false;
+  }
+  try {
+    const predicates = filters.map(filter => {
+      const dataType = filter.dataType ?? 'string';
+      if (!Number.isSafeInteger(filter.column) || filter.column < 0 || !operators.has(filter.operator) || !dataTypes.has(dataType) || typeof filter.value !== 'string' || filter.value.length > MAX_FILTER_VALUE_LENGTH) {
+        throw new Error('Invalid column filter.');
+      }
+      const matches = compileValuePredicate(filter.operator, filter.value, dataType);
+      return (row: readonly string[]) => matches(String(row[filter.column] ?? ''));
+    });
+    return row => predicates.every(matches => matches(row));
+  } catch {
+    return () => false;
+  }
+}
+
+export function rowMatchesFilters(row: readonly string[], filters: readonly ColumnFilter[]): boolean {
+  return compileColumnFilters(filters)(row);
+}
+
+export function visibleSourceRows(data: readonly string[][], hiddenRows: number, header: boolean, filters: readonly ColumnFilter[]): number[] {
+  const start = Math.min(Math.max(0, hiddenRows), data.length);
+  const rows: number[] = [];
+  const matches = compileColumnFilters(filters);
+  for (let row = start; row < data.length; row++) {
+    if ((header && row === start) || matches(data[row])) {
+      rows.push(row);
+    }
+  }
+  return rows;
+}
+
+// new column index -> original index; -1 denotes an inserted empty column.
+export function remapColumnFilters(filters: readonly ColumnFilter[], columnOrder: readonly number[]): ColumnFilter[] {
+  return filters.flatMap(filter => columnOrder.flatMap((oldColumn, column) =>
+    oldColumn === filter.column ? [{ ...filter, column }] : []));
+}
diff --git a/src/commands.ts b/src/commands.ts
index 6241b3d..e890437 100644
--- a/src/commands.ts
+++ b/src/commands.ts
@@ -1,6 +1,11 @@
 import { getFonts } from 'font-list';
 import * as vscode from 'vscode';
 import { CsvEditorProvider } from './CsvEditorProvider';
+import { openLargeFilePreview } from './large-file-preview';
+import { toggleCsvEditor } from './editor-switch';
+import type { EditorSwitchRouting } from './editor-associations';
+import { compareFilesAsTable } from './table-comparison';
+import { saveActiveUntitledCsvEditor } from './untitled-editors';
 
 function displaySeparator(separator: string): string {
   return separator === '\t' ? '\\t' : separator;
@@ -19,11 +24,61 @@ async function toggleBooleanConfig(key: string, defaultVal: boolean, messagePref
   CsvEditorProvider.editors.forEach(ed => ed.refresh());
 }
 
-export function registerCsvCommands(context: vscode.ExtensionContext) {
+async function changeFrozenPaneCount(axis: 'rows' | 'columns') {
+  const active = CsvEditorProvider.getActiveProvider();
+  if (!active) {
+    vscode.window.showInformationMessage('Open a CSV/TSV/PSV file in the CSV editor.');
+    return;
+  }
+  const current = active.getCurrentFrozenPanes()[axis];
+  const input = await vscode.window.showInputBox({
+    prompt: `Number of leading visible ${axis} to freeze (0 unfreezes)`,
+    value: String(current),
+    validateInput: value => /^\d+$/.test(value) && Number.isSafeInteger(Number(value)) ? undefined : 'Enter a non-negative whole number.'
+  });
+  if (input !== undefined && /^\d+$/.test(input) && Number.isSafeInteger(Number(input))) {
+    await active.setFrozenPanes({ [axis]: Number(input) });
+  }
+}
+
+async function toggleCsvEnabled(synchronizeRouting: () => Promise<void>): Promise<void> {
+  const config = vscode.workspace.getConfiguration('csv');
+  const inspected = config.inspect<boolean>('enabled');
+  const target = inspected?.workspaceValue !== undefined ? vscode.ConfigurationTarget.Workspace : vscode.ConfigurationTarget.Global;
+  const previous = target === vscode.ConfigurationTarget.Workspace ? inspected?.workspaceValue : inspected?.globalValue;
+  const next = !config.get<boolean>('enabled', true);
+  await config.update('enabled', next, target);
+  try {
+    await synchronizeRouting();
+  } catch (error) {
+    // Do not report Off while VS Code still routes searches into the custom view.
+    const current = config.inspect<boolean>('enabled');
+    const value = target === vscode.ConfigurationTarget.Workspace ? current?.workspaceValue : current?.globalValue;
+    if (value === next) {
+      await config.update('enabled', previous, target);
+      try { await synchronizeRouting(); } catch (restoreError) { console.error('CSV: routing rollback failed', restoreError); }
+    }
+    console.error('CSV: extension toggle was not applied', error);
+    return;
+  }
+  vscode.window.showInformationMessage(`CSV extension ${next ? 'enabled' : 'disabled'}.`);
+  CsvEditorProvider.editors.slice().forEach(ed => ed.refresh());
+}
+
+export function registerCsvCommands(context: vscode.ExtensionContext, synchronizeRouting: () => Promise<void> = async () => {}, prepareEditorRouting?: (uri: vscode.Uri, target: 'default' | 'csv.editor') => Promise<EditorSwitchRouting>) {
+  let pendingToggle: Promise<void> = Promise.resolve();
   context.subscriptions.push(
-    vscode.commands.registerCommand('csv.toggleExtension', () =>
-      toggleBooleanConfig('enabled', true, 'CSV extension')
-    ),
+    vscode.commands.registerCommand('csv.changeFrozenRows', () => changeFrozenPaneCount('rows')),
+    vscode.commands.registerCommand('csv.changeFrozenColumns', () => changeFrozenPaneCount('columns')),
+    vscode.commands.registerCommand('csv.openLargeFilePreview', openLargeFilePreview),
+    vscode.commands.registerCommand('csv.toggleEditor', () => toggleCsvEditor(prepareEditorRouting)),
+    vscode.commands.registerCommand('csv.compareFilesAsTable', (resource?: vscode.Uri, selected?: vscode.Uri[]) => compareFilesAsTable(context, resource, selected)),
+    vscode.commands.registerCommand('csv.saveUntitled', saveActiveUntitledCsvEditor),
+    vscode.commands.registerCommand('csv.toggleExtension', () => {
+      const next = pendingToggle.catch(() => {}).then(() => toggleCsvEnabled(synchronizeRouting));
+      pendingToggle = next;
+      return next;
+    }),
     vscode.commands.registerCommand('csv.toggleClickableLinks', () =>
       toggleBooleanConfig('clickableLinks', true, 'CSV clickable links')
     ),
@@ -114,23 +169,29 @@ export function registerCsvCommands(context: vscode.ExtensionContext) {
       const uri = active.getDocumentUri();
       const current = CsvEditorProvider.getHiddenRowsForUri(context, uri);
       const input = await vscode.window.showInputBox({
-        prompt: 'Hide first N rows (per file)',
+        prompt: 'Hide first N rows for this file (blank inherits csv.defaultIgnoreRows)',
         value: String(current),
-        validateInput: (val: string) => (/^\d+$/.test(val) ? undefined : 'Enter a non-negative integer')
+        validateInput: (val: string) => (val.trim() === '' || (/^\d+$/.test(val) && Number.isSafeInteger(Number(val))) ? undefined : 'Enter a non-negative integer or leave blank to inherit')
       });
       if (input === undefined) { return; }
-      const n = parseInt(input, 10);
+      if (input.trim() !== '' && (!/^\d+$/.test(input) || !Number.isSafeInteger(Number(input)))) { return; }
+      const n = input.trim() === '' ? undefined : Number(input);
       await CsvEditorProvider.setHiddenRowsForUri(context, uri, n);
       // Refresh only editors showing this URI
       CsvEditorProvider.editors
         .filter(ed => ed.getDocumentUri().toString() === uri.toString())
-        .forEach(ed => ed.refresh());
-      vscode.window.showInformationMessage(`CSV: Hiding first ${n} row(s) for this file.`);
+        .forEach(ed => ed.refreshViewSafely());
+      vscode.window.showInformationMessage(n === undefined ? 'CSV: Hidden rows now inherit csv.defaultIgnoreRows for this file.' : `CSV: Hiding first ${n} row(s) for this file.`);
     }),
-    vscode.commands.registerCommand('csv.changeEncoding', async () => {
+    vscode.commands.registerCommand('csv.changeEncoding', async (requestedUri?: vscode.Uri) => {
       const active = CsvEditorProvider.getActiveProvider();
-      if (!active) { vscode.window.showInformationMessage('Open a CSV/TSV/PSV file in the CSV editor.'); return; }
-      const uri = active.getDocumentUri();
+      const uri = requestedUri instanceof vscode.Uri ? requestedUri : active?.getDocumentUri();
+      if (!uri) { vscode.window.showInformationMessage('Open a CSV/TSV/PSV file in the CSV editor.'); return; }
+      if (uri.scheme === 'untitled') {
+        vscode.window.showInformationMessage('Save this document before changing its file encoding.');
+        return;
+      }
+
 
       // Close any existing tabs for this URI so we can reuse the slot cleanly
       try {
@@ -144,10 +205,14 @@ export function registerCsvCommands(context: vscode.ExtensionContext) {
         });
         if (toClose.length) {
           console.log(`[CSV(encoding)]: closing ${toClose.length} tab(s) for ${uri.fsPath}`);
-          await vscode.window.tabGroups.close(toClose);
+          const closed = await vscode.window.tabGroups.close(toClose);
+          if (!closed) {
+            return;
+          }
         }
       } catch (e) {
         console.warn('[CSV(encoding)]: failed to close existing tabs', e);
+        return;
       }
 
       // Open the default text editor in-place and invoke the built-in encoding picker
diff --git a/src/csv-table-diff.ts b/src/csv-table-diff.ts
new file mode 100644
index 0000000..641b1e5
--- /dev/null
+++ b/src/csv-table-diff.ts
@@ -0,0 +1,234 @@
+import Papa from 'papaparse';
+
+export const comparisonLimits = {
+  sourceBytes: 10 * 1024 * 1024,
+  textBytes: 5 * 1024 * 1024,
+  rows: 10000,
+  cells: 100000,
+  columns: 1000,
+  cellChars: 64 * 1024,
+  recordChars: 256 * 1024,
+  alignmentCells: 1000000,
+  replacementCells: 1000000,
+  alignmentDepth: 20,
+  pageRows: 200,
+  pageCells: 20000,
+  pageChars: 512 * 1024
+};
+
+export type ComparedRecord = {
+  original?: number;
+  modified?: number;
+  kind: 'equal' | 'changed' | 'added' | 'removed';
+  changedColumns: number[];
+};
+export type CsvTableDiff = {
+  originalRows: string[][];
+  modifiedRows: string[][];
+  records: ComparedRecord[];
+  approximate: boolean;
+  added: number;
+  removed: number;
+  changed: number;
+};
+
+export function parseComparisonRows(text: string, delimiter: string): string[][] {
+  if (Buffer.byteLength(text, 'utf8') > comparisonLimits.textBytes) {
+    throw new Error('Table comparison supports at most 5 MiB of decoded text per file. Use a text diff for larger files.');
+  }
+  const parsed = Papa.parse<string[]>(text, { delimiter, dynamicTyping: false });
+  if (parsed.errors.some(error => error.type === 'Quotes')) {
+    throw new Error('The input contains malformed quoted CSV. Correct it before comparing as a table.');
+  }
+  const rows = parsed.data;
+  if (/[\r\n]$/.test(text) && rows.length && rows[rows.length - 1].length === 1 && rows[rows.length - 1][0] === '') {
+    rows.pop(); // Papa's EOF marker is not an additional logical record.
+  }
+  if (rows.length > comparisonLimits.rows) {
+    throw new Error('Table comparison supports at most 10,000 records per file. Use a text diff for larger files.');
+  }
+  let cells = 0;
+  for (const row of rows) {
+    cells += row.length;
+    if (row.length > comparisonLimits.columns || cells > comparisonLimits.cells) {
+      throw new Error('Table comparison supports at most 1,000 columns and 100,000 cells per file. No fields were truncated.');
+    }
+    if (row.some(value => value.length > comparisonLimits.cellChars) || row.reduce((sum, value) => sum + value.length, 0) > comparisonLimits.recordChars) {
+      throw new Error('A value or record exceeds the table comparison display limit. No content was truncated.');
+    }
+  }
+  return rows;
+}
+
+export function compareCsvRows(originalRows: string[][], modifiedRows: string[][]): CsvTableDiff {
+  const original = originalRows.map(row => JSON.stringify(row));
+  const modified = modifiedRows.map(row => JSON.stringify(row));
+  const matches: Array<[number, number]> = [];
+  let budget = comparisonLimits.alignmentCells;
+  let approximate = false;
+
+  const uniqueAnchors = (a0: number, a1: number, b0: number, b1: number): Array<[number, number]> => {
+    const indices = (values: string[], start: number, end: number) => {
+      const map = new Map<string, number>();
+      for (let index = start; index < end; index++) {
+        map.set(values[index], map.has(values[index]) ? -1 : index);
+      }
+      return map;
+    };
+    const left = indices(original, a0, a1);
+    const right = indices(modified, b0, b1);
+    const candidates: Array<[number, number]> = [];
+    for (let index = a0; index < a1; index++) {
+      const other = right.get(original[index]);
+      if (left.get(original[index]) === index && other !== undefined && other >= 0) {
+        candidates.push([index, other]);
+      }
+    }
+    const tails: number[] = [];
+    const predecessors = Array(candidates.length).fill(-1);
+    for (let index = 0; index < candidates.length; index++) {
+      let low = 0, high = tails.length;
+      while (low < high) {
+        const middle = (low + high) >>> 1;
+        if (candidates[tails[middle]][1] < candidates[index][1]) { low = middle + 1; } else { high = middle; }
+      }
+      predecessors[index] = low > 0 ? tails[low - 1] : -1;
+      tails[low] = index;
+    }
+    const anchors: Array<[number, number]> = [];
+    for (let index = tails.length ? tails[tails.length - 1] : -1; index >= 0; index = predecessors[index]) {
+      anchors.push(candidates[index]);
+    }
+    return anchors.reverse();
+  };
+
+  const align = (a0: number, a1: number, b0: number, b1: number, depth: number): void => {
+    while (a0 < a1 && b0 < b1 && original[a0] === modified[b0]) {
+      matches.push([a0++, b0++]);
+    }
+    const suffix: Array<[number, number]> = [];
+    while (a0 < a1 && b0 < b1 && original[a1 - 1] === modified[b1 - 1]) {
+      suffix.push([--a1, --b1]);
+    }
+    if (a0 < a1 && b0 < b1) {
+      const height = a1 - a0, width = b1 - b0;
+      const cost = (height + 1) * (width + 1);
+      if (cost <= budget) {
+        budget -= cost;
+        const stride = width + 1;
+        const lengths = new Uint16Array(cost);
+        for (let a = height - 1; a >= 0; a--) {
+          for (let b = width - 1; b >= 0; b--) {
+            lengths[a * stride + b] = original[a0 + a] === modified[b0 + b]
+              ? lengths[(a + 1) * stride + b + 1] + 1
+              : Math.max(lengths[(a + 1) * stride + b], lengths[a * stride + b + 1]);
+          }
+        }
+        let a = 0, b = 0;
+        while (a < height && b < width) {
+          if (original[a0 + a] === modified[b0 + b]) { matches.push([a0 + a++, b0 + b++]); }
+          else if (lengths[(a + 1) * stride + b] >= lengths[a * stride + b + 1]) { a++; }
+          else { b++; }
+        }
+      } else if (depth < comparisonLimits.alignmentDepth) {
+        const anchors = uniqueAnchors(a0, a1, b0, b1);
+        if (!anchors.length) {
+          approximate = true;
+        } else {
+          for (const [a, b] of anchors) {
+            align(a0, a, b0, b, depth + 1);
+            matches.push([a, b]);
+            a0 = a + 1; b0 = b + 1;
+          }
+          align(a0, a1, b0, b1, depth + 1);
+        }
+      } else {
+        approximate = true;
+      }
+    }
+    matches.push(...suffix.reverse());
+  };
+  align(0, original.length, 0, modified.length, 0);
+
+  const result: CsvTableDiff = { originalRows, modifiedRows, records: [], approximate, added: 0, removed: 0, changed: 0 };
+  const append = (a: number | undefined, b: number | undefined) => {
+    const before = a === undefined ? undefined : originalRows[a];
+    const after = b === undefined ? undefined : modifiedRows[b];
+    const changedColumns: number[] = [];
+    for (let col = 0; col < Math.max(before?.length ?? 0, after?.length ?? 0); col++) {
+      if (!before || !after || col >= before.length || col >= after.length || before[col] !== after[col]) {
+        changedColumns.push(col);
+      }
+    }
+    const kind = a === undefined ? 'added' : b === undefined ? 'removed' : changedColumns.length ? 'changed' : 'equal';
+    result.records.push({ original: a, modified: b, kind, changedColumns });
+    if (kind !== 'equal') { result[kind]++; }
+  };
+  let replacementBudget = comparisonLimits.replacementCells;
+  const appendGap = (a0: number, a1: number, b0: number, b1: number) => {
+    const height = a1 - a0, width = b1 - b0;
+    const columns = Math.max(1, ...originalRows.slice(a0, a1).map(row => row.length), ...modifiedRows.slice(b0, b1).map(row => row.length));
+    const work = height * width * columns;
+    if (height && width && work <= replacementBudget && (height + 1) * (width + 1) <= comparisonLimits.replacementCells) {
+      replacementBudget -= work;
+      const stride = width + 1;
+      const costs = new Float64Array((height + 1) * stride);
+      const choices = new Uint8Array(height * width);
+      for (let a = 0; a <= height; a++) { costs[a * stride + width] = height - a; }
+      for (let b = 0; b <= width; b++) { costs[height * stride + b] = width - b; }
+      for (let a = height - 1; a >= 0; a--) {
+        for (let b = width - 1; b >= 0; b--) {
+          const before = originalRows[a0 + a], after = modifiedRows[b0 + b];
+          let equal = 0;
+          for (let col = 0; col < Math.min(before.length, after.length); col++) {
+            if (before[col] === after[col]) { equal++; }
+          }
+          // Shared fields favor pairing a modified record over an adjacent insertion/deletion.
+          const replace = 2 * (1 - equal / Math.max(1, before.length, after.length)) + costs[(a + 1) * stride + b + 1];
+          const remove = 1 + costs[(a + 1) * stride + b];
+          const add = 1 + costs[a * stride + b + 1];
+          const choice = replace <= remove && replace <= add ? 0 : remove <= add ? 1 : 2;
+          choices[a * width + b] = choice;
+          costs[a * stride + b] = choice === 0 ? replace : choice === 1 ? remove : add;
+        }
+      }
+      let a = 0, b = 0;
+      while (a < height || b < width) {
+        const choice = a === height ? 2 : b === width ? 1 : choices[a * width + b];
+        if (choice === 0) { append(a0 + a++, b0 + b++); }
+        else if (choice === 1) { append(a0 + a++, undefined); }
+        else { append(undefined, b0 + b++); }
+      }
+    } else {
+      if (height && width) { result.approximate = true; }
+      for (let index = 0; index < Math.max(height, width); index++) {
+        append(a0 + index < a1 ? a0 + index : undefined, b0 + index < b1 ? b0 + index : undefined);
+      }
+    }
+  };
+  let a = 0, b = 0;
+  for (const [nextA, nextB] of [...matches, [original.length, modified.length]]) {
+    appendGap(a, nextA, b, nextB);
+    if (nextA < original.length && nextB < modified.length) { append(nextA, nextB); }
+    a = nextA + 1; b = nextB + 1;
+  }
+  return result;
+}
+
+export function comparisonPages(diff: CsvTableDiff): Array<{ start: number; end: number }> {
+  const pages: Array<{ start: number; end: number }> = [];
+  let start = 0, cells = 0, chars = 0;
+  for (let index = 0; index < diff.records.length; index++) {
+    const record = diff.records[index];
+    const before = record.original === undefined ? [] : diff.originalRows[record.original];
+    const after = record.modified === undefined ? [] : diff.modifiedRows[record.modified];
+    const nextCells = Math.max(before.length, after.length) * 2 + 2;
+    const nextChars = [...before, ...after].reduce((sum, value) => sum + value.length, 0);
+    if (index > start && (index - start >= comparisonLimits.pageRows || cells + nextCells > comparisonLimits.pageCells || chars + nextChars > comparisonLimits.pageChars)) {
+      pages.push({ start, end: index }); start = index; cells = 0; chars = 0;
+    }
+    cells += nextCells; chars += nextChars;
+  }
+  pages.push({ start, end: diff.records.length });
+  return pages;
+}
diff --git a/src/editor-associations.ts b/src/editor-associations.ts
new file mode 100644
index 0000000..c98ed74
--- /dev/null
+++ b/src/editor-associations.ts
@@ -0,0 +1,390 @@
+import type * as vscode from 'vscode';
+import { randomBytes } from 'crypto';
+import { performance } from 'perf_hooks';
+
+const journalPrefix = 'csv.nativeEditorRouting.';
+type Journal = { created: number; state: Ownership };
+export const csvEditorSelectors = ['*.csv', '*.tsv', '*.tab', '*.psv'] as const;
+const csvEditor = 'csv.editor';
+type Associations = Record<string, unknown>;
+type OwnedEntry = { previous?: string; hadPrevious: boolean; applied: string; textView?: boolean; owner?: string };
+type Ownership = { version: 1; entries: Record<string, OwnedEntry>; ignored: string[]; released: Record<string, string>; containerAbsent: boolean };
+type Scope = 'global' | 'workspace';
+
+const has = (object: object, key: string) => Object.prototype.hasOwnProperty.call(object, key);
+const equal = (a: unknown, b: unknown) => JSON.stringify(a) === JSON.stringify(b);
+const put = <T>(object: Record<string, T>, key: string, value: T): Record<string, T> => ({ ...object, [key]: value });
+function dictionary(value: unknown): Associations {
+  if (value === undefined) { return {}; }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('workbench.editorAssociations must be an object before CSV can change its routing.');
+  }
+  return { ...value as Associations };
+}
+function ownership(raw: unknown): Ownership {
+  const empty: Ownership = { version: 1, entries: {}, ignored: [], released: {}, containerAbsent: false };
+  if (!raw || typeof raw !== 'object') { return empty; }
+  const value = raw as Ownership;
+  if (value.version !== 1 || !value.entries || typeof value.entries !== 'object' || Array.isArray(value.entries) || !Array.isArray(value.ignored)) { return empty; }
+  const entries: Record<string, OwnedEntry> = {};
+  for (const [pattern, entry] of Object.entries(value.entries)) {
+    if (!entry || typeof entry !== 'object' || typeof entry.hadPrevious !== 'boolean' ||
+        (entry.previous !== undefined && typeof entry.previous !== 'string') ||
+        (entry.applied !== 'default' && entry.applied !== csvEditor)) { continue; }
+    Object.defineProperty(entries, pattern, { value: { ...entry }, enumerable: true, configurable: true, writable: true });
+  }
+  const released = Object.fromEntries(Object.entries(value.released || {}).filter(([, token]) => typeof token === 'string'));
+  return { version: 1, entries, ignored: value.ignored.filter(pattern => typeof pattern === 'string'), released, containerAbsent: value.containerAbsent === true };
+}
+function recovery(storage: vscode.Memento): { state: Ownership; journals: Array<{ key: string; value: Journal }> } {
+  const journals = storage.keys().filter(key => key.startsWith(journalPrefix)).map(key => ({ key, value: storage.get<Journal>(key)! }))
+    .filter(({ value }) => value && typeof value.created === 'number' && value.state?.version === 1)
+    .sort((a, b) => b.value.created - a.value.created || b.key.localeCompare(a.key));
+  const state = ownership(undefined);
+  state.containerAbsent = journals[0]?.value.state.containerAbsent ?? false;
+  const decided = new Set<string>();
+  for (const journal of journals) {
+    const stored = ownership(journal.value.state);
+    for (const [pattern, entry] of Object.entries(stored.entries)) {
+      if (!decided.has(pattern)) {
+        Object.defineProperty(state.entries, pattern, { value: entry, enumerable: true, configurable: true, writable: true });
+        decided.add(pattern);
+      }
+    }
+    for (const pattern of stored.ignored) {
+      if (!decided.has(pattern)) { state.ignored.push(pattern); decided.add(pattern); }
+    }
+    for (const [pattern, token] of Object.entries(stored.released)) {
+      if (!decided.has(pattern)) { state.released[pattern] = token; decided.add(pattern); }
+    }
+  }
+  return { state, journals };
+}
+function observe(current: Associations, stored: Ownership): { original: Associations; state: Ownership } {
+  let original = { ...current }, entries = { ...stored.entries };
+  const ignored = new Set(stored.ignored);
+  let containerAbsent = stored.containerAbsent;
+  for (const [pattern, entry] of Object.entries(entries)) {
+    if (current[pattern] !== entry.applied) {
+      // An intervening user edit owns this key for the rest of this disabled period.
+      delete entries[pattern];
+      ignored.add(pattern);
+      containerAbsent = false;
+      continue;
+    }
+    if (entry.hadPrevious) { original = put(original, pattern, entry.previous); }
+    else { delete original[pattern]; }
+  }
+  return { original, state: { ...stored, entries, ignored: [...ignored], containerAbsent } };
+}
+function desiredNative(original: Associations): Map<string, string> {
+  const external = Object.entries(original).filter(([, editor]) => typeof editor === 'string' && editor !== csvEditor);
+  // These patterns cover every CSV-like basename. Their explicit editor choice
+  // already outranks the contributed editor, so adding *.csv would change it.
+  const universal = new Set(['*', '**', '**/*', '*.*', '**/*.*']);
+  const hasUniversal = external.some(([pattern]) => universal.has(pattern));
+  const patterns = new Set<string>(Object.keys(original).filter(pattern => original[pattern] === csvEditor));
+  for (const selector of csvEditorSelectors) {
+    if (has(original, selector) || hasUniversal) { continue; }
+    const extension = selector.slice(1);
+    const overlaps = external.filter(([pattern]) => {
+      if (pattern.length > selector.length || !/[*?{[]/.test(pattern)) { return false; }
+      const suffix = pattern.split(/[*?}\]]/).pop() || '';
+      return !suffix || extension.endsWith(suffix);
+    });
+    if (overlaps.length) {
+      throw new Error(`CSV preserved overlapping editor associations (${overlaps.map(([pattern]) => pattern).join(', ')}). Add an explicit ${selector} choice before retrying the toggle.`);
+    }
+    patterns.add(selector);
+  }
+  return new Map([...patterns].map(pattern => [pattern, 'default']));
+}
+function plan(current: Associations, absent: boolean, stored: Ownership, desired: Map<string, string>, enabled: boolean) {
+  let next = { ...current }, entries = { ...stored.entries };
+  const ignored = enabled ? new Set<string>() : new Set(stored.ignored);
+  const released = { ...stored.released };
+  if (enabled) { for (const pattern of stored.ignored) { released[pattern] = ''; } }
+  const beforeWrite = { ...stored, entries: { ...entries }, ignored: [...ignored], released: { ...released } };
+  if (!Object.keys(entries).length) { beforeWrite.containerAbsent = absent; }
+  for (const [pattern, entry] of Object.entries(entries)) {
+    if (desired.get(pattern) === entry.applied) { continue; }
+    if (current[pattern] === entry.applied) {
+      if (entry.hadPrevious) { next = put(next, pattern, entry.previous); }
+      else { delete next[pattern]; }
+    }
+    delete entries[pattern];
+    released[pattern] = '';
+  }
+  for (const [pattern, value] of desired) {
+    if (ignored.has(pattern) || next[pattern] === value) { continue; }
+    // Existing associations to another editor belong to that editor/user.
+    if (has(next, pattern) && next[pattern] !== csvEditor && !stored.entries[pattern]) { continue; }
+    const previous = next[pattern];
+    const entry: OwnedEntry = { hadPrevious: has(next, pattern), previous: typeof previous === 'string' ? previous : undefined, applied: value };
+    entries = put(entries, pattern, entry);
+    delete released[pattern];
+    delete beforeWrite.released[pattern];
+    beforeWrite.entries = put(beforeWrite.entries, pattern, entry);
+    next = put(next, pattern, value);
+  }
+  const conflicts = [...desired].filter(([pattern, value]) => ignored.has(pattern) && current[pattern] !== value);
+  if (conflicts.length) {
+    throw new Error(`CSV preserved your changed editor associations (${conflicts.map(([pattern]) => pattern).join(', ')}). Remove or change those CSV editor choices before retrying the toggle.`);
+  }
+  const finalState: Ownership = { ...beforeWrite, entries, ignored: [...ignored], released };
+  const removeContainer = !Object.keys(next).length && beforeWrite.containerAbsent;
+  return { next, value: removeContainer ? undefined : next, beforeWrite, finalState };
+}
+
+export type EditorSwitchRouting = { supported: boolean; limitation?: string; commit(): Promise<void>; rollback(): Promise<void> };
+export function exactFileEditorPattern(uri: vscode.Uri): string | undefined {
+  // The workbench matches scheme:path, case-insensitively, and omits authority.
+  // Do not turn a remote/virtual URI into a wider preference for other hosts.
+  if (uri.scheme !== 'file' || uri.authority || uri.query || uri.fragment) { return undefined; }
+  return `${uri.scheme}:${uri.path}`.replace(/[\[\]*?{}]/g, character => `[${character}]`);
+}
+
+/** Reversible native routing uses the existing toggle; no document text is stored. */
+export class CsvEditorAssociationRouting implements vscode.Disposable {
+  private pending: Promise<void> = Promise.resolve();
+  private disposed = false;
+  constructor(private readonly context: vscode.ExtensionContext, private readonly api: typeof vscode) {}
+  dispose(): void { this.disposed = true; }
+  synchronize(): Promise<void> {
+    const next = this.pending.catch(() => {}).then(() => this.synchronizeOnce());
+    this.pending = next;
+    return next;
+  }
+  prepareEditorSwitch(uri: vscode.Uri, target: 'default' | 'csv.editor'): Promise<EditorSwitchRouting> {
+    if (target === csvEditor) {
+      // Keep Text routing until its replacement table is genuinely usable.
+      return Promise.resolve({ supported: true, rollback: async () => {}, commit: () => {
+        const commit = this.pending.catch(() => {}).then(async () => {
+          // A prior no-workspace choice can coexist with a workspace override.
+          for (let scope = 0; scope < 2; scope++) { await this.prepareEditorSwitchOnce(uri, csvEditor); }
+        });
+        this.pending = commit;
+        return commit;
+      } });
+    }
+    const next = this.pending.catch(() => {}).then(() => this.prepareEditorSwitchOnce(uri, target));
+    this.pending = next.then(() => {}, () => {});
+    return next;
+  }
+  private async prepareEditorSwitchOnce(uri: vscode.Uri, target: 'default' | 'csv.editor'): Promise<EditorSwitchRouting> {
+    const pattern = exactFileEditorPattern(uri);
+    const unsupported = (limitation: string): EditorSwitchRouting => ({ supported: false, limitation, commit: async () => {}, rollback: async () => {} });
+    if (!pattern) {
+      return unsupported('CSV: This view can switch, but VS Code cannot isolate this URI in editor associations. Turn CSV off in this workspace before using Find in Files in its text view.');
+    }
+    if (this.disposed) { throw new Error('CSV: Editor routing is no longer active.'); }
+    const hasWorkspace = !!this.api.workspace.workspaceFile || !!this.api.workspace.workspaceFolders?.length;
+    let scope: Scope = hasWorkspace ? 'workspace' : 'global';
+    const setting = this.api.workspace.getConfiguration('workbench').inspect<Associations>('editorAssociations');
+    if (target === 'csv.editor' && !recovery(this.context.workspaceState).state.entries[pattern]?.textView &&
+      recovery(this.context.globalState).state.entries[pattern]?.textView) { scope = 'global'; }
+    const storage = scope === 'global' ? this.context.globalState : this.context.workspaceState;
+    const raw = scope === 'global' ? setting?.globalValue : setting?.workspaceValue;
+    const current = dictionary(raw);
+    const stored = recovery(storage).state;
+    const observed = observe(current, stored);
+    if (!equal(stored, observed.state)) { await this.recordObservedOwnership(scope, current, raw === undefined, observed.state); }
+    const previousEntry = observed.state.entries[pattern] && { ...observed.state.entries[pattern] };
+    const hadPrevious = has(current, pattern), previousValue = current[pattern];
+    const token = randomBytes(12).toString('hex');
+    const desired = new Map(Object.entries(observed.state.entries).map(([key, entry]) => [key, entry.applied]));
+    if (target === 'default') {
+      const inherited = { ...dictionary(setting?.defaultValue), ...(scope === 'workspace' ? dictionary(setting?.globalValue) : {}) };
+      if (!has(current, pattern) && typeof inherited[pattern] === 'string' && inherited[pattern] !== csvEditor && inherited[pattern] !== 'default') {
+        return unsupported('CSV: Your inherited editor association has been preserved. The view can switch; turn CSV off before using Find in Files if that association opens another editor.');
+      }
+      if (!previousEntry && current[pattern] === 'default') { return { supported: true, commit: async () => {}, rollback: async () => {} }; }
+      if (observed.state.ignored.includes(pattern) || (has(current, pattern) && current[pattern] !== csvEditor && !previousEntry)) {
+        return unsupported('CSV: Your editor association has been preserved. The view can switch; turn CSV off before using Find in Files if that association opens another editor.');
+      }
+      desired.set(pattern, 'default');
+    } else {
+      if (!previousEntry?.textView) { return { supported: true, commit: async () => {}, rollback: async () => {} }; }
+      desired.delete(pattern);
+    }
+    const change = plan(current, raw === undefined, observed.state, desired, false);
+    if (target === 'default') {
+      const entry = { ...change.finalState.entries[pattern], textView: true, owner: token };
+      change.beforeWrite.entries[pattern] = { ...entry };
+      change.finalState.entries[pattern] = entry;
+    } else { change.finalState.released[pattern] = token; }
+    const config = this.api.workspace.getConfiguration('csv');
+    const enabled = config.get<boolean>('enabled', true);
+    const stillCurrent = () => !this.disposed && this.api.workspace.getConfiguration('csv').get<boolean>('enabled', true) === enabled;
+    const readCurrent = () => {
+      const latest = this.api.workspace.getConfiguration('workbench').inspect<Associations>('editorAssociations');
+      return dictionary(scope === 'global' ? latest?.globalValue : latest?.workspaceValue);
+    };
+    const expectedHas = has(change.next, pattern), expectedValue = change.next[pattern];
+    const rollbackOnce = async () => {
+      const latest = readCurrent();
+      const stored = recovery(storage).state;
+      const recovered = observe(latest, stored);
+      if (!equal(stored, recovered.state)) { await this.recordObservedOwnership(scope, latest, false, recovered.state, true); }
+      const decision = recovered.state.entries[pattern]?.owner ?? recovered.state.released[pattern];
+      if (decision !== token || has(latest, pattern) !== expectedHas || latest[pattern] !== expectedValue) { return; }
+      const nextMap = { ...latest };
+      if (hadPrevious) { Object.defineProperty(nextMap, pattern, { value: previousValue, enumerable: true, configurable: true, writable: true }); }
+      else { delete nextMap[pattern]; }
+      const finalState: Ownership = { ...recovered.state, entries: { ...recovered.state.entries }, released: { ...recovered.state.released } };
+      if (previousEntry) { finalState.entries[pattern] = previousEntry; delete finalState.released[pattern]; }
+      else { delete finalState.entries[pattern]; finalState.released[pattern] = randomBytes(12).toString('hex'); }
+      const beforeWrite = previousEntry ? finalState : recovered.state;
+      await this.apply(scope, latest, {
+        next: nextMap, value: !Object.keys(nextMap).length && change.beforeWrite.containerAbsent ? undefined : nextMap,
+        beforeWrite, finalState
+      }, () => true, true);
+    };
+    try {
+      await this.apply(scope, current, change, stillCurrent);
+      if (!stillCurrent()) { throw new Error('CSV: Editor routing changed while switching views.'); }
+      if (has(readCurrent(), pattern) !== expectedHas || readCurrent()[pattern] !== expectedValue) {
+        throw new Error('CSV: Could not prepare the file’s editor routing.');
+      }
+    } catch (error) {
+      await rollbackOnce();
+      throw error;
+    }
+    return {
+      supported: true, commit: async () => {},
+      rollback: () => {
+        const rollback = this.pending.catch(() => {}).then(rollbackOnce);
+        this.pending = rollback;
+        return rollback;
+      }
+    };
+  }
+  private async recordObservedOwnership(scope: Scope, current: Associations, absent: boolean, observed: Ownership, cleanup = false): Promise<void> {
+    const desired = new Map(Object.entries(observed.entries).map(([pattern, entry]) => [pattern, entry.applied]));
+    await this.apply(scope, current, plan(current, absent, observed, desired, false), () => cleanup || !this.disposed, cleanup);
+  }
+  private async synchronizeOnce(): Promise<void> {
+    if (this.disposed) { return; }
+    const workbench = this.api.workspace.getConfiguration('workbench');
+    const setting = workbench.inspect<Associations>('editorAssociations');
+    const enabledSetting = this.api.workspace.getConfiguration('csv').inspect<boolean>('enabled');
+    const globalEnabled = enabledSetting?.globalValue ?? enabledSetting?.defaultValue ?? true;
+    const effectiveEnabled = this.api.workspace.getConfiguration('csv').get<boolean>('enabled', true);
+    const hasWorkspace = !!this.api.workspace.workspaceFile || !!this.api.workspace.workspaceFolders?.length;
+    const defaults = dictionary(setting?.defaultValue);
+    const globalCurrent = dictionary(setting?.globalValue);
+    const globalRecovery = recovery(this.context.globalState);
+    const globalObserved = observe(globalCurrent, globalRecovery.state);
+    const globalOriginal = { ...defaults, ...globalObserved.original };
+    const globalDesired = (hasWorkspace ? globalEnabled : effectiveEnabled) ? new Map<string, string>() : desiredNative(globalOriginal);
+    for (const [pattern, entry] of Object.entries(globalObserved.state.entries)) {
+      if (entry.textView) { globalDesired.set(pattern, 'default'); }
+    }
+    const globalPlan = plan(globalCurrent, setting?.globalValue === undefined, globalObserved.state, globalDesired, globalEnabled);
+    const stillCurrent = () => {
+      const config = this.api.workspace.getConfiguration('csv');
+      const global = config.inspect<boolean>('enabled');
+      return (global?.globalValue ?? global?.defaultValue ?? true) === globalEnabled && config.get<boolean>('enabled', true) === effectiveEnabled;
+    };
+    await this.apply('global', globalCurrent, globalPlan, stillCurrent);
+    if (this.disposed || !stillCurrent()) { return; }
+    if (!hasWorkspace) { this.verifyEffectiveRouting(effectiveEnabled); return; }
+
+    const fresh = workbench.inspect<Associations>('editorAssociations');
+    const workspaceCurrent = dictionary(fresh?.workspaceValue);
+    const observed = observe(workspaceCurrent, recovery(this.context.workspaceState).state);
+    const desired = new Map<string, string>();
+    if (!effectiveEnabled) {
+      const patterns = new Set(desiredNative({ ...globalOriginal, ...observed.original }).keys());
+      for (const pattern of patterns) {
+        if (has(observed.original, pattern)) {
+          if (observed.original[pattern] === csvEditor) { desired.set(pattern, 'default'); }
+        } else if (({ ...defaults, ...globalPlan.next })[pattern] === undefined || ({ ...defaults, ...globalPlan.next })[pattern] === csvEditor) {
+          desired.set(pattern, 'default');
+        }
+      }
+    } else {
+      // A workspace explicitly enabled above global Off must counter only our
+      // inherited temporary native bindings, leaving other editor choices alone.
+      for (const [pattern, entry] of Object.entries(globalPlan.finalState.entries)) {
+        if (!entry.textView && !has(observed.original, pattern) && globalPlan.next[pattern] === entry.applied) {
+          desired.set(pattern, entry.hadPrevious ? entry.previous! : csvEditor);
+        }
+      }
+    }
+    for (const [pattern, entry] of Object.entries(observed.state.entries)) {
+      if (entry.textView) { desired.set(pattern, 'default'); }
+    }
+    await this.apply('workspace', workspaceCurrent,
+      plan(workspaceCurrent, fresh?.workspaceValue === undefined, observed.state, desired, effectiveEnabled), stillCurrent);
+    if (!this.disposed && stillCurrent()) { this.verifyEffectiveRouting(effectiveEnabled); }
+  }
+  private verifyEffectiveRouting(enabled: boolean): void {
+    if (enabled) { return; }
+    const effective = this.api.workspace.getConfiguration('workbench').get<Associations>('editorAssociations', {});
+    const blocked = Object.keys(effective).filter(pattern => effective[pattern] === csvEditor);
+    if (blocked.length) {
+      throw new Error(`CSV could not disable its effective editor associations (${blocked.join(', ')}). A policy or another settings scope still selects CSV.`);
+    }
+  }
+  private async apply(scope: Scope, previous: Associations, change: ReturnType<typeof plan>, stillCurrent: () => boolean, cleanup = false): Promise<void> {
+    const storage = scope === 'global' ? this.context.globalState : this.context.workspaceState;
+    const target = scope === 'global' ? this.api.ConfigurationTarget.Global : this.api.ConfigurationTarget.Workspace;
+    const current = () => {
+      const setting = this.api.workspace.getConfiguration('workbench').inspect<Associations>('editorAssociations');
+      return dictionary(scope === 'global' ? setting?.globalValue : setting?.workspaceValue);
+    };
+    if (!equal(previous, change.next)) {
+      // Each operation owns an immutable key. A delayed window cannot overwrite
+      // another window's backup of a more-specific user association.
+      const key = `${journalPrefix}${Date.now()}.${randomBytes(12).toString('hex')}`;
+      const journal: Journal = { created: performance.timeOrigin + performance.now(), state: change.beforeWrite };
+      await storage.update(key, journal);
+      const discardUnappliedJournal = async () => {
+        if (equal(current(), previous) && equal(storage.get(key), journal)) { await storage.update(key, undefined); }
+      };
+      if ((!cleanup && this.disposed) || !stillCurrent()) { await discardUnappliedJournal(); return; }
+      const fresh = current();
+      if (!equal(fresh, previous)) {
+        // We have not changed preferences. Only the operation that actually
+        // installed this map owns its recovery; a coalesced stale plan must not
+        // supersede a newer user choice captured by that operation.
+        if (equal(storage.get(key), journal)) { await storage.update(key, undefined); }
+        if (!equal(fresh, change.next)) {
+          throw new Error('Editor associations changed while CSV was updating routing; retry the toggle.');
+        }
+        return; // The actual writer also owns finalization of this map.
+      }
+      try {
+        if (!equal(fresh, change.next)) {
+          await this.api.workspace.getConfiguration('workbench').update('editorAssociations', change.value, target);
+        }
+        if (!equal(current(), change.next)) {
+          throw new Error('VS Code did not apply the routing preferences; a policy or read-only settings may prevent this change.');
+        }
+      } catch (error) {
+        await discardUnappliedJournal();
+        throw new Error(`CSV could not update ${scope} editor routing: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    if (!stillCurrent() || (!cleanup && this.disposed)) { return; }
+    const keep = Object.keys(change.finalState.entries).length || change.finalState.ignored.length;
+    const recovered = recovery(storage);
+    if (keep && !equal(recovered.state, change.finalState)) {
+      // A real observed user edit relinquishes ownership even if it needs no
+      // settings write. Choosing the old value later must remain user-owned.
+      const key = `${journalPrefix}${Date.now()}.${randomBytes(12).toString('hex')}`;
+      await storage.update(key, { created: performance.timeOrigin + performance.now(), state: change.finalState } as Journal);
+    }
+    if (!keep) {
+      const live = current();
+      const relinquished = new Set([...recovered.state.ignored, ...Object.keys(recovered.state.released)]);
+      for (const { key, value } of recovered.journals) {
+        // Clear only the observed immutable record after its temporary values
+        // have gone. A concurrently added journal has a different key.
+        if (Object.entries(ownership(value.state).entries).some(([pattern, entry]) => !relinquished.has(pattern) && live[pattern] === entry.applied)) { continue; }
+        if (equal(storage.get(key), value)) { await storage.update(key, undefined); }
+      }
+    }
+  }
+}
diff --git a/src/editor-switch.ts b/src/editor-switch.ts
new file mode 100644
index 0000000..3da7440
--- /dev/null
+++ b/src/editor-switch.ts
@@ -0,0 +1,222 @@
+import * as path from 'path';
+import * as vscode from 'vscode';
+import { CsvEditorProvider } from './CsvEditorProvider';
+import type { EditorSwitchRouting } from './editor-associations';
+import { getActiveUntitledCsvEditor, isUntitledCsv, openUntitledCsvEditor, showActiveUntitledCsvSource } from './untitled-editors';
+
+const switchingTabs = new Set<string>();
+const supportedExtensions = new Set(['.csv', '.tsv', '.tab', '.psv']);
+
+function getInputUri(input: unknown, viewType: string): vscode.Uri | undefined {
+  if (viewType === 'default') {
+    return input instanceof vscode.TabInputText ? input.uri : undefined;
+  }
+  return input instanceof vscode.TabInputCustom && input.viewType === viewType ? input.uri : undefined;
+}
+
+export function supportsEditorReplacement(version: string, dirty: boolean): boolean {
+  const match = /^(\d+)\.(\d+)\./.exec(version);
+  if (!match) {
+    return false;
+  }
+  return Number(match[1]) > 1 || (Number(match[1]) === 1 && Number(match[2]) >= (dirty ? 120 : 100));
+}
+
+function showUpdateGuidance(dirty: boolean): void {
+  void vscode.window.showInformationMessage(
+    `CSV: Switching ${dirty ? 'an unsaved document' : 'between table and text'} requires VS Code ${dirty ? '1.120' : '1.100'} or newer. Update VS Code to use this action.`
+  );
+}
+
+function observeEditorReplacement(uri: vscode.Uri, source: string, target: string, viewColumn: vscode.ViewColumn) {
+  let resolve!: (complete: boolean) => void;
+  let subscription: vscode.Disposable | undefined;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let settled = false;
+  const promise = new Promise<boolean>(finish => { resolve = finish; });
+  const finish = (complete: boolean) => {
+    if (settled) { return; }
+    settled = true;
+    subscription?.dispose();
+    if (timer) { clearTimeout(timer); }
+    resolve(complete);
+  };
+  const check = () => {
+    const group = vscode.window.tabGroups.all.find(candidate => candidate.viewColumn === viewColumn);
+    if (group?.tabs.some(tab => getInputUri(tab.input, target)?.toString() === uri.toString()) &&
+        !group.tabs.some(tab => getInputUri(tab.input, source)?.toString() === uri.toString())) { finish(true); }
+  };
+  // Native command completion can precede extension-host TabGroups events.
+  subscription = vscode.window.tabGroups.onDidChangeTabs(check);
+  return { promise, check, startTimeout: () => {
+    if (!settled) { timer = setTimeout(() => finish(false), 5000); }
+  }, cancel: () => finish(false) };
+}
+
+export async function toggleCsvEditor(prepareRouting?: (uri: vscode.Uri, target: 'default' | 'csv.editor') => Promise<EditorSwitchRouting>): Promise<void> {
+  const untitled = getActiveUntitledCsvEditor();
+  if (untitled) {
+    await showActiveUntitledCsvSource();
+    return;
+  }
+  const group = vscode.window.tabGroups.activeTabGroup;
+  const activeInput = group.activeTab?.input;
+  const activeDocument = activeInput instanceof vscode.TabInputText
+    ? vscode.window.visibleTextEditors.find(editor => editor.viewColumn === group.viewColumn &&
+      editor.document.uri.toString() === activeInput.uri.toString())?.document
+    : undefined;
+  if (activeDocument && isUntitledCsv(activeDocument)) {
+    await openUntitledCsvEditor(activeDocument, group.viewColumn);
+    return;
+  }
+  const tab = group.activeTab;
+  if (!tab) {
+    return;
+  }
+  const tableUri = getInputUri(tab.input, CsvEditorProvider.viewType);
+  const uri = tableUri ?? getInputUri(tab.input, 'default');
+  if (!uri || uri.scheme === 'untitled' || !supportedExtensions.has(path.posix.extname(uri.path).toLowerCase())) {
+    return;
+  }
+  const source = tableUri ? CsvEditorProvider.viewType : 'default';
+  const target = tableUri ? 'default' : CsvEditorProvider.viewType;
+  const switchKey = `${group.viewColumn}:${uri.toString()}`;
+  if (switchingTabs.has(switchKey)) {
+    return;
+  }
+  if (target === CsvEditorProvider.viewType && !vscode.workspace.getConfiguration('csv', uri).get<boolean>('enabled', true)) {
+    void vscode.window.showInformationMessage('Enable the CSV extension to switch to the table view.');
+    return;
+  }
+  if (!supportsEditorReplacement(vscode.version, false)) {
+    showUpdateGuidance(false);
+    return;
+  }
+
+  switchingTabs.add(switchKey);
+  let routing: EditorSwitchRouting | undefined;
+  let replaced = false;
+  let replacement: ReturnType<typeof observeEditorReplacement> | undefined;
+  try {
+    if (!(await vscode.commands.getCommands(true)).includes('reopenActiveEditorWith')) {
+      showUpdateGuidance(false);
+      return;
+    }
+    if (tableUri) {
+      const controller = CsvEditorProvider.editors.find(candidate =>
+        candidate.getDocumentUri().toString() === uri.toString() && candidate.getViewColumn() === group.viewColumn
+      );
+      if (!controller || !(await controller.commitPendingDraft())) {
+        void vscode.window.showErrorMessage('CSV: Could not commit the active cell. The current view has been kept open.');
+        return;
+      }
+    }
+    // The user may have changed tabs while the webview committed its draft.
+    const current = vscode.window.tabGroups.activeTabGroup;
+    if (current.viewColumn !== group.viewColumn || getInputUri(current.activeTab?.input, source)?.toString() !== uri.toString()) {
+      return;
+    }
+    const dirty = current.activeTab!.isDirty || vscode.workspace.textDocuments.some(document =>
+      document.uri.toString() === uri.toString() && document.isDirty
+    );
+    if (!supportsEditorReplacement(vscode.version, dirty)) {
+      showUpdateGuidance(dirty);
+      return;
+    }
+    const sameFileTableElsewhere = target === CsvEditorProvider.viewType && vscode.window.tabGroups.all.some(other =>
+      other.viewColumn !== group.viewColumn && other.tabs.some(otherTab =>
+        getInputUri(otherTab.input, target)?.toString() === uri.toString()
+      )
+    );
+    if (sameFileTableElsewhere) {
+      void vscode.window.showInformationMessage('CSV: This file already has a table in another editor group. Switch from that group to keep both groups intact.');
+      return;
+    }
+    if (current.activeTab!.isPreview) {
+      await vscode.commands.executeCommand('workbench.action.keepEditor');
+      const pinned = vscode.window.tabGroups.activeTabGroup;
+      if (pinned.viewColumn !== group.viewColumn || getInputUri(pinned.activeTab?.input, source)?.toString() !== uri.toString()) {
+        return;
+      }
+    }
+    routing = await prepareRouting?.(uri, target);
+    const afterRouting = vscode.window.tabGroups.activeTabGroup;
+    if (afterRouting.viewColumn !== group.viewColumn || getInputUri(afterRouting.activeTab?.input, source)?.toString() !== uri.toString()) { return; }
+    if (routing?.limitation) { void vscode.window.showInformationMessage(routing.limitation); }
+    // An unqualified open proves that the per-file association actually wins;
+    // explicit openWith would hide a longer user association taking precedence.
+    if (target === 'default' && routing?.supported) {
+      await vscode.commands.executeCommand('vscode.open', uri, {
+        viewColumn: group.viewColumn, preserveFocus: false, preview: false
+      });
+    } else {
+      await vscode.commands.executeCommand('vscode.openWith', uri, target, {
+        viewColumn: group.viewColumn, preserveFocus: false, preview: false
+      });
+    }
+    const targetGroup = vscode.window.tabGroups.activeTabGroup;
+    let targetReady = targetGroup.viewColumn === group.viewColumn &&
+      getInputUri(targetGroup.activeTab?.input, target)?.toString() === uri.toString();
+    if (targetReady && target === CsvEditorProvider.viewType) {
+      const controller = CsvEditorProvider.editors.find(candidate =>
+        candidate.getDocumentUri().toString() === uri.toString() && candidate.getViewColumn() === group.viewColumn
+      );
+      targetReady = !!controller && await controller.commitPendingDraft();
+    } else if (targetReady) {
+      // Text focus can remain in a different split group after opening the target.
+      targetReady = vscode.window.visibleTextEditors.some(editor =>
+        editor.viewColumn === group.viewColumn && editor.document.uri.toString() === uri.toString()
+      );
+    }
+    const afterReady = vscode.window.tabGroups.activeTabGroup;
+    if (afterReady.viewColumn !== group.viewColumn ||
+      (targetReady && getInputUri(afterReady.activeTab?.input, target)?.toString() !== uri.toString())) {
+      return;
+    }
+    if (!targetReady) {
+      if (target === 'default' && routing?.supported) { void vscode.window.showInformationMessage('CSV: Your editor associations still choose another view. They have been preserved; turn CSV off before using Find in Files.'); }
+      const original = vscode.window.tabGroups.all.find(candidate => candidate.viewColumn === group.viewColumn);
+      if (original?.tabs.some(candidate => getInputUri(candidate.input, source)?.toString() === uri.toString()) &&
+        afterReady.viewColumn === group.viewColumn &&
+        (!afterReady.activeTab || getInputUri(afterReady.activeTab.input, target)?.toString() === uri.toString())) {
+        await vscode.commands.executeCommand('vscode.openWith', uri, source, {
+          viewColumn: group.viewColumn, preserveFocus: false, preview: false
+        });
+      }
+      return;
+    }
+    // Reopening acts on selected tabs. Revealing this exact source through the
+    // ordinary open path narrows selection before replacing just this tab.
+    await vscode.commands.executeCommand('vscode.openWith', uri, source, {
+      viewColumn: group.viewColumn, preserveFocus: false, preview: false
+    });
+    const revealed = vscode.window.tabGroups.activeTabGroup;
+    if (revealed.viewColumn !== group.viewColumn || getInputUri(revealed.activeTab?.input, source)?.toString() !== uri.toString()) {
+      return;
+    }
+    const dirtyAfterOpen = revealed.activeTab!.isDirty || vscode.workspace.textDocuments.some(document =>
+      document.uri.toString() === uri.toString() && document.isDirty
+    );
+    if (!supportsEditorReplacement(vscode.version, dirtyAfterOpen)) {
+      showUpdateGuidance(dirtyAfterOpen);
+      return;
+    }
+    // Native replacement opens the target before removing the source and retains
+    // the shared dirty text working copy. A separate tab close can prompt/discard.
+    replacement = observeEditorReplacement(uri, source, target, group.viewColumn);
+    await vscode.commands.executeCommand('reopenActiveEditorWith', target);
+    replacement.check();
+    replacement.startTimeout();
+    replaced = await replacement.promise;
+    if (replaced) { await routing?.commit(); }
+  } catch (error) {
+    console.error('CSV: could not switch editor', error);
+    void vscode.window.showErrorMessage('CSV: Could not switch between the table and text editor.');
+  } finally {
+    replacement?.cancel();
+    if (!replaced) {
+      try { await routing?.rollback(); } catch (error) { console.error('CSV: could not restore file routing after a cancelled switch', error); }
+    }
+    switchingTabs.delete(switchKey);
+  }
+}
diff --git a/src/extension.ts b/src/extension.ts
index 50ec42b..0012fd5 100644
--- a/src/extension.ts
+++ b/src/extension.ts
@@ -1,91 +1,79 @@
 import * as vscode from 'vscode';
 import { CsvEditorProvider } from './CsvEditorProvider';
 import { registerCsvCommands } from './commands';
+import { CsvEditorAssociationRouting } from './editor-associations';
+import { LargeFilePreviewProvider } from './large-file-preview';
+import { registerUntitledCsvEditors } from './untitled-editors';
 
-export function activate(context: vscode.ExtensionContext) {
+export async function activate(context: vscode.ExtensionContext) {
   console.log('CSV: Extension activated');
 
-  // Commands (toggle features, change separator/font)
-  registerCsvCommands(context);
-
+  const routing = new CsvEditorAssociationRouting(context, vscode);
+  context.subscriptions.push(routing);
+  let lastRoutingError: string | undefined;
+  const synchronizeRouting = async () => {
+    try {
+      await routing.synchronize();
+      lastRoutingError = undefined;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message !== lastRoutingError) { void vscode.window.showErrorMessage(message); }
+      lastRoutingError = message;
+      throw error;
+    }
+  };
+  let routingGeneration = 0;
   // Auto-refresh all open CSV editors when relevant CSV settings change
-  const cfgListener = vscode.workspace.onDidChangeConfiguration(e => {
-    // If the user turned the extension on, immediately upgrade open CSV/TSV tabs
+  const cfgListener = vscode.workspace.onDidChangeConfiguration(async e => {
+    const invokingGroup = vscode.window.tabGroups.activeTabGroup;
+    const invokingTab = invokingGroup?.activeTab;
+    const affectsRouting = e.affectsConfiguration('csv.enabled') || e.affectsConfiguration('workbench.editorAssociations');
+    if (affectsRouting) { ++routingGeneration; }
+    if (affectsRouting) {
+      try { await synchronizeRouting(); } catch (error) { console.error('CSV: editor routing update failed', error); return; }
+    }
+    // Re-enable the invoking saved file; background tabs keep their current view.
     if (e.affectsConfiguration('csv.enabled')) {
+      const generation = routingGeneration;
       const enabled = vscode.workspace.getConfiguration('csv').get<boolean>('enabled', true);
       console.log(`[CSV(enable)]: configuration changed -> enabled=${enabled}`);
       if (enabled) {
-        // Snapshot candidates first to avoid mutating collections during iteration
-        type Candidate = { group: vscode.TabGroup; groupIndex: number; tab: vscode.Tab; tabIndex: number; uri: vscode.Uri; wasActive: boolean; wasPreview: boolean; viewColumn: vscode.ViewColumn | undefined };
-        const candidates: Candidate[] = [];
-        const groups = vscode.window.tabGroups.all;
-        console.log(`[CSV(enable)]: scanning ${groups.length} tab group(s)`);
-        groups.forEach((group, gi) => {
-          console.log(`[CSV(enable)]: group[${gi}] has ${group.tabs.length} tab(s)`);
-          group.tabs.forEach((tab, ti) => {
-            const input: any = (tab as any).input;
-            const viewType = input?.viewType;
-            const uri: vscode.Uri | undefined = input?.uri instanceof vscode.Uri ? (input.uri as vscode.Uri) : undefined;
-            const path = uri?.fsPath || '(no-uri)';
-            console.log(`[CSV(enable)]: group[${gi}] tab[${ti}] vt=${viewType ?? '(text?)'} uri=${path} active=${tab.isActive} preview=${tab.isPreview}`);
-            if (!input) return;
-            if (viewType === CsvEditorProvider.viewType) return; // already our editor
-            if (!uri) return;
-            const fsPath = uri.fsPath?.toLowerCase?.() || '';
-            const isCsvLike = fsPath.endsWith('.csv') || fsPath.endsWith('.tsv') || fsPath.endsWith('.tab') || fsPath.endsWith('.psv');
-            console.log(`[CSV(enable)]: -> eligible=${isCsvLike}`);
-            if (!isCsvLike) return;
-            candidates.push({ group, groupIndex: gi, tab, tabIndex: ti, uri, wasActive: tab.isActive, wasPreview: tab.isPreview, viewColumn: group.viewColumn });
-          });
-        });
-
-        console.log(`[CSV(enable)]: candidates=${candidates.length}`);
-        (async () => {
-          const processed = new Set<string>();
-          for (const c of candidates) {
-            try {
-              console.log(`[CSV(enable)]: closing group[${c.groupIndex}] tab[${c.tabIndex}] uri=${c.uri.fsPath}`);
-              await vscode.window.tabGroups.close(c.tab);
-            } catch (err) {
-              console.error(`[CSV(enable)]: close failed for ${c.uri.fsPath}`, err);
-            }
-            try {
-              const openOpts: any = { viewColumn: c.viewColumn, preserveFocus: !c.wasActive, preview: c.wasPreview };
-              console.log(`[CSV(enable)]: opening custom editor for ${c.uri.fsPath} in column=${c.viewColumn}`);
-              await vscode.commands.executeCommand('vscode.openWith', c.uri, CsvEditorProvider.viewType, openOpts);
-              processed.add(c.uri.toString());
-            } catch (err) {
-              console.error(`[CSV(enable)]: openWith failed for ${c.uri.fsPath}`, err);
-            }
-          }
-
-          // Final sweep: ensure no stale non-custom tabs remain for processed URIs across all groups
+        const input: any = invokingTab?.input;
+        const uri: vscode.Uri | undefined = input?.uri instanceof vscode.Uri ? input.uri : undefined;
+        const eligible = !input?.viewType && uri?.scheme !== 'untitled' && /\.(csv|tsv|tab|psv)$/i.test(uri?.path || uri?.fsPath || '');
+        const stillEnabled = () => generation === routingGeneration && vscode.workspace.getConfiguration('csv').get<boolean>('enabled', true);
+        // An inactive tab cannot be opened in-place without activating it inside
+        // its group. Upgrade only the owner that invoked this mode change.
+        if (eligible && uri && invokingTab && invokingGroup && stillEnabled() &&
+            vscode.window.tabGroups.activeTabGroup === invokingGroup && invokingGroup.activeTab === invokingTab) {
           try {
-            const stale: vscode.Tab[] = [];
-            vscode.window.tabGroups.all.forEach((g, gi) => {
-              g.tabs.forEach((t, ti) => {
-                const inp: any = (t as any).input;
-                const vt = inp?.viewType;
-                const u: vscode.Uri | undefined = inp?.uri instanceof vscode.Uri ? (inp.uri as vscode.Uri) : undefined;
-                const key = u?.toString();
-                if (key && processed.has(key) && vt !== CsvEditorProvider.viewType) {
-                  console.log(`[CSV(enable)]: final-sweep closing group[${gi}] tab[${ti}] uri=${u?.fsPath} vt=${vt}`);
-                  stale.push(t);
-                }
-              });
+            const hadTable = invokingGroup.tabs.some(tab => {
+              const candidate: any = tab.input;
+              return candidate?.viewType === CsvEditorProvider.viewType && candidate?.uri?.toString() === uri.toString();
+            });
+            await vscode.commands.executeCommand('vscode.open', uri, {
+              viewColumn: invokingGroup.viewColumn, preserveFocus: false, preview: invokingTab.isPreview
             });
-            if (stale.length) {
-              await vscode.window.tabGroups.close(stale);
+            if (stillEnabled() && vscode.window.tabGroups.activeTabGroup === invokingGroup) {
+              const active: any = invokingGroup.activeTab?.input;
+              const choseTable = active?.viewType === CsvEditorProvider.viewType && active?.uri?.toString() === uri.toString();
+              if (!hadTable && choseTable && invokingGroup.tabs.includes(invokingTab) && !invokingTab.isDirty) {
+                await vscode.window.tabGroups.close(invokingTab, true);
+              }
             }
-          } catch (err) {
-            console.error('[CSV(enable)]: final-sweep error', err);
-          }
-
-          console.log(`[CSV(enable)]: done processing ${candidates.length} candidate(s)`);
-        })();
+          } catch (error) { console.error('[CSV(enable)]: editor upgrade failed', error); }
+        }
+      } else {
+        CsvEditorProvider.editors.slice().forEach(ed => ed.refresh());
       }
     }
 
+    if (e.affectsConfiguration('csv.defaultIgnoreRows')) {
+      CsvEditorProvider.editors
+        .filter(editor => !CsvEditorProvider.hasHiddenRowsOverride(context, editor.getDocumentUri()) && e.affectsConfiguration('csv.defaultIgnoreRows', editor.getDocumentUri()))
+        .forEach(editor => editor.refreshViewSafely());
+    }
+
     const keys = [
       'csv.fontFamily',
       'csv.cellPadding',
@@ -105,14 +93,21 @@ export function activate(context: vscode.ExtensionContext) {
   });
   context.subscriptions.push(cfgListener);
 
+  // Listen before the first await so settings changes during recovery are queued.
+  // Persisted Off routing must be installed before commands/provider handoffs.
+  try { await synchronizeRouting(); } catch (error) { console.error('CSV: editor routing initialization failed', error); }
+  registerCsvCommands(context, synchronizeRouting, (uri, target) => routing.prepareEditorSwitch(uri, target));
+
   // Register the custom editor provider for CSV/TSV
   context.subscriptions.push(
+    vscode.window.registerCustomEditorProvider(LargeFilePreviewProvider.viewType, new LargeFilePreviewProvider(context)),
     vscode.window.registerCustomEditorProvider(
       CsvEditorProvider.viewType,
       new CsvEditorProvider(context),
       { supportsMultipleEditorsPerDocument: false }
     )
   );
+  registerUntitledCsvEditors(context);
 }
 
 export function deactivate() {
diff --git a/src/filter-values.ts b/src/filter-values.ts
new file mode 100644
index 0000000..b9321af
--- /dev/null
+++ b/src/filter-values.ts
@@ -0,0 +1,288 @@
+export type FilterDataType = 'string' | 'number' | 'date' | 'boolean';
+
+const decimalNumber = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
+const groupedNumber = /^[+-]?\d{1,3}([, '\u00a0\u202f])\d{3}(?:\1\d{3})*(?:\.\d*)?(?:e[+-]?\d+)?$/i;
+
+function numericText(value: string): string | undefined {
+  const text = value.trim();
+  return decimalNumber.test(text) || groupedNumber.test(text) ? text.replace(/[, '\u00a0\u202f]/g, '') : undefined;
+}
+
+/** Parse a complete finite decimal, optionally using consistent thousands groups. */
+export function parseFilterNumber(value: string): number | undefined {
+  const text = numericText(value);
+  if (text === undefined) {
+    return undefined;
+  }
+  const number = Number(text);
+  return Number.isFinite(number) ? number : undefined;
+}
+
+type NumberComparison = -1 | 0 | 1;
+interface ComparableNumber {
+  sign: NumberComparison;
+  digits: string;
+  exponent: number;
+  shift: number;
+}
+
+function comparableNumber(value: string): ComparableNumber | undefined {
+  const text = numericText(value);
+  if (text === undefined || !Number.isFinite(Number(text))) {
+    return undefined;
+  }
+  const [mantissa, exponentText] = text.toLowerCase().split('e');
+  const [integer, fraction = ''] = mantissa.replace(/^[+-]/, '').split('.');
+  const digits = (integer + fraction).replace(/^0+/, '');
+  if (!digits) {
+    return { sign: 0, digits: '', exponent: 0, shift: 0 };
+  }
+  const exponent = Number(exponentText || '0');
+  if (!Number.isSafeInteger(exponent)) {
+    return undefined;
+  }
+  return { sign: text.startsWith('-') ? -1 : 1, digits, exponent, shift: digits.length - fraction.length };
+}
+
+function compareNumbers(a: ComparableNumber, b: ComparableNumber): NumberComparison {
+  if (a.sign !== b.sign) {
+    return a.sign < b.sign ? -1 : 1;
+  }
+  if (a.sign === 0) {
+    return 0;
+  }
+  const exponentDifference = a.exponent - b.exponent;
+  const shiftDifference = a.shift - b.shift;
+  // Do not add an input-length shift to an exponent at the safe-integer boundary.
+  // Close exponents subtract exactly; distant exponents already determine order.
+  const orderDifference = exponentDifference > Math.abs(shiftDifference) ? 1
+    : exponentDifference < -Math.abs(shiftDifference) ? -1
+      : exponentDifference + shiftDifference;
+  if (orderDifference !== 0) {
+    return (orderDifference < 0 ? -a.sign : a.sign) as NumberComparison;
+  }
+  for (let index = 0; index < Math.max(a.digits.length, b.digits.length); index++) {
+    const first = index < a.digits.length ? a.digits.charCodeAt(index) : 48;
+    const second = index < b.digits.length ? b.digits.charCodeAt(index) : 48;
+    if (first !== second) {
+      return (first < second ? -a.sign : a.sign) as NumberComparison;
+    }
+  }
+  return 0;
+}
+
+/** Normalize the threshold once while retaining exact decimal comparison. */
+export function compileFilterNumberComparison(query: string): ((cell: string) => NumberComparison | undefined) | undefined {
+  const threshold = comparableNumber(query);
+  if (!threshold) {
+    return undefined;
+  }
+  return cell => {
+    const value = comparableNumber(cell);
+    return value ? compareNumbers(value, threshold) : undefined;
+  };
+}
+
+export function compareFilterNumbers(a: string, b: string): NumberComparison | undefined {
+  return compileFilterNumberComparison(b)?.(a);
+}
+
+const trueValues = new Set(['true', 't', 'yes', 'y', 'on', '1']);
+const falseValues = new Set(['false', 'f', 'no', 'n', 'off', '0']);
+
+export function parseFilterBoolean(value: string): boolean | undefined {
+  const text = value.trim().toLowerCase();
+  if (trueValues.has(text)) {
+    return true;
+  }
+  if (falseValues.has(text)) {
+    return false;
+  }
+  return undefined;
+}
+
+interface DateParts {
+  year: number;
+  month: number;
+  day: number;
+  tail: string;
+  ordinal?: string;
+}
+
+interface TimeParts {
+  hour: number;
+  minute: number;
+  second: number;
+  millisecond: number;
+  remainder: string;
+  offset: number;
+}
+
+const monthNames = ['january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december'];
+const weekdays = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
+
+function monthNumber(value: string): number {
+  const name = value.toLowerCase().replace(/\.$/, '');
+  return monthNames.findIndex(month => month === name || month.slice(0, 3) === name || (month === 'september' && name === 'sept')) + 1;
+}
+
+function parseDateParts(value: string): DateParts | undefined {
+  let match = /^(\d{4})([-/])(\d{1,2})\2(\d{1,2})(.*)$/.exec(value);
+  if (match) {
+    return { year: Number(match[1]), month: Number(match[3]), day: Number(match[4]), tail: match[5] };
+  }
+  match = /^(\d{1,2})([-/.])(\d{1,2})\2(\d{4})(.*)$/.exec(value);
+  if (match) {
+    const first = Number(match[1]), second = Number(match[3]);
+    // Prefer month/day when both are possible; a leading value above 12 is a day.
+    const dayFirst = first > 12;
+    return { year: Number(match[4]), month: dayFirst ? second : first, day: dayFirst ? first : second, tail: match[5] };
+  }
+  match = /^([a-z]{3,9}\.?)(?:\s+|-)(\d{1,2})(st|nd|rd|th)?(?:,\s*|\s+|-)(\d{4})(.*)$/i.exec(value);
+  if (match) {
+    return { year: Number(match[4]), month: monthNumber(match[1]), day: Number(match[2]), ordinal: match[3], tail: match[5] };
+  }
+  match = /^(\d{1,2})(st|nd|rd|th)?(?:\s+|-)([a-z]{3,9}\.?)(?:,\s*|\s+|-)(\d{4})(.*)$/i.exec(value);
+  if (match) {
+    return { year: Number(match[4]), month: monthNumber(match[3]), day: Number(match[1]), ordinal: match[2], tail: match[5] };
+  }
+  return undefined;
+}
+
+function parseOffset(value: string | undefined): number | undefined {
+  if (!value || /^(?:z|utc|gmt)$/i.test(value)) {
+    return 0;
+  }
+  const match = /^(?:utc|gmt)?([+-])(\d{2})(?::?(\d{2}))?$/i.exec(value);
+  if (!match) {
+    return undefined;
+  }
+  const hour = Number(match[2]), minute = Number(match[3] || '0');
+  if (hour > 23 || minute > 59) {
+    return undefined;
+  }
+  return (match[1] === '-' ? -1 : 1) * (hour * 60 + minute);
+}
+
+function parseTimeParts(tail: string): TimeParts | undefined {
+  const midnight = { hour: 0, minute: 0, second: 0, millisecond: 0, remainder: '', offset: 0 };
+  if (!tail) {
+    return midnight;
+  }
+  if (!/^(?:[tT]|\s)/.test(tail)) {
+    return undefined;
+  }
+  const hasTimeSeparator = /^[tT]/.test(tail);
+  const text = (hasTimeSeparator ? tail.slice(1) : tail).trim();
+  if (!text) {
+    return undefined;
+  }
+  if (!hasTimeSeparator && /^(?:z|utc|gmt)$/i.test(text)) {
+    return midnight;
+  }
+  const match = /^(\d{1,2})(?::(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?[ \t]*(am|pm)?[ \t]*(\S+)?$/i.exec(text);
+  if (!match || (match[2] === undefined && match[5] === undefined)) {
+    return undefined;
+  }
+  let hour = Number(match[1]);
+  const minute = Number(match[2] || '0'), second = Number(match[3] || '0');
+  const meridiem = match[5]?.toLowerCase();
+  if (minute > 59 || second > 59 || (meridiem ? hour < 1 || hour > 12 : hour > 23)) {
+    return undefined;
+  }
+  if (meridiem) {
+    hour = hour % 12 + (meridiem === 'pm' ? 12 : 0);
+  }
+  const offset = parseOffset(match[6]);
+  if (offset === undefined) {
+    return undefined;
+  }
+  const fraction = match[4] || '';
+  const millisecond = Number(fraction.slice(0, 3).padEnd(3, '0'));
+  const remainder = fraction.slice(3).replace(/0+$/, '');
+  return { hour, minute, second, millisecond, remainder, offset };
+}
+
+function validCalendarDate({ year, month, day, ordinal }: DateParts): boolean {
+  if (month < 1 || month > 12 || day < 1) {
+    return false;
+  }
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+  if (day > days[month - 1]) {
+    return false;
+  }
+  if (ordinal) {
+    const suffix = day % 100 >= 11 && day % 100 <= 13 ? 'th' : ({ 1: 'st', 2: 'nd', 3: 'rd' } as Record<number, string>)[day % 10] || 'th';
+    if (suffix !== ordinal.toLowerCase()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+interface ComparableDate {
+  millisecond: number;
+  remainder: string;
+}
+
+function comparableDate(value: string): ComparableDate | undefined {
+  let text = value.trim();
+  const prefix = /^(sun(?:day)?|mon(?:day)?|tue(?:sday)?|wed(?:nesday)?|thu(?:rsday)?|fri(?:day)?|sat(?:urday)?),?\s+/i.exec(text);
+  const weekday = prefix ? weekdays.indexOf(prefix[1].slice(0, 3).toLowerCase()) : undefined;
+  if (prefix) {
+    text = text.slice(prefix[0].length);
+  }
+  const date = parseDateParts(text);
+  if (!date || !validCalendarDate(date)) {
+    return undefined;
+  }
+  const time = parseTimeParts(date.tail);
+  if (!time) {
+    return undefined;
+  }
+  // setUTCFullYear avoids Date.UTC's special interpretation of years 00 through 99.
+  const result = new Date(0);
+  result.setUTCFullYear(date.year, date.month - 1, date.day);
+  if (weekday !== undefined && result.getUTCDay() !== weekday) {
+    return undefined;
+  }
+  result.setUTCHours(time.hour, time.minute, time.second, time.millisecond);
+  return { millisecond: result.getTime() - time.offset * 60000, remainder: time.remainder };
+}
+
+/** Parse explicit complete calendar formats; date-only and unzoned times use UTC. */
+export function parseFilterDate(value: string): number | undefined {
+  return comparableDate(value)?.millisecond;
+}
+
+/** Compare accepted timestamps without discarding microsecond/nanosecond digits. */
+export function compileFilterDateComparison(query: string): ((cell: string) => NumberComparison | undefined) | undefined {
+  const threshold = comparableDate(query);
+  if (!threshold) {
+    return undefined;
+  }
+  return cell => {
+    const value = comparableDate(cell);
+    if (!value) {
+      return undefined;
+    }
+    if (value.millisecond !== threshold.millisecond) {
+      return value.millisecond < threshold.millisecond ? -1 : 1;
+    }
+    // Remainders are nonnegative even before the Unix epoch. Compare their
+    // decimal digits with implicit right zeros, using only the input's length.
+    for (let index = 0; index < Math.max(value.remainder.length, threshold.remainder.length); index++) {
+      const first = index < value.remainder.length ? value.remainder.charCodeAt(index) : 48;
+      const second = index < threshold.remainder.length ? threshold.remainder.charCodeAt(index) : 48;
+      if (first !== second) {
+        return first < second ? -1 : 1;
+      }
+    }
+    return 0;
+  };
+}
+
+export function compareFilterDates(a: string, b: string): NumberComparison | undefined {
+  return compileFilterDateComparison(b)?.(a);
+}
diff --git a/src/large-file-preview.ts b/src/large-file-preview.ts
new file mode 100644
index 0000000..8d63c12
--- /dev/null
+++ b/src/large-file-preview.ts
@@ -0,0 +1,170 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { randomBytes } from 'crypto';
+import { CsvEditorProvider } from './CsvEditorProvider';
+import { CsvPreviewPage, PreviewHistory, readCsvPreviewPage } from './bounded-csv-reader';
+
+const escapeHtml = (value: string): string => value.replace(/[&<>"']/g, char => ({
+  '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;'
+}[char] as string));
+
+export function renderPreviewRows(rows: string[][], firstRecord: number): string {
+  if (rows.length === 0) {
+    return '<p>No records in this file.</p>';
+  }
+  const width = Math.max(...rows.map(row => row.length));
+  const headings = Array.from({ length: width }, (_, index) => `<th scope="col">Column ${index + 1}</th>`).join('');
+  const body = rows.map((row, index) => `<tr><th scope="row">${firstRecord + index + 1}</th>${row.map(value => `<td>${escapeHtml(value)}</td>`).join('')}</tr>`).join('');
+  return `<table><thead><tr><th scope="col">Record</th>${headings}</tr></thead><tbody>${body}</tbody></table>`;
+}
+
+class PreviewDocument implements vscode.CustomDocument {
+  disposed = false;
+  constructor(readonly uri: vscode.Uri) {}
+  dispose(): void { this.disposed = true; }
+}
+
+export class LargeFilePreviewProvider implements vscode.CustomReadonlyEditorProvider<PreviewDocument> {
+  static readonly viewType = 'csv.largeFilePreview';
+  constructor(private readonly context: vscode.ExtensionContext) {}
+
+  async openCustomDocument(uri: vscode.Uri): Promise<PreviewDocument> {
+    if (uri.scheme !== 'file') {
+      throw new Error('Large File Preview currently supports host-local file URIs only. Use the normal CSV editor for this location.');
+    }
+    return new PreviewDocument(uri);
+  }
+
+  async resolveCustomEditor(document: PreviewDocument, panel: vscode.WebviewPanel, token: vscode.CancellationToken): Promise<void> {
+    panel.webview.options = {
+      enableScripts: true,
+      localResourceRoots: [vscode.Uri.file(path.join(this.context.extensionPath, 'media'))]
+    };
+    panel.webview.html = this.html(panel.webview);
+    const history = new PreviewHistory();
+    let page: CsvPreviewPage | undefined;
+    let fileVersion: string | undefined;
+    let selectedDelimiter: string | undefined;
+    let lastError = '';
+    let disposed = false;
+    let pending = Promise.resolve();
+    const cancelled = () => disposed || document.disposed || token.isCancellationRequested;
+    const send = (error?: string) => {
+      if (cancelled()) {
+        return;
+      }
+      const first = history.current.record;
+      void panel.webview.postMessage({
+        type: 'page',
+        html: page ? renderPreviewRows(page.rows, first) : '',
+        status: page?.rows.length ? `Saved file · Records ${first + 1}–${first + page.rows.length} · Read-only` : 'Saved file · Read-only',
+        canBack: history.canGoBack,
+        canNext: !!page && !page.done && !error,
+        error: error ?? ''
+      });
+    };
+    const read = async (reset: boolean) => {
+      const config = vscode.workspace.getConfiguration('csv', document.uri);
+      if (!config.get<boolean>('enabled', true)) {
+        throw new Error('CSV is disabled. Enable it before opening Large File Preview.');
+      }
+      const settings = CsvEditorProvider.getSeparatorSettings(document.uri);
+      const override = CsvEditorProvider.getSeparatorForUri(this.context, document.uri);
+      if (!override && settings.mode === 'auto') {
+        throw new Error('Large File Preview does not support automatic separator detection. Set a per-file separator override in the normal editor, or set csv.separatorMode to extension/default, then choose Back to Start.');
+      }
+      const delimiter = override ?? CsvEditorProvider.resolveInheritedSeparator(document.uri.fsPath, '', settings);
+      if (!reset && selectedDelimiter !== delimiter) {
+        throw new Error('The separator changed. Choose Back to Start to reload the preview.');
+      }
+      selectedDelimiter = delimiter;
+      page = await readCsvPreviewPage(document.uri.fsPath, {
+        delimiter,
+        offset: history.current.offset,
+        maxRows: config.get<number>('largeFilePreviewRows', 1000),
+        expectedVersion: reset ? undefined : fileVersion,
+        cancelled
+      });
+      fileVersion = page.version;
+      lastError = '';
+      send();
+    };
+    panel.webview.onDidReceiveMessage(message => {
+      pending = pending.then(async () => {
+        if (cancelled()) {
+          return;
+        }
+        if (message.type === 'ready') {
+          if (page) {
+            send();
+          } else if (lastError) {
+            send(lastError);
+          } else {
+            await read(true);
+          }
+        } else if (message.type === 'start') {
+          history.reset();
+          page = undefined;
+          fileVersion = undefined;
+          lastError = '';
+          await read(true);
+        } else if (message.type === 'next' && page && !page.done) {
+          history.next({ offset: page.nextOffset, record: history.current.record + page.rows.length });
+          await read(false);
+        } else if (message.type === 'previous' && history.canGoBack) {
+          history.previous();
+          await read(false);
+        }
+      }).catch(error => {
+        // Discard stale rows if navigation or source validation fails. The error
+        // remains visible; Back to Start can always retry a changed file.
+        page = undefined;
+        lastError = error instanceof Error ? error.message : 'Unable to read this preview page.';
+        send(lastError);
+      });
+      return pending;
+    });
+    panel.onDidDispose(() => { disposed = true; });
+  }
+
+  private html(webview: vscode.Webview): string {
+    const nonce = randomBytes(16).toString('hex');
+    const script = webview.asWebviewUri(vscode.Uri.file(path.join(this.context.extensionPath, 'media', 'large-preview.js')));
+    return `<!DOCTYPE html><html><head><meta charset="UTF-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}';">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<style nonce="${nonce}">
+body { font-family: var(--vscode-font-family); color: var(--vscode-editor-foreground); background: var(--vscode-editor-background); margin: 12px; }
+nav { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+button { color: var(--vscode-button-foreground); background: var(--vscode-button-background); border: 1px solid var(--vscode-contrastBorder, transparent); padding: 5px 10px; }
+button:disabled { opacity: .5; } #error { color: var(--vscode-errorForeground); white-space: pre-wrap; }
+#records { overflow: auto; max-height: calc(100vh - 125px); } table { border-collapse: collapse; }
+th, td { padding: 4px 8px; border: 1px solid var(--vscode-panel-border, #888); white-space: pre-wrap; overflow-wrap: anywhere; max-width: 60ch; }
+thead th { position: sticky; top: 0; background: var(--vscode-editor-background); } th { text-align: left; }
+</style></head><body>
+<nav aria-label="Preview pages"><button id="start">Back to Start</button><button id="previous" disabled>Previous</button><button id="next" disabled>Next</button><span id="status" role="status">Loading saved file…</span></nav>
+<p>Large File Preview · UTF-8 · Read-only. Each page replaces the previous page. The first record is shown as data.</p>
+<p id="error" role="alert"></p><div id="records" tabindex="0" aria-label="CSV records"></div>
+<script nonce="${nonce}" src="${script}"></script></body></html>`;
+  }
+}
+
+export async function openLargeFilePreview(uri?: vscode.Uri): Promise<void> {
+  if (!vscode.workspace.getConfiguration('csv').get<boolean>('enabled', true)) {
+    void vscode.window.showInformationMessage('Enable CSV before opening Large File Preview.');
+    return;
+  }
+  const target = uri instanceof vscode.Uri ? uri : (await vscode.window.showOpenDialog({
+    canSelectMany: false,
+    openLabel: 'Open Read-only Preview',
+    filters: { 'CSV/TSV/PSV': ['csv', 'tsv', 'tab', 'psv'] }
+  }))?.[0];
+  if (!target) {
+    return;
+  }
+  if (target.scheme !== 'file') {
+    void vscode.window.showErrorMessage('Large File Preview currently supports host-local files only. Use the normal CSV editor for this location.');
+    return;
+  }
+  await vscode.commands.executeCommand('vscode.openWith', target, LargeFilePreviewProvider.viewType, { preview: false });
+}
diff --git a/src/table-comparison.ts b/src/table-comparison.ts
new file mode 100644
index 0000000..b92b815
--- /dev/null
+++ b/src/table-comparison.ts
@@ -0,0 +1,204 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+import { randomBytes } from 'crypto';
+import { CsvEditorProvider } from './CsvEditorProvider';
+import { compareCsvRows, comparisonLimits, comparisonPages, CsvTableDiff, parseComparisonRows } from './csv-table-diff';
+
+const escapeHtml = (value: string): string => value.replace(/[&<>"']/g, char => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[char] as string));
+
+export function renderComparisonSide(diff: CsvTableDiff, side: 'original' | 'modified', start: number, end: number): string {
+  const columns = Math.max(1, ...diff.originalRows.map(row => row.length), ...diff.modifiedRows.map(row => row.length));
+  const headings = Array.from({ length: columns }, (_, col) => `<th scope="col">${col + 1}</th>`).join('');
+  const rows = diff.records.slice(start, end).map((record, index) => {
+    const source = record[side];
+    const values = source === undefined ? undefined : (side === 'original' ? diff.originalRows : diff.modifiedRows)[source];
+    const otherIndex = record[side === 'original' ? 'modified' : 'original'];
+    const other = otherIndex === undefined ? undefined : (side === 'original' ? diff.modifiedRows : diff.originalRows)[otherIndex];
+    const rowLabel = record.kind === 'added' ? 'Added' : record.kind === 'removed' ? 'Removed' : record.kind === 'changed' ? 'Changed' : 'Unchanged';
+    const cells = values === undefined ? `<td class="gap" colspan="${columns}">No record</td>`
+      : Array.from({ length: Math.max(values.length, other?.length ?? 0) }, (_, col) => {
+        if (col >= values.length) { return '<td class="gap" title="No field">—</td>'; }
+        const changed = record.changedColumns.includes(col);
+        const kind = changed ? (side === 'original' ? 'removed' : 'added') : '';
+        return `<td${kind ? ` class="${kind}" title="${rowLabel} cell"` : ''}>${escapeHtml(values[col])}</td>`;
+      }).join('');
+    return `<tr data-align="${start + index}" aria-label="${rowLabel} record"><th scope="row" title="${rowLabel}">${source === undefined ? '—' : source + 1}</th>${cells}</tr>`;
+  }).join('');
+  return `<table data-columns="${columns}"><colgroup><col width="60">${'<col width="180">'.repeat(columns)}</colgroup><thead><tr><th scope="col">Record</th>${headings}</tr></thead><tbody>${rows}</tbody></table>`;
+}
+
+export class TableComparison {
+  private diff: CsvTableDiff | undefined;
+  private pages = [{ start: 0, end: 0 }];
+  private currentPage = 0;
+  private focusedRecord: number | undefined;
+  private error = '';
+  private disposed = false;
+  private timer: ReturnType<typeof setTimeout> | undefined;
+  private readonly changeSubscription: vscode.Disposable;
+
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private original: vscode.TextDocument,
+    private modified: vscode.TextDocument,
+    private readonly panel: vscode.WebviewPanel
+  ) {
+    panel.webview.options = { enableScripts: true, localResourceRoots: [vscode.Uri.file(path.join(context.extensionPath, 'media'))] };
+    panel.webview.html = this.html();
+    panel.webview.onDidReceiveMessage(message => {
+      if (this.disposed) { return; }
+      if (message.type === 'ready') { this.showPage(); }
+      else if (message.type === 'page' && Number.isInteger(message.index)) {
+        this.currentPage = Math.max(0, Math.min(this.pages.length - 1, message.index));
+        this.focusedRecord = undefined;
+        this.showPage();
+      } else if (message.type === 'change' && (message.direction === 1 || message.direction === -1)) {
+        const changes = this.diff?.records.map((record, index) => record.kind === 'equal' ? -1 : index).filter(index => index >= 0) ?? [];
+        const boundary = this.focusedRecord ?? (this.pages[this.currentPage].start - (message.direction === 1 ? 1 : 0));
+        const target = message.direction === 1 ? changes.find(index => index > boundary) : changes.reverse().find(index => index < boundary);
+        if (target !== undefined) {
+          this.focusedRecord = target;
+          this.currentPage = this.pages.findIndex(page => target >= page.start && target < page.end);
+        }
+        this.showPage();
+      }
+    });
+    this.changeSubscription = vscode.workspace.onDidChangeTextDocument(event => {
+      if (event.document.uri.toString() !== original.uri.toString() && event.document.uri.toString() !== modified.uri.toString()) { return; }
+      if (event.document.uri.toString() === original.uri.toString()) { this.original = event.document; }
+      if (event.document.uri.toString() === modified.uri.toString()) { this.modified = event.document; }
+      if (this.timer) { clearTimeout(this.timer); }
+      this.timer = setTimeout(() => this.refresh(), 150);
+    });
+    panel.onDidDispose(() => this.dispose());
+    this.refresh();
+  }
+
+  dispose(): void {
+    this.disposed = true;
+    if (this.timer) { clearTimeout(this.timer); }
+    this.changeSubscription.dispose();
+  }
+
+  refresh(): void {
+    if (this.disposed) { return; }
+    try {
+      const rows = (document: vscode.TextDocument) => {
+        const text = document.getText();
+        const config = vscode.workspace.getConfiguration('csv', document.uri);
+        if (!config.get<boolean>('enabled', true)) { throw new Error('CSV is disabled.'); }
+        const limit = config.get<number>('maxFileSizeMB', 10);
+        if (Number.isFinite(limit) && limit > 0 && Buffer.byteLength(text, 'utf8') > limit * 1024 * 1024) {
+          throw new Error('An input exceeds csv.maxFileSizeMB. Use a text diff or adjust the existing file-size limit.');
+        }
+        const separator = CsvEditorProvider.getSeparatorForUri(this.context, document.uri)
+          ?? CsvEditorProvider.resolveInheritedSeparator(document.uri.fsPath || document.uri.path, text, CsvEditorProvider.getSeparatorSettings(document.uri));
+        return parseComparisonRows(text, separator);
+      };
+      this.diff = compareCsvRows(rows(this.original), rows(this.modified));
+      this.pages = comparisonPages(this.diff);
+      this.currentPage = Math.min(this.currentPage, this.pages.length - 1);
+      this.focusedRecord = undefined;
+      this.error = '';
+    } catch (error) {
+      this.diff = undefined;
+      this.pages = [{ start: 0, end: 0 }];
+      this.currentPage = 0;
+      this.error = error instanceof Error ? error.message : 'Unable to compare these files.';
+    }
+    this.showPage();
+  }
+
+  private showPage(): void {
+    if (this.disposed) { return; }
+    const { start, end } = this.pages[this.currentPage];
+    const changes = this.diff?.records.map((record, index) => record.kind === 'equal' ? -1 : index).filter(index => index >= 0) ?? [];
+    const boundary = this.focusedRecord ?? start;
+    void this.panel.webview.postMessage({
+      type: 'comparison',
+      originalHtml: this.diff ? renderComparisonSide(this.diff, 'original', start, end) : '',
+      modifiedHtml: this.diff ? renderComparisonSide(this.diff, 'modified', start, end) : '',
+      page: this.currentPage,
+      pageCount: this.pages.length,
+      canPreviousChange: changes.some(index => index < boundary),
+      canNextChange: changes.some(index => index > (this.focusedRecord ?? start - 1)),
+      focusRecord: this.focusedRecord,
+      status: this.diff ? `Page ${this.currentPage + 1}/${this.pages.length} · Added ${this.diff.added} · Removed ${this.diff.removed} · Changed ${this.diff.changed} records` : '',
+      notice: this.diff?.approximate ? 'Some large changed sections are aligned by position after the alignment work limit. Cell differences are exact for the displayed pairs.' : '',
+      error: this.error
+    });
+  }
+
+  private html(): string {
+    const nonce = randomBytes(16).toString('hex');
+    const script = this.panel.webview.asWebviewUri(vscode.Uri.file(path.join(this.context.extensionPath, 'media', 'table-comparison.js')));
+    return `<!DOCTYPE html><html><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}';">
+<style nonce="${nonce}">
+body { font-family: var(--vscode-font-family, sans-serif); color: var(--vscode-editor-foreground); background: var(--vscode-editor-background); margin: 10px; }
+nav { display: flex; align-items: center; gap: 7px; flex-wrap: wrap; } button { padding: 4px 8px; background: var(--vscode-button-background); color: var(--vscode-button-foreground); border: 1px solid var(--vscode-contrastBorder, #888); } button:disabled { opacity: .5; }
+#error, #notice { white-space: pre-wrap; } #error { color: var(--vscode-errorForeground); }
+.panes { display: grid; grid-template-columns: minmax(0,1fr) minmax(0,1fr); gap: 10px; } section { min-width: 0; } h2 { font-size: 1em; margin: 5px 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.viewport { overflow: auto; height: calc(100vh - 170px); min-height: 150px; border: 1px solid var(--vscode-panel-border, #888); }
+table { border-collapse: collapse; table-layout: fixed; } th, td { box-sizing: border-box; border: 1px solid var(--vscode-panel-border, #888); padding: 4px 7px; white-space: pre-wrap; overflow-wrap: anywhere; vertical-align: top; }
+thead th { position: sticky; top: 0; z-index: 1; background: var(--vscode-editor-background, white); } th { text-align: left; }
+.added { background: var(--vscode-diffEditor-insertedTextBackground, rgba(40,180,80,.22)); box-shadow: inset 3px 0 var(--vscode-editorGutter-addedBackground, #259c45); }
+.removed { background: var(--vscode-diffEditor-removedTextBackground, rgba(220,60,60,.22)); box-shadow: inset 3px 0 var(--vscode-editorGutter-deletedBackground, #d23b3b); }
+.gap { opacity: .65; border-style: dashed; } tr.focused { outline: 2px solid var(--vscode-focusBorder, #007acc); outline-offset: -2px; }
+</style></head><body>
+<nav><button id="previousPage">Previous Page</button><button id="nextPage">Next Page</button><button id="previousChange">Previous Change</button><button id="nextChange">Next Change</button><span id="status" role="status"></span></nav>
+<p>Read-only cell comparison · Red: original differences · Green: modified differences · Scrolling stays synchronized. Quoting and line-ending style are not compared.</p>
+<div id="error" role="alert"></div><div id="notice" role="status"></div>
+<div class="panes"><section><h2 title="${escapeHtml(path.basename(this.original.uri.path))}">Original: ${escapeHtml(path.basename(this.original.uri.path))}</h2><div id="original" class="viewport" tabindex="0" aria-label="Original CSV"></div></section>
+<section><h2 title="${escapeHtml(path.basename(this.modified.uri.path))}">Modified: ${escapeHtml(path.basename(this.modified.uri.path))}</h2><div id="modified" class="viewport" tabindex="0" aria-label="Modified CSV"></div></section></div>
+<script nonce="${nonce}" src="${script}"></script></body></html>`;
+  }
+}
+
+export async function compareFilesAsTable(context: vscode.ExtensionContext, resource?: vscode.Uri, selected?: vscode.Uri[]): Promise<void> {
+  if (!vscode.workspace.getConfiguration('csv').get<boolean>('enabled', true)) {
+    void vscode.window.showInformationMessage('Enable CSV before comparing files as a table.'); return;
+  }
+  let original: vscode.Uri | undefined;
+  let modified: vscode.Uri | undefined;
+  if (Array.isArray(selected) && selected.length === 2 && selected.every(uri => uri instanceof vscode.Uri)) {
+    [original, modified] = selected;
+  } else {
+    const active = CsvEditorProvider.getActiveProvider();
+    original = resource instanceof vscode.Uri ? resource : vscode.window.activeTextEditor?.document.uri ?? (active?.isActive() ? active.getDocumentUri() : undefined);
+    if (!original) {
+      original = (await vscode.window.showOpenDialog({ canSelectMany: false, openLabel: 'Select Original CSV File' }))?.[0];
+    }
+    if (!original) { return; }
+    modified = (await vscode.window.showOpenDialog({ canSelectMany: false, openLabel: 'Select Modified CSV File' }))?.[0];
+  }
+  if (!original || !modified) { return; }
+  try {
+    const documents: vscode.TextDocument[] = [];
+    for (const uri of [original, modified]) {
+      const limit = vscode.workspace.getConfiguration('csv', uri).get<number>('maxFileSizeMB', 10);
+      const existing = vscode.workspace.textDocuments.find(document => !document.isClosed && document.uri.toString() === uri.toString());
+      let size: number | undefined;
+      try { size = (await vscode.workspace.fs.stat(uri)).size; } catch { /* Existing documents can still be compared within decoded-size limits. */ }
+      if (size === undefined && !existing) {
+        throw new Error('Cannot verify this source size. Open it in a normal editor first, then compare the already-open document.');
+      }
+      if (size !== undefined && size > comparisonLimits.sourceBytes) {
+        throw new Error('Table comparison supports at most 10 MiB of saved bytes per input, regardless of csv.maxFileSizeMB. Use a text diff for larger files.');
+      }
+      if (size !== undefined && Number.isFinite(limit) && limit > 0 && size > limit * 1024 * 1024) {
+        throw new Error('An input exceeds csv.maxFileSizeMB. Use a text diff or adjust the existing file-size limit.');
+      }
+      const document = existing ?? await vscode.workspace.openTextDocument(uri);
+      if (Buffer.byteLength(document.getText(), 'utf8') > comparisonLimits.textBytes) {
+        throw new Error('Table comparison supports at most 5 MiB of decoded text per input. Use a text diff for larger files.');
+      }
+      documents.push(document);
+    }
+    const [before, after] = documents;
+    const panel = vscode.window.createWebviewPanel('csv.tableComparison', `CSV Compare: ${path.basename(original.path)} ↔ ${path.basename(modified.path)}`, vscode.ViewColumn.Active, {});
+    new TableComparison(context, before, after, panel);
+  } catch (error) {
+    void vscode.window.showErrorMessage(error instanceof Error ? error.message : 'Unable to open the CSV comparison.');
+  }
+}
diff --git a/src/test-support/sizing-webview-harness.ts b/src/test-support/sizing-webview-harness.ts
new file mode 100644
index 0000000..59ff053
--- /dev/null
+++ b/src/test-support/sizing-webview-harness.ts
@@ -0,0 +1,174 @@
+import fs from 'fs';
+import path from 'path';
+import vm from 'vm';
+
+type Listener = { callback: (event: any) => void; capture: boolean };
+
+// Execute the complete shipped script. The small DOM model supplies selection,
+// focus and event propagation; it does not reimplement clipboard behavior.
+export function createWebview(options: { state?: any; persistedColumns?: Record<string, number>; header?: boolean } = {}) {
+  class Element {
+    listeners = new Map<string, Listener[]>();
+    attributes = new Map<string, string>();
+    classes = new Set<string>();
+    children: Element[] = [];
+    parentElement: Element | null = null;
+    style: Record<string, string> = {};
+    dataset: Record<string, string> = {};
+    textContent = '';
+    value = '';
+    isContentEditable = false;
+    isConnected = true;
+    rect = { left: 0, right: 100, top: 0, bottom: 30, width: 100, height: 30 };
+    getBoundingClientRect() { return this.rect; }
+    get previousElementSibling(): Element | null { return this.parentElement?.children[this.parentElement.children.indexOf(this) - 1] ?? null; }
+    get nextElementSibling(): Element | null { return this.parentElement?.children[this.parentElement.children.indexOf(this) + 1] ?? null; }
+    classList = {
+      add: (...names: string[]) => names.forEach(name => this.classes.add(name)),
+      remove: (...names: string[]) => names.forEach(name => this.classes.delete(name)),
+      contains: (name: string) => this.classes.has(name),
+      toggle: (name: string, force?: boolean) => {
+        const next = force ?? !this.classes.has(name);
+        if (next) { this.classes.add(name); } else { this.classes.delete(name); }
+        return next;
+      }
+    };
+    constructor(public tagName = 'DIV', public id = '') {}
+    addEventListener(type: string, callback: (event: any) => void, options?: any) {
+      const listeners = this.listeners.get(type) || [];
+      listeners.push({ callback, capture: options === true });
+      this.listeners.set(type, listeners);
+    }
+    removeEventListener() {}
+    setAttribute(name: string, value: string) { this.attributes.set(name, value); }
+    getAttribute(name: string) { return this.attributes.get(name) ?? null; }
+    get tBodies() { return this.children.filter(child => child.tagName === 'TBODY'); }
+    hasAttribute(name: string) { return this.attributes.has(name); }
+    appendChild(child: Element) { child.parentElement = this; this.children.push(child); }
+    contains(other: Element): boolean { return other === this || this.children.some(child => child.contains(other)); }
+    focus() { document.activeElement = this; }
+    scrollIntoView() {}
+    matches(selector: string): boolean {
+      if (selector.endsWith(':last-child')) {
+        return this === this.parentElement?.children[this.parentElement.children.length - 1] && this.matches(selector.slice(0, -':last-child'.length));
+      }
+      if (selector.includes(' ')) {
+        const [ancestor, child] = selector.split(' ');
+        return this.matches(child) && !!this.parentElement?.closest(ancestor);
+      }
+      if (selector.startsWith('#')) { return this.id === selector.slice(1); }
+      const tag = selector.match(/^[a-z]+/i)?.[0];
+      if (tag && this.tagName !== tag.toUpperCase()) { return false; }
+      if (selector.includes('.')) { return selector.split('.').slice(1).every(name => this.classes.has(name)); }
+      for (const match of selector.matchAll(/\[([^=\]]+)(?:="([^"]*)")?\]/g)) {
+        if (match[2] === undefined ? !this.hasAttribute(match[1]) : this.getAttribute(match[1]) !== match[2]) { return false; }
+      }
+      return true;
+    }
+    closest(selector: string): Element | null {
+      if (selector.split(',').some(part => this.matches(part.trim()))) { return this; }
+      return this.parentElement?.closest(selector) ?? null;
+    }
+    querySelectorAll(selector: string): Element[] {
+      const descendants = this.children.flatMap(child => [child, ...child.querySelectorAll('*')]);
+      return descendants.filter(child => selector === '*' || selector.split(',').some(part => child.matches(part.trim())));
+    }
+    querySelector(selector: string) { return this.querySelectorAll(selector)[0] ?? null; }
+    get innerHTML() { return ''; }
+    set innerHTML(_value: string) { this.children = []; }
+    get innerText() { return this.textContent; }
+    set innerText(value: string) { this.textContent = value; }
+  }
+  const document = new Element('DOCUMENT') as Element & { body: Element; activeElement: Element | null; getElementById: (id: string) => Element };
+  document.body = new Element('BODY');
+  document.activeElement = null;
+  document.appendChild(document.body);
+  const elements = new Map<string, Element>();
+  const byId = (id: string) => {
+    if (!elements.has(id)) {
+      const el = new Element(id.endsWith('Input') ? 'INPUT' : 'DIV', id);
+      elements.set(id, el);
+      document.body.appendChild(el);
+    }
+    return elements.get(id)!;
+  };
+  document.getElementById = byId;
+  const root = byId('csv-root');
+  const table = new Element('TABLE');
+  const head = new Element('THEAD');
+  const body = new Element('TBODY');
+  const rows = new Map<string, Element>();
+  if (options.header !== false) { table.appendChild(head); }
+  table.appendChild(body);
+  root.appendChild(table);
+  root.dataset.columnsizes = JSON.stringify(options.persistedColumns || {});
+  byId('__csvChunks').textContent = '[]';
+  const widget = byId('findReplaceWidget');
+  for (const id of ['findInput', 'replaceInput']) {
+    const input = byId(id);
+    document.body.children = document.body.children.filter(el => el !== input);
+    widget.appendChild(input);
+  }
+  const window = new Element('WINDOW') as any;
+  window.getComputedStyle = () => ({ fontSize: '14px' });
+  const messages: any[] = [];
+  let savedState = options.state || {};
+  class IntersectionObserver {
+    private readonly observed = new Set<Element>();
+    observe(target: Element) { this.observed.add(target); }
+    unobserve(target: Element) { this.observed.delete(target); }
+    disconnect() { this.observed.clear(); }
+    takeRecords() { return []; }
+  }
+  const context = vm.createContext({
+    document, window, Element, Node: Element, IntersectionObserver,
+    acquireVsCodeApi: () => ({ getState: () => savedState, setState: (state: any) => { savedState = state; }, postMessage: (message: any) => messages.push(JSON.parse(JSON.stringify(message))) }),
+    setTimeout: () => 0, clearTimeout: () => {}, requestAnimationFrame: () => 0,
+    console
+  });
+  (document as any).createElement = (tag: string) => new Element(tag.toUpperCase());
+  vm.runInContext(fs.readFileSync(path.join(process.cwd(), 'media', 'main.js'), 'utf8'), context);
+  // Interaction assertions begin after the independent initialization handshake.
+  messages.length = 0;
+  const cell = (row: number, col: number, value: string, header = false) => {
+    const el = new Element(header ? 'TH' : 'TD');
+    el.rect = { left: col * 100, right: (col + 1) * 100, top: row * 30, bottom: (row + 1) * 30, width: 100, height: 30 };
+    el.style.width = ''; el.style.minWidth = '8ch'; el.style.maxWidth = '100ch'; el.style.boxSizing = '';
+    el.setAttribute('data-row', String(row));
+    el.setAttribute('data-col', String(col));
+    el.textContent = value;
+    const key = `${header}:${row}`;
+    if (!rows.has(key)) {
+      const tr = new Element('TR');
+      (header ? head : body).appendChild(tr);
+      rows.set(key, tr);
+    }
+    rows.get(key)!.appendChild(el);
+    return el;
+  };
+  (document as any).elementFromPoint = (x: number, y: number) => table.querySelectorAll('td, th').find(cell => {
+    const rect = cell.getBoundingClientRect();
+    return rect.width > 0 && rect.height > 0 && x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+  }) ?? table;
+  const dispatch = (target: Element, type: string, options: any = {}) => {
+    const event: any = {
+      type, target, defaultPrevented: false, stopped: false, immediate: false,
+      preventDefault() { this.defaultPrevented = true; },
+      stopPropagation() { this.stopped = true; },
+      stopImmediatePropagation() { this.stopped = true; this.immediate = true; },
+      ...options
+    };
+    const invoke = (el: Element, capture: boolean) => {
+      for (const listener of el.listeners.get(type) || []) {
+        if (listener.capture === capture && !event.immediate) { listener.callback(event); }
+      }
+    };
+    invoke(document, true);
+    if (!event.stopped) { invoke(target, false); }
+    for (let parent = target.parentElement; parent && !event.stopped; parent = parent.parentElement) { invoke(parent, false); }
+    return event;
+  };
+  return { context, cell, byId, document, table, messages, dispatch, select: (startRow: number, startCol: number, endRow = startRow, endCol = startCol) => {
+    vm.runInContext(`selectRange({ row: ${startRow}, col: ${startCol} }, { row: ${endRow}, col: ${endCol} }); anchorCell = currentSelection[0];`, context);
+  }};
+}
diff --git a/src/test/bounded-csv-reader.test.ts b/src/test/bounded-csv-reader.test.ts
new file mode 100644
index 0000000..56bfe9e
--- /dev/null
+++ b/src/test/bounded-csv-reader.test.ts
@@ -0,0 +1,157 @@
+import assert from 'assert';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, it } from 'node:test';
+import Papa from 'papaparse';
+import { previewLimits, PreviewHistory, readCsvPreviewPage } from '../bounded-csv-reader';
+
+async function fixture(value: string | Buffer, run: (file: string) => Promise<void>) {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'csv-bounded-'));
+  const file = path.join(directory, 'source.csv');
+  try {
+    await fs.writeFile(file, value);
+    await run(file);
+  } finally {
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+}
+
+describe('Bounded CSV reader', () => {
+  for (const delimiter of [',', '\t', '|']) {
+    for (const readBytes of [1, 2, 3, 7, 64]) {
+      it(`preserves UTF-8, CRLF and quoted boundaries with ${JSON.stringify(delimiter)} / ${readBytes}-byte reads`, async () => {
+        const data = [['name', 'value'], ['éä😀', `inside${delimiter}field`], ['two\r\nlines', 'a"b'], ['\uFEFFintentional', 'end']];
+        const source = '\uFEFF' + Papa.unparse(data, { delimiter, newline: '\r\n' }) + '\r\n';
+        await fixture(source, async file => {
+          const actual: string[][] = [];
+          let offset = 0;
+          let fileVersion: string | undefined;
+          let done = false;
+          while (!done) {
+            const page = await readCsvPreviewPage(file, { delimiter, offset, readBytes, maxRows: 1, expectedVersion: fileVersion });
+            actual.push(...page.rows);
+            assert.ok(page.nextOffset > offset);
+            offset = page.nextOffset;
+            fileVersion = page.version;
+            done = page.done;
+          }
+          assert.deepStrictEqual(actual, data);
+          assert.strictEqual(offset, Buffer.byteLength(source));
+        });
+      });
+    }
+  }
+
+  for (const source of ['', '\uFEFF', '\n', '\r\n', 'a,b\r', 'a,b\nc,d', 'a,b\n\n']) {
+    it(`handles EOF and empty records in ${JSON.stringify(source)}`, async () => {
+      await fixture(source, async file => {
+        const page = await readCsvPreviewPage(file, { delimiter: ',', readBytes: 1 });
+        const expected = source === '' || source === '\uFEFF' ? []
+          : source === '\n' || source === '\r\n' ? [['']]
+          : source === 'a,b\nc,d' ? [['a', 'b'], ['c', 'd']]
+          : source === 'a,b\n\n' ? [['a', 'b'], ['']]
+          : [['a', 'b']];
+        assert.deepStrictEqual(page.rows, expected);
+        assert.ok(page.done);
+      });
+    });
+  }
+
+  it('reads only a bounded prefix and never a whole large file', async () => {
+    const source = 'alpha,beta\n'.repeat(200000);
+    await fixture(source, async file => {
+      const page = await readCsvPreviewPage(file, { delimiter: ',', maxRows: 1000 });
+      assert.strictEqual(page.rows.length, 1000);
+      assert.ok(!page.done);
+      assert.ok(page.bytesRead <= previewLimits.readBytes + 3);
+      assert.ok(page.bytesRead < Buffer.byteLength(source) / 10);
+    });
+  });
+
+  it('caps source bytes and cells independently of the requested row count', async () => {
+    const source = `${'x'.repeat(200000)}\n`.repeat(4);
+    await fixture(source, async file => {
+      const page = await readCsvPreviewPage(file, { delimiter: ',', maxRows: 10000 });
+      assert.strictEqual(page.rows.length, 2);
+      assert.strictEqual(page.nextOffset, 400002);
+      assert.ok(page.bytesRead <= previewLimits.pageBytes + previewLimits.recordBytes + previewLimits.readBytes + 3);
+    });
+    await fixture(`${Array(1000).fill('x').join(',')}\n`.repeat(30), async file => {
+      const page = await readCsvPreviewPage(file, { delimiter: ',', maxRows: 10000 });
+      assert.strictEqual(page.rows.length, 20);
+      assert.strictEqual(page.rows.flat().length, previewLimits.pageCells);
+      assert.ok(!page.done);
+    });
+  });
+
+  for (const [source, error] of [
+    ['a,"unfinished\n', /Unterminated quoted record/],
+    ['a,"closed"junk\n', /Malformed quoted field/],
+    ['x'.repeat(previewLimits.recordBytes + 1), /No partial record was displayed/],
+    [Array(1001).fill('x').join(','), /No fields were truncated/]
+  ] as const) {
+    it(`rejects malformed/oversized input visibly (${error.source})`, async () => {
+      await fixture(source, file => assert.rejects(readCsvPreviewPage(file, { delimiter: ',' }), error));
+    });
+  }
+
+  it('rejects non-UTF8, UTF16 BOMs, NULs and unsupported separators without guessing', async () => {
+    for (const bytes of [Buffer.from([0x84, 10]), Buffer.from([0xFF, 0xFE, 97, 0]), Buffer.from('a\0b')]) {
+      await fixture(bytes, file => assert.rejects(readCsvPreviewPage(file, { delimiter: ',' }), /UTF-8/));
+    }
+    await fixture('a,b', file => assert.rejects(readCsvPreviewPage(file, { delimiter: '||' }), /single ASCII separator/));
+  });
+
+  it('detects source changes between pages', async () => {
+    await fixture('a,b\n1,2\n', async file => {
+      const first = await readCsvPreviewPage(file, { delimiter: ',', maxRows: 1 });
+      await fs.appendFile(file, '3,4\n');
+      await assert.rejects(readCsvPreviewPage(file, { delimiter: ',', offset: first.nextOffset, expectedVersion: first.version }), /file changed/);
+    });
+  });
+
+  it('closes the file descriptor after success, cancellation and malformed records', async () => {
+    const originalOpen = fs.open;
+    const handles: Array<{ closed: number }> = [];
+    (fs as any).open = async (...args: Parameters<typeof fs.open>) => {
+      const handle = await originalOpen(...args);
+      const state = { closed: 0 };
+      handles.push(state);
+      return new Proxy(handle, {
+        get(target, key) {
+          if (key === 'close') {
+            return async () => { state.closed++; await target.close(); };
+          }
+          const value = Reflect.get(target, key);
+          return typeof value === 'function' ? value.bind(target) : value;
+        }
+      });
+    };
+    try {
+      await fixture('a,b\n1,2\n', async file => {
+        await readCsvPreviewPage(file, { delimiter: ',' });
+        let checks = 0;
+        await assert.rejects(readCsvPreviewPage(file, { delimiter: ',', readBytes: 1, cancelled: () => ++checks > 2 }), /cancelled/);
+      });
+      await fixture('"unfinished', file => assert.rejects(readCsvPreviewPage(file, { delimiter: ',' }), /Unterminated/));
+      assert.deepStrictEqual(handles.map(handle => handle.closed), [1, 1, 1]);
+    } finally {
+      fs.open = originalOpen;
+    }
+  });
+
+  it('retains only a bounded navigation history', () => {
+    const history = new PreviewHistory();
+    for (let index = 1; index < 1000; index++) {
+      history.next({ offset: index * 100, record: index });
+    }
+    assert.strictEqual(history.size, previewLimits.history);
+    let previous = 0;
+    while (history.canGoBack) { history.previous(); previous++; }
+    assert.strictEqual(previous, previewLimits.history - 1);
+    history.reset();
+    assert.deepStrictEqual(history.current, { offset: 0, record: 0 });
+    assert.strictEqual(history.size, 1);
+  });
+});
diff --git a/src/test/clipboard-column.test.ts b/src/test/clipboard-column.test.ts
new file mode 100644
index 0000000..22c8503
--- /dev/null
+++ b/src/test/clipboard-column.test.ts
@@ -0,0 +1,142 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+import { parseClipboardMatrix, serializeClipboardMatrix } from '../clipboard';
+
+const select = (view: ReturnType<typeof createWebviewDom>, start: any, end = start) => {
+  start.dispatchEvent(new view.window.MouseEvent('mousedown', { bubbles: true, button: 0, clientX: 100, clientY: 50 }));
+  if (end !== start) { end.dispatchEvent(new view.window.MouseEvent('mousemove', { bubbles: true, clientX: 100, clientY: 50 })); }
+  end.dispatchEvent(new view.window.MouseEvent('mouseup', { bubbles: true, button: 0 }));
+};
+const copy = (view: ReturnType<typeof createWebviewDom>, target: any, route: string) => {
+  if (route === 'copy' || route === 'cut') {
+    const event = new view.window.Event(route, { bubbles: true, cancelable: true });
+    target.dispatchEvent(event);
+    return event;
+  }
+  if (route === 'keyboard-copy' || route === 'keyboard-cut') {
+    const event = new view.window.KeyboardEvent('keydown', { key: route === 'keyboard-copy' ? 'c' : 'x', metaKey: true, bubbles: true, cancelable: true });
+    target.dispatchEvent(event);
+    return event;
+  }
+  target.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 100, clientY: 50 }));
+  const label = route === 'context-copy' ? 'Copy' : 'Cut';
+  const item = Array.from(view.window.document.querySelectorAll('#contextMenu div')).find((element: any) => element.textContent === label) as any;
+  assert.ok(item);
+  item.click();
+};
+
+describe('Whole-column clipboard and the append row', () => {
+  it('copies ordinary header columns without quotes or the virtual append cell', async () => {
+    for (const separator of [',', '\t']) {
+      const host = await createEditorHarness({ rows: [['Name'], ['alpha'], ['beta']], separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const header = view.cell(0, 0);
+        select(view, header);
+        copy(view, header, 'copy');
+        const message = view.messages.find(item => item.type === 'copyCells');
+        assert.deepStrictEqual(JSON.parse(JSON.stringify(message.matrix)), [['Name'], ['alpha'], ['beta']]);
+        assert.strictEqual(serializeClipboardMatrix(message.matrix, separator), 'Name\r\nalpha\r\nbeta');
+        assert.strictEqual(host.document.getText(), host.diskText);
+      } finally { view.close(); }
+    }
+  });
+
+  it('quotes only the real complex/empty values in a selected column and preserves every real source row', async () => {
+    for (const separator of [',', '\t']) {
+      const host = await createEditorHarness({ rows: [['Name', 'Other'], ['plain', 'value'], ['', 'keep'], ['with,comma', 'value'], ['last', 'value']], separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const header = view.cell(0, 0);
+        select(view, header);
+        copy(view, header, 'keyboard-copy');
+        const matrix = view.messages.find(item => item.type === 'copyCells').matrix;
+        assert.strictEqual(serializeClipboardMatrix(matrix, separator), 'Name\r\nplain\r\n""\r\n"with,comma"\r\nlast');
+        assert.deepStrictEqual(parseClipboardMatrix(serializeClipboardMatrix(matrix, separator), separator), [['Name'], ['plain'], [''], ['with,comma'], ['last']]);
+        assert.strictEqual(view.window.document.querySelector('#csv-root').dataset.realrowcount, '5');
+      } finally { view.close(); }
+    }
+  });
+
+  it('excludes ghost rows from range and Select All Copy/Cut routes, and consumes ghost-only copies without touching clipboard', async () => {
+    for (const route of ['copy', 'cut', 'keyboard-copy', 'keyboard-cut', 'context-copy', 'context-cut']) {
+      for (const selection of ['range', 'all', 'ghost']) {
+        const host = await createEditorHarness({ rows: [['Name', 'Other'], ['', ''], ['last', 'value']] });
+        const view = createWebviewDom(host.panel.webview.html);
+        try {
+          const ghost = view.cell(3, 0);
+          assert.ok(ghost);
+          if (selection === 'all') {
+            view.window.editingTestApi.setSingleSelection(view.cell(1, 0));
+            view.key('a', { metaKey: true });
+          } else if (selection === 'range') {
+            select(view, view.cell(1, 0), ghost);
+          } else {
+            view.window.editingTestApi.setSingleSelection(ghost);
+          }
+          const event = copy(view, ghost, route);
+          const messages = view.messages.filter(item => item.type === 'copyCells');
+          if (selection === 'ghost') {
+            assert.strictEqual(messages.length, 0, `${route}: do not send a clipboard write for append-row-only selection`);
+            if (event) { assert.strictEqual(event.defaultPrevented, true, 'native empty copy must not overwrite the existing system clipboard'); }
+          } else {
+            assert.strictEqual(messages.length, 1);
+            const expected = selection === 'all' ? [['Name', 'Other'], ['', ''], ['last', 'value']] : [[''], ['last']];
+            assert.deepStrictEqual(JSON.parse(JSON.stringify(messages[0].matrix)), expected, route);
+            assert.strictEqual(messages[0].cut, route.includes('cut'));
+          }
+          assert.strictEqual(host.document.getText(), host.diskText);
+        } finally { view.close(); }
+      }
+    }
+  });
+  it('uses the full source count instead of treating the last loaded chunk row as a ghost', async () => {
+    const rows = [['Name'], ...Array.from({ length: 1002 }, (_value, index) => [`row-${index}`])];
+    const host = await createEditorHarness({ rows, remote: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      assert.strictEqual(view.window.document.querySelector('#csv-root').dataset.realrowcount, '1003');
+      const header = view.cell(0, 0);
+      select(view, header);
+      copy(view, header, 'copy');
+      const first = view.messages.filter(item => item.type === 'copyCells').slice(-1)[0];
+      assert.strictEqual(first.matrix.length, 1001);
+      assert.strictEqual(first.matrix[1000][0], 'row-999', 'the last loaded real source row is retained');
+      let cursor = view.messages.length;
+      view.window.__csvLoadNextChunk();
+      for (let guard = 0; guard < 5 && !view.cell(1003, 0); guard++) {
+        const requests = view.messages.slice(cursor).filter(item => item.type === 'requestChunk');
+        cursor = view.messages.length;
+        for (const request of requests) {
+          await host.receive(request);
+          const response = host.messages.filter(item => item.type === 'chunkData' && item.requestId === request.requestId).slice(-1)[0];
+          view.window.dispatchEvent(new view.window.MessageEvent('message', { data: response }));
+          view.window.__csvLoadNextChunk();
+        }
+      }
+      assert.ok(view.cell(1003, 0), 'the remote append row is eventually rendered');
+      view.window.editingTestApi.setSingleSelection(view.cell(1, 0));
+      select(view, header);
+      copy(view, header, 'copy');
+      const complete = view.messages.filter(item => item.type === 'copyCells').slice(-1)[0];
+      assert.strictEqual(complete.matrix.length, 1003);
+      assert.strictEqual(complete.matrix[1002][0], 'row-1001');
+    } finally { view.close(); }
+  });
+
+  it('does not copy the only ghost cell in an empty file', async () => {
+    const host = await createEditorHarness({ rows: [] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      assert.strictEqual(view.window.document.querySelector('#csv-root').dataset.realrowcount, '0');
+      const ghost = view.cell(0, 0);
+      view.window.editingTestApi.setSingleSelection(ghost);
+      const event = copy(view, ghost, 'cut');
+      assert.strictEqual(event.defaultPrevented, true);
+      assert.strictEqual(view.messages.some(item => item.type === 'copyCells'), false);
+      assert.strictEqual(host.document.getText(), '');
+    } finally { view.close(); }
+  });
+
+});
diff --git a/src/test/clipboard.test.ts b/src/test/clipboard.test.ts
new file mode 100644
index 0000000..8d2eb36
--- /dev/null
+++ b/src/test/clipboard.test.ts
@@ -0,0 +1,124 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import Papa from 'papaparse';
+import { parseClipboardMatrix, serializeClipboardMatrix } from '../clipboard';
+
+// Independent expectations exercise the same codec used by the extension host.
+describe('Clipboard matrix fidelity', () => {
+  it('copies ordinary single-cell strings as plain text for Search and other text inputs', () => {
+    for (const value of ['hello', 'hello world', 'SKU-123', '00123', 'https://example.test/path?query=one&other=two']) {
+      assert.strictEqual(serializeClipboardMatrix([[value]], ','), value);
+      assert.strictEqual(serializeClipboardMatrix([[value]], '\t'), value);
+    }
+  });
+
+  it('does not add quotes to ordinary fields in a copied range', () => {
+    const matrix = [['name', 'value'], ['alpha', '42']];
+    assert.strictEqual(serializeClipboardMatrix(matrix, ','), 'name,value\r\nalpha,42');
+    assert.strictEqual(serializeClipboardMatrix(matrix, '\t'), 'name\tvalue\r\nalpha\t42');
+  });
+
+  it('quotes complex fields without wrapping their ordinary neighbors', () => {
+    assert.strictEqual(
+      serializeClipboardMatrix([['hello', 'with,comma', 'say "hi"', 'line\nvalue']], ','),
+      'hello,"with,comma","say ""hi""","line\nvalue"'
+    );
+  });
+
+  it('keeps alternate separators inside one copied cell during automatic paste detection', () => {
+    for (const delimiter of [',', '\t', '|', ';', '^']) {
+      for (const value of ['with,comma', 'with\ttab', 'with;semicolon', 'with|pipe']) {
+        assert.deepStrictEqual(parseClipboardMatrix(serializeClipboardMatrix([[value]], delimiter), delimiter), [[value]]);
+      }
+    }
+  });
+
+  it('does not guess separators from inside later quoted fields in a copied range', () => {
+    for (const delimiter of [',', '\t', '|', ';', '^']) {
+      for (const value of ['a,b,c', 'a\tb\tc', 'a;;b', 'a||b']) {
+        const matrix = [['hello', value], ['ordinary text', value]];
+        const copied = serializeClipboardMatrix(matrix, delimiter);
+        assert.deepStrictEqual(Papa.parse(copied, { delimiter }).data, matrix);
+        assert.deepStrictEqual(parseClipboardMatrix(copied, delimiter), matrix);
+      }
+    }
+  });
+
+  it('preserves mixed punctuation when copying between CSV and TSV documents', () => {
+    const matrix = [['a"b', 'a^b'], ['trailing ', ',;|\t']];
+    for (const sourceDelimiter of [',', '\t']) {
+      const copied = serializeClipboardMatrix(matrix, sourceDelimiter);
+      for (const targetDelimiter of [',', '\t']) {
+        assert.deepStrictEqual(parseClipboardMatrix(copied, targetDelimiter), matrix);
+      }
+    }
+  });
+
+  it('preserves blank records at the end of a single copied column', () => {
+    const matrix = [['hello'], [''], ['']];
+    assert.deepStrictEqual(parseClipboardMatrix(serializeClipboardMatrix(matrix, ','), ','), matrix);
+  });
+
+  for (const delimiter of [',', '\t', '|', ';', '^']) {
+    it(`preserves cell and record boundaries with delimiter ${JSON.stringify(delimiter)}`, () => {
+      const matrix = [
+        ['comma,value', 'line one\nline two', 'a "literal" quote', ''],
+        ['tab\tvalue', 'windows\r\nnewline', '  whitespace  ', ''],
+        ['', '', '', '']
+      ];
+      const text = serializeClipboardMatrix(matrix, delimiter);
+      assert.deepStrictEqual(Papa.parse(text, { delimiter }).data, matrix);
+      assert.deepStrictEqual(parseClipboardMatrix(text, delimiter), matrix);
+    });
+  }
+
+  it('keeps each special value in a single cell', () => {
+    for (const value of ['comma,value', 'line\nvalue', '"literal"', '  ', '\t', '\r\n']) {
+      assert.deepStrictEqual(parseClipboardMatrix(serializeClipboardMatrix([[value]], ','), ','), [[value]]);
+    }
+  });
+
+  it('preserves one empty cell and rows made entirely of empty cells', () => {
+    for (const matrix of [[['']], [[''], ['']], [['', ''], ['', '']]]) {
+      assert.deepStrictEqual(parseClipboardMatrix(serializeClipboardMatrix(matrix, '\t'), '\t'), matrix);
+    }
+  });
+
+  it('accepts external spreadsheet TSV in a CSV document', () => {
+    assert.deepStrictEqual(parseClipboardMatrix('one\t"two\nlines"\t\r\nthree\tfour\t\r\n', ','), [
+      ['one', 'two\nlines', ''], ['three', 'four', '']
+    ]);
+  });
+
+  it('removes a terminal parser sentinel while preserving intentional empty records', () => {
+    assert.deepStrictEqual(parseClipboardMatrix('one,two\n,,\n', ','), [['one', 'two', ''], ['', '', '']]);
+    assert.deepStrictEqual(parseClipboardMatrix('one\n""\n', ','), [['one'], ['']]);
+    assert.deepStrictEqual(parseClipboardMatrix('"\n"', ','), [['\n']]);
+    assert.deepStrictEqual(parseClipboardMatrix('', ','), []);
+  });
+  it('keeps external literal quotes and quoted later fields out of delimiter guesses', () => {
+    assert.deepStrictEqual(parseClipboardMatrix('left"quote\tright\nother\tvalue', ','), [['left"quote', 'right'], ['other', 'value']]);
+    assert.deepStrictEqual(parseClipboardMatrix('plain\t"a,b,c"\nother\t"d,e,f"', ','), [['plain', 'a,b,c'], ['other', 'd,e,f']]);
+    assert.deepStrictEqual(parseClipboardMatrix('plain||"a,b,c"\nother||""', '||'), [['plain', 'a,b,c'], ['other', '']]);
+  });
+
+  it('round-trips diverse rectangular matrices across common delimiters and within custom formats', () => {
+    const values = ['plain', '42', '', 'a,b', 'a\tb', 'a;b', 'a|b', 'say "hi"', 'a\nb', 'a\r\nb', ' edge ', '\uFEFFvalue', 'a^b', 'a::b', 'a||b'];
+    const common = [',', '\t', ';', '|'];
+    let seed = 1729;
+    const next = () => { seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0; return seed; };
+    for (let sample = 0; sample < 100; sample++) {
+      const height = 1 + next() % 4;
+      const width = 1 + next() % 4;
+      const matrix = Array.from({ length: height }, () => Array.from({ length: width }, () => values[next() % values.length]));
+      for (const delimiter of [...common, '^', '||', '::']) {
+        const text = serializeClipboardMatrix(matrix, delimiter);
+        assert.deepStrictEqual(Papa.parse(text, { delimiter }).data, matrix);
+        for (const target of common.includes(delimiter) ? common : [delimiter]) {
+          assert.deepStrictEqual(parseClipboardMatrix(text, target), matrix, `source ${JSON.stringify(delimiter)}, target ${JSON.stringify(target)}, sample ${sample}`);
+        }
+      }
+    }
+  });
+
+});
diff --git a/src/test/column-filter-view.test.ts b/src/test/column-filter-view.test.ts
new file mode 100644
index 0000000..8e35589
--- /dev/null
+++ b/src/test/column-filter-view.test.ts
@@ -0,0 +1,426 @@
+import assert from 'assert';
+import Papa from 'papaparse';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+const filter = [{ column: 1, operator: 'equals', value: 'keep' }];
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['Name', 'State'], ['one', 'keep'], ['hidden', 'drop'], ['three', 'KEEP']];
+
+async function fixture(options: Parameters<typeof createEditorHarness>[0] = {}) {
+  const host = await createEditorHarness({ rows, filters: filter, ...options });
+  const view = createWebviewDom(host.panel.webview.html);
+  return { host, view };
+}
+async function refresh(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>) {
+  const prepare = host.messages.slice().reverse().find((message: any) => message.type === 'prepareViewRefresh');
+  assert.ok(prepare);
+  const start = view.messages.length;
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: prepare }));
+  for (const message of view.messages.slice(start)) { await host.receive(message); }
+}
+
+async function submitFilters(host: Host, view: View, filters: any[]) {
+  const originalHtml = host.panel.webview.html;
+  const table = view.window.document.querySelector('table');
+  const start = view.messages.length;
+  for (const remove of Array.from(view.window.document.querySelectorAll('[data-remove-filter]')) as any[]) { remove.click(); }
+  for (const condition of filters) {
+    view.window.csvColumnFilters.add(condition.column);
+    const controls = Array.from(view.window.document.querySelectorAll('.column-filter-row')) as any[];
+    const row = controls[controls.length - 1];
+    const operator = row.querySelector('[data-filter-operator]');
+    operator.value = condition.operator;
+    operator.dispatchEvent(new view.window.Event('change', { bubbles: true }));
+    const value = row.querySelector('[data-filter-value]');
+    if (value) {
+      value.value = condition.value;
+      value.dispatchEvent(new view.window.Event('input', { bubbles: true }));
+    }
+  }
+  await settleControls(host, view, start);
+  const request = view.messages.slice(start).filter((message: any) => message.type === 'updateColumnFilters').pop();
+  assert.ok(request, 'Inline controls submit one current filter snapshot');
+  const result = host.messages.filter((message: any) => message.type === 'columnFiltersResult' && message.revision === request.revision).pop();
+  assert.ok(result, 'Every live snapshot receives its matching revision result');
+  assert.strictEqual(host.panel.webview.html, originalHtml, 'Live filter changes must not replace the entire webview');
+  assert.strictEqual(view.window.document.querySelector('table'), table, 'Delegated table listeners keep their original table');
+  return result;
+}
+
+async function settleControls(host: Host, view: View, start = 0) {
+  await new Promise(resolve => view.window.setTimeout(resolve, 140));
+  let clientCursor = start;
+  let hostCursor = host.messages.length;
+  while (clientCursor < view.messages.length) {
+    const message = view.messages[clientCursor++];
+    await host.receive(message);
+    for (const reply of host.messages.slice(hostCursor)) {
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: reply }));
+    }
+    hostCursor = host.messages.length;
+  }
+}
+
+describe('Full-source filtered view operations', () => {
+  it('filters beyond the initial source chunk and shows editable independent conditions', async () => {
+    const source = [['Name', 'State'], ...Array.from({ length: 2004 }, (_, row) => [`row${row}`, row === 1500 || row === 1998 ? 'keep' : 'drop'])];
+    const { host, view } = await fixture({ rows: source });
+    try {
+      assert.strictEqual(view.cell(1501, 0).textContent, 'row1500');
+      assert.strictEqual(view.cell(1999, 0).textContent, 'row1998');
+      assert.strictEqual(view.cell(1999, -1).textContent, '1999');
+      assert.strictEqual(view.cell(1, 0), null);
+      assert.ok(view.window.document.getElementById('filterStatus').textContent.includes('2 of 2004 rows'));
+      assert.strictEqual(view.window.document.querySelectorAll('.column-filter-row').length, 1);
+      assert.strictEqual(view.window.document.querySelector('[data-filter-value]').value, 'keep');
+      assert.ok(view.window.document.querySelector('[data-remove-filter]'));
+      assert.ok(view.window.document.getElementById('clearAllFilters'));
+      assert.ok(view.window.document.getElementById('addColumnFilter'));
+      assert.strictEqual(view.cell(0, 1).getAttribute('data-filter-column'), 'active');
+      assert.deepStrictEqual(host.rows(), source);
+    } finally { view.close(); }
+  });
+
+  it('keeps original absolute IDs in remote filtered chunks', async () => {
+    const source = [['Name', 'State'], ...Array.from({ length: 3000 }, (_, row) => [`row${row}`, row % 2 === 0 ? 'keep' : 'drop'])];
+    const { host, view } = await fixture({ rows: source });
+    try {
+      assert.ok(view.cell(1999, 0));
+      assert.strictEqual(view.cell(2001, 0), null);
+      view.window.__csvLoadNextChunk();
+      const request = view.messages.slice().reverse().find((message: any) => message.type === 'requestChunk');
+      assert.strictEqual(request.filterEpoch, 0);
+      assert.strictEqual(request.session, JSON.parse(view.window.document.getElementById('__csvFilters').textContent).session);
+      await host.receive(request);
+      const response = host.messages.slice().reverse().find((message: any) => message.type === 'chunkData');
+      assert.strictEqual(response.filterEpoch, 0);
+      assert.strictEqual(response.session, request.session);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: response }));
+      view.window.__csvLoadNextChunk();
+      assert.strictEqual(view.cell(2001, 0).textContent, 'row2000');
+      assert.strictEqual(view.cell(2001, -1).textContent, '2001');
+      assert.strictEqual(view.cell(2002, 0), null);
+    } finally { view.close(); }
+  });
+
+  it('copies and cuts only selected visible source rows across gaps', async () => {
+    const { host, view } = await fixture();
+    try {
+      view.window.editingTestApi.selectRange({ row: 1, col: 0 }, { row: 3, col: 1 });
+      view.cell(1, 0).dispatchEvent(new view.window.Event('copy', { bubbles: true, cancelable: true }));
+      const copy = view.messages.find((message: any) => message.type === 'copyCells');
+      assert.deepStrictEqual(Array.from(copy.rowIds), [1, 3]);
+      await host.receive(copy);
+      assert.deepStrictEqual(Papa.parse(host.clipboardText).data, [['one', 'keep'], ['three', 'KEEP']]);
+      await host.receive({ ...copy, cut: true });
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['', ''], ['hidden', 'drop'], ['', '']]);
+    } finally { view.close(); }
+  });
+
+  it('pastes a matrix across visible rows and appends at the physical end without touching hidden rows', async () => {
+    const { host, view } = await fixture();
+    try {
+      await host.receive({ type: 'pasteCells', text: 'first\nsecond\nappended', anchorRow: 1, anchorCol: 0 });
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['first', 'keep'], ['hidden', 'drop'], ['second', 'KEEP'], ['appended']]);
+      await host.document.save();
+      assert.deepStrictEqual(Papa.parse(host.diskText).data, host.rows());
+    } finally { view.close(); }
+  });
+
+  it('fills only visible cells in a selected rectangle, leaving hidden records intact', async () => {
+    const { host, view } = await fixture();
+    try {
+      view.window.editingTestApi.selectRange({ row: 1, col: 0 }, { row: 3, col: 1 });
+      const event = new view.window.Event('paste', { bubbles: true, cancelable: true });
+      Object.defineProperty(event, 'clipboardData', { value: { getData: () => 'filled' } });
+      view.cell(1, 0).dispatchEvent(event);
+      const paste = view.messages.find((message: any) => message.type === 'pasteCells');
+      assert.strictEqual(paste.selection.rectangular, true);
+      await host.receive(paste);
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['filled', 'filled'], ['hidden', 'drop'], ['filled', 'filled']]);
+    } finally { view.close(); }
+  });
+
+  it('finds and replaces only matching rows while preserving preambles and hidden values', async () => {
+    const source = [['metadata', 'keep'], ['Name', 'State'], ['needle one', 'keep'], ['needle hidden', 'drop'], ['needle two', 'KEEP']];
+    const { host, view } = await fixture({ rows: source, hiddenRows: 1 });
+    try {
+      await host.receive({ type: 'findMatches', requestId: 1, query: 'needle', options: {} });
+      const found = host.messages.slice().reverse().find((message: any) => message.type === 'findMatchesResult');
+      assert.deepStrictEqual(found.matches.map((match: any) => match.row), [2, 4]);
+      await host.receive({ type: 'replaceCells', replacements: found.matches.map((match: any) => ({ row: match.row, col: match.col, value: 'replaced' })) });
+      assert.deepStrictEqual(host.rows(), [['metadata', 'keep'], ['Name', 'State'], ['replaced', 'keep'], ['needle hidden', 'drop'], ['replaced', 'KEEP']]);
+    } finally { view.close(); }
+  });
+
+  it('sorts matching slots and reorders/deletes by absolute source indices', async () => {
+    const source = [['Name', 'State'], ['z', 'keep'], ['hidden', 'drop'], ['a', 'KEEP']];
+    const { host, view } = await fixture({ rows: source });
+    try {
+      await host.receive({ type: 'sortColumn', index: 0, ascending: true });
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['a', 'KEEP'], ['hidden', 'drop'], ['z', 'keep']]);
+      await host.receive({ type: 'reorderRows', indices: [3], beforeIndex: 1 });
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['z', 'keep'], ['a', 'KEEP'], ['hidden', 'drop']]);
+      await host.receive({ type: 'deleteRows', indices: [1, 2] });
+      assert.deepStrictEqual(host.rows(), [['Name', 'State'], ['hidden', 'drop']]);
+    } finally { view.close(); }
+  });
+
+  it('moves filters with inserted/reordered columns and clears a deleted column predicate', async () => {
+    const { host, view } = await fixture();
+    try {
+      const getFilters = () => CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any);
+      await host.receive({ type: 'insertColumn', index: 0 });
+      assert.strictEqual(getFilters()[0].column, 2);
+      await host.receive({ type: 'reorderColumns', indices: [2], beforeIndex: 0 });
+      assert.strictEqual(getFilters()[0].column, 0);
+      await host.receive({ type: 'deleteColumn', index: 0 });
+      assert.deepStrictEqual(getFilters(), []);
+      assert.ok(host.rows().some(row => row.includes('hidden')));
+    } finally { view.close(); }
+  });
+
+  it('navigates/selects visible rows and freezes visible leading rows with a toolbar inset', async () => {
+    const { view } = await fixture({ frozenRows: 3, frozenColumns: 1 });
+    try {
+      view.window.editingTestApi.setSingleSelection(view.cell(1, 0));
+      view.key('ArrowDown');
+      assert.strictEqual(view.window.document.activeElement, view.cell(3, 0));
+      view.key('ArrowUp', { shiftKey: true });
+      assert.strictEqual(view.window.document.querySelectorAll('td.selected[data-col="0"]').length, 2);
+      const status = view.window.document.getElementById('filterStatus');
+      status.getBoundingClientRect = () => ({ height: 20 });
+      for (const row of Array.from(view.window.document.querySelectorAll('tr')) as any[]) { row.getBoundingClientRect = () => ({ height: 30 }); }
+      // JSDOM drops border shorthand containing a CSS variable; model the browser's 1px border.
+      view.window.document.querySelector('th, td').style.borderTopWidth = '1px';
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(0, 0).style.top, '19.5px');
+      assert.strictEqual(view.cell(1, 0).style.top, '49.5px');
+      assert.strictEqual(view.cell(3, 0).style.top, '79.5px');
+      assert.ok(!view.cell(4, 0).classList.contains('csv-frozen-row'));
+    } finally { view.close(); }
+  });
+
+  it('handles zero matches with headers off and keeps the append row at the full-source end', async () => {
+    const { host, view } = await fixture({ header: false, filters: [{ column: 1, operator: 'equals', value: 'absent' }], frozenRows: 10 });
+    try {
+      assert.strictEqual(view.window.document.querySelectorAll('tbody tr').length, 1);
+      assert.ok(view.cell(4, 0));
+      view.window.csvFrozenPanes.layout();
+      assert.ok(!view.cell(4, 0).classList.contains('csv-frozen-row'));
+      await host.receive({ type: 'pasteCells', text: 'new', anchorRow: 4, anchorCol: 0 });
+      assert.deepStrictEqual(host.rows().slice(0, 4), rows);
+      assert.strictEqual(host.rows()[4][0], 'new');
+    } finally { view.close(); }
+  });
+
+  it('persists live filter text safely and clears all without replacing the editor', async () => {
+    const { host, view } = await fixture({ filters: [] });
+    try {
+      const input = '</button><script>bad()</script>';
+      const conditions = [{ column: 0, operator: 'equals', value: input }];
+      const result = await submitFilters(host, view, conditions);
+      assert.ok(!result.error && !result.errors?.length);
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any), conditions);
+      assert.strictEqual(view.window.document.querySelector('[data-filter-value]').value, input);
+      assert.strictEqual(view.window.document.querySelectorAll('#filterStatus script').length, 0);
+      const start = view.messages.length;
+      view.window.document.getElementById('clearAllFilters').click();
+      await settleControls(host, view, start);
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any), []);
+      assert.ok(view.window.document.getElementById('filterStatus').hidden);
+      assert.deepStrictEqual(host.rows(), rows);
+      assert.strictEqual(host.quickPickCalls.length, 0);
+      assert.strictEqual(host.inputBoxCalls.length, 0);
+    } finally { view.close(); }
+  });
+
+  it('re-evaluates an edited filter value using the safe commit-before-refresh path', async () => {
+    const { host, view } = await fixture();
+    try {
+      await host.receive({ type: 'editCell', row: 1, col: 1, value: 'drop' });
+      await refresh(host, view);
+      assert.ok(!host.panel.webview.html.includes('data-row="1"'));
+      assert.strictEqual(host.rows()[1][1], 'drop');
+      assert.deepStrictEqual(host.rows()[2], ['hidden', 'drop']);
+    } finally { view.close(); }
+  });
+  it('preserves exact metadata and hidden record formatting during filtered paste, fill and sort', async () => {
+    const text = '"metadata","preserve"\r\nName,"State"\r\n"z","keep"\r\nNaN,"drop"\r\n"a",KEEP\r\n';
+    const { host, view } = await fixture({ text, hiddenRows: 1 });
+    try {
+      await host.receive({ type: 'pasteCells', text: 'changed', anchorRow: 2, anchorCol: 0 });
+      assert.strictEqual(host.document.getText(), '"metadata","preserve"\r\nName,"State"\r\n"changed","keep"\r\nNaN,"drop"\r\n"a",KEEP\r\n');
+      await host.receive({ type: 'sortColumn', index: 0, ascending: true });
+      assert.strictEqual(host.document.getText(), '"metadata","preserve"\r\nName,"State"\r\n"a",KEEP\r\nNaN,"drop"\r\n"changed","keep"\r\n');
+      await host.receive({ type: 'pasteCells', text: 'new,keep', anchorRow: 5, anchorCol: 0 });
+      assert.ok(host.document.getText().startsWith('"metadata","preserve"\r\nName,"State"\r\n"a",KEEP\r\nNaN,"drop"\r\n"changed","keep"\r\n'));
+      await host.receive({ type: 'pasteCells', text: 'filled', anchorRow: 2, anchorCol: 0, selection: { minRow: 2, maxRow: 4, minCol: 0, maxCol: 0, rectangular: true } });
+      assert.ok(host.document.getText().includes('NaN,"drop"\r\n'));
+      assert.ok(host.document.getText().startsWith('"metadata","preserve"\r\nName,"State"\r\n'));
+    } finally { view.close(); }
+  });
+
+  it('preserves raw tokens for hidden records during filtered row/column structural actions', async () => {
+    const text = '"Name","State"\n"one","keep"\nhidden,"drop"\n"three",KEEP\n';
+    const { host, view } = await fixture({ text });
+    try {
+      await host.receive({ type: 'deleteRows', indices: [1, 3] });
+      assert.strictEqual(host.document.getText(), '"Name","State"\nhidden,"drop"\n');
+      await host.receive({ type: 'insertColumns', index: 0, count: 2 });
+      assert.ok(host.document.getText().includes(',,hidden,"drop"\n'));
+      await host.receive({ type: 'deleteColumns', indices: [0, 1] });
+      assert.strictEqual(host.document.getText(), '"Name","State"\nhidden,"drop"\n');
+    } finally { view.close(); }
+  });
+
+  it('retains quoted tabs/newlines in filtered TSV clipboard and paste flows', async () => {
+    const source = [['Name', 'State'], ['tab\tand\nnewline', 'keep'], ['hidden', 'drop'], ['three', 'keep']];
+    const { host, view } = await fixture({ rows: source, separator: '\t' });
+    try {
+      view.window.editingTestApi.setSingleSelection(view.cell(1, 0));
+      view.cell(1, 0).dispatchEvent(new view.window.Event('copy', { bubbles: true, cancelable: true }));
+      await host.receive(view.messages.find((message: any) => message.type === 'copyCells'));
+      await host.receive({ type: 'pasteCells', text: host.clipboardText, anchorRow: 3, anchorCol: 0 });
+      assert.strictEqual(host.rows()[3][0], 'tab\tand\nnewline');
+      assert.deepStrictEqual(host.rows()[2], ['hidden', 'drop']);
+    } finally { view.close(); }
+  });
+
+  it('leaves filter-bar keyboard activation native and tab navigation follows visible rows', async () => {
+    const { view } = await fixture();
+    try {
+      view.window.editingTestApi.setSingleSelection(view.cell(1, 1));
+      view.key('Tab');
+      assert.strictEqual(view.window.document.activeElement, view.cell(3, 0));
+      view.key('Tab', { shiftKey: true });
+      assert.strictEqual(view.window.document.activeElement, view.cell(1, 1));
+      const clear = view.window.document.getElementById('clearAllFilters');
+      clear.focus();
+      const event = new view.window.KeyboardEvent('keydown', { key: 'Enter', bubbles: true, cancelable: true });
+      clear.dispatchEvent(event);
+      assert.strictEqual(event.defaultPrevented, false);
+      assert.strictEqual(view.window.document.querySelector('[contenteditable="true"]'), null);
+      clear.click();
+      await new Promise(resolve => view.window.setTimeout(resolve, 140));
+      assert.ok(view.messages.some((message: any) => message.type === 'updateColumnFilters' && message.filters.length === 0));
+    } finally { view.close(); }
+  });
+
+  it('rejects oversized live snapshots atomically and isolates saved conditions per URI', async () => {
+    const { host, view } = await fixture();
+    try {
+      const saved = () => CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any);
+      const beforeRows = view.window.document.querySelector('table').innerHTML;
+      await host.receive({ type: 'updateColumnFilters', session: JSON.parse(view.window.document.getElementById('__csvFilters').textContent).session, revision: 1, filters: [{ column: 1, operator: 'contains', value: 'x'.repeat(4097) }] });
+      const invalid = host.messages.find((message: any) => message.type === 'columnFiltersResult' && message.revision === 1);
+      assert.ok(invalid);
+      assert.ok(invalid.error || invalid.errors?.length);
+      assert.strictEqual(invalid.filters?.[0]?.value ?? filter[0].value, filter[0].value);
+      assert.deepStrictEqual(saved(), filter);
+      assert.strictEqual(view.window.document.querySelector('table').innerHTML, beforeRows);
+      assert.ok(!host.messages.some((message: any) => message.type === 'prepareViewRefresh'));
+      const other = { toString: () => 'file:///other.csv' } as any;
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, other), []);
+      await CsvEditorProvider.setColumnFiltersForUri(host.context as any, other, [{ column: 0, operator: 'empty', value: '' }]);
+      await host.receive({ type: 'updateColumnFilters', session: JSON.parse(view.window.document.getElementById('__csvFilters').textContent).session, revision: 2, filters: [] });
+      assert.deepStrictEqual(saved(), []);
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, other), [{ column: 0, operator: 'empty', value: '' }]);
+    } finally { view.close(); }
+  });
+
+  it('removes only one same-column AND condition and commits a multiline draft before live refresh', async () => {
+    const conditions = [...filter, { column: 0, operator: 'notEmpty', value: '' }, { column: 1, operator: 'notEquals', value: 'drop' }];
+    const { host, view } = await fixture({ filters: conditions });
+    try {
+      const cell = view.cell(1, 0);
+      view.start(cell);
+      cell.textContent = 'unsaved\nmultiline draft';
+      const start = view.messages.length;
+      view.window.document.querySelectorAll('[data-remove-filter]')[2].click();
+      await settleControls(host, view, start);
+      assert.strictEqual(host.rows()[1][0], 'unsaved\nmultiline draft');
+      assert.deepStrictEqual(host.rows()[2], ['hidden', 'drop']);
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any), conditions.slice(0, 2));
+      assert.strictEqual(view.window.document.querySelectorAll('.column-filter-row').length, 2);
+      assert.strictEqual(view.cell(1, 0).textContent, 'unsaved\nmultiline draft');
+      assert.strictEqual(host.diskText.includes('unsaved'), false, 'Changing filters never saves a file');
+    } finally { view.close(); }
+  });
+
+  it('aligns the last valid result when an older success was ignored before a newer invalid draft', async () => {
+    const { host, view } = await fixture({ filters: [] });
+    try {
+      const table = view.window.document.querySelector('table');
+      const originalHtml = host.panel.webview.html;
+      view.window.csvColumnFilters.add(0);
+      const input = view.window.document.querySelector('[data-filter-value]');
+      const operator = view.window.document.querySelector('[data-filter-operator]');
+      input.value = 'one';
+      input.dispatchEvent(new view.window.Event('input', { bubbles: true }));
+      await new Promise(resolve => view.window.setTimeout(resolve, 140));
+      const validRequest = view.messages.filter((message: any) => message.type === 'updateColumnFilters').pop();
+      await host.receive(validRequest);
+      const success = host.messages.filter((message: any) => message.type === 'columnFiltersResult' && message.revision === validRequest.revision).pop();
+      assert.ok(success.tableHtml);
+
+      operator.value = 'regex';
+      operator.dispatchEvent(new view.window.Event('change', { bubbles: true }));
+      input.value = '[';
+      input.dispatchEvent(new view.window.Event('input', { bubbles: true }));
+      await new Promise(resolve => view.window.setTimeout(resolve, 140));
+      const invalidRequest = view.messages.filter((message: any) => message.type === 'updateColumnFilters').pop();
+      assert.ok(invalidRequest.revision > validRequest.revision);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: success }));
+      assert.ok(view.cell(3, 0), 'The older success must not update a newer local draft');
+      await host.receive(invalidRequest);
+      const invalid = host.messages.filter((message: any) => message.type === 'columnFiltersResult' && message.revision === invalidRequest.revision).pop();
+      assert.ok(invalid.error || invalid.errors?.length);
+      assert.strictEqual(invalid.filterEpoch, success.filterEpoch);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: invalid }));
+      assert.strictEqual(view.cell(1, 0).textContent, 'one');
+      assert.strictEqual(view.cell(3, 0), null, 'The latest invalid reply aligns the last accepted visible result');
+      assert.strictEqual(view.window.document.querySelector('[data-filter-value]'), input);
+      assert.strictEqual(input.value, '[');
+      assert.strictEqual(input.getAttribute('aria-invalid'), 'true');
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any), [{ column: 0, operator: 'contains', value: 'one' }]);
+      assert.strictEqual(view.window.document.querySelector('table'), table);
+      assert.strictEqual(host.panel.webview.html, originalHtml);
+      assert.deepStrictEqual(host.rows(), rows);
+    } finally { view.close(); }
+  });
+
+  it('keeps literal whitespace as an independent same-column AND text condition', async () => {
+    const source = [['Name', 'State'], ['two words', 'keep'], ['twowords', 'keep'], ['another', 'drop']];
+    const { host, view } = await fixture({ rows: source, filters: [] });
+    try {
+      const conditions = [{ column: 0, operator: 'contains', value: 'two' }, { column: 0, operator: 'contains', value: ' ' }];
+      const result = await submitFilters(host, view, conditions);
+      assert.ok(!result.error && !result.errors?.length);
+      assert.deepStrictEqual(CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any), conditions);
+      assert.strictEqual(view.cell(1, 0).textContent, 'two words');
+      assert.strictEqual(view.cell(2, 0), null);
+      assert.strictEqual(view.window.document.querySelectorAll('.column-filter-row').length, 2);
+      assert.strictEqual(view.window.document.querySelectorAll('[data-filter-value]')[1].value, ' ');
+      assert.deepStrictEqual(host.rows(), source);
+    } finally { view.close(); }
+  });
+
+  it('retains both same-column predicates through column insert, reorder and delete', async () => {
+    const conditions = [filter[0], { column: 1, operator: 'notEquals', value: 'drop' }, { column: 0, operator: 'notEmpty', value: '' }];
+    const { host, view } = await fixture({ filters: conditions });
+    try {
+      const saved = () => CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any);
+      await host.receive({ type: 'insertColumn', index: 0 });
+      assert.deepStrictEqual(saved().map(condition => condition.column), [2, 2, 1]);
+      await host.receive({ type: 'reorderColumns', indices: [2], beforeIndex: 0 });
+      assert.deepStrictEqual(saved().map(condition => condition.column), [0, 0, 2]);
+      await host.receive({ type: 'deleteColumn', index: 0 });
+      assert.deepStrictEqual(saved(), [{ column: 1, operator: 'notEmpty', value: '' }]);
+      assert.ok(host.rows().some(row => row.includes('hidden')));
+    } finally { view.close(); }
+  });
+
+});
diff --git a/src/test/column-filters.test.ts b/src/test/column-filters.test.ts
new file mode 100644
index 0000000..053937d
--- /dev/null
+++ b/src/test/column-filters.test.ts
@@ -0,0 +1,281 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { RE2JS } from 're2js';
+import {
+  ColumnFilter, ColumnFilterOperator, FilterDataType, compileColumnFilters,
+  getFilterOperatorChoices, normalizeColumnFilters, rowMatchesFilters, visibleSourceRows,
+  remapColumnFilters, validateColumnFilterInput, MAX_COLUMN_FILTERS, MAX_FILTER_VALUE_LENGTH
+} from '../column-filters';
+
+const filter = (operator: ColumnFilterOperator, value: string, dataType?: FilterDataType): ColumnFilter => ({ column: 0, operator, value, ...(dataType === undefined ? {} : { dataType }) });
+
+function matchingValues(values: string[], predicate: ColumnFilter): string[] {
+  const matches = compileColumnFilters([predicate]);
+  return values.filter(value => matches([value]));
+}
+
+describe('Column filter predicates and identities', () => {
+  it('combines case-insensitive text predicates and exact empty-cell predicates', () => {
+    assert.ok(rowMatchesFilters(['Alpha Beta', 'YES', ''], [{ column: 0, operator: 'contains', value: 'BETA' }, { column: 1, operator: 'equals', value: 'yes' }, { column: 2, operator: 'empty', value: '' }]));
+    assert.ok(!rowMatchesFilters(['Alpha', 'yes', ''], [filter('contains', 'beta')]));
+    assert.ok(rowMatchesFilters([], [{ column: 2, operator: 'empty', value: '' }]));
+    assert.ok(!rowMatchesFilters([''], [filter('notEmpty', '')]));
+    assert.ok(rowMatchesFilters([' '], [filter('notEmpty', '')]));
+  });
+
+  it('negates contains and equality without trimming or interpreting text as patterns', () => {
+    const values = ['Alpha Beta', 'ALPHA', 'alpha ', '', '<a.*>'];
+    assert.deepStrictEqual(matchingValues(values, filter('notContains', 'ALPHA')), ['', '<a.*>']);
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', 'alpha')), ['Alpha Beta', 'alpha ', '', '<a.*>']);
+    assert.deepStrictEqual(matchingValues(values, filter('contains', '<a.*>')), ['<a.*>']);
+    assert.ok(rowMatchesFilters([], [filter('notEquals', 'alpha')]));
+    assert.deepStrictEqual(matchingValues(values, filter('notContains', '')), []);
+    assert.deepStrictEqual(matchingValues(values, filter('contains', '')), values);
+  });
+
+  it('retains literal text and empty predicates for every inferred data type', () => {
+    for (const type of ['string', 'number', 'date', 'boolean'] as const) {
+      assert.deepStrictEqual(matchingValues(['USD 1,000', 'usd 2', '1,000'], filter('contains', 'USD', type)), ['USD 1,000', 'usd 2']);
+      assert.ok(rowMatchesFilters(['not a scalar'], [filter('notContains', 'USD', type)]));
+      assert.ok(rowMatchesFilters([], [filter('empty', '', type)]));
+      assert.ok(rowMatchesFilters([' '], [filter('notEmpty', '', type)]));
+    }
+  });
+
+  it('compares numeric equivalents rather than their formatting', () => {
+    const values = ['1000', '1,000.00', '1e3', '1001', '1,00', '', '  ', 'NaN'];
+    assert.deepStrictEqual(matchingValues(values, filter('equals', '1,000', 'number')), ['1000', '1,000.00', '1e3']);
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', '1e3', 'number')), ['1001']);
+    assert.deepStrictEqual(matchingValues(['-0', '0', '0.0', '1'], filter('equals', '0', 'number')), ['-0', '0', '0.0']);
+    assert.deepStrictEqual(matchingValues(['1000', '1,000.00'], filter('equals', '1000')), ['1000']);
+  });
+
+  it('preserves exact numeric identity and order beyond floating-point precision', () => {
+    const values = ['9007199254740992', '9007199254740993', '9,007,199,254,740,993', '9.007199254740993e15', '9007199254740994', '', 'invalid'];
+    assert.deepStrictEqual(matchingValues(values, filter('equals', '9007199254740993', 'number')), values.slice(1, 4));
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', '9007199254740993', 'number')), [values[0], values[4]]);
+    assert.deepStrictEqual(matchingValues(values, filter('greaterThan', '9007199254740992', 'number')), values.slice(1, 5));
+    assert.deepStrictEqual(matchingValues(values, filter('lessThan', '9007199254740993', 'number')), [values[0]]);
+    assert.deepStrictEqual(matchingValues(['0.10000000000000000001', '0.1', '0.09999999999999999999'], filter('greaterThan', '0.1', 'number')), ['0.10000000000000000001']);
+    assert.deepStrictEqual(matchingValues(['-9007199254740993', '-9007199254740992'], filter('lessThan', '-9007199254740992', 'number')), ['-9007199254740993']);
+    assert.deepStrictEqual(matchingValues(['1e-1000', '0', '-1e-1000'], filter('equals', '0', 'number')), ['0']);
+  });
+
+  it('applies all numeric boundaries and excludes invalid or blank cells', () => {
+    const values = ['9', '10', '1e1', '11', '', 'not numeric', 'Infinity'];
+    const expected: Array<[ColumnFilterOperator, string[]]> = [
+      ['greaterThan', ['11']], ['greaterThanOrEqual', ['10', '1e1', '11']],
+      ['lessThan', ['9']], ['lessThanOrEqual', ['9', '10', '1e1']]
+    ];
+    for (const [operator, result] of expected) {
+      assert.deepStrictEqual(matchingValues(values, filter(operator, '10', 'number')), result, operator);
+    }
+  });
+
+  it('compares date instants consistently across timezone and date-only formats', () => {
+    const values = ['2024-01-02', '2024-01-02T00:00:00Z', '2024-01-01T19:00:00-05:00', '2024-01-03', '2024-02-30', ''];
+    assert.deepStrictEqual(matchingValues(values, filter('equals', '2024-01-02', 'date')), values.slice(0, 3));
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', '2024-01-02', 'date')), ['2024-01-03']);
+    assert.deepStrictEqual(matchingValues(values, filter('greaterThan', '2024-01-02', 'date')), ['2024-01-03']);
+    assert.deepStrictEqual(matchingValues(values, filter('greaterThanOrEqual', '2024-01-02', 'date')), values.slice(0, 4));
+    assert.deepStrictEqual(matchingValues(values, filter('lessThan', '2024-01-03', 'date')), values.slice(0, 3));
+    assert.deepStrictEqual(matchingValues(values, filter('lessThanOrEqual', '2024-01-02', 'date')), values.slice(0, 3));
+  });
+
+  it('compares sub-millisecond date fractions without collapsing nearby instants', () => {
+    const values = ['2024-01-01T00:00:00.0001Z', '2024-01-01T00:00:00.0002Z', '2023-12-31T19:00:00.000200-05:00', '2024-01-01T00:00:00.001Z', '', 'not a date'];
+    const query = '2024-01-01T00:00:00.0002Z';
+    const expected: Array<[ColumnFilterOperator, string[]]> = [
+      ['equals', values.slice(1, 3)], ['notEquals', [values[0], values[3]]],
+      ['greaterThan', [values[3]]], ['greaterThanOrEqual', values.slice(1, 4)],
+      ['lessThan', [values[0]]], ['lessThanOrEqual', values.slice(0, 3)]
+    ];
+    for (const [operator, result] of expected) {
+      assert.deepStrictEqual(matchingValues(values, filter(operator, query, 'date')), result, operator);
+    }
+    assert.ok(!rowMatchesFilters([], [filter('notEquals', query, 'date')]));
+    const data = [['metadata'], ['Timestamp'], ...values.map(value => [value])];
+    assert.deepStrictEqual(visibleSourceRows(data, 1, true, [filter('equals', query, 'date')]), [1, 3, 4]);
+  });
+
+  it('retains nanosecond equality across trailing zeros and equivalent timezone offsets', () => {
+    const values = ['2024-01-01T00:00:00.123456788Z', '2024-01-01T00:00:00.123456789Z', '2024-01-01T00:00:00.123456789000Z', '2024-01-01T01:00:00.123456789+01:00', '2024-01-01T00:00:00.123456790Z'];
+    const query = values[1];
+    assert.strictEqual(validateColumnFilterInput('equals', query, 'date'), undefined);
+    assert.deepStrictEqual(matchingValues(values, filter('equals', query, 'date')), values.slice(1, 4));
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', query, 'date')), [values[0], values[4]]);
+    assert.deepStrictEqual(matchingValues(values, filter('lessThan', query, 'date')), [values[0]]);
+    assert.deepStrictEqual(matchingValues(values, filter('greaterThan', query, 'date')), [values[4]]);
+  });
+
+  it('orders exact pre-epoch fractions across the zero epoch and equivalent zones', () => {
+    const values = ['1969-12-31T23:59:59.9991Z', '1969-12-31T23:59:59.9999Z', '1969-12-31T18:59:59.999900-05:00', '1970-01-01T00:00:00Z', '1970-01-01T00:00:00.0001Z'];
+    const query = values[1];
+    assert.deepStrictEqual(matchingValues(values, filter('equals', query, 'date')), values.slice(1, 3));
+    assert.deepStrictEqual(matchingValues(values, filter('lessThan', query, 'date')), [values[0]]);
+    assert.deepStrictEqual(matchingValues(values, filter('greaterThan', query, 'date')), values.slice(3));
+    assert.deepStrictEqual(matchingValues(values, filter('lessThan', values[3], 'date')), values.slice(0, 3));
+    assert.deepStrictEqual(matchingValues(['1969-12-31T23:59:59.0001Z', '1969-12-31T23:59:59.0002Z'], filter('lessThan', '1969-12-31T23:59:59.0002Z', 'date')), ['1969-12-31T23:59:59.0001Z']);
+  });
+
+  it('handles both boolean thresholds without treating false as an invalid parse', () => {
+    const values = ['true', 'TRUE', 'false', 'FALSE', '', 'unknown'];
+    assert.deepStrictEqual(matchingValues(values, filter('equals', 'true', 'boolean')), ['true', 'TRUE']);
+    assert.deepStrictEqual(matchingValues(values, filter('equals', 'false', 'boolean')), ['false', 'FALSE']);
+    assert.deepStrictEqual(matchingValues(values, filter('notEquals', 'FALSE', 'boolean')), ['true', 'TRUE']);
+    assert.ok(!rowMatchesFilters([], [filter('notEquals', 'true', 'boolean')]));
+  });
+
+  it('rejects invalid query scalars and unsupported ordered data types', () => {
+    for (const type of ['number', 'date', 'boolean'] as const) {
+      for (const operator of ['equals', 'notEquals'] as const) {
+        for (const value of ['', '  ', 'not a scalar']) {
+          assert.match(validateColumnFilterInput(operator, value, type) ?? '', /valid/);
+          assert.deepStrictEqual(matchingValues(['0', 'false', '2024-01-02', 'other', ''], filter(operator, value, type)), []);
+        }
+      }
+    }
+    for (const type of ['string', 'boolean'] as const) {
+      assert.match(validateColumnFilterInput('greaterThan', '1', type) ?? '', /number or date/);
+      assert.ok(!rowMatchesFilters(['2'], [filter('greaterThan', '1', type)]));
+    }
+    assert.strictEqual(validateColumnFilterInput('equals', ''), undefined);
+    assert.strictEqual(validateColumnFilterInput('contains', ''), undefined);
+    assert.match(validateColumnFilterInput('contains', 'x'.repeat(MAX_FILTER_VALUE_LENGTH + 1)) ?? '', /4096/);
+  });
+
+  it('offers all universal operators and ordered comparisons only for numbers and dates', () => {
+    const universal = ['contains', 'notContains', 'regex', 'equals', 'notEquals', 'empty', 'notEmpty'];
+    for (const type of ['string', 'boolean'] as const) {
+      assert.deepStrictEqual(getFilterOperatorChoices(type).map(choice => choice.operator), universal);
+    }
+    const ordered = ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual'];
+    for (const type of ['number', 'date'] as const) {
+      const choices = getFilterOperatorChoices(type);
+      assert.deepStrictEqual(choices.map(choice => choice.operator), [...universal.slice(0, 5), ...ordered, ...universal.slice(5)]);
+      assert.ok(choices.every(choice => choice.label.length > 0));
+    }
+  });
+
+  it('keeps absolute row identities, a real header, and excludes hidden preambles', () => {
+    const data = [['metadata'], ['Header'], ['keep'], ['drop'], ['KEEP']];
+    const filters = [filter('equals', 'keep')];
+    assert.deepStrictEqual(visibleSourceRows(data, 1, true, filters), [1, 2, 4]);
+    assert.deepStrictEqual(visibleSourceRows(data, 1, false, filters), [2, 4]);
+    assert.deepStrictEqual(visibleSourceRows(data, 100, true, filters), []);
+  });
+
+  it('retains absolute identities for typed filters across metadata, header-off, and ragged rows', () => {
+    const data = [['metadata'], ['ID', 'amount'], ['first', '10'], ['ragged'], ['second', '1e1'], ['third', '11'], ['invalid', 'oops']];
+    const original = JSON.stringify(data);
+    const filters = [{ column: 1, operator: 'notEquals' as const, value: '10', dataType: 'number' as const }];
+    assert.deepStrictEqual(visibleSourceRows(data, 1, true, filters), [1, 5]);
+    assert.deepStrictEqual(visibleSourceRows(data, 1, false, filters), [5]);
+    assert.strictEqual(JSON.stringify(data), original);
+  });
+
+  it('normalizes bounded structural state while retaining invalid query text to fail closed', () => {
+    const invalidQuery = { column: 0, operator: 'equals', value: 'invalid number', dataType: 'number' };
+    const normalized = normalizeColumnFilters([
+      { column: 1, operator: 'equals', value: 'before', dataType: 'boolean' }, { column: 1, operator: 'contains', value: '<literal.*>' },
+      { column: -1, operator: 'empty', value: '' }, { column: 0, operator: 'unknown', value: 'x' },
+      { column: 2, operator: 'equals', value: '1', dataType: 'unknown' },
+      { column: 2, operator: 'contains', value: 'a'.repeat(MAX_FILTER_VALUE_LENGTH + 1) }, invalidQuery
+    ], 3);
+    assert.deepStrictEqual(normalized, [{ column: 1, operator: 'equals', value: 'before', dataType: 'boolean' }, { column: 1, operator: 'contains', value: '<literal.*>' }, invalidQuery]);
+    assert.deepStrictEqual(visibleSourceRows([['metadata'], ['Header'], ['invalid number'], ['1']], 1, true, normalized), [1]);
+    assert.strictEqual(normalizeColumnFilters(Array.from({ length: MAX_COLUMN_FILTERS + 10 }, (_, column) => ({ column, operator: 'empty', value: '' }))).length, MAX_COLUMN_FILTERS);
+    assert.deepStrictEqual(normalizeColumnFilters(null), []);
+    assert.deepStrictEqual(normalizeColumnFilters([{ column: 3, operator: 'empty', value: '' }], 3), []);
+    assert.ok(!compileColumnFilters(Array.from({ length: MAX_COLUMN_FILTERS + 1 }, () => filter('contains', '')))(['anything']));
+  });
+
+  it('retains every same-column AND condition through persistence and structural remapping', () => {
+    const conditions: ColumnFilter[] = [
+      filter('greaterThan', '2', 'number'),
+      { column: 1, operator: 'equals', value: 'keep' },
+      filter('lessThan', '10', 'number'),
+      filter('notEquals', '5', 'number')
+    ];
+    assert.deepStrictEqual(normalizeColumnFilters(conditions), conditions, 'condition order and duplicate columns survive storage');
+    const source = [['Amount', 'State'], ['2', 'keep'], ['3', 'keep'], ['5', 'keep'], ['9', 'keep'], ['10', 'keep'], ['7', 'drop']];
+    assert.deepStrictEqual(visibleSourceRows(source, 0, true, normalizeColumnFilters(conditions)), [0, 2, 4]);
+    assert.deepStrictEqual(remapColumnFilters(conditions, [-1, 1, 0]), conditions.map(item => ({ ...item, column: item.column === 0 ? 2 : 1 })));
+    assert.deepStrictEqual(remapColumnFilters(conditions, [1]), [{ column: 0, operator: 'equals', value: 'keep' }]);
+    const withoutMiddleBound = conditions.filter((_item, index) => index !== 2);
+    assert.deepStrictEqual(visibleSourceRows(source, 0, true, withoutMiddleBound), [0, 2, 4, 5]);
+    const contradictions = [filter('contains', 'a'), filter('notContains', 'a')];
+    assert.deepStrictEqual(visibleSourceRows([['Header'], ['alpha'], ['beta'], ['']], 0, true, contradictions), [0]);
+  });
+
+  it('moves and duplicates typed predicates with their columns and removes deleted ones', () => {
+    const filters = [filter('greaterThanOrEqual', '1,000', 'number'), { column: 2, operator: 'empty' as const, value: '' }];
+    assert.deepStrictEqual(remapColumnFilters(filters, [2, -1, 0, 1, 0]), [
+      { column: 2, operator: 'greaterThanOrEqual', value: '1,000', dataType: 'number' },
+      { column: 4, operator: 'greaterThanOrEqual', value: '1,000', dataType: 'number' }, { column: 0, operator: 'empty', value: '' }
+    ]);
+    assert.deepStrictEqual(remapColumnFilters(filters, [1, 2]), [{ column: 1, operator: 'empty', value: '' }]);
+  });
+});
+
+describe('Bounded RE2 column filters', () => {
+  it('searches case-insensitively by default and supports explicit case, multiline, and dotall flags', () => {
+    assert.deepStrictEqual(matchingValues(['Alpha', 'ALPHA', 'beta alpha'], filter('regex', '^alpha$')), ['Alpha', 'ALPHA']);
+    assert.deepStrictEqual(matchingValues(['alpha', 'ALPHA'], filter('regex', '/^alpha$/')), ['alpha']);
+    assert.deepStrictEqual(matchingValues(['alpha', 'ALPHA'], filter('regex', '/^alpha$/i')), ['alpha', 'ALPHA']);
+    assert.ok(rowMatchesFilters(['first\nsecond'], [filter('regex', '/^second$/m')]));
+    assert.ok(rowMatchesFilters(['a\nb'], [filter('regex', '/a.b/s')]));
+    assert.ok(rowMatchesFilters(['FIRST\nA\nB'], [filter('regex', '/^a.b$/ims')]));
+    assert.strictEqual(validateColumnFilterInput('regex', ''), undefined);
+    assert.ok(rowMatchesFilters([''], [filter('regex', '')]));
+  });
+
+  it('distinguishes escaped delimiters, slashes in character classes, and plain path patterns', () => {
+    assert.ok(rowMatchesFilters(['A/B'], [filter('regex', '/^a\\/b$/i')]));
+    assert.ok(rowMatchesFilters(['a/b'], [filter('regex', '/^a[/]b$/')]));
+    assert.ok(rowMatchesFilters(['/path'], [filter('regex', '/path')]));
+    assert.ok(!rowMatchesFilters(['path'], [filter('regex', '/path')]));
+    assert.ok(rowMatchesFilters(['a\\'], [filter('regex', '/^a\\\\$/')]));
+  });
+
+  it('rejects unsupported flags, lookarounds, backreferences, and malformed patterns with useful validation', () => {
+    for (const query of ['/a/g', '/a/ii', '/a/x', '(?=a)', '(a)\\1', '[']) {
+      assert.match(validateColumnFilterInput('regex', query) ?? '', /RE2 regular expression/);
+      assert.deepStrictEqual(matchingValues(['a', 'aa', 'anything', ''], filter('regex', query)), []);
+    }
+    const persisted = normalizeColumnFilters([filter('regex', '(?=a)')]);
+    assert.strictEqual(persisted.length, 1);
+    assert.deepStrictEqual(visibleSourceRows([['header'], ['a'], ['aa']], 0, true, persisted), [0]);
+  });
+
+  it('compiles patterns once per full-source pass and reuses them for every cell', () => {
+    const originalCompile = RE2JS.compile;
+    let count = 0;
+    RE2JS.compile = function(pattern: string, flags?: number): RE2JS {
+      count++;
+      return originalCompile.call(this, pattern, flags);
+    };
+    try {
+      const rows = Array.from({ length: 2000 }, (_, index) => [`row ${index}`, index % 2 ? 'KEEP' : 'drop']);
+      const filters = [filter('regex', '^row [0-9]+$'), { column: 1, operator: 'regex' as const, value: '^keep$' }];
+      const ids = visibleSourceRows(rows, 0, false, filters);
+      assert.strictEqual(count, 2);
+      assert.strictEqual(ids.length, 1000);
+      assert.strictEqual(ids[0], 1);
+      assert.strictEqual(ids[ids.length - 1], 1999);
+      const matches = compileColumnFilters(filters);
+      assert.strictEqual(count, 4);
+      assert.ok(matches(['row 1', 'KEEP']));
+      assert.ok(!matches(['row 2', 'drop']));
+      assert.strictEqual(count, 4);
+    } finally {
+      RE2JS.compile = originalCompile;
+    }
+  });
+
+  it('handles a nested repetition with a long failing cell through the linear-time engine', () => {
+    const matches = compileColumnFilters([filter('regex', '(a+)+$')]);
+    assert.ok(!matches(['a'.repeat(100000) + '!']));
+    assert.ok(matches(['a'.repeat(100000)]));
+  });
+});
diff --git a/src/test/column-sizing.test.ts b/src/test/column-sizing.test.ts
new file mode 100644
index 0000000..b119796
--- /dev/null
+++ b/src/test/column-sizing.test.ts
@@ -0,0 +1,114 @@
+import assert from 'assert';
+import Module from 'module';
+import vm from 'vm';
+import { describe, it } from 'node:test';
+import { createWebview } from '../test-support/sizing-webview-harness';
+
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') { return { window: { activeColorTheme: { kind: 1 } }, ColorThemeKind: { Dark: 1 } }; }
+  return originalRequire.apply(this, arguments as any);
+};
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+describe('Column sizing behavior', () => {
+  it('measures longest physical line across LF, CRLF and CR without counting separators', () => {
+    assert.deepStrictEqual(CsvEditorProvider.__test.computeColumnWidths([
+      ['short\nlongest', 'a\r\nb\r\nc', '123\r45', ''],
+      ['x\nx\nx\nx\nx\nx\nx\nx', 'header', '1', 'tiny']
+    ]), [7, 6, 3, 4]);
+  });
+
+  it('stores validated manual widths per URI and removes only the reset file', async () => {
+    const store: Record<string, any> = {};
+    const context = { workspaceState: {
+      get: (key: string, fallback: any) => store[key] ?? fallback,
+      update: async (key: string, value: any) => { store[key] = value; }
+    }} as any;
+    const first = { toString: () => 'file:///one.csv' } as any;
+    const second = { toString: () => 'file:///two.tsv' } as any;
+    await CsvEditorProvider.setColumnSizesForUri(context, first, { '0': 180.3, '-1': 100, invalid: 200, '1': 39, '2': Infinity });
+    await CsvEditorProvider.setColumnSizesForUri(context, second, { '1': 220 });
+    assert.deepStrictEqual(CsvEditorProvider.getColumnSizesForUri(context, first), { '0': 180 });
+    assert.deepStrictEqual(CsvEditorProvider.getColumnSizesForUri(context, second), { '1': 220 });
+    await CsvEditorProvider.setColumnSizesForUri(context, first, {});
+    assert.deepStrictEqual(CsvEditorProvider.getColumnSizesForUri(context, first), {});
+    assert.deepStrictEqual(CsvEditorProvider.getColumnSizesForUri(context, second), { '1': 220 });
+  });
+
+  it('restores durable widths when a fresh webview opens, including newly mounted chunks', () => {
+    const view = createWebview({ persistedColumns: { '0': 210 } });
+    const cell = view.cell(1, 0, 'initial');
+    vm.runInContext('applySizeStateToRenderedCells();', view.context);
+    assert.strictEqual(cell.style.width, '210px');
+    assert.strictEqual(cell.style.boxSizing, 'border-box');
+    const chunkCell = view.cell(1001, 0, 'later chunk');
+    vm.runInContext('applySizeStateToRenderedCells();', view.context);
+    assert.strictEqual(chunkCell.style.minWidth, '210px');
+    assert.strictEqual(chunkCell.style.boxSizing, 'border-box');
+    vm.runInContext('resetColumnWidth(0);', view.context);
+    assert.strictEqual(cell.style.boxSizing, '');
+    assert.strictEqual(chunkCell.style.boxSizing, '');
+  });
+
+  it('honors an explicit webview reset over durable values and restores automatic CSS', () => {
+    const reset = createWebview({ state: { columnSizes: {} }, persistedColumns: { '0': 210 } });
+    const untouched = reset.cell(1, 0, 'initial');
+    vm.runInContext('applySizeStateToRenderedCells();', reset.context);
+    assert.strictEqual(untouched.style.minWidth, '8ch');
+    const view = createWebview({ persistedColumns: { '0': 210 } });
+    const cell = view.cell(1, 0, 'initial');
+    vm.runInContext('applySizeStateToRenderedCells(); resetColumnWidth(0); persistColumnSizes();', view.context);
+    assert.strictEqual(cell.style.width, '');
+    assert.strictEqual(cell.style.minWidth, '8ch');
+    assert.strictEqual(cell.style.maxWidth, '100ch');
+    assert.deepStrictEqual(view.messages, [{ type: 'columnSizesChanged', columnSizes: {} }]);
+  });
+
+  it("restores each cell's original box sizing after repeated resizes", () => {
+    const view = createWebview();
+    const header = view.cell(0, 0, 'header', true);
+    const body = view.cell(1, 0, 'body');
+    header.style.boxSizing = 'content-box';
+    body.style.boxSizing = 'border-box';
+    vm.runInContext('applyColumnWidth(0, 140); applyColumnWidth(0, 180);', view.context);
+    assert.strictEqual(header.style.boxSizing, 'border-box');
+    assert.strictEqual(body.style.boxSizing, 'border-box');
+    vm.runInContext('resetColumnWidth(0);', view.context);
+    assert.strictEqual(header.style.boxSizing, 'content-box');
+    assert.strictEqual(body.style.boxSizing, 'border-box');
+    assert.strictEqual(header.style.minWidth, '8ch');
+    assert.strictEqual(body.style.maxWidth, '100ch');
+  });
+
+  it('starts and saves a resize from both sides of a boundary with headers on or off', () => {
+    for (const header of [true, false]) {
+      for (const side of ['left', 'right']) {
+        const view = createWebview({ header });
+        const first = view.cell(header ? 0 : 1, 0, 'one', header);
+        const second = view.cell(header ? 0 : 1, 1, 'two', header);
+        const target = side === 'left' ? first : second;
+        const clientX = side === 'left' ? 97 : 103;
+        const clientY = header ? 15 : 45;
+        const event = view.dispatch(target, 'mousedown', { button: 0, clientX, clientY });
+        assert.strictEqual(event.defaultPrevented, true);
+        assert.strictEqual(view.table.style.cursor, 'col-resize');
+        view.dispatch(target, 'mousemove', { clientX: clientX + 50, clientY });
+        view.dispatch(target, 'mouseup');
+        assert.strictEqual(first.style.width, '150px');
+        assert.strictEqual(second.style.width, '');
+        assert.deepStrictEqual(view.messages, [{ type: 'columnSizesChanged', columnSizes: { '0': 150 } }]);
+      }
+    }
+  });
+
+  it('double-click resets a resized column and persists the reset', () => {
+    const view = createWebview();
+    const header = view.cell(0, 0, 'one', true);
+    vm.runInContext('applyColumnWidth(0, 230);', view.context);
+    view.dispatch(header, 'dblclick', { clientX: 96, clientY: 15 });
+    assert.strictEqual(header.style.minWidth, '8ch');
+    assert.deepStrictEqual(view.messages, [{ type: 'columnSizesChanged', columnSizes: {} }]);
+  });
+});
diff --git a/src/test/context-menu-positioning.test.ts b/src/test/context-menu-positioning.test.ts
new file mode 100644
index 0000000..5ca10c1
--- /dev/null
+++ b/src/test/context-menu-positioning.test.ts
@@ -0,0 +1,211 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+async function fixture(separator = ',') {
+  const host = await createEditorHarness({ rows: [['Name', 'Value'], ['one', 'two']], header: true, separator });
+  const view = createWebviewDom(host.panel.webview.html);
+  const { window } = view;
+  const menu = window.document.getElementById('contextMenu');
+  let naturalSize: { width: number; height: number } | undefined;
+  const measurements: Array<{ left: string; top: string; display: string }> = [];
+  const baseFontSize = Number.parseFloat(window.getComputedStyle(window.document.body).fontSize);
+  const natural = () => {
+    if (naturalSize) { return naturalSize; }
+    const scale = Number.parseFloat(window.getComputedStyle(window.document.body).fontSize) / baseFontSize;
+    return {
+      width: Math.max(...Array.from(menu.children).map((item: any) => item.textContent.length * 8 * scale + 26)),
+      height: Array.from(menu.children).reduce((sum: number, item: any) => sum + (item.textContent ? 24 * scale : 4), 2)
+    };
+  };
+  const size = () => ({
+    width: Math.min(natural().width, Number.parseFloat(menu.style.maxWidth)),
+    height: Math.min(natural().height, Number.parseFloat(menu.style.maxHeight))
+  });
+  menu.getBoundingClientRect = () => {
+    measurements.push({ left: menu.style.left, top: menu.style.top, display: menu.style.display });
+    const { width, height } = size();
+    const left = Number.parseFloat(menu.style.left), top = Number.parseFloat(menu.style.top);
+    return { left, top, right: left + width, bottom: top + height, width, height };
+  };
+  Object.defineProperty(menu, 'scrollHeight', { get: () => natural().height });
+  Object.defineProperty(menu, 'clientHeight', { get: () => size().height });
+  const viewport = (width: number, height: number) => {
+    Object.defineProperty(window, 'innerWidth', { value: width, configurable: true });
+    Object.defineProperty(window, 'innerHeight', { value: height, configurable: true });
+  };
+  viewport(1000, 700);
+  const open = (x: number, y: number, row = 1, column = 0, pageOffsetX = 0, pageOffsetY = 0) => {
+    const target = view.cell(row, column);
+    target.dispatchEvent(new window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true, clientX: x, clientY: y }));
+    const event = new window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: x, clientY: y });
+    Object.defineProperty(event, 'pageX', { value: x + pageOffsetX });
+    Object.defineProperty(event, 'pageY', { value: y + pageOffsetY });
+    target.dispatchEvent(event);
+    assert.strictEqual(event.defaultPrevented, true);
+    return { left: Number.parseFloat(menu.style.left), top: Number.parseFloat(menu.style.top), ...size() };
+  };
+  return { ...view, menu, measurements, viewport, open, setSize: (width: number, height: number) => { naturalSize = { width, height }; } };
+}
+
+describe('Context menu viewport positioning', () => {
+  it('renders the provider popup at natural width with bounded wrapping and scrolling', async () => {
+    const view = await fixture();
+    try {
+      const css = view.window.getComputedStyle(view.menu);
+      assert.strictEqual(css.position, 'fixed');
+      assert.strictEqual(css.width, 'max-content');
+      assert.strictEqual(css.boxSizing, 'border-box');
+      assert.strictEqual(css.overflow, 'auto');
+      assert.strictEqual(css.overflowWrap, 'anywhere');
+    } finally { view.close(); }
+  });
+
+  for (const separator of [',', '\t']) {
+    it(`flips at the measured right-space threshold, including fractional coordinates (${JSON.stringify(separator)})`, async () => {
+      const view = await fixture(separator);
+      try {
+        view.setSize(200, 120);
+        assert.strictEqual(view.open(792, 100).left, 792, 'exact fit stays on the right, beyond the screen midpoint');
+        assert.strictEqual(view.open(792.5, 100).left, 592.5, 'half a pixel beyond the measured threshold opens left');
+        assert.ok(view.measurements.every(measurement => measurement.left === '8px' && measurement.top === '8px' && measurement.display === 'block'));
+      } finally { view.close(); }
+    });
+  }
+
+  it('chooses a side again for differently sized menus at the same pointer position', async () => {
+    const view = await fixture();
+    try {
+      view.setSize(100, 120);
+      assert.strictEqual(view.open(650, 100).left, 650);
+      view.setSize(400, 120);
+      assert.strictEqual(view.open(650, 100).left, 250);
+    } finally { view.close(); }
+  });
+
+  it('measures the completed header menu, including its extra actions', async () => {
+    const view = await fixture();
+    try {
+      const body = view.open(100, 100, 1);
+      const x = 1000 - 8 - body.width;
+      const y = 700 - 8 - body.height;
+      const fittedBody = view.open(x, y, 1);
+      assert.strictEqual(fittedBody.left, x);
+      assert.strictEqual(fittedBody.top, y);
+      const header = view.open(x, y, 0);
+      assert.ok(header.width >= body.width);
+      assert.ok(header.height > body.height);
+      assert.strictEqual(header.left, header.width > body.width ? x - header.width : x);
+      assert.strictEqual(header.top, Math.max(8, y - header.height));
+      assert.ok(Array.from(view.menu.children).some((item: any) => item.textContent === 'Treat first row as data'));
+      assert.ok(Array.from(view.menu.children).some((item: any) => item.textContent === 'Sort: A-Z'));
+    } finally { view.close(); }
+  });
+
+  it('flips upward at the measured bottom-space threshold', async () => {
+    const view = await fixture();
+    try {
+      view.setSize(200, 120);
+      assert.strictEqual(view.open(100, 572).top, 572);
+      assert.strictEqual(view.open(100, 572.5).top, 452.5);
+    } finally { view.close(); }
+  });
+
+  it('clamps all four corners inside the viewport margins', async () => {
+    const view = await fixture();
+    try {
+      view.setSize(200, 120);
+      for (const [x, y, left, top] of [[0, 0, 8, 8], [1000, 0, 792, 8], [0, 700, 8, 572], [1000, 700, 792, 572]]) {
+        const placed = view.open(x, y);
+        assert.strictEqual(placed.left, left);
+        assert.strictEqual(placed.top, top);
+        assert.ok(placed.left + placed.width <= 992);
+        assert.ok(placed.top + placed.height <= 692);
+      }
+    } finally { view.close(); }
+  });
+
+  it('uses viewport client coordinates independently of document and table scrolling', async () => {
+    const view = await fixture();
+    try {
+      view.setSize(200, 120);
+      Object.defineProperty(view.window, 'scrollX', { value: 5000 });
+      Object.defineProperty(view.window, 'scrollY', { value: 7000 });
+      const container = view.window.document.querySelector('.table-container');
+      container.scrollLeft = 300;
+      container.scrollTop = 600;
+      const placed = view.open(100, 200, 1, 0, 5000, 7000);
+      assert.strictEqual(placed.left, 100);
+      assert.strictEqual(placed.top, 200);
+      assert.strictEqual(container.scrollLeft, 300);
+      assert.strictEqual(container.scrollTop, 600);
+    } finally { view.close(); }
+  });
+
+  it('bounds tiny editor menus and retains reachable actions through vertical scrolling', async () => {
+    const view = await fixture();
+    try {
+      view.setSize(300, 500);
+      for (const [width, height] of [[120, 90], [16, 12]]) {
+        view.viewport(width, height);
+        const placed = view.open(width - 1, height - 1);
+        assert.ok(placed.width <= width - 2 * Math.min(8, width / 4));
+        assert.ok(placed.height <= height - 2 * Math.min(8, height / 4));
+        assert.ok(placed.left >= 0 && placed.left + placed.width <= width);
+        assert.ok(placed.top >= 0 && placed.top + placed.height <= height);
+        assert.ok(view.menu.scrollHeight > view.menu.clientHeight);
+      }
+      view.menu.scrollTop = view.menu.scrollHeight - view.menu.clientHeight;
+      const last = view.menu.lastElementChild;
+      assert.strictEqual(last.textContent, 'Delete COLUMN');
+      last.click();
+      assert.strictEqual(view.messages.at(-1).type, 'deleteColumn');
+      assert.strictEqual(view.messages.at(-1).index, 0);
+      assert.strictEqual(view.menu.style.display, 'none');
+    } finally { view.close(); }
+  });
+
+  it('dismisses only when CSV zoom changes and measures the enlarged menu on reopen', async () => {
+    const view = await fixture();
+    try {
+      const original = view.open(100, 100);
+      const x = 1000 - 8 - original.width;
+      assert.strictEqual(view.open(x, 100).left, x);
+      view.key('0', { ctrlKey: true });
+      assert.strictEqual(view.menu.style.display, 'block', 'reset at the existing zoom leaves the menu open');
+      const originalFontSize = Number.parseFloat(view.window.getComputedStyle(view.window.document.body).fontSize);
+      view.key('+', { ctrlKey: true });
+      assert.strictEqual(view.menu.style.display, 'none');
+      assert.ok(Number.parseFloat(view.window.document.body.style.fontSize) > originalFontSize);
+      const enlarged = view.open(x, 100);
+      assert.ok(enlarged.width > original.width);
+      assert.strictEqual(enlarged.left, x - enlarged.width);
+      assert.ok(enlarged.left + enlarged.width <= 992);
+      assert.strictEqual(view.menu.style.display, 'block');
+    } finally { view.close(); }
+  });
+
+  it('dismisses on viewport resize and remeasures/reset scroll when reopened', async () => {
+    const view = await fixture();
+    try {
+      view.viewport(120, 90);
+      view.setSize(300, 500);
+      view.open(119, 89);
+      view.menu.scrollTop = 200;
+      view.menu.scrollLeft = 20;
+      view.viewport(1000, 700);
+      view.window.dispatchEvent(new view.window.Event('resize'));
+      assert.strictEqual(view.menu.style.display, 'none');
+      view.setSize(180, 100);
+      const placed = view.open(100, 100);
+      assert.strictEqual(placed.left, 100);
+      assert.strictEqual(placed.top, 100);
+      assert.strictEqual(placed.width, 180);
+      assert.strictEqual(placed.height, 100);
+      assert.strictEqual(view.menu.scrollTop, 0);
+      assert.strictEqual(view.menu.scrollLeft, 0);
+      assert.strictEqual(view.menu.style.display, 'block');
+      assert.ok(Array.from(view.menu.children).some((item: any) => item.textContent === 'Copy'));
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/csv-table-diff.test.ts b/src/test/csv-table-diff.test.ts
new file mode 100644
index 0000000..9a7c93c
--- /dev/null
+++ b/src/test/csv-table-diff.test.ts
@@ -0,0 +1,97 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { compareCsvRows, comparisonLimits, comparisonPages, parseComparisonRows } from '../csv-table-diff';
+
+describe('CSV table difference model', () => {
+  it('aligns inserted/deleted records and isolates changed fields around multiline values', () => {
+    const original = parseComparisonRows('id,value\r\n1,"one\r\ntwo"\r\n2,old\r\n3,remove\r\n4,same\r\n', ',');
+    const modified = parseComparisonRows('id,value\n0,added\n1,"one\r\ntwo"\n2,new\n4,same\n', ',');
+    const diff = compareCsvRows(original, modified);
+    assert.deepStrictEqual(diff.records.map(record => [record.original, record.modified, record.kind]), [
+      [0, 0, 'equal'], [undefined, 1, 'added'], [1, 2, 'equal'], [2, 3, 'changed'], [3, undefined, 'removed'], [4, 4, 'equal']
+    ]);
+    assert.deepStrictEqual(diff.records[3].changedColumns, [1]);
+    assert.deepStrictEqual([diff.added, diff.removed, diff.changed, diff.approximate], [1, 1, 1, false]);
+  });
+
+  it('aligns a modified record with shared fields after an adjacent deletion', () => {
+    const diff = compareCsvRows([['gone', 'old'], ['id', 'before']], [['id', 'after']]);
+    assert.deepStrictEqual(diff.records.map(record => [record.original, record.modified, record.kind]), [
+      [0, undefined, 'removed'], [1, 0, 'changed']
+    ]);
+    assert.deepStrictEqual(diff.records[1].changedColumns, [1]);
+  });
+
+  it('distinguishes a missing field from an empty field, without counting quote/terminator style', () => {
+    const diff = compareCsvRows(parseComparisonRows('"a",b\r\nx\r\n', ','), parseComparisonRows('a,b\nx,\n', ','));
+    assert.strictEqual(diff.records[0].kind, 'equal');
+    assert.deepStrictEqual(diff.records[1].changedColumns, [1]);
+    assert.strictEqual(diff.changed, 1);
+    assert.deepStrictEqual(parseComparisonRows('a\n\n', ','), [['a'], ['']]);
+  });
+
+  for (const delimiter of [',', '\t', '|']) {
+    it(`parses ${JSON.stringify(delimiter)} fields with doubled quotes, BOM and multiline Unicode`, () => {
+      const rows = parseComparisonRows(`\ufeffname${delimiter}value\r\n"é\n🙂"${delimiter}"a""b"\r\n`, delimiter);
+      assert.deepStrictEqual(rows, [['name', 'value'], ['é\n🙂', 'a"b']]);
+    });
+  }
+
+  it('preserves every source record in order with duplicates and empty sides', () => {
+    const inputs = [[], [['']], [['a'], ['a'], ['b']], [['a'], ['b'], ['a']], [['x', ''], ['y']]];
+    for (const original of inputs) {
+      for (const modified of inputs) {
+        const diff = compareCsvRows(original, modified);
+        assert.deepStrictEqual(diff.records.flatMap(record => record.original === undefined ? [] : [record.original]), original.map((_, index) => index));
+        assert.deepStrictEqual(diff.records.flatMap(record => record.modified === undefined ? [] : [record.modified]), modified.map((_, index) => index));
+      }
+    }
+  });
+
+  it('bounds large alignment work and explicitly reports positional sections', () => {
+    const original = Array.from({ length: comparisonLimits.rows }, (_, index) => [`old-${index}`]);
+    const modified = Array.from({ length: comparisonLimits.rows }, (_, index) => [`new-${index}`]);
+    const diff = compareCsvRows(original, modified);
+    assert.strictEqual(diff.approximate, true);
+    assert.strictEqual(diff.records.length, comparisonLimits.rows);
+    assert.strictEqual(diff.changed, comparisonLimits.rows);
+    assert.deepStrictEqual(diff.records.at(-1)?.changedColumns, [0]);
+  });
+
+  it('uses unique unchanged anchors on large inputs with additions', () => {
+    const original = Array.from({ length: 1500 }, (_, index) => [String(index)]);
+    const modified = [['first'], ...original.map(row => [...row]), ['last']];
+    modified[750] = ['changed'];
+    const diff = compareCsvRows(original, modified);
+    assert.strictEqual(diff.added, 2);
+    assert.strictEqual(diff.changed, 1);
+    assert.strictEqual(diff.removed, 0);
+    assert.strictEqual(diff.records.find(record => record.original === 1499)?.modified, 1500);
+  });
+
+  it('rejects malformed and oversized values, records, rows, cells and decoded input without truncation', () => {
+    assert.throws(() => parseComparisonRows('"unfinished', ','), /malformed/);
+    assert.throws(() => parseComparisonRows('a'.repeat(comparisonLimits.cellChars + 1), ','), /display limit/);
+    assert.throws(() => parseComparisonRows(Array(6).fill('x'.repeat(50000)).join(','), ','), /display limit/);
+    assert.throws(() => parseComparisonRows(Array(comparisonLimits.rows + 1).fill('x').join('\n'), ','), /10,000/);
+    assert.throws(() => parseComparisonRows(Array(1001).fill('x').join(','), ','), /1,000/);
+    assert.throws(() => parseComparisonRows(Array(101).fill(Array(1000).fill('x').join(',')).join('\n'), ','), /100,000/);
+    assert.throws(() => parseComparisonRows('é'.repeat(comparisonLimits.textBytes / 2 + 1), ','), /5 MiB/);
+  });
+
+  it('pages within row, rendered body-cell and text bounds', () => {
+    for (const rows of [Array.from({ length: 501 }, () => ['a']), Array.from({ length: 30 }, () => Array(1000).fill('x')), Array.from({ length: 30 }, () => ['x'.repeat(60000)])]) {
+      const diff = compareCsvRows(rows, rows);
+      const pages = comparisonPages(diff);
+      assert.ok(pages.length > 1);
+      assert.strictEqual(pages[0].start, 0);
+      assert.strictEqual(pages.at(-1)?.end, rows.length);
+      for (const page of pages) {
+        const slice = rows.slice(page.start, page.end);
+        assert.ok(slice.length <= comparisonLimits.pageRows);
+        assert.ok(slice.reduce((sum, row) => sum + row.length * 2 + 2, 0) <= comparisonLimits.pageCells);
+        assert.ok(slice.reduce((sum, row) => sum + row.join('').length * 2, 0) <= comparisonLimits.pageChars);
+      }
+    }
+  });
+});
diff --git a/src/test/default-ignore-rows-commands.test.ts b/src/test/default-ignore-rows-commands.test.ts
new file mode 100644
index 0000000..220409a
--- /dev/null
+++ b/src/test/default-ignore-rows-commands.test.ts
@@ -0,0 +1,61 @@
+import assert from 'assert';
+import { createTestMemento } from './test-memento';
+import Module from 'module';
+import { describe, it } from 'node:test';
+
+const commands = new Map<string, () => Promise<void>>();
+let input: string | undefined;
+let prompt: any;
+const routingErrors: string[] = [];
+const configurationListeners: Array<(event: any) => Promise<void>> = [];
+let changedConfiguration: (event: any) => Promise<void[]>;
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return {
+      TabInputText: class {},
+      ConfigurationTarget: { Global: 1, Workspace: 2 },
+      commands: { registerCommand: (name: string, callback: () => Promise<void>) => { commands.set(name, callback); return { dispose() {} }; } },
+      window: { tabGroups: { all: [], activeTabGroup: { viewColumn: 1, tabs: [], activeTab: undefined } }, visibleTextEditors: [], onDidChangeActiveTextEditor: () => ({ dispose() {} }), showInputBox: async (options: any) => { prompt = options; return input; }, showInformationMessage() {}, showErrorMessage: (message: string) => { routingErrors.push(message); }, registerCustomEditorProvider: () => ({ dispose() {} }) },
+      workspace: { textDocuments: [], onDidOpenTextDocument: () => ({ dispose() {} }), onDidCloseTextDocument: () => ({ dispose() {} }), getConfiguration: (section: string) => ({ inspect: (key: string) => section === 'csv' && key === 'enabled' ? { defaultValue: true } : undefined, get: (key: string, fallback: any) => section === 'csv' && key === 'defaultIgnoreRows' ? 7 : fallback }), onDidChangeConfiguration: (listener: any) => { configurationListeners.push(listener); changedConfiguration = event => Promise.all(configurationListeners.map(callback => callback(event))); return { dispose() {} }; } }
+    };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { activate } from '../extension';
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+describe('Hidden-row override controls', () => {
+  it('uses zero as an explicit override and blank input to inherit again; cancellation keeps the override', async () => {
+    const values: Record<string, any> = {};
+    const context = { subscriptions: [], globalState: createTestMemento(), workspaceState: { keys: () => Object.keys(values).filter(key => values[key] !== undefined), get: (key: string, fallback: any) => values[key] ?? fallback, update: async (key: string, value: any) => { values[key] = value; } } } as any;
+    await activate(context);
+    assert.deepStrictEqual(routingErrors, [], 'routing initialization must finish without fixture errors');
+    const uri = { toString: () => 'file:///sample.csv' } as any;
+    let refreshed = 0;
+    const active = { isActive: () => true, getDocumentUri: () => uri, refreshViewSafely: () => refreshed++ } as any;
+    CsvEditorProvider.currentActive = active;
+    CsvEditorProvider.editors = [active];
+    input = '0';
+    await commands.get('csv.changeIgnoreRows')!();
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(context, uri), 0);
+    await changedConfiguration!({ affectsConfiguration: (key: string) => key === 'csv.defaultIgnoreRows' });
+    assert.strictEqual(refreshed, 1, 'an explicit override must not interrupt editing when defaults change');
+    assert.strictEqual(prompt.validateInput(''), undefined);
+    assert.ok(prompt.validateInput('-1'));
+    assert.ok(prompt.validateInput('1.5'));
+    input = undefined;
+    await commands.get('csv.changeIgnoreRows')!();
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(context, uri), 0);
+    input = '';
+    await commands.get('csv.changeIgnoreRows')!();
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(context, uri), 7);
+    assert.strictEqual(refreshed, 2);
+    await changedConfiguration!({ affectsConfiguration: (key: string) => key === 'csv.defaultIgnoreRows' });
+    assert.strictEqual(refreshed, 3, 'default setting updates use the edit-safe refresh path');
+    assert.deepStrictEqual(routingErrors, []);
+    CsvEditorProvider.currentActive = undefined;
+    CsvEditorProvider.editors = [];
+  });
+});
diff --git a/src/test/default-ignore-rows.test.ts b/src/test/default-ignore-rows.test.ts
new file mode 100644
index 0000000..4a0da63
--- /dev/null
+++ b/src/test/default-ignore-rows.test.ts
@@ -0,0 +1,76 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+
+describe('Default hidden rows', () => {
+  it('inherits resource-specific defaults while explicit per-file zero wins until reset', async () => {
+    const host = await createEditorHarness({ defaultIgnoreRows: 1 });
+    const uri = host.document.uri as any;
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, uri), 1);
+    assert.ok(host.configurationRequests.includes(uri));
+    const other = { toString: () => 'file:///other.csv' } as any;
+    host.resourceDefaults[other.toString()] = 3;
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, other), 3);
+    await CsvEditorProvider.setHiddenRowsForUri(host.context as any, uri, 0);
+    host.defaultIgnoreRows = 2;
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, uri), 0);
+    await CsvEditorProvider.setHiddenRowsForUri(host.context as any, uri, 4);
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, uri), 4);
+    await CsvEditorProvider.setHiddenRowsForUri(host.context as any, uri, undefined);
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, uri), 2);
+    assert.strictEqual(CsvEditorProvider.getHiddenRowsForUri(host.context as any, other), 3);
+  });
+
+  it('hides inherited metadata from the view while preserving source rows and frozen-row identities', async () => {
+    const rows = [['metadata', 'preserve'], ['Name', 'Value'], ['one', 'two']];
+    const host = await createEditorHarness({ rows, defaultIgnoreRows: 1, frozenRows: 2 });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      assert.strictEqual(view.cell(0, 0), null);
+      assert.strictEqual(view.cell(1, 0).tagName, 'TH');
+      assert.strictEqual(view.cell(2, 0).textContent, 'one');
+      view.window.csvFrozenPanes.layout();
+      assert.ok(view.cell(1, 0).classList.contains('csv-frozen-row'));
+      assert.ok(view.cell(2, 0).classList.contains('csv-frozen-row'));
+      assert.deepStrictEqual(host.rows(), rows);
+    } finally { view.close(); }
+  });
+
+  it('commits an active multiline draft before refreshing an inherited default', async () => {
+    const host = await createEditorHarness({ rows: [['metadata', 'keep'], ['Name', 'Value'], ['one', 'two'], ['three', 'four']], defaultIgnoreRows: 1 });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const cell = view.cell(2, 0);
+      view.start(cell);
+      cell.textContent = 'unsaved\nmultiline draft';
+      host.defaultIgnoreRows = 2;
+      CsvEditorProvider.currentActive!.refreshViewSafely();
+      const prepare = host.messages.slice().reverse().find((message: any) => message.type === 'prepareViewRefresh');
+      assert.ok(prepare);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: prepare }));
+      const messages = view.messages.filter((message: any) => ['editCell', 'viewRefreshReady'].includes(message.type));
+      assert.deepStrictEqual(messages.map((message: any) => message.type), ['editCell', 'viewRefreshReady']);
+      for (const message of messages) { await host.receive(message); }
+      assert.strictEqual(host.rows()[2][0], 'unsaved\nmultiline draft');
+      assert.deepStrictEqual(host.rows()[0], ['metadata', 'keep']);
+      assert.ok(host.panel.webview.html.includes('data-firstrow="2"'));
+      assert.ok(host.panel.webview.html.includes('unsaved'));
+    } finally { view.close(); }
+  });
+
+  it('declares one resource-scoped integer setting and documents explicit zero/inherit reset', () => {
+    const manifest = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+    const setting = manifest.contributes.configuration.properties['csv.defaultIgnoreRows'];
+    assert.strictEqual(setting.type, 'integer');
+    assert.strictEqual(setting.default, 0);
+    assert.strictEqual(setting.minimum, 0);
+    assert.strictEqual(setting.scope, 'resource');
+    const readme = fs.readFileSync(path.join(process.cwd(), 'README.md'), 'utf8');
+    assert.ok(readme.includes('csv.defaultIgnoreRows'));
+    assert.ok(readme.includes('blank'));
+    assert.ok(readme.includes('explicit `0`'));
+  });
+});
diff --git a/src/test/edit-integrity-harness.ts b/src/test/edit-integrity-harness.ts
new file mode 100644
index 0000000..6da5ede
--- /dev/null
+++ b/src/test/edit-integrity-harness.ts
@@ -0,0 +1,406 @@
+import { TestExtensionUri } from './test-extension-uri';
+import { createTestMemento } from './test-memento';
+import fs from 'fs';
+import path from 'path';
+import Module from 'module';
+import Papa from 'papaparse';
+
+class TestUri {
+  constructor(public readonly path: string, public readonly scheme = 'file') {}
+  get fsPath() { return this.path; }
+  toString() { return `${this.scheme}://${this.path}`; }
+  static file(filePath: string) { return new TestUri(filePath); }
+}
+
+let activeHarness: any;
+const vscodeStub = {
+  Uri: TestUri,
+  TabInputText: class { constructor(readonly uri: TestUri) {} },
+  ConfigurationTarget: { Global: 1, Workspace: 2 },
+  ViewColumn: { Active: -1 },
+  Range: class {},
+  WorkspaceEdit: class {
+    text = '';
+    replace(_uri: unknown, _range: unknown, text: string) { this.text = text; }
+  },
+  ColorThemeKind: { Dark: 1 },
+  window: {
+    activeColorTheme: { kind: 1 },
+    onDidChangeActiveTextEditor: () => ({ dispose() {} }),
+    showTextDocument: async (document: any) => {
+      activeHarness.sourceReveals.push(document.getText());
+      return { document };
+    },
+    showWarningMessage: async (message: string) => {
+      activeHarness.warnings.push(message);
+      return activeHarness.warningChoice;
+    },
+    showQuickPick: async (items: any[], options: any) => {
+      activeHarness.quickPickCalls.push({ items, options });
+      return typeof activeHarness.filterChoice === 'function' ? activeHarness.filterChoice(items, options) : activeHarness.filterChoice;
+    },
+    showInputBox: async (options: any) => {
+      activeHarness.inputBoxCalls.push(options);
+      return activeHarness.filterInput;
+    },
+    showInformationMessage: (text: string) => activeHarness.notifications.push(text),
+    showErrorMessage: async (text: string) => { activeHarness.notifications.push(text); activeHarness.errors.push(text); },
+    showOpenDialog: async () => activeHarness.dialogResults.shift(),
+    get visibleTextEditors() { return activeHarness.visibleTextEditors; },
+    get activeTextEditor() { return activeHarness.activeTextDocument ? { document: activeHarness.activeTextDocument } : undefined; },
+    createWebviewPanel: (...args: unknown[]) => activeHarness.createPanel(...args),
+    tabGroups: {
+      get activeTabGroup() { return this.all[0]; },
+      get all() { return activeHarness.tabGroups ?? [{ tabs: [{ input: { uri: activeHarness.document.uri, viewType: 'csv.editor' } }] }]; },
+      close: async () => activeHarness.closeResult
+    },
+    registerCustomEditorProvider: (viewType: string) => {
+      activeHarness.providers.push(viewType);
+      return { dispose() {} };
+    }
+  },
+  commands: {
+    registerCommand: (name: string, command: (...args: any[]) => unknown) => {
+      activeHarness.commands.set(name, command);
+      return { dispose() {} };
+    },
+    executeCommand: async (name: string, ...args: unknown[]) => {
+      activeHarness.executedCommands.push({ name, args });
+      activeHarness.recordedCommands.push([name, ...args]);
+      if (activeHarness.commandError) {
+        throw activeHarness.commandError;
+      }
+      if (name === 'workbench.action.editor.changeEncoding') {
+        await activeHarness.commandWait;
+      }
+      if (name === 'workbench.action.files.save') {
+        activeHarness.nativeSaveCommands.push(name);
+        return activeHarness.document.save();
+      }
+    }
+  },
+  env: { clipboard: { writeText: async (text: string) => { activeHarness.clipboardText = text; }, readText: async () => activeHarness.clipboardText } },
+  workspace: {
+    onDidOpenTextDocument: () => ({ dispose() {} }),
+    onDidCloseTextDocument: () => ({ dispose() {} }),
+    getConfiguration: (section: string, resource?: TestUri) => {
+      if (activeHarness) { activeHarness.configurationRequests.push(resource); }
+      return { inspect: (key: string) => section === 'csv' && key === 'enabled' ? { defaultValue: true, globalValue: activeHarness.configuration.enabled ?? activeHarness.enabled } : undefined,
+        get: (key: string, fallback: unknown) => {
+        if (key in activeHarness.configuration) { return activeHarness.configuration[key]; }
+        if (key === 'enabled') { return activeHarness?.enabled ?? true; }
+        if (key === 'maxFileSizeMB') { return 0; }
+        if (key === 'defaultIgnoreRows') { return activeHarness.resourceDefaults[resource?.toString() ?? ''] ?? activeHarness.defaultIgnoreRows; }
+        return fallback;
+      } };
+    },
+    fs: {
+      stat: async (uri: TestUri) => {
+        if (activeHarness.statError) { throw activeHarness.statError; }
+        return { size: activeHarness.statSize ?? Buffer.byteLength(activeHarness.sourceDocuments.get(uri.toString())?.getText() ?? '') };
+      }
+    },
+    get textDocuments() { return activeHarness.existingDocuments; },
+    openTextDocument: async (uri: TestUri) => {
+      activeHarness.openedDocuments.push(uri.toString());
+      const document = activeHarness.sourceDocuments.get(uri.toString());
+      if (!document) { throw new Error('Unknown test document'); }
+      return document;
+    },
+    applyEdit: (edit: { text: string }) => activeHarness.applyEdit(edit.text),
+    onDidChangeTextDocument: (listener: (event: unknown) => void) => {
+      activeHarness.changeListeners.push(listener);
+      return { dispose() {} };
+    },
+    onDidChangeConfiguration: (listener: (event: any) => void) => {
+      activeHarness.configurationListeners.push(listener);
+      return { dispose() {} };
+    },
+    onWillSaveTextDocument: (listener: (event: unknown) => void) => {
+      activeHarness.saveListeners.push(listener);
+      return { dispose() {} };
+    }
+  }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return vscodeStub;
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+// Load the provider only after installing the VS Code API stub.
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+const { JSDOM } = require('jsdom');
+
+export async function createEditorHarness(options: {
+  text?: string;
+  warningChoice?: string | Promise<string | undefined>;
+  rows?: string[][];
+  separator?: string;
+  header?: boolean;
+  serialIndex?: boolean;
+  remote?: boolean;
+  frozenRows?: number;
+  frozenColumns?: number;
+  hiddenRows?: number;
+  defaultIgnoreRows?: number;
+  filters?: unknown;
+  untitled?: boolean;
+  fileName?: string;
+  separatorOverride?: string;
+  cancelInitialization?: boolean;
+  closeDuringInitialization?: boolean;
+} = {}) {
+  const separator = options.separator ?? ',';
+  let text = options.text ?? Papa.unparse(options.rows ?? [['name', 'value'], ['one', 'two']], { delimiter: separator });
+  let diskText = text;
+  let messageListener: (message: any) => Promise<void>;
+  const changeListeners: Array<(event: unknown) => void> = [];
+  const viewListeners: Array<(event: unknown) => void> = [];
+  const saveListeners: Array<(event: unknown) => void> = [];
+  const disposeListeners: Array<() => void> = [];
+  let controller: any;
+  const messages: any[] = [];
+  const delayedEdits: Array<() => void> = [];
+  let deferEdits = false;
+  let editFailure: 'false' | 'throw' | undefined;
+  const uri = new TestUri(options.fileName ?? `/test/data.${separator === '\t' ? 'tsv' : 'csv'}`, options.untitled ? 'untitled' : options.remote ? 'vscode-remote' : 'file');
+  const document = {
+    uri,
+    isClosed: false,
+    languageId: separator === '\t' ? 'tsv' : 'csv',
+    version: 1,
+    getText: () => text,
+    get lineCount() { return text.split(/\r\n|\n|\r/).length; },
+    lineAt: (index: number) => ({ text: text.split(/\r\n|\n|\r/)[index] ?? '' }),
+    save: async () => {
+      const pending: Promise<unknown>[] = [];
+      saveListeners.forEach(listener => listener({ document, waitUntil: (promise: Promise<unknown>) => pending.push(promise) }));
+      await Promise.all(pending);
+      diskText = text;
+      return true;
+    }
+  };
+  const context = {
+    subscriptions: [] as unknown[],
+    extensionPath: process.cwd(), extensionUri: new TestExtensionUri(),
+    globalState: createTestMemento(),
+    workspaceState: {
+      keys() { return Object.keys(this.values).filter(key => this.values[key] !== undefined); },
+      values: {} as Record<string, unknown>,
+      get(key: string, fallback: unknown) { return this.values[key] ?? fallback; },
+      async update(key: string, value: unknown) { this.values[key] = value; }
+    }
+  };
+  await CsvEditorProvider.setHeaderForUri(context as any, uri as any, options.header ?? true);
+  await CsvEditorProvider.setSerialIndexForUri(context as any, uri as any, options.serialIndex ?? true);
+  if (options.separatorOverride) {
+    await CsvEditorProvider.setSeparatorForUri(context as any, uri as any, options.separatorOverride);
+  }
+  await CsvEditorProvider.setColumnFiltersForUri(context as any, uri as any, options.filters);
+  if (options.hiddenRows !== undefined) {
+    await CsvEditorProvider.setHiddenRowsForUri(context as any, uri as any, options.hiddenRows);
+  }
+  await CsvEditorProvider.setFrozenPanesForUri(context as any, uri as any, { rows: options.frozenRows, columns: options.frozenColumns });
+  const panel = {
+    active: true,
+    viewColumn: 2,
+    visible: true,
+    title: 'data.csv',
+    webview: {
+      html: '',
+      options: {},
+      cspSource: 'test:',
+      asWebviewUri: (resource: TestUri) => resource.toString(),
+      postMessage: (message: unknown) => { messages.push(message); return Promise.resolve(true); },
+      onDidReceiveMessage: (listener: typeof messageListener) => { messageListener = listener; }
+    },
+    onDidChangeViewState: (listener: (event: unknown) => void) => { viewListeners.push(listener); },
+    disposed: false,
+    onDidDispose(listener: () => void) { disposeListeners.push(listener); },
+    dispose() {
+      panel.disposed = true;
+      panel.active = false;
+      panel.visible = false;
+      disposeListeners.forEach(listener => listener());
+    }
+  };
+  const harness = {
+    document, panel, messages, changeListeners, saveListeners,
+    configuration: {} as Record<string, unknown>,
+    configurationListeners: [] as Array<(event: any) => void>,
+    providers: [] as string[],
+    tabGroups: undefined as any[] | undefined,
+    errors: [] as string[],
+    dialogResults: [] as Array<unknown>,
+    activeTextDocument: undefined as any,
+    visibleTextEditors: [] as any[],
+    createPanel: undefined as any,
+    openedDocuments: [] as string[],
+    sourceDocuments: new Map<string, any>(),
+    existingDocuments: [] as any[],
+    statError: undefined as Error | undefined,
+    statSize: undefined as number | undefined,
+    warnings: [] as string[],
+    warningChoice: options.warningChoice,
+    commandError: undefined as Error | undefined,
+    commandWait: undefined as Promise<void> | undefined,
+    dispose() { panel.dispose(); },
+    closeResult: true,
+    commands: new Map<string, (...args: any[]) => unknown>(),
+    executedCommands: [] as Array<{ name: string; args: unknown[] }>,
+    registerCommands() {
+      const { registerCsvCommands } = require('../commands') as typeof import('../commands');
+      registerCsvCommands(context as any);
+    },
+    context,
+    defaultIgnoreRows: options.defaultIgnoreRows ?? 0,
+    clipboardText: '',
+    filterChoice: undefined as any,
+    filterInput: undefined as string | undefined,
+    quickPickCalls: [] as Array<{ items: any[]; options: any }>,
+    inputBoxCalls: [] as any[],
+    notifications: [] as string[],
+    resourceDefaults: {} as Record<string, number>,
+    configurationRequests: [] as Array<TestUri | undefined>,
+    enabled: true,
+    recordedCommands: [] as unknown[][],
+    refresh() { CsvEditorProvider.editors.find(controller => controller.getDocumentUri() === uri as any)!.refresh(); },
+    get isOpen() { return CsvEditorProvider.editors.some(controller => controller.getDocumentUri() === uri as any); },
+    async setSeparator(separator: string) { await CsvEditorProvider.setSeparatorForUri(context as any, uri as any, separator); },
+    sourceReveals: [] as string[],
+    nativeSaveCommands: [] as string[],
+    get controllerCount() { return CsvEditorProvider.editors.length; },
+    get activeController() { return CsvEditorProvider.currentActive; },
+    saveUntitledAfterCommit() { controller.saveUntitledAfterCommit(); },
+    requestViewCommit() { controller.requestViewCommit(); },
+    commitPendingDraft() { return controller.commitPendingDraft() as Promise<boolean>; },
+    revealSourceAfterCommit() { harness.enabled = false; controller.revealSourceAfterCommit(); },
+    setEnabled(enabled: boolean) { harness.enabled = enabled; controller.refresh(); },
+    getCurrentSeparator() { return controller.getCurrentSeparator() as string; },
+    rebindDocument(languageId: string) {
+      const replacement = {
+        ...document, languageId,
+        get version() { return document.version; },
+        getText: () => text,
+        get lineCount() { return text.split(/\r\n|\n|\r/).length; }
+      };
+      controller.updateDocumentReference(replacement);
+      return replacement;
+    },
+    get diskText() { return diskText; },
+    get pendingEdits() { return delayedEdits.length; },
+    get pendingDraftRequestId(): number | undefined { return controller?.viewCommitRequested ? controller.viewCommitSequence : undefined; },
+    deferEdits() { deferEdits = true; },
+    resumeEdits() { deferEdits = false; },
+    failEdits(mode: 'false' | 'throw' | undefined) { editFailure = mode; },
+    releaseEdit() { delayedEdits.shift()?.(); },
+    async applyEdit(nextText: string): Promise<boolean> {
+      if (editFailure === 'false') { return false; }
+      if (editFailure === 'throw') { throw new Error('applyEdit rejected'); }
+      return new Promise(resolve => {
+        const apply = () => {
+          text = nextText;
+          document.version += 1;
+          changeListeners.forEach(listener => listener({ document }));
+          resolve(true);
+        };
+        if (deferEdits) {
+          delayedEdits.push(apply);
+        } else {
+          apply();
+        }
+      });
+    },
+    receive(message: unknown) { return messageListener(message); },
+    async view(active: boolean, visible: boolean) {
+      panel.active = active;
+      panel.visible = visible;
+      viewListeners.forEach(listener => listener({ webviewPanel: panel }));
+      await messageListener({ type: 'test-drain' });
+    },
+    rows() { return Papa.parse<string[]>(text, { delimiter: separator }).data; }
+  };
+  activeHarness = harness;
+  const token = { isCancellationRequested: false };
+  const initializing = new CsvEditorProvider(context as any).resolveCustomTextEditor(document as any, panel as any, token as any);
+  if (options.cancelInitialization || options.closeDuringInitialization) {
+    token.isCancellationRequested = !!options.cancelInitialization;
+    document.isClosed = !!options.closeDuringInitialization;
+    panel.dispose();
+  }
+  await initializing;
+  controller = CsvEditorProvider.currentActive;
+  return harness;
+}
+
+export function createWebviewDom(html: string) {
+  const dom = new JSDOM(html, { runScripts: 'outside-only', pretendToBeVisual: true });
+  const { window } = dom;
+  const messages: any[] = [];
+  let state: unknown = {};
+  window.acquireVsCodeApi = () => ({
+    postMessage: (message: unknown) => messages.push(message),
+    getState: () => state,
+    setState: (nextState: unknown) => { state = nextState; }
+  });
+  window.HTMLElement.prototype.scrollIntoView = () => {};
+  // JSDOM has no paint hit testing. Interaction tests may supply cell geometry;
+  // use those rectangles unless a scenario installs its own occlusion model.
+  window.document.elementFromPoint = (x: number, y: number) =>
+    Array.from(window.document.querySelectorAll('td, th')).reverse().find((cell: any) => {
+      const rect = cell.getBoundingClientRect();
+      return rect.width > 0 && rect.height > 0 && x >= rect.left && x <= rect.right && y >= rect.top && y <= rect.bottom;
+    }) ?? null;
+  window.IntersectionObserver = class { observe() {} disconnect() {} };
+  const source = fs.readFileSync(path.join(process.cwd(), 'media', 'main.js'), 'utf8');
+  const freezeSource = fs.readFileSync(path.join(process.cwd(), 'media', 'frozen-panes.js'), 'utf8');
+  window.eval(freezeSource);
+  window.eval(fs.readFileSync(path.join(process.cwd(), 'media', 'column-filters.js'), 'utf8'));
+  window.eval(`${source}\nwindow.editingTestApi = { editCell, setSingleSelection, selectRange, selectFullRowRange };`);
+  return {
+    window, messages,
+    state: () => state,
+    close() { window.close(); },
+    cell(row = 1, col = 0) {
+      return window.document.querySelector(`[data-row="${row}"][data-col="${col}"]`);
+    },
+    start(cell: any) { window.editingTestApi.setSingleSelection(cell); window.editingTestApi.editCell(cell); },
+    key(key: string, options: Record<string, unknown> = {}) {
+      window.document.activeElement.dispatchEvent(new window.KeyboardEvent('keydown', { key, bubbles: true, cancelable: true, ...options }));
+    },
+    type(value: string) {
+      const selection = window.getSelection();
+      const range = selection.getRangeAt(0);
+      range.deleteContents();
+      const node = window.document.createTextNode(value);
+      range.insertNode(node);
+      range.setStartAfter(node);
+      range.collapse(true);
+      selection.removeAllRanges();
+      selection.addRange(range);
+    },
+    caret(node: any, offset: number) {
+      const range = window.document.createRange();
+      range.setStart(node, offset);
+      range.collapse(true);
+      const selection = window.getSelection();
+      selection.removeAllRanges();
+      selection.addRange(range);
+    }
+  };
+}
+
+export async function flushViewCommits(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>): Promise<void> {
+  for (let round = 0; round < 10; round++) {
+    const requestId = host.pendingDraftRequestId;
+    if (requestId === undefined) { return; }
+    const request = host.messages.find(message => message.type === 'prepareViewRefresh' && message.requestId === requestId);
+    if (!request) { throw new Error('Missing prepare message'); }
+    const cursor = view.messages.length;
+    view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+    await Promise.all(view.messages.slice(cursor).map(message => host.receive(message)));
+  }
+  throw new Error('View commit did not settle');
+}
diff --git a/src/test/edit-integrity.test.ts b/src/test/edit-integrity.test.ts
new file mode 100644
index 0000000..755c07f
--- /dev/null
+++ b/src/test/edit-integrity.test.ts
@@ -0,0 +1,220 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+describe('Multiline editing preserves text', () => {
+  for (const separator of [',', '\t']) {
+    for (const header of [true, false]) {
+      it(`keeps repeated Shift+Enter lines on blur (${JSON.stringify(separator)}, header ${header})`, async () => {
+        const host = await createEditorHarness({ separator, header });
+        const view = createWebviewDom(host.panel.webview.html);
+        try {
+          const cell = view.cell();
+          view.start(cell);
+          for (const line of ['second', 'third', 'fourth']) {
+            view.key('Enter', { shiftKey: true });
+            view.type(line);
+          }
+          cell.blur();
+          const edit = view.messages.find(message => message.type === 'editCell');
+          assert.strictEqual(edit.value, 'one\nsecond\nthird\nfourth');
+          assert.strictEqual(cell.querySelector('[data-csv-newline-sentinel]'), null);
+          await host.receive(edit);
+          assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one\nsecond\nthird\nfourth', 'two']]);
+        } finally {
+          view.close();
+        }
+      });
+    }
+  }
+
+  it('inserts exactly one break in the middle and at the end after reopening an edit', async () => {
+    const host = await createEditorHarness({ rows: [['name'], ['first\nlast']] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const cell = view.cell();
+      view.start(cell);
+      view.caret(cell.firstChild, 5);
+      view.key('Enter', { shiftKey: true });
+      cell.blur();
+      view.start(cell);
+      view.key('Enter', { shiftKey: true });
+      view.type('final');
+      cell.blur();
+      assert.strictEqual(view.messages.filter(message => message.type === 'editCell').at(-1)?.value, 'first\n\nlast\nfinal');
+    } finally {
+      view.close();
+    }
+  });
+
+  it('starts Shift+Enter from selection without a delayed caret moving after the placeholder', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const cell = view.cell();
+      view.window.editingTestApi.setSingleSelection(cell);
+      view.key('Enter', { shiftKey: true });
+      await new Promise(resolve => setTimeout(resolve, 20));
+      const selection = view.window.getSelection();
+      assert.strictEqual(selection.anchorNode, cell);
+      assert.strictEqual(cell.childNodes[selection.anchorOffset].nodeName, 'BR');
+      view.type('second');
+      cell.blur();
+      assert.strictEqual(view.messages.find(message => message.type === 'editCell').value, 'one\nsecond');
+    } finally {
+      view.close();
+    }
+  });
+
+  it('commits the full multiline value before a save message', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell());
+      view.key('Enter', { shiftKey: true });
+      view.type('second');
+      view.key('s', { ctrlKey: true });
+      const operations = view.messages.filter(message => message.type === 'editCell' || message.type === 'save');
+      assert.deepStrictEqual(operations.map(message => message.type), ['editCell', 'save']);
+      await Promise.all(operations.map(message => host.receive(message)));
+      assert.strictEqual(host.diskText, host.document.getText());
+      assert.strictEqual(host.rows()[1][0], 'one\nsecond');
+    } finally {
+      view.close();
+    }
+  });
+
+  it('does not replace an active edit with an earlier update acknowledgment', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const cell = view.cell();
+      view.start(cell);
+      view.type(' changed');
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: {
+        type: 'updateCell', row: 1, col: 0, value: 'old', rendered: 'old'
+      } }));
+      cell.blur();
+      assert.strictEqual(view.messages.find(message => message.type === 'editCell').value, 'one changed');
+    } finally {
+      view.close();
+    }
+  });
+
+  for (const leave of ['window blur', 'hidden document']) {
+    it(`commits an active multiline edit on ${leave}`, async () => {
+      const host = await createEditorHarness();
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell());
+        view.key('Enter', { shiftKey: true });
+        view.type('second');
+        if (leave === 'window blur') {
+          view.window.dispatchEvent(new view.window.Event('blur'));
+        } else {
+          Object.defineProperty(view.window.document, 'visibilityState', { value: 'hidden' });
+          view.window.document.dispatchEvent(new view.window.Event('visibilitychange'));
+        }
+        assert.strictEqual(view.messages.find(message => message.type === 'editCell').value, 'one\nsecond');
+      } finally {
+        view.close();
+      }
+    });
+  }
+
+  it('restores the original multiline value when cancelling an edit', async () => {
+    const host = await createEditorHarness({ rows: [['name'], ['first\nlast']] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell());
+      view.type(' changed');
+      view.key('Escape');
+      assert.strictEqual(view.messages.find(message => message.type === 'editCell').value, 'first\nlast');
+    } finally {
+      view.close();
+    }
+  });
+});
+
+describe('Document operations use current unsaved contents', () => {
+  it('native Save waits for a pending blur edit', async () => {
+    const host = await createEditorHarness();
+    host.deferEdits();
+    const edit = host.receive({ type: 'editCell', row: 1, col: 0, value: 'one\nsecond' });
+    await new Promise(resolve => setImmediate(resolve));
+    const save = host.document.save();
+    host.releaseEdit();
+    await Promise.all([edit, save]);
+    assert.ok(host.diskText.includes('second'));
+  });
+
+  it('waits for a pending edit before saving and applying the next edit', async () => {
+    const host = await createEditorHarness();
+    host.deferEdits();
+    const edit = host.receive({ type: 'editCell', row: 1, col: 0, value: 'one\nsecond' });
+    const save = host.receive({ type: 'save' });
+    const nextEdit = host.receive({ type: 'editCell', row: 1, col: 1, value: 'next' });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.strictEqual(host.pendingEdits, 1);
+    assert.ok(!host.diskText.includes('second'));
+    host.releaseEdit();
+    await edit;
+    await save;
+    assert.ok(host.diskText.includes('second'));
+    await new Promise(resolve => setImmediate(resolve));
+    assert.strictEqual(host.pendingEdits, 1);
+    host.releaseEdit();
+    await nextEdit;
+    assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one\nsecond', 'next']]);
+  });
+
+  for (const separator of [',', '\t']) {
+    for (const header of [true, false]) {
+      it(`inserts rows after a pending multiline edit (${JSON.stringify(separator)}, header ${header})`, async () => {
+        const host = await createEditorHarness({ separator, header });
+        const edit = host.receive({ type: 'editCell', row: 1, col: 0, value: 'one\nsecond' });
+        const insert = host.receive({ type: 'insertRow', index: 2 });
+        const fill = host.receive({ type: 'editCell', row: 2, col: 0, value: 'new' });
+        await Promise.all([edit, insert, fill]);
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one\nsecond', 'two'], ['new', '']]);
+      });
+    }
+  }
+
+  it('rebuilds a hidden remote webview from dirty contents and supplies current later chunks', async () => {
+    const rows = [['name', 'value'], ...Array.from({ length: 1100 }, (_, index) => [`row-${index}`, 'old'])];
+    const host = await createEditorHarness({ rows, remote: true });
+    const originalHtml = host.panel.webview.html;
+    await host.receive({ type: 'editCell', row: 1, col: 0, value: 'unsaved-first' });
+    await host.receive({ type: 'editCell', row: 1050, col: 1, value: 'unsaved-later' });
+    assert.strictEqual(host.panel.webview.html, originalHtml);
+    await host.view(false, false);
+    await host.view(true, true);
+    assert.ok(host.panel.webview.html.includes('unsaved-first'));
+    assert.ok(!host.diskText.includes('unsaved'));
+    const current = createWebviewDom(host.panel.webview.html);
+    try {
+      const metadata = JSON.parse(current.window.document.getElementById('__csvFilters').textContent);
+      await host.receive({ type: 'requestChunk', start: 1001, requestId: 1, filterEpoch: 0, session: metadata.session });
+      assert.ok(host.messages.find(message => message.type === 'chunkData').html.includes('unsaved-later'));
+    } finally { current.close(); }
+  });
+
+  it('keeps one virtual row and ignores an empty edit on it after multiline editing', async () => {
+    const host = await createEditorHarness();
+    await host.receive({ type: 'editCell', row: 1, col: 0, value: 'one\nsecond' });
+    await host.receive({ type: 'editCell', row: 2, col: 0, value: '' });
+    await host.view(false, false);
+    await host.view(true, true);
+    assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one\nsecond', 'two']]);
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const dataRows = view.window.document.querySelectorAll('tbody tr');
+      assert.strictEqual(dataRows.length, 2);
+      assert.strictEqual(view.cell(2, 0).textContent, '');
+      assert.strictEqual(view.cell(3, 0), null);
+    } finally {
+      view.close();
+    }
+  });
+});
diff --git a/src/test/editor-associations.test.ts b/src/test/editor-associations.test.ts
new file mode 100644
index 0000000..3541a53
--- /dev/null
+++ b/src/test/editor-associations.test.ts
@@ -0,0 +1,447 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { CsvEditorAssociationRouting, csvEditorSelectors, exactFileEditorPattern } from '../editor-associations';
+
+type MapValue = Record<string, string> | undefined;
+const clone = <T>(value: T): T => value === undefined ? value : JSON.parse(JSON.stringify(value));
+function fixture(options: { global?: MapValue; workspace?: MapValue; globalEnabled?: boolean; workspaceEnabled?: boolean; hasWorkspace?: boolean; defaults?: MapValue } = {}) {
+  const data = {
+    global: clone(options.global), workspace: clone(options.workspace),
+    globalEnabled: options.globalEnabled, workspaceEnabled: options.workspaceEnabled,
+    storeAfterWait: false, fail: false, ignoreWrite: false, policy: undefined as MapValue, beforeStorage: undefined as (() => Promise<void>) | undefined, beforeWrite: undefined as (() => Promise<void>) | undefined,
+    writes: [] as Array<{ target: number; value: MapValue }>, storageWrites: 0
+  };
+  const globalValues = new Map<string, unknown>(), workspaceValues = new Map<string, unknown>();
+  const store = (values: Map<string, unknown>) => ({
+    get: (key: string) => clone(values.get(key)),
+    keys: () => [...values.keys()].filter(key => values.get(key) !== undefined),
+    update: async (key: string, value: unknown) => { data.storageWrites++; if (!data.storeAfterWait) { values.set(key, clone(value)); } await data.beforeStorage?.(); if (data.storeAfterWait) { values.set(key, clone(value)); } }
+  });
+  const context = { globalState: store(globalValues), workspaceState: store(workspaceValues) } as any;
+  const api = {
+    ConfigurationTarget: { Global: 1, Workspace: 2 },
+    workspace: {
+      workspaceFolders: options.hasWorkspace === false ? undefined : [{}],
+      workspaceFile: undefined,
+      getConfiguration: (section: string) => section === 'csv' ? {
+        get: () => data.workspaceEnabled ?? data.globalEnabled ?? true,
+        inspect: () => ({ defaultValue: true, globalValue: data.globalEnabled, workspaceValue: data.workspaceEnabled })
+      } : {
+        inspect: () => ({ defaultValue: clone(options.defaults), globalValue: clone(data.global), workspaceValue: clone(data.workspace) }),
+        get: () => clone(data.policy ?? { ...(options.defaults || {}), ...(data.global || {}), ...(data.workspace || {}) }),
+        update: async (_key: string, value: MapValue, target: number) => {
+          await data.beforeWrite?.();
+          if (data.fail) { throw new Error('settings are read-only'); }
+          data.writes.push({ target, value: clone(value) });
+          if (!data.ignoreWrite) { if (target === 1) { data.global = clone(value); } else { data.workspace = clone(value); } }
+        }
+      }
+    }
+  } as any;
+  return { data, context, api, globalValues, workspaceValues, manager: () => new CsvEditorAssociationRouting(context, api) };
+}
+const native = () => Object.fromEntries(csvEditorSelectors.map(pattern => [pattern, 'default']));
+
+describe('Reversible disabled CSV editor associations', () => {
+  it('routes all four selectors and more-specific CSV choices natively while preserving other editors', async () => {
+    const original = { '**/special.csv': 'csv.editor', '*.tsv': 'another.editor', '*.tab': 'default', '*.md': 'markdown.preview' };
+    const h = fixture({ global: original, globalEnabled: false, hasWorkspace: false });
+    const routing = h.manager();
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, { ...native(), ...original, '**/special.csv': 'default', '*.csv': 'default', '*.psv': 'default' });
+    h.data.globalEnabled = true;
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, original);
+  });
+
+  for (const original of [undefined, {}]) {
+    it(`restores an originally ${original ? 'empty' : 'absent'} settings object exactly`, async () => {
+      const h = fixture({ global: original, globalEnabled: false, hasWorkspace: false });
+      const routing = h.manager();
+      await routing.synchronize();
+      assert.deepStrictEqual(h.data.global, native());
+      h.data.globalEnabled = true;
+      await routing.synchronize();
+      assert.deepStrictEqual(h.data.global, original);
+    });
+  }
+
+  it('limits workspace Off to workspace settings, including inherited specific CSV choices', async () => {
+    const global = { '**/data.csv': 'csv.editor', '*.tsv': 'external.tsv' };
+    const workspace = { '*.psv': 'external.psv' };
+    const h = fixture({ global, workspace, workspaceEnabled: false });
+    const routing = h.manager();
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, global);
+    assert.deepStrictEqual(h.data.workspace, { ...workspace, '*.csv': 'default', '*.tab': 'default', '**/data.csv': 'default' });
+    assert.ok(h.data.writes.every(write => write.target === 2));
+    h.data.workspaceEnabled = true;
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.workspace, workspace);
+  });
+
+  it('uses workspace On counterbindings only for this extension’s inherited global shadows', async () => {
+    const h = fixture({ globalEnabled: false, workspaceEnabled: true, global: { '**/data.csv': 'csv.editor', '*.tsv': 'external.tsv' }, workspace: { '*.psv': 'external.psv' } });
+    const routing = h.manager();
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, { '*.csv': 'default', '*.tab': 'default', '*.psv': 'default', '**/data.csv': 'default', '*.tsv': 'external.tsv' });
+    assert.deepStrictEqual(h.data.workspace, { '*.psv': 'external.psv', '*.csv': 'csv.editor', '*.tab': 'csv.editor', '**/data.csv': 'csv.editor' });
+    h.data.globalEnabled = true;
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, { '**/data.csv': 'csv.editor', '*.tsv': 'external.tsv' });
+    assert.deepStrictEqual(h.data.workspace, { '*.psv': 'external.psv' });
+  });
+
+  it('does not add redundant workspace overrides when native global routing is inherited', async () => {
+    const h = fixture({ globalEnabled: false });
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.global, native());
+    assert.strictEqual(h.data.workspace, undefined);
+  });
+
+  it('restores preferences after restart and preserves unrelated additions made while disabled', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false, global: { '*.csv': 'csv.editor' } });
+    await h.manager().synchronize();
+    h.data.global = { ...h.data.global, '*.json': 'external.json' };
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.global, { '*.csv': 'csv.editor', '*.json': 'external.json' });
+  });
+
+  it('does not overwrite an intervening choice of another editor or native editor on re-enable', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    const routing = h.manager();
+    await routing.synchronize();
+    h.data.global = { ...h.data.global, '*.csv': 'external.csv' };
+    await routing.synchronize();
+    h.data.globalEnabled = true;
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, { '*.csv': 'external.csv' });
+  });
+
+  it('preserves an intervening deletion or explicit CSV choice and reports the routing conflict', async () => {
+    for (const replacement of [undefined, 'csv.editor']) {
+      const h = fixture({ globalEnabled: false, hasWorkspace: false });
+      const routing = h.manager();
+      await routing.synchronize();
+      if (replacement === undefined) { delete h.data.global!['*.csv']; }
+      else { h.data.global!['*.csv'] = replacement; }
+      const current = clone(h.data.global);
+      await assert.rejects(routing.synchronize(), /preserved your changed editor associations/);
+      assert.deepStrictEqual(h.data.global, current);
+      h.data.globalEnabled = true;
+      await routing.synchronize();
+      assert.deepStrictEqual(h.data.global, replacement === undefined ? {} : { '*.csv': replacement });
+    }
+  });
+
+  it('fails clearly on a denied write and can retry without a poisoned ownership record', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    const routing = h.manager();
+    h.data.fail = true;
+    await assert.rejects(routing.synchronize(), /could not update global editor routing: settings are read-only/);
+    assert.strictEqual(h.data.global, undefined);
+    h.data.fail = false;
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, native());
+    h.data.globalEnabled = true;
+    await routing.synchronize();
+    assert.strictEqual(h.data.global, undefined);
+  });
+
+  it('stores recovery metadata before settings change and avoids repeated writes when synchronized', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    h.data.beforeWrite = async () => {
+      assert.ok([...h.globalValues.values()].some((value: any) => Object.keys(value?.state?.entries || {}).length === 4));
+    };
+    const routing = h.manager();
+    await routing.synchronize();
+    const writes = h.data.writes.length;
+    await routing.synchronize();
+    assert.strictEqual(h.data.writes.length, writes);
+  });
+  it('preserves blanket and more-specific external choices while converting specific CSV overrides', async () => {
+    for (const blanket of ['*', '**/*', '*.*']) {
+      const original = { [blanket]: 'external.editor', '**/special.csv': 'csv.editor', '/path/*.csv': 'external.path' };
+      const h = fixture({ global: original, globalEnabled: false, hasWorkspace: false });
+      await h.manager().synchronize();
+      assert.deepStrictEqual(h.data.global, { ...original, '**/special.csv': 'default' });
+      h.data.globalEnabled = true;
+      await h.manager().synchronize();
+      assert.deepStrictEqual(h.data.global, original);
+    }
+    const h = fixture({ global: { 'a*': 'external.editor' }, globalEnabled: false, hasWorkspace: false });
+    await assert.rejects(h.manager().synchronize(), /preserved overlapping editor associations/);
+    assert.deepStrictEqual(h.data.global, { 'a*': 'external.editor' });
+  });
+
+  it('handles inherited blanket choices and more-specific CSV associations without global writes', async () => {
+    const global = { '**/*': 'external.editor', '**/special.csv': 'csv.editor' };
+    const h = fixture({ global, workspaceEnabled: false });
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.global, global);
+    assert.deepStrictEqual(h.data.workspace, { '**/special.csv': 'default' });
+  });
+
+  it('shadows contributed default CSV associations and detects policy-valued routing', async () => {
+    const h = fixture({ defaults: { '**/special.csv': 'csv.editor', '*.tsv': 'external.editor' }, globalEnabled: false, hasWorkspace: false });
+    await h.manager().synchronize();
+    assert.strictEqual(h.data.global!['**/special.csv'], 'default');
+    assert.strictEqual(h.data.global!['*.tsv'], undefined);
+    h.data.policy = { '*.csv': 'csv.editor' };
+    await assert.rejects(h.manager().synchronize(), /policy or another settings scope/);
+  });
+
+  it('detects an ignored settings write and can recover without ownership debris', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    h.data.ignoreWrite = true;
+    await assert.rejects(h.manager().synchronize(), /did not apply the routing preferences/);
+    assert.strictEqual(h.data.global, undefined);
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+    h.data.ignoreWrite = false;
+    await h.manager().synchronize();
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.strictEqual(h.data.global, undefined);
+    assert.ok([...h.globalValues.values()].every(value => value === undefined), 'final state removes provisional ownership');
+  });
+
+  it('does not write settings after disposal during recovery metadata persistence', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    const routing = h.manager();
+    h.data.beforeStorage = async () => { h.data.beforeStorage = undefined; routing.dispose(); };
+    await routing.synchronize();
+    assert.strictEqual(h.data.writes.length, 0);
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+  });
+
+  it('finishes recovery ownership if disposed during an in-flight settings write', async () => {
+    const h = fixture({ globalEnabled: false, workspaceEnabled: true });
+    const routing = h.manager();
+    h.data.beforeWrite = async () => { routing.dispose(); };
+    await routing.synchronize();
+    assert.deepStrictEqual(h.data.global, native());
+    assert.strictEqual(h.data.workspace, undefined);
+    h.data.beforeWrite = undefined;
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.strictEqual(h.data.global, undefined);
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+  });
+
+  it('does not overwrite a user map changed while recovery data was being persisted', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    h.data.beforeStorage = async () => { h.data.beforeStorage = undefined; h.data.global = { '*.csv': 'external.editor' }; };
+    await assert.rejects(h.manager().synchronize(), /changed while CSV was updating/);
+    assert.deepStrictEqual(h.data.global, { '*.csv': 'external.editor' });
+  });
+
+  it('keeps recovery when another window has already installed the same temporary routing', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    h.data.storeAfterWait = true;
+    let releaseFirst!: () => void, releaseSecond!: () => void;
+    let count = 0;
+    h.data.beforeStorage = async () => {
+      const operation = ++count;
+      if (operation === 1) { await new Promise<void>(resolve => { releaseFirst = resolve; }); }
+      if (operation === 2) { await new Promise<void>(resolve => { releaseSecond = resolve; }); }
+    };
+    const first = h.manager().synchronize();
+    while (!releaseFirst) { await new Promise(resolve => setImmediate(resolve)); }
+    const second = h.manager().synchronize();
+    while (!releaseSecond) { await new Promise(resolve => setImmediate(resolve)); }
+    releaseFirst(); await first;
+    assert.deepStrictEqual(h.data.global, native());
+    releaseSecond(); await second;
+    assert.deepStrictEqual(h.data.global, native());
+    assert.strictEqual(h.data.writes.length, 1);
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.strictEqual(h.data.global, undefined, 'last window retains the original absence for restoration');
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+  });
+
+  for (const original of [undefined, 'csv.editor']) {
+    it(`does not let an older coalesced plan replace a newer user's ${original ? 'explicit CSV choice' : 'deletion'}`, async () => {
+      const h = fixture({ globalEnabled: false, hasWorkspace: false, global: original ? undefined : { '*.csv': 'csv.editor' } });
+      h.data.storeAfterWait = true;
+      let release!: () => void;
+      let held = false;
+      h.data.beforeStorage = async () => {
+        if (!held) { held = true; await new Promise<void>(resolve => { release = resolve; }); }
+      };
+      const pending = h.manager().synchronize();
+      while (!release) { await new Promise(resolve => setImmediate(resolve)); }
+      h.data.global = original ? { '*.csv': original } : undefined;
+      await h.manager().synchronize();
+      release(); await pending;
+      h.data.globalEnabled = true;
+      await h.manager().synchronize();
+      assert.deepStrictEqual(h.data.global, original ? { '*.csv': original } : undefined);
+      assert.ok([...h.globalValues.values()].every(value => value === undefined));
+    });
+  }
+
+  it('keeps a newer window’s extra original binding when a delayed older plan conflicts', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    h.data.storeAfterWait = true;
+    let release!: () => void;
+    let held = false;
+    h.data.beforeStorage = async () => {
+      if (!held) { held = true; await new Promise<void>(resolve => { release = resolve; }); }
+    };
+    const pending = h.manager().synchronize();
+    while (!release) { await new Promise(resolve => setImmediate(resolve)); }
+    h.data.global = { '**/special.csv': 'csv.editor' };
+    await h.manager().synchronize();
+    release(); await assert.rejects(pending, /changed while CSV was updating/);
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.global, { '**/special.csv': 'csv.editor' });
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+  });
+
+  it('durably relinquishes an observed user edit even when no settings write is necessary', async () => {
+    const h = fixture({ globalEnabled: false, hasWorkspace: false });
+    await h.manager().synchronize();
+    h.data.global!['*.csv'] = 'external.editor';
+    const writeCount = h.data.writes.length;
+    await h.manager().synchronize();
+    assert.strictEqual(h.data.writes.length, writeCount, 'external choice needs no preference mutation');
+    h.data.global!['*.csv'] = 'default';
+    await h.manager().synchronize();
+    h.data.globalEnabled = true;
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.global, { '*.csv': 'default' }, 'later user native choice remains on restart/re-enable');
+    assert.ok([...h.globalValues.values()].every(value => value === undefined));
+  });
+
+});
+
+
+const file = (path: string, fields: Partial<Record<string, string>> = {}) => ({ scheme: 'file', authority: '', query: '', fragment: '', path, ...fields } as any);
+describe('Continuing per-file Text view routing', () => {
+  it('uses literal scheme:path patterns and rejects URI identities the workbench cannot isolate', () => {
+    assert.strictEqual(exactFileEditorPattern(file('/one [x]*?{y}/check.csv')), 'file:/one [[]x[]][*][?][{]y[}]/check.csv');
+    for (const fields of [{ scheme: 'vscode-remote', authority: 'wsl+Ubuntu' }, { authority: 'server' }, { query: 'revision=1' }, { fragment: 'line50' }]) {
+      assert.strictEqual(exactFileEditorPattern(file('/check.csv', fields)), undefined);
+    }
+  });
+
+  it('keeps a workspace Text choice across synchronization, restart and Off→On', async () => {
+    const h = fixture(), uri = file('/one/check.csv'), pattern = exactFileEditorPattern(uri)!;
+    const text = await h.manager().prepareEditorSwitch(uri, 'default'); await text.commit();
+    assert.deepStrictEqual(h.data.workspace, { [pattern]: 'default' }); assert.strictEqual(h.data.global, undefined);
+    await h.manager().synchronize();
+    h.data.globalEnabled = false; await h.manager().synchronize();
+    h.data.globalEnabled = true; await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.workspace, { [pattern]: 'default' }); assert.strictEqual(h.data.global, undefined);
+    const table = await h.manager().prepareEditorSwitch(uri, 'csv.editor');
+    await table.rollback();
+    assert.deepStrictEqual(h.data.workspace, { [pattern]: 'default' }, 'cancelled Table does not change Text routing');
+    const successfulTable = await h.manager().prepareEditorSwitch(uri, 'csv.editor'); await successfulTable.commit();
+    assert.strictEqual(h.data.workspace, undefined); assert.ok([...h.workspaceValues.values()].every(value => value === undefined));
+  });
+
+  it('releases only one file while another Text choice remains, without resurrecting older journals', async () => {
+    const h = fixture(), a = file('/one/check.csv'), b = file('/two/check.csv');
+    await (await h.manager().prepareEditorSwitch(a, 'default')).commit();
+    await (await h.manager().prepareEditorSwitch(b, 'default')).commit();
+    await (await h.manager().prepareEditorSwitch(b, 'csv.editor')).commit();
+    await h.manager().synchronize();
+    assert.deepStrictEqual(h.data.workspace, { [exactFileEditorPattern(a)!]: 'default' });
+    await (await h.manager().prepareEditorSwitch(a, 'csv.editor')).commit();
+    assert.strictEqual(h.data.workspace, undefined);
+  });
+
+  for (const original of [undefined, {}]) {
+    it(`rolls a cancelled Text switch back to an originally ${original ? 'empty' : 'absent'} preference object`, async () => {
+      const h = fixture({ workspace: original }), uri = file('/one/check.tsv');
+      const transaction = await h.manager().prepareEditorSwitch(uri, 'default');
+      await transaction.rollback();
+      assert.deepStrictEqual(h.data.workspace, original);
+      assert.ok([...h.workspaceValues.values()].every(value => value === undefined));
+    });
+  }
+
+  it('preserves an unrelated concurrent preference and a user edit to the owned key on rollback/Table return', async () => {
+    const h = fixture(), uri = file('/one/check.csv'), pattern = exactFileEditorPattern(uri)!;
+    const transaction = await h.manager().prepareEditorSwitch(uri, 'default');
+    h.data.workspace!['*.md'] = 'markdown.preview';
+    h.data.workspace![pattern] = 'external.editor';
+    await transaction.rollback();
+    await (await h.manager().prepareEditorSwitch(uri, 'csv.editor')).commit();
+    assert.deepStrictEqual(h.data.workspace, { '*.md': 'markdown.preview', [pattern]: 'external.editor' });
+  });
+
+  it('restores an existing exact CSV choice and preserves a preexisting native or external choice', async () => {
+    const uri = file('/one/check.csv'), pattern = exactFileEditorPattern(uri)!;
+    for (const prior of ['csv.editor', 'default', 'external.editor']) {
+      const h = fixture({ workspace: { [pattern]: prior } });
+      const transaction = await h.manager().prepareEditorSwitch(uri, 'default');
+      assert.strictEqual(transaction.supported, prior !== 'external.editor');
+      await transaction.commit();
+      await (await h.manager().prepareEditorSwitch(uri, 'csv.editor')).commit();
+      assert.deepStrictEqual(h.data.workspace, { [pattern]: prior });
+    }
+  });
+
+  it('internally rolls back a provisional Text write when enablement changes during preparation', async () => {
+    const h = fixture(), uri = file('/one/check.csv');
+    h.data.beforeWrite = async () => { h.data.beforeWrite = undefined; h.data.globalEnabled = false; };
+    await assert.rejects(h.manager().prepareEditorSwitch(uri, 'default'), /routing changed while switching/);
+    assert.strictEqual(h.data.workspace, undefined);
+    assert.ok([...h.workspaceValues.values()].every(value => value === undefined));
+  });
+
+  it('internally rolls back a provisional Text write if disposed while it is applying', async () => {
+    const h = fixture(), uri = file('/one/check.csv'), manager = h.manager();
+    h.data.beforeWrite = async () => { h.data.beforeWrite = undefined; manager.dispose(); };
+    await assert.rejects(manager.prepareEditorSwitch(uri, 'default'), /routing changed while switching/);
+    assert.strictEqual(h.data.workspace, undefined);
+    assert.ok([...h.workspaceValues.values()].every(value => value === undefined));
+  });
+
+  it('does not leave ownership after denied or ignored provisional writes', async () => {
+    for (const failure of ['fail', 'ignoreWrite'] as const) {
+      const h = fixture(); h.data[failure] = true;
+      await assert.rejects(h.manager().prepareEditorSwitch(file('/one/check.csv'), 'default'));
+      assert.strictEqual(h.data.workspace, undefined);
+      assert.ok([...h.workspaceValues.values()].every(value => value === undefined));
+    }
+  });
+
+  it('leaves unsupported remote view switching available without changing any associations', async () => {
+    const h = fixture();
+    const transaction = await h.manager().prepareEditorSwitch(file('/one/check.csv', { scheme: 'vscode-remote', authority: 'wsl+Ubuntu' }), 'default');
+    assert.strictEqual(transaction.supported, false); assert.match(transaction.limitation!, /Turn CSV off/);
+    await transaction.commit(); await transaction.rollback();
+    assert.strictEqual(h.data.writes.length, 0);
+  });
+  it('does not shadow an inherited exact choice of another editor', async () => {
+    const uri = file('/one/check.csv'), pattern = exactFileEditorPattern(uri)!;
+    const h = fixture({ global: { [pattern]: 'external.editor' } });
+    const transaction = await h.manager().prepareEditorSwitch(uri, 'default');
+    assert.strictEqual(transaction.supported, false);
+    assert.strictEqual(h.data.workspace, undefined);
+    assert.deepStrictEqual(h.data.global, { [pattern]: 'external.editor' });
+  });
+
+  for (const observedBy of ['table', 'rollback']) {
+    for (const userValue of ['external.editor', undefined]) {
+      it(`durably relinquishes a user ${userValue ? 'editor change' : 'deletion'} observed by ${observedBy} before the user chooses native again`, async () => {
+        const h = fixture(), uri = file('/one/check.csv'), pattern = exactFileEditorPattern(uri)!;
+        const text = await h.manager().prepareEditorSwitch(uri, 'default'); await text.commit();
+        if (userValue === undefined) { delete h.data.workspace![pattern]; }
+        else { h.data.workspace![pattern] = userValue; }
+        if (observedBy === 'table') { await (await h.manager().prepareEditorSwitch(uri, 'csv.editor')).commit(); }
+        else { await text.rollback(); }
+        h.data.workspace![pattern] = 'default';
+        await h.manager().synchronize();
+        await (await h.manager().prepareEditorSwitch(uri, 'csv.editor')).commit();
+        assert.deepStrictEqual(h.data.workspace, { [pattern]: 'default' });
+      });
+    }
+  }
+
+});
diff --git a/src/test/editor-lifecycle.test.ts b/src/test/editor-lifecycle.test.ts
new file mode 100644
index 0000000..2d81a67
--- /dev/null
+++ b/src/test/editor-lifecycle.test.ts
@@ -0,0 +1,490 @@
+import assert from 'assert';
+import Module from 'module';
+import { beforeEach, describe, it } from 'node:test';
+
+class Uri {
+  constructor(public scheme: string, public authority: string, public path: string) {}
+  get fsPath() { return this.path; }
+  toString() { return `${this.scheme}://${this.authority}${this.path}`; }
+  with(changes: { path: string }) {
+    return new Uri(this.scheme, this.authority, changes.path);
+  }
+}
+
+const state = {
+  enabled: true,
+  activeGroup: undefined as any,
+  groups: [] as any[],
+  focusListeners: new Set<(...args: any[]) => void>(),
+  shown: [] as any[],
+  visibleTextEditors: [] as any[],
+  commands: [] as any[][],
+  stat: async (): Promise<{ size: number }> => ({ size: 12 }),
+  executeCommand: async (..._args: any[]): Promise<void> => {},
+  documentListeners: new Set<(...args: any[]) => void>()
+};
+const vscode = {
+  Uri,
+  ColorThemeKind: { Dark: 1 },
+  window: {
+    activeColorTheme: { kind: 1 },
+    tabGroups: { get all() { return state.groups; }, get activeTabGroup() { return state.activeGroup; } },
+    onDidChangeActiveTextEditor: (callback: (...args: any[]) => void) => {
+      state.focusListeners.add(callback);
+      return { dispose: () => state.focusListeners.delete(callback) };
+    },
+    showTextDocument: async (document: any, options: any) => {
+      state.shown.push({ document, options });
+      const editor = { document, viewColumn: options.viewColumn };
+      state.visibleTextEditors = [editor];
+      state.activeGroup = { viewColumn: options.viewColumn, activeTab: { input: { uri: document.uri } } };
+      state.focusListeners.forEach(callback => callback(editor));
+      return editor;
+    },
+    get visibleTextEditors() { return state.visibleTextEditors; }
+  },
+  workspace: {
+    getConfiguration: () => ({
+      get: (key: string, fallback: any) => key === 'enabled' ? state.enabled : fallback
+    }),
+    fs: { stat: () => state.stat() },
+    onWillSaveTextDocument: () => ({ dispose() {} }),
+    onDidChangeTextDocument: (callback: (...args: any[]) => void) => {
+      state.documentListeners.add(callback);
+      return { dispose: () => state.documentListeners.delete(callback) };
+    }
+  },
+  commands: {
+    executeCommand: async (...args: any[]) => {
+      state.commands.push(args);
+      await state.executeCommand(...args);
+    }
+  }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return vscode;
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+const context = {
+  extensionUri: new Uri('vscode-remote', 'wsl+Ubuntu', '/home/user/.vscode-server/extensions/csv'),
+  // A path alone cannot carry the remote authority of extensionUri.
+  extensionPath: '/home/user/.vscode-server/extensions/csv',
+  workspaceState: { get: (_key: string, fallback: any) => fallback }
+};
+
+function makePanel(viewColumn = 1) {
+  const disposeListeners: Array<() => void> = [];
+  const viewStateListeners: Array<(event: any) => void> = [];
+  const messages: any[] = [];
+  const resources: Uri[] = [];
+  let html = '';
+  let disposed = false;
+  let receiveMessage: (message: any) => Promise<void> = async () => {};
+  const panel = {
+    active: true,
+    visible: true,
+    viewColumn,
+    title: 'test.csv',
+    get disposed() { return disposed; },
+    webview: {
+      options: {} as { localResourceRoots?: Uri[] },
+      cspSource: 'vscode-webview:',
+      get html() { return html; },
+      set html(value: string) {
+        assert.strictEqual(disposed, false, 'must not render into a disposed webview');
+        html = value;
+      },
+      asWebviewUri: (uri: Uri) => { resources.push(uri); return uri; },
+      postMessage: (message: any) => { messages.push(message); return Promise.resolve(true); },
+      onDidReceiveMessage: (listener: typeof receiveMessage) => { receiveMessage = listener; return { dispose() {} }; }
+    },
+    onDidDispose: (callback: () => void) => {
+      disposeListeners.push(callback);
+      return { dispose() {} };
+    },
+    onDidChangeViewState: (callback: (event: any) => void) => {
+      viewStateListeners.push(callback);
+      return { dispose() {} };
+    },
+    dispose: () => {
+      if (!disposed) {
+        disposed = true;
+        disposeListeners.forEach(callback => callback());
+      }
+    },
+    receive: (message: any) => receiveMessage(message),
+    setActive: (active: boolean) => {
+      panel.active = active;
+      viewStateListeners.forEach(callback => callback({ webviewPanel: panel }));
+    }
+  };
+  return { panel, messages, resources };
+}
+
+function makeDocument(uri: Uri, text = 'name,value\nfirst,1') {
+  return { uri, version: 1, getText: () => text };
+}
+
+async function resolve(document: ReturnType<typeof makeDocument>, panel: ReturnType<typeof makePanel>['panel'], token = { isCancellationRequested: false }) {
+  const provider = new CsvEditorProvider(context as any);
+  await provider.resolveCustomTextEditor(document as any, panel as any, token as any);
+}
+
+beforeEach(() => {
+  state.enabled = true;
+  state.activeGroup = undefined;
+  state.groups = [];
+  state.focusListeners.clear();
+  state.shown = [];
+  state.visibleTextEditors = [];
+  state.commands = [];
+  state.stat = async () => ({ size: 12 });
+  state.executeCommand = async () => {};
+  state.documentListeners.clear();
+  CsvEditorProvider.editors = [];
+  CsvEditorProvider.currentActive = undefined;
+});
+
+describe('CSV editor lifecycle and native text handoff', () => {
+  for (const [extension, text, separatorCode] of [
+    ['csv', 'name,value\nfirst,1', 44],
+    ['tsv', 'name\tvalue\nfirst\t1', 9]
+  ] as const) {
+    for (const scheme of ['file', 'vscode-remote']) {
+      it(`preserves the ${scheme} ${extension.toUpperCase()} controller and resources across tab changes`, async () => {
+        const uri = new Uri(scheme, scheme === 'file' ? '' : 'wsl+Ubuntu', `/workspace/data.${extension}`);
+        const document = makeDocument(uri, text);
+        const { panel, messages, resources } = makePanel();
+        await resolve(document, panel);
+        assert.ok(panel.webview.html.includes(`data-sepcode="${separatorCode}"`));
+        assert.strictEqual(CsvEditorProvider.editors.length, 1);
+        assert.strictEqual(state.documentListeners.size, 1);
+        const controller = CsvEditorProvider.getActiveProvider();
+        assert.ok(controller);
+
+        panel.setActive(false);
+        assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+        panel.setActive(true);
+        assert.strictEqual(CsvEditorProvider.getActiveProvider(), controller);
+        assert.deepStrictEqual(messages[messages.length - 1], { type: 'focus' });
+        assert.strictEqual(state.commands.length, 0, 'tab changes must not reopen or replace editors');
+        assert.strictEqual(CsvEditorProvider.editors.length, 1);
+        assert.strictEqual(resources[0].toString(), `${context.extensionUri}/media/main.js`);
+        assert.deepStrictEqual(resources.map(resource => resource.path.split('/').pop()).sort(), ['column-filters.js', 'frozen-panes.js', 'high-contrast.css', 'main.js']);
+        assert.ok(resources.every(resource => resource.scheme === context.extensionUri.scheme && resource.authority === context.extensionUri.authority));
+        assert.strictEqual(panel.webview.options.localResourceRoots?.[0].toString(), `${context.extensionUri}/media`);
+        panel.dispose();
+        assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+        assert.strictEqual(state.documentListeners.size, 0);
+      });
+    }
+  }
+
+  it('does not register or render a preview closed during a slow remote file check', async () => {
+    let finishStat!: (value: { size: number }) => void;
+    state.stat = () => new Promise(resolveStat => { finishStat = resolveStat; });
+    const { panel } = makePanel();
+    const pending = resolve(makeDocument(new Uri('vscode-remote', 'wsl+Ubuntu', '/data.csv')), panel);
+    panel.dispose();
+    finishStat({ size: 12 });
+    await pending;
+    assert.strictEqual(panel.webview.html, '');
+    assert.strictEqual(CsvEditorProvider.editors.length, 0);
+    assert.strictEqual(state.documentListeners.size, 0);
+    assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+
+    state.stat = async () => ({ size: 12 });
+    const replacement = makePanel();
+    await resolve(makeDocument(new Uri('vscode-remote', 'wsl+Ubuntu', '/data.csv')), replacement.panel);
+    assert.ok(replacement.panel.webview.html.includes('<table>'));
+    assert.strictEqual(CsvEditorProvider.editors.length, 1);
+    assert.ok(CsvEditorProvider.getActiveProvider());
+    replacement.panel.dispose();
+  });
+
+  it('honors cancellation during asynchronous initialization', async () => {
+    let finishStat!: (value: { size: number }) => void;
+    state.stat = () => new Promise(resolveStat => { finishStat = resolveStat; });
+    const { panel } = makePanel();
+    const token = { isCancellationRequested: false };
+    const pending = resolve(makeDocument(new Uri('file', '', '/data.csv')), panel, token);
+    token.isCancellationRequested = true;
+    finishStat({ size: 12 });
+    await pending;
+    assert.strictEqual(panel.webview.html, '');
+    assert.strictEqual(CsvEditorProvider.editors.length, 0);
+    assert.strictEqual(state.documentListeners.size, 0);
+  });
+
+  for (const extension of ['csv', 'tsv']) {
+    it(`keeps an already visible ${extension.toUpperCase()} search destination when disabled`, async () => {
+      state.enabled = false;
+      const document = makeDocument(new Uri('vscode-remote', 'wsl+Ubuntu', `/data.${extension}`));
+      const selection = { start: { line: 87, character: 4 }, end: { line: 87, character: 10 } };
+      const editor = { document, viewColumn: 2, selection };
+      state.visibleTextEditors.push(editor);
+      const { panel } = makePanel(2);
+      await resolve(document, panel);
+      assert.strictEqual(state.commands.length, 0, 'must not reopen a text editor already at the requested result');
+      assert.strictEqual(editor.selection, selection);
+      assert.strictEqual(panel.disposed, true);
+      assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+    });
+  }
+
+  it('reopens the correct group once when disabling with no visible text editor', async () => {
+    const document = makeDocument(new Uri('file', '', '/data.csv'));
+    const { panel, messages } = makePanel(2);
+    await resolve(document, panel);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    panel.setActive(false);
+    let finishOpen!: () => void;
+    state.executeCommand = () => new Promise(resolveOpen => { finishOpen = resolveOpen; });
+    state.enabled = false;
+    controller.refresh();
+    controller.refresh();
+    assert.strictEqual(state.commands.length, 0, 'disable waits for the current webview draft');
+    const request = messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(panel.webview.html)![1]);
+    const completing = panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    await new Promise(resolveTurn => setImmediate(resolveTurn));
+    assert.deepStrictEqual(state.commands, [[
+      'vscode.openWith', document.uri, 'default', { viewColumn: 2, preserveFocus: true }
+    ]]);
+    finishOpen();
+    await completing;
+    controller.refresh();
+    assert.strictEqual(state.commands.length, 1, 'a disposed controller cannot reopen the file later');
+    assert.strictEqual(panel.disposed, true);
+    assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+  });
+
+  it('retains an initialized table when On overtakes an already-started native handoff', async () => {
+    const document = makeDocument(new Uri('file', '', '/data.csv'));
+    const { panel, messages } = makePanel(2);
+    await resolve(document, panel);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    const html = panel.webview.html;
+    let finishOpen!: () => void;
+    state.executeCommand = () => new Promise(resolveOpen => { finishOpen = resolveOpen; });
+    state.enabled = false;
+    controller.refresh();
+    const request = messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(html)![1]);
+    const completing = panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    await new Promise(resolveTurn => setImmediate(resolveTurn));
+    state.enabled = true;
+    controller.refresh();
+    assert.strictEqual(panel.webview.html, html, 'On does not replace live DOM during a native handoff');
+    finishOpen();
+    await completing;
+    assert.strictEqual(panel.disposed, false);
+    assert.ok(CsvEditorProvider.editors.includes(controller));
+    assert.strictEqual(state.focusListeners.size, 0);
+    panel.dispose();
+  });
+
+  it('restores the current untitled owner after an inactive saved-file handoff takes its group', async () => {
+    const document = makeDocument(new Uri('file', '', '/previous.csv'));
+    const { panel, messages } = makePanel(2);
+    await resolve(document, panel);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    panel.setActive(false);
+    const owner = makeDocument(new Uri('untitled', '', '/new.tsv'), 'name\tvalue\nlatest\tdraft');
+    state.visibleTextEditors = [{ document: owner, viewColumn: 2 }];
+    const ownerTab = { input: { uri: owner.uri } };
+    const group = { viewColumn: 2, activeTab: ownerTab, tabs: [ownerTab] };
+    state.activeGroup = group; state.groups = [group];
+    state.executeCommand = async () => {
+      // Workbench publication can occur after the active owner was captured.
+      const nativeTab = { input: { uri: document.uri } };
+      group.tabs.push(nativeTab); group.activeTab = nativeTab;
+      state.focusListeners.forEach(callback => callback({ document, viewColumn: 2 }));
+    };
+    state.enabled = false;
+    controller.refresh();
+    const request = messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(panel.webview.html)![1]);
+    await panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    assert.strictEqual(state.shown.length, 1);
+    assert.strictEqual(state.shown[0].document, owner);
+    assert.strictEqual(state.activeGroup.activeTab.input.uri, owner.uri);
+    assert.strictEqual(panel.disposed, true);
+    assert.strictEqual(state.focusListeners.size, 0);
+  });
+
+  it('restores the native untitled owner after its captured grid closes before another handoff settles', async () => {
+    const saved = makeDocument(new Uri('file', '', '/previous.csv'));
+    const previous = makePanel(2);
+    await resolve(saved, previous.panel);
+    const savedController = CsvEditorProvider.getActiveProvider()!;
+    previous.panel.setActive(false);
+    const document = { ...makeDocument(new Uri('untitled', '', '/new.tsv'), 'name\tvalue\nlatest\tdraft'), languageId: 'tsv' };
+    const current = makePanel(2);
+    await resolve(document, current.panel);
+    const nativeTab = { input: { uri: document.uri } };
+    const gridTab: any = { input: { viewType: 'mainThreadWebview-csv.untitledEditor' } };
+    const group = { viewColumn: 2, tabs: [nativeTab, gridTab], activeTab: gridTab };
+    state.activeGroup = group; state.groups = [group];
+    state.visibleTextEditors = [];
+    state.executeCommand = async () => {
+      current.panel.dispose();
+      const target = { input: { uri: saved.uri } };
+      group.tabs = [nativeTab, target]; group.activeTab = target;
+      state.focusListeners.forEach(callback => callback({ document: saved, viewColumn: 2 }));
+    };
+    state.enabled = false;
+    savedController.refresh();
+    const request = previous.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(previous.panel.webview.html)![1]);
+    await previous.panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    assert.strictEqual(state.shown.length, 1);
+    assert.strictEqual(state.shown[0].document, document);
+    assert.strictEqual(document.getText(), 'name\tvalue\nlatest\tdraft');
+    assert.strictEqual(previous.panel.disposed, true);
+  });
+
+  it('restores the current saved owner after its own native handoff settles before an older one', async () => {
+    const previousDocument = makeDocument(new Uri('file', '', '/previous.csv'));
+    const previous = makePanel(2);
+    await resolve(previousDocument, previous.panel);
+    const previousController = CsvEditorProvider.getActiveProvider()!;
+    previous.panel.setActive(false);
+    const owner = makeDocument(new Uri('file', '', '/current.tsv'), 'name\tvalue\ncurrent\tdraft');
+    const current = makePanel(2);
+    await resolve(owner, current.panel);
+    const gridTab: any = { input: { uri: owner.uri, viewType: 'csv.editor' } };
+    const group = { viewColumn: 2, tabs: [gridTab], activeTab: gridTab };
+    state.activeGroup = group; state.groups = [group];
+    state.executeCommand = async () => {
+      current.panel.dispose();
+      const nativeOwner = { input: { uri: owner.uri } };
+      const previousTarget = { input: { uri: previousDocument.uri } };
+      group.tabs = [nativeOwner, previousTarget]; group.activeTab = previousTarget;
+      state.focusListeners.forEach(callback => callback({ document: previousDocument, viewColumn: 2 }));
+    };
+    state.enabled = false;
+    previousController.refresh();
+    const request = previous.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(previous.panel.webview.html)![1]);
+    await previous.panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    assert.strictEqual(state.shown.length, 1);
+    assert.strictEqual(state.shown[0].document, owner);
+    assert.strictEqual(owner.getText(), 'name\tvalue\ncurrent\tdraft');
+  });
+
+  it('does not restore the old group after its captured live grid moves elsewhere', async () => {
+    const previousDocument = makeDocument(new Uri('file', '', '/previous.csv'));
+    const previous = makePanel(2);
+    await resolve(previousDocument, previous.panel);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    previous.panel.setActive(false);
+    const owner = makeDocument(new Uri('file', '', '/current.tsv'));
+    const current = makePanel(2);
+    await resolve(owner, current.panel);
+    const nativeTab: any = { input: { uri: owner.uri } };
+    const gridTab: any = { input: { uri: owner.uri, viewType: 'csv.editor' } };
+    const group = { viewColumn: 2, tabs: [nativeTab, gridTab], activeTab: gridTab };
+    state.activeGroup = group; state.groups = [group];
+    state.executeCommand = async () => {
+      current.panel.viewColumn = 3;
+      current.panel.setActive(false);
+      const target: any = { input: { uri: previousDocument.uri } };
+      group.tabs = [nativeTab, target]; group.activeTab = target;
+      state.groups.push({ viewColumn: 3, tabs: [gridTab], activeTab: gridTab });
+      state.focusListeners.forEach(callback => callback({ document: previousDocument, viewColumn: 2 }));
+    };
+    state.enabled = false;
+    controller.refresh();
+    const request = previous.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(previous.panel.webview.html)![1]);
+    await previous.panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    assert.strictEqual(state.shown.length, 0);
+    assert.strictEqual(current.panel.viewColumn, 3);
+    assert.strictEqual(current.panel.disposed, false);
+    current.panel.dispose();
+  });
+
+  it('does not recreate a captured owner tab closed while native handoff is pending', async () => {
+    const document = makeDocument(new Uri('file', '', '/previous.csv'));
+    const { panel, messages } = makePanel(2);
+    await resolve(document, panel);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    panel.setActive(false);
+    const owner = makeDocument(new Uri('untitled', '', '/still-live-elsewhere.tsv'));
+    const ownerTab = { input: { uri: owner.uri } };
+    const group = { viewColumn: 2, activeTab: ownerTab, tabs: [ownerTab] };
+    state.activeGroup = group; state.groups = [group];
+    state.visibleTextEditors = [{ document: owner, viewColumn: 2 }];
+    state.executeCommand = async () => {
+      const target = { input: { uri: document.uri } };
+      group.tabs = [target]; group.activeTab = target;
+      state.focusListeners.forEach(callback => callback({ document, viewColumn: 2 }));
+    };
+    state.enabled = false;
+    controller.refresh();
+    const request = messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+    const metadata = JSON.parse(/<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(panel.webview.html)![1]);
+    await panel.receive({ type: 'viewRefreshReady', session: metadata.session, requestId: request.requestId });
+    assert.strictEqual(state.shown.length, 0);
+    assert.strictEqual(panel.disposed, true);
+  });
+
+  it('disposes an uninitialized disabled fallback even if On arrives during native open', async () => {
+    state.enabled = false;
+    let finishOpen!: () => void;
+    state.executeCommand = () => new Promise(resolveOpen => { finishOpen = resolveOpen; });
+    const { panel } = makePanel(2);
+    const pending = resolve(makeDocument(new Uri('file', '', '/data.tsv')), panel);
+    await new Promise(resolveTurn => setImmediate(resolveTurn));
+    state.enabled = true;
+    finishOpen();
+    await pending;
+    assert.strictEqual(panel.disposed, true);
+    assert.strictEqual(CsvEditorProvider.editors.length, 0);
+    assert.strictEqual(state.focusListeners.size, 0);
+  });
+
+  it('does not reuse a matching text editor from another group during fallback', async () => {
+    state.enabled = false;
+    const document = makeDocument(new Uri('file', '', '/data.tsv'));
+    state.visibleTextEditors.push({ document, viewColumn: 1 });
+    const { panel } = makePanel(2);
+    await resolve(document, panel);
+    assert.deepStrictEqual(state.commands, [[
+      'vscode.openWith', document.uri, 'default', { viewColumn: 2, preserveFocus: false }
+    ]]);
+    assert.strictEqual(panel.disposed, true);
+  });
+
+  it('honors disabling while the remote size check is pending', async () => {
+    let finishStat!: (value: { size: number }) => void;
+    state.stat = () => new Promise(resolveStat => { finishStat = resolveStat; });
+    const { panel } = makePanel();
+    const document = makeDocument(new Uri('vscode-remote', 'wsl+Ubuntu', '/data.csv'));
+    const pending = resolve(document, panel);
+    state.enabled = false;
+    finishStat({ size: 12 });
+    await pending;
+    assert.strictEqual(panel.webview.html, '');
+    assert.strictEqual(state.commands.length, 1);
+    assert.strictEqual(CsvEditorProvider.editors.length, 0);
+    assert.strictEqual(panel.disposed, true);
+  });
+
+  it('cleans up a disabled panel even if the native fallback fails', async () => {
+    state.enabled = false;
+    state.executeCommand = async () => { throw new Error('editor unavailable'); };
+    const { panel } = makePanel();
+    await assert.rejects(resolve(makeDocument(new Uri('file', '', '/data.csv')), panel), /editor unavailable/);
+    assert.strictEqual(panel.disposed, true);
+    assert.strictEqual(CsvEditorProvider.editors.length, 0);
+    assert.strictEqual(CsvEditorProvider.getActiveProvider(), undefined);
+  });
+});
diff --git a/src/test/editor-routing-commands.test.ts b/src/test/editor-routing-commands.test.ts
new file mode 100644
index 0000000..f9677f8
--- /dev/null
+++ b/src/test/editor-routing-commands.test.ts
@@ -0,0 +1,195 @@
+import assert from 'assert';
+import Module from 'module';
+import { describe, it } from 'node:test';
+
+class TabInputText { constructor(readonly uri: any) {} }
+class Uri {
+  readonly scheme = 'file';
+  constructor(readonly fsPath: string) {}
+  toString() { return `file://${this.fsPath}`; }
+}
+const clone = <T>(value: T): T => value === undefined ? value : JSON.parse(JSON.stringify(value));
+function fixture(initial: { enabled?: boolean; workspaceEnabled?: boolean; associations?: Record<string, string> } = {}) {
+  const data = { enabled: initial.enabled, workspaceEnabled: initial.workspaceEnabled, associations: clone(initial.associations), workspaceAssociations: undefined as Record<string, string> | undefined,
+    failRouting: false, updates: [] as any[], opened: [] as any[], closed: [] as any[], errors: [] as string[], infos: [] as string[], beforeOpen: undefined as (() => Promise<void>) | undefined };
+  const listeners: Array<(e: any) => Promise<void>> = [], events = new Set<Promise<void>>(), handlers = new Map<string, (...args: any[]) => any>();
+  const emit = (key: string) => {
+    for (const listener of listeners) {
+      const next = Promise.resolve(listener({ affectsConfiguration: (candidate: string) => candidate === key }));
+      events.add(next); void next.finally(() => events.delete(next));
+    }
+  };
+  const store = () => {
+    const values = new Map();
+    return { keys: () => [...values.keys()].filter(key => values.get(key) !== undefined), get: (key: string) => clone(values.get(key)), update: async (key: string, value: unknown) => { values.set(key, clone(value)); } };
+  };
+  const group: any = { viewColumn: 1, tabs: [], activeTab: undefined };
+  const groups = [group];
+  let activeGroup = group;
+  const api: any = {
+    Uri, TabInputText, ConfigurationTarget: { Global: 1, Workspace: 2 },
+    workspace: {
+      workspaceFolders: [{}], workspaceFile: undefined, textDocuments: [],
+      onDidOpenTextDocument: () => ({ dispose() {} }),
+      onDidCloseTextDocument: () => ({ dispose() {} }),
+      getConfiguration: (section: string) => ({
+        get: (key: string, fallback: unknown) => section === 'csv' && key === 'enabled' ? (data.workspaceEnabled ?? data.enabled ?? fallback) : section === 'workbench' && key === 'editorAssociations' ? { ...data.associations, ...data.workspaceAssociations } : fallback,
+        inspect: (key: string) => section === 'csv' && key === 'enabled' ? { defaultValue: true, globalValue: data.enabled, workspaceValue: data.workspaceEnabled } : section === 'workbench' && key === 'editorAssociations' ? { globalValue: clone(data.associations), workspaceValue: clone(data.workspaceAssociations) } : undefined,
+        update: async (key: string, value: any, target: number) => {
+          data.updates.push({ section, key, value: clone(value), target });
+          if (section === 'csv') {
+            if (target === 2) { data.workspaceEnabled = value; } else { data.enabled = value; }
+          } else {
+            if (data.failRouting) { throw new Error('read-only test settings'); }
+            if (target === 2) { data.workspaceAssociations = clone(value); } else { data.associations = clone(value); }
+          }
+          emit(`${section}.${key}`);
+        }
+      }),
+      onDidChangeConfiguration: (listener: (e: any) => Promise<void>) => { listeners.push(listener); return { dispose() {} }; }
+    },
+    window: {
+      visibleTextEditors: [],
+      onDidChangeActiveTextEditor: () => ({ dispose() {} }),
+      tabGroups: { get all() { return groups; }, get activeTabGroup() { return activeGroup; }, close: async (tab: any) => { data.closed.push(tab); group.tabs = group.tabs.filter((candidate: any) => candidate !== tab); return true; } },
+      showErrorMessage: (message: string) => { data.errors.push(message); },
+      showInformationMessage: (message: string) => { data.infos.push(message); },
+      registerCustomEditorProvider: () => ({ dispose() {} })
+    },
+    commands: {
+      registerCommand: (id: string, handler: (...args: any[]) => any) => { handlers.set(id, handler); return { dispose() {} }; },
+      executeCommand: async (...args: any[]) => {
+        data.opened.push(args);
+        await data.beforeOpen?.();
+        if (args[0] === 'vscode.open' && args[1].fsPath !== '/keep-native.csv') {
+          const table = { input: { uri: args[1], viewType: 'csv.editor' } };
+          group.tabs.push(table); group.activeTab = table;
+        }
+      }
+    }
+  };
+  class Provider {
+    static viewType = 'csv.editor';
+    static editors: any[] = [];
+    constructor(_context: unknown) {}
+  }
+  const original = Module.prototype.require;
+  Module.prototype.require = function (id: string) {
+    if (id === 'vscode') { return api; }
+    if (id === './CsvEditorProvider') { return { CsvEditorProvider: Provider }; }
+    return original.apply(this, arguments as any);
+  };
+  let activate: (context: any) => Promise<void>;
+  try {
+    delete require.cache[require.resolve('../extension')];
+    delete require.cache[require.resolve('../commands')];
+    delete require.cache[require.resolve('../untitled-editors')];
+    activate = require('../extension').activate;
+  } finally { Module.prototype.require = original; }
+  const context = { subscriptions: [], globalState: store(), workspaceState: store() };
+  const idle = async () => {
+    for (let n = 0; n < 100; n++) {
+      if (!events.size) { return; }
+      await Promise.all([...events]);
+    }
+    throw new Error('configuration events did not settle');
+  };
+  const addText = (path: string, dirty = false) => {
+    group.tabs.forEach((tab: any) => { tab.isActive = false; });
+    const tab = { input: new TabInputText(new Uri(path)), isActive: true, isPreview: false, isDirty: dirty };
+    group.tabs.push(tab); group.activeTab = tab; return tab;
+  };
+  return { data, group, groups, setActiveGroup: (next: any) => { activeGroup = next; }, handlers, api, idle, addText, activate: () => activate(context), updateEnabled: (value: boolean) => api.workspace.getConfiguration('csv').update('enabled', value, 1) };
+}
+
+describe('CSV routing toggle and native resolver handoff', () => {
+  it('serializes complete rapid toggles and restores the original association scope', async () => {
+    const h = fixture(); await h.activate();
+    const toggle = h.handlers.get('csv.toggleExtension')!;
+    await Promise.all([toggle(), toggle()]); await h.idle();
+    assert.strictEqual(h.data.enabled, true);
+    assert.strictEqual(h.data.associations, undefined);
+    assert.deepStrictEqual(h.data.updates.filter(update => update.key === 'enabled').map(update => update.value), [false, true]);
+  });
+
+  it('toggles an existing workspace override without changing global enablement or associations', async () => {
+    const h = fixture({ enabled: true, workspaceEnabled: true, associations: { '*.md': 'default' } }); await h.activate();
+    await h.handlers.get('csv.toggleExtension')!(); await h.idle();
+    assert.strictEqual(h.data.workspaceEnabled, false); assert.strictEqual(h.data.enabled, true);
+    assert.deepStrictEqual(h.data.associations, { '*.md': 'default' });
+    assert.ok(h.data.updates.every(update => update.target === 2));
+  });
+
+  it('reports denied routing and rolls the toggle back without a disabled success notice', async () => {
+    const h = fixture(); await h.activate(); h.data.failRouting = true;
+    await h.handlers.get('csv.toggleExtension')!(); await h.idle();
+    assert.strictEqual(h.data.enabled, undefined);
+    assert.ok(h.data.errors.some(message => message.includes('read-only test settings')));
+    assert.ok(h.data.infos.every(message => !message.includes('disabled')));
+  });
+
+  it('uses native resolution and preserves explicit native, external custom, and dirty source tabs', async () => {
+    const h = fixture({ enabled: false, associations: { '**/keep-native.csv': 'default' } }); await h.activate();
+    const native = h.addText('/keep-native.csv'), clean = h.addText('/normal.csv'), dirty = h.addText('/dirty.tsv', true);
+    const external = { input: { uri: new Uri('/external.csv'), viewType: 'other.editor' } }; h.group.tabs.push(external);
+    await h.updateEnabled(true); await h.idle();
+    assert.ok(h.data.opened.every(args => args[0] === 'vscode.open'));
+    assert.deepStrictEqual(h.data.closed, [], 'the active dirty owner stays open; inactive clean tabs are untouched');
+    assert.ok(h.group.tabs.includes(clean));
+    assert.deepStrictEqual(h.data.opened.map(args => args[1].fsPath), ['/dirty.tsv']);
+    assert.ok(h.group.tabs.includes(native)); assert.ok(h.group.tabs.includes(dirty)); assert.ok(h.group.tabs.includes(external));
+    assert.ok(h.data.opened.every(args => args[1].fsPath !== '/external.csv'));
+  });
+
+  it('does not close a captured source after Off supersedes an awaited On upgrade', async () => {
+    const h = fixture({ enabled: false }); await h.activate(); const source = h.addText('/normal.csv');
+    let release!: () => void;
+    h.data.beforeOpen = () => new Promise<void>(resolve => { release = resolve; });
+    await h.updateEnabled(true);
+    while (!release) { await new Promise(resolve => setImmediate(resolve)); }
+    await h.updateEnabled(false);
+    release(); await h.idle();
+    assert.strictEqual(h.data.enabled, false);
+    assert.ok(h.group.tabs.includes(source)); assert.deepStrictEqual(h.data.closed, []);
+  });
+  it('keeps an explicit native source when an older counterpart table was already open', async () => {
+    const h = fixture({ enabled: false, associations: { '**/keep-native.csv': 'default' } }); await h.activate();
+    const source = h.addText('/keep-native.csv');
+    const table = { input: { uri: source.input.uri, viewType: 'csv.editor' } }; h.group.tabs.push(table);
+    await h.updateEnabled(true); await h.idle();
+    assert.ok(h.group.tabs.includes(source)); assert.ok(h.group.tabs.includes(table));
+    assert.deepStrictEqual(h.data.closed, []);
+  });
+
+  it('does not upgrade an inactive saved CSV over the invoking untitled owner', async () => {
+    const h = fixture({ enabled: false }); await h.activate();
+    const saved = h.addText('/old.csv');
+    const owner = { input: new TabInputText({ scheme: 'untitled', fsPath: '/new.tsv', toString: () => 'untitled:/new.tsv' }), isActive: true, isDirty: true };
+    saved.isActive = false; h.group.tabs.push(owner); h.group.activeTab = owner;
+    await h.updateEnabled(true); await h.idle();
+    assert.deepStrictEqual(h.data.opened, []);
+    assert.deepStrictEqual(h.data.closed, []);
+    assert.strictEqual(h.group.activeTab, owner);
+  });
+  it('upgrades only the active saved owner and leaves other groups intact', async () => {
+    const h = fixture({ enabled: false }); await h.activate();
+    const inactive = h.addText('/inactive.csv'), current = h.addText('/current.csv');
+    const other = { viewColumn: 2, tabs: [{ input: new TabInputText(new Uri('/other.tsv')), isActive: true, isDirty: false }], activeTab: undefined as any };
+    other.activeTab = other.tabs[0]; h.groups.push(other);
+    await h.updateEnabled(true); await h.idle();
+    assert.deepStrictEqual(h.data.opened.map(args => args[1].fsPath), ['/current.csv']);
+    assert.deepStrictEqual(h.data.closed, [current]);
+    assert.ok(h.group.tabs.includes(inactive)); assert.strictEqual(other.tabs.length, 1);
+  });
+  it('does not follow a captured saved owner after the user changes groups during routing', async () => {
+    const h = fixture({ enabled: false }); await h.activate();
+    const original = h.addText('/original.csv');
+    const other = { viewColumn: 2, tabs: [] as any[], activeTab: undefined as any };
+    h.groups.push(other);
+    // The settings promise yields after the event starts but before routing completes.
+    await h.updateEnabled(true); h.setActiveGroup(other);
+    await h.idle();
+    assert.deepStrictEqual(h.data.opened, []); assert.ok(h.group.tabs.includes(original));
+  });
+
+});
diff --git a/src/test/editor-switch-draft.test.ts b/src/test/editor-switch-draft.test.ts
new file mode 100644
index 0000000..f55219a
--- /dev/null
+++ b/src/test/editor-switch-draft.test.ts
@@ -0,0 +1,95 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+describe('table switching commits the actual webview draft before replacement', () => {
+  for (const separator of [',', '\t']) {
+    it(`waits for a delayed multiline edit before acknowledging (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell()); view.key('Enter', { shiftKey: true }); view.type('switch draft');
+        host.deferEdits(); let committed = false;
+        const commit = host.commitPendingDraft().then(result => { committed = result; });
+        const request = host.messages.find(message => message.type === 'prepareViewRefresh');
+        assert.ok(request);
+        view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+        const messages = view.messages.filter(message => message.type === 'editCell' || message.type === 'viewRefreshReady');
+        assert.deepStrictEqual(messages.map(message => message.type), ['editCell', 'viewRefreshReady']);
+        const operations = messages.map(message => host.receive(message));
+        await new Promise(resolve => setImmediate(resolve));
+        assert.strictEqual(host.pendingEdits, 1); assert.strictEqual(committed, false);
+        host.releaseEdit(); await Promise.all(operations); await commit;
+        assert.strictEqual(committed, true);
+        assert.strictEqual(host.rows()[1][0], 'one\nswitch draft');
+        assert.ok(!host.diskText.includes('switch draft'), 'switching must not save');
+      } finally { view.close(); }
+    });
+  }
+
+  for (const failure of ['false', 'throw'] as const) {
+    it(`keeps and can retry the live draft when applyEdit returns ${failure}`, async () => {
+      const host = await createEditorHarness();
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell()); view.type('failure draft');
+        host.failEdits(failure);
+        const html = host.panel.webview.html;
+        const pending = host.commitPendingDraft();
+        const request = host.messages.at(-1);
+        view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+        await Promise.all(view.messages.filter(message => ['editCell', 'viewRefreshReady'].includes(message.type)).map(message => host.receive(message)));
+        assert.strictEqual(await pending, false);
+        assert.strictEqual(host.panel.webview.html, html);
+        assert.strictEqual(host.rows()[1][0], 'one');
+        assert.ok(view.cell().textContent.includes('failure draft'));
+        const failed = host.messages.find(message => message.type === 'editCellFailed');
+        assert.ok(failed);
+        view.window.dispatchEvent(new view.window.MessageEvent('message', { data: failed }));
+        assert.strictEqual(view.cell().getAttribute('contenteditable'), 'true', 'retry keeps the failed draft editable');
+        host.failEdits(undefined); view.messages.length = 0;
+        const retry = host.commitPendingDraft();
+        view.window.dispatchEvent(new view.window.MessageEvent('message', { data: host.messages.at(-1) }));
+        await Promise.all(view.messages.filter(message => ['editCell', 'viewRefreshReady'].includes(message.type)).map(message => host.receive(message)));
+        await flushViewCommits(host, view);
+        assert.strictEqual(await retry, true);
+        assert.strictEqual(host.rows()[1][0], 'onefailure draft');
+      } finally { view.close(); }
+    });
+  }
+
+  it('does not authorize a hidden view with a failed edit', async () => {
+    const host = await createEditorHarness();
+    host.failEdits('false');
+    await host.receive({ type: 'editCell', row: 1, col: 0, value: 'failed' });
+    host.panel.visible = false;
+    assert.strictEqual(await host.commitPendingDraft(), false);
+  });
+
+  it('keeps the active DOM during a structural virtual-row commit', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell(2, 0)); view.type('appended row');
+      const html = host.panel.webview.html;
+      const pending = host.commitPendingDraft();
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: host.messages.at(-1) }));
+      const edit = view.messages.find(message => message.type === 'editCell');
+      await host.receive(edit);
+      assert.strictEqual(host.panel.webview.html, html, 'structural edits cannot replace the DOM before acknowledgment');
+      await host.receive(view.messages.find(message => message.type === 'viewRefreshReady'));
+      assert.strictEqual(await pending, true);
+      assert.strictEqual(host.rows()[2][0], 'appended row');
+    } finally { view.close(); }
+  });
+
+  it('resends initialization-time requests, ignores stale acks, and aborts on disposal', async () => {
+    const host = await createEditorHarness();
+    let settled = false; const pending = host.commitPendingDraft().then(result => { settled = true; return result; });
+    const request = host.messages.at(-1);
+    await host.receive({ type: 'webviewReady' }); assert.deepStrictEqual(host.messages.at(-1), request);
+    await host.receive({ type: 'viewRefreshReady', requestId: request.requestId - 1 });
+    assert.strictEqual(settled, false);
+    host.panel.dispose(); assert.strictEqual(await pending, false);
+  });
+});
diff --git a/src/test/editor-switch.test.ts b/src/test/editor-switch.test.ts
new file mode 100644
index 0000000..604113c
--- /dev/null
+++ b/src/test/editor-switch.test.ts
@@ -0,0 +1,403 @@
+import assert from 'assert';
+import fs from 'fs';
+import Module from 'module';
+import path from 'path';
+import { beforeEach, describe, it } from 'node:test';
+import type { EditorSwitchRouting } from '../editor-associations';
+
+class Uri {
+  constructor(public scheme: string, public authority: string, public path: string) {}
+  toString() { return `${this.scheme}://${this.authority}${this.path}`; }
+}
+class TabInputText { constructor(public uri: Uri) {} }
+class TabInputCustom { constructor(public uri: Uri, public viewType: string) {} }
+class TabInputTextDiff { constructor(public original: Uri, public modified: Uri) {} }
+const state = {
+  group: { viewColumn: 2, tabs: [] as any[], activeTab: undefined as any },
+  otherGroups: [] as any[],
+  activeTextEditor: undefined as any,
+  visibleTextEditors: undefined as any[] | undefined,
+  enabled: true, version: '1.142.0', available: true,
+  events: [] as any[][], errors: [] as string[], information: [] as string[],
+  registered: new Map<string, (...args: any[]) => any>(),
+  prepareRouting: undefined as ((uri: Uri, target: string) => Promise<EditorSwitchRouting>) | undefined,
+  unqualifiedTable: false,
+  tabListeners: new Set<() => void>(),
+  commit: async (): Promise<boolean> => true,
+  replace: async (_viewType: string): Promise<void> => {},
+  reveal: async (_uri: Uri, _viewType: string): Promise<void> => {}
+};
+const vscode = {
+  Uri, TabInputText, TabInputCustom,
+  get version() { return state.version; },
+  window: {
+    get activeTextEditor() {
+      return state.activeTextEditor ?? (state.group.activeTab?.input instanceof TabInputText
+        ? { document: { uri: state.group.activeTab.input.uri }, viewColumn: state.group.viewColumn } : undefined);
+    },
+    get visibleTextEditors() {
+      return state.visibleTextEditors ?? [state.group, ...state.otherGroups].flatMap(group =>
+        group.activeTab?.input instanceof TabInputText
+          ? [{ document: { uri: group.activeTab.input.uri }, viewColumn: group.viewColumn }] : []
+      );
+    },
+    tabGroups: {
+      onDidChangeTabs: (listener: () => void) => { state.tabListeners.add(listener); return { dispose: () => state.tabListeners.delete(listener) }; },
+      get activeTabGroup() { return state.group; },
+      get all() { return [state.group, ...state.otherGroups]; },
+      close: () => { assert.fail('native replacement owns source removal; no separate close is safe'); }
+    },
+    showErrorMessage: (message: string) => { state.errors.push(message); },
+    showInformationMessage: (message: string) => { state.information.push(message); }
+  },
+  workspace: { textDocuments: [] as any[], getConfiguration: () => ({ get: () => state.enabled }) },
+  commands: {
+    getCommands: async () => state.available ? ['reopenActiveEditorWith'] : [],
+    executeCommand: async (command: string, ...args: any[]) => {
+      state.events.push([command, ...args]);
+      if (command === 'vscode.openWith') { await state.reveal(args[0], args[1]); }
+      else if (command === 'vscode.open') { await state.reveal(args[0], state.unqualifiedTable ? 'csv.editor' : 'default'); }
+      else if (command === 'workbench.action.keepEditor') { state.group.activeTab.isPreview = false; }
+      else if (command === 'reopenActiveEditorWith') { await state.replace(args[0]); }
+      else { assert.fail(`unexpected command: ${command}`); }
+    },
+    registerCommand: (name: string, callback: (...args: any[]) => any) => {
+      state.registered.set(name, callback); return { dispose() {} };
+    }
+  }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') { return vscode; }
+  if (id === 'font-list') { return { getFonts: async () => [] }; }
+  return originalRequire.apply(this, arguments as any);
+};
+import { registerCsvCommands } from '../commands';
+import { CsvEditorProvider } from '../CsvEditorProvider';
+import { supportsEditorReplacement } from '../editor-switch';
+Module.prototype.require = originalRequire;
+
+function makeTab(uri: Uri, table: boolean, dirty = true) {
+  return { input: table ? new TabInputCustom(uri, 'csv.editor') : new TabInputText(uri), isDirty: dirty };
+}
+function activateTab(tab: any) {
+  state.group.tabs = [tab]; state.group.activeTab = tab;
+  if (tab.input instanceof TabInputCustom && tab.input.viewType === 'csv.editor') {
+    CsvEditorProvider.editors.push({
+      getDocumentUri: () => tab.input.uri,
+      getViewColumn: () => 2,
+      commitPendingDraft: async () => { state.events.push(['commit']); return state.commit(); }
+    } as any);
+  }
+}
+async function toggle() { await state.registered.get('csv.toggleEditor')!(); }
+
+beforeEach(() => {
+  state.group = { viewColumn: 2, tabs: [], activeTab: undefined };
+  state.otherGroups = [];
+  state.activeTextEditor = undefined; state.visibleTextEditors = undefined;
+  state.enabled = true; state.version = '1.142.0'; state.available = true;
+  state.events = []; state.errors = []; state.information = [];
+  state.registered.clear(); CsvEditorProvider.editors = []; vscode.workspace.textDocuments = [];
+  state.prepareRouting = undefined; state.unqualifiedTable = false; state.tabListeners.clear();
+  registerCsvCommands({ subscriptions: [] } as any, async () => {}, (uri, target) => state.prepareRouting?.(uri, target) ?? Promise.resolve({ supported: false, commit: async () => {}, rollback: async () => {} }));
+  state.commit = async () => true;
+  state.reveal = async (uri, viewType) => {
+    const source = state.group.activeTab;
+    const table = viewType === 'csv.editor';
+    const target = state.group.tabs.find(tab => tab.input.uri?.toString() === uri.toString() &&
+      (table ? tab.input instanceof TabInputCustom : tab.input instanceof TabInputText)) ?? makeTab(uri, table, source.isDirty);
+    if (!state.group.tabs.includes(target)) { state.group.tabs.push(target); }
+    state.group.activeTab = target;
+    if (table && !CsvEditorProvider.editors.some(controller => controller.getDocumentUri().toString() === uri.toString())) {
+      CsvEditorProvider.editors.push({ getDocumentUri: () => uri, getViewColumn: () => 2,
+        commitPendingDraft: async () => { state.events.push(['commit']); return state.commit(); } } as any);
+    }
+  };
+  state.replace = async viewType => {
+    const original = state.group.activeTab;
+    const table = viewType === 'csv.editor';
+    const target = state.group.tabs.find(tab => tab !== original &&
+      tab.input.uri?.toString() === original.input.uri.toString() &&
+      (table ? tab.input instanceof TabInputCustom : tab.input instanceof TabInputText)
+    ) ?? makeTab(original.input.uri, table, original.isDirty);
+    state.group.tabs = state.group.tabs.filter(tab => tab !== original && tab !== target);
+    state.group.tabs.push(target); state.group.activeTab = target;
+    if (table) {
+      CsvEditorProvider.editors.push({ getDocumentUri: () => target.input.uri, getViewColumn: () => 2,
+        commitPendingDraft: async () => { state.events.push(['commit']); return state.commit(); } } as any);
+    }
+  };
+});
+
+describe('single-view CSV table/text switching', () => {
+  for (const scheme of ['file', 'vscode-remote']) {
+    for (const extension of ['csv', 'tsv', 'tab', 'psv', 'CSV']) {
+      it(`replaces only the ${scheme} .${extension} source in its group`, async () => {
+        const uri = new Uri(scheme, scheme === 'file' ? '' : 'wsl+Ubuntu', `/data/example.${extension}`);
+        activateTab(makeTab(uri, false));
+        const unrelated = makeTab(new Uri('file', '', '/other.csv'), false);
+        state.group.tabs.push(unrelated);
+        for (let round = 0; round < 4; round++) {
+          await toggle();
+          assert.strictEqual(state.group.tabs.filter(tab => tab.input.uri.toString() === uri.toString()).length, 1);
+          assert.strictEqual(state.group.activeTab.input.uri, uri);
+          assert.strictEqual(state.group.activeTab.isDirty, true);
+          assert.ok(state.group.tabs.includes(unrelated));
+        }
+        assert.deepStrictEqual(state.events.slice(0, 4), [
+          ['vscode.openWith', uri, 'csv.editor', { viewColumn: 2, preserveFocus: false, preview: false }],
+          ['commit'],
+          ['vscode.openWith', uri, 'default', { viewColumn: 2, preserveFocus: false, preview: false }],
+          ['reopenActiveEditorWith', 'csv.editor']
+        ]);
+        assert.strictEqual(state.events.filter(event => event[0] === 'commit').length, 4);
+        assert.strictEqual(state.errors.length, 0);
+      });
+    }
+  }
+
+  it('reuses a counterpart that is already open while removing only its source', async () => {
+    const uri = new Uri('file', '', '/data.csv');
+    const source = makeTab(uri, false); const target = makeTab(uri, true);
+    activateTab(source); state.group.tabs.push(target);
+    await toggle();
+    assert.deepStrictEqual(state.group.tabs, [target]);
+    assert.strictEqual(state.group.activeTab, target);
+  });
+
+  for (const extension of ['csv', 'tsv']) {
+    it(`replaces a ${extension} table when its ready text target is visible but focus remains in another group`, async () => {
+      const uri = new Uri('file', '', `/data.${extension}`);
+      activateTab(makeTab(uri, true));
+      const unrelated = makeTab(new Uri('file', '', '/other-group.csv'), false);
+      const other = { viewColumn: 3, tabs: [unrelated], activeTab: unrelated };
+      state.otherGroups = [other];
+      state.activeTextEditor = { document: { uri: unrelated.input.uri }, viewColumn: 3 };
+      await toggle();
+      assert.deepStrictEqual(state.group.tabs.map(tab => tab.input.constructor), [TabInputText]);
+      assert.strictEqual(state.group.activeTab.input.uri, uri);
+      assert.strictEqual(state.group.activeTab.isDirty, true);
+      assert.deepStrictEqual(state.events.at(-1), ['reopenActiveEditorWith', 'default']);
+      assert.deepStrictEqual(other.tabs, [unrelated]);
+      assert.strictEqual(other.activeTab, unrelated);
+      assert.strictEqual(vscode.window.activeTextEditor.document.uri, unrelated.input.uri);
+      assert.deepStrictEqual(state.errors, []);
+    });
+
+    it(`retains a ${extension} table if matching text is visible only in a different group`, async () => {
+      const uri = new Uri('file', '', `/data.${extension}`);
+      const source = makeTab(uri, true);
+      activateTab(source);
+      const otherText = makeTab(uri, false);
+      const other = { viewColumn: 3, tabs: [otherText], activeTab: otherText };
+      state.otherGroups = [other];
+      state.activeTextEditor = { document: { uri }, viewColumn: 3 };
+      state.visibleTextEditors = [state.activeTextEditor];
+      await toggle();
+      assert.ok(state.group.tabs.includes(source));
+      assert.strictEqual(state.group.activeTab, source);
+      assert.ok(!state.events.some(event => event[0] === 'reopenActiveEditorWith'));
+      assert.deepStrictEqual(other.tabs, [otherText]);
+      assert.strictEqual(other.activeTab, otherText);
+    });
+  }
+
+  it('keeps the dirty source when native opening fails or is cancelled', async () => {
+    const source = makeTab(new Uri('file', '', '/data.csv'), false);
+    activateTab(source); state.reveal = async () => { throw new Error('open failed'); };
+    await toggle();
+    assert.deepStrictEqual(state.group.tabs, [source]); assert.strictEqual(source.isDirty, true);
+    assert.strictEqual(state.errors.length, 1);
+    state.reveal = async () => {};
+    await toggle();
+    assert.deepStrictEqual(state.group.tabs, [source]); assert.strictEqual(source.isDirty, true);
+  });
+
+  it('waits for a table draft, aborting if it cannot commit or the user changes tabs', async () => {
+    const source = makeTab(new Uri('file', '', '/data.csv'), true);
+    activateTab(source); state.commit = async () => false;
+    await toggle(); assert.deepStrictEqual(state.events, [['commit']]);
+    assert.deepStrictEqual(state.group.tabs, [source]);
+    state.events = []; state.commit = async () => {
+      state.group.activeTab = makeTab(new Uri('file', '', '/unrelated.csv'), false); return true;
+    };
+    await toggle(); assert.deepStrictEqual(state.events, [['commit']]);
+  });
+
+  it('does not steal focus back after the user changes tabs during target readiness', async () => {
+    const uri = new Uri('file', '', '/data.csv');
+    activateTab(makeTab(uri, false));
+    state.commit = async () => {
+      state.group.activeTab = makeTab(new Uri('file', '', '/another.csv'), false);
+      return true;
+    };
+    await toggle();
+    assert.deepStrictEqual(state.events.map(event => event[0]), ['vscode.openWith', 'commit']);
+    assert.strictEqual(state.group.activeTab.input.uri.path, '/another.csv');
+  });
+
+  it('does not move a preexisting table from a different editor group', async () => {
+    const uri = new Uri('file', '', '/data.csv');
+    activateTab(makeTab(uri, false));
+    const other = { viewColumn: 3, tabs: [makeTab(uri, true)] };
+    state.otherGroups = [other];
+    await toggle();
+    assert.strictEqual(state.events.length, 0);
+    assert.strictEqual(other.tabs.length, 1);
+    assert.match(state.information[0], /another editor group/);
+  });
+
+  it('coalesces duplicate clicks during replacement', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data.csv'), false));
+    let finish!: () => void; state.replace = () => new Promise(resolve => { finish = resolve; });
+    const pending = toggle(); await new Promise(resolve => setImmediate(resolve));
+    await toggle(); finish(); await pending;
+    assert.strictEqual(state.events.filter(event => event[0] === 'reopenActiveEditorWith').length, 1);
+  });
+
+  it('respects disabled state while allowing a table to return to source', async () => {
+    state.enabled = false; activateTab(makeTab(new Uri('file', '', '/data.tsv'), false));
+    await toggle(); assert.strictEqual(state.events.length, 0); assert.strictEqual(state.information.length, 1);
+    activateTab(makeTab(new Uri('file', '', '/data.tsv'), true));
+    await toggle(); assert.strictEqual(state.events.at(-1)?.[1], 'default');
+  });
+
+  it('ignores other custom editors, native diffs, unsupported files, untitled URIs and empty groups', async () => {
+    const uri = new Uri('file', '', '/data.csv');
+    for (const input of [new TabInputCustom(uri, 'another.editor'), new TabInputTextDiff(uri, uri),
+      new TabInputText(new Uri('file', '', '/notes.md')), new TabInputText(new Uri('untitled', '', '/data.csv'))]) {
+      activateTab({ input }); await toggle();
+    }
+    state.group.activeTab = undefined; await toggle(); assert.strictEqual(state.events.length, 0);
+  });
+
+  it('guards old/forked hosts and rechecks dirty state after the draft commits', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data.csv'), false, false));
+    state.version = '1.99.0'; await toggle(); assert.strictEqual(state.events.length, 0);
+    state.version = '1.119.0'; await toggle(); assert.strictEqual(state.events.at(-1)?.[0], 'reopenActiveEditorWith');
+    state.events = []; activateTab(makeTab(new Uri('file', '', '/data.csv'), true, false));
+    state.commit = async () => { state.group.activeTab.isDirty = true; return true; };
+    await toggle(); assert.deepStrictEqual(state.events, [['commit']]); assert.match(state.information.at(-1)!, /1\.120/);
+    state.version = '1.120.0'; state.events = []; await toggle();
+    assert.strictEqual(state.events.at(-1)?.[0], 'reopenActiveEditorWith');
+    state.events = []; state.available = false; await toggle(); assert.strictEqual(state.events.length, 0);
+  });
+
+  it('tests the native command and dirty-working-copy compatibility boundaries', () => {
+    for (const [version, dirty, expected] of [
+      ['1.99.0', false, false], ['1.100.0', false, true], ['1.119.0', false, true],
+      ['1.119.0', true, false], ['1.120.0', true, true], ['1.142.0', true, true],
+      ['1.120.0-insider', true, true], ['2.0.0', true, true], ['unknown', false, false]
+    ] as const) { assert.strictEqual(supportsEditorReplacement(version, dirty), expected); }
+  });
+
+  it('contributes the real native text-pane toolbar context and updated documentation', () => {
+    const root = path.join(__dirname, '..', '..');
+    const manifest = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
+    const action = manifest.contributes.menus['editor/title'].find((entry: any) => entry.command === 'csv.toggleEditor');
+    assert.ok(manifest.activationEvents.includes('onCommand:csv.toggleEditor'));
+    assert.match(action.when, /activeEditor == workbench\.editors\.files\.textFileEditor/);
+    assert.match(action.when, /activeCustomEditorId == csv\.editor/);
+    assert.ok(action.when.includes('!isInDiffEditor'));
+    assert.ok(action.when.includes('resourceScheme != untitled'));
+    assert.ok(!action.when.includes('workbench.editors.textEditor'));
+    const readme = fs.readFileSync(path.join(root, 'README.md'), 'utf8');
+    assert.ok(!readme.includes('Both representations may remain open'));
+    assert.ok(readme.includes('one representation remains'));
+  });
+});
+
+
+describe('Text routing transaction around native replacement', () => {
+  function transaction(): EditorSwitchRouting {
+    return { supported: true, commit: async () => { state.events.push(['routing-commit']); }, rollback: async () => { state.events.push(['routing-rollback']); } };
+  }
+  it('proves native routing with an unqualified open and finalizes only after replacement', async () => {
+    const uri = new Uri('file', '', '/data/check.csv'); activateTab(makeTab(uri, true));
+    state.prepareRouting = async () => { state.events.push(['routing-prepare']); return transaction(); };
+    await toggle();
+    assert.ok(state.group.activeTab.input instanceof TabInputText);
+    assert.ok(state.events.some(event => event[0] === 'vscode.open'));
+    const replacement = state.events.findIndex(event => event[0] === 'reopenActiveEditorWith');
+    assert.ok(state.events.findIndex(event => event[0] === 'routing-commit') > replacement);
+    assert.ok(state.events.every(event => event[0] !== 'routing-rollback'));
+  });
+  it('rolls provisional Text routing back after a failed native replacement', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data/check.csv'), true));
+    state.prepareRouting = async () => transaction(); state.replace = async () => { throw new Error('cancelled'); };
+    await toggle();
+    assert.ok(state.events.some(event => event[0] === 'routing-rollback'));
+    assert.ok(state.events.every(event => event[0] !== 'routing-commit'));
+    assert.ok(state.group.activeTab.input instanceof TabInputCustom);
+  });
+  it('does not close the source or finalize Text when a longer user association still chooses table', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data/check.csv'), true));
+    state.prepareRouting = async () => transaction(); state.unqualifiedTable = true;
+    await toggle();
+    assert.ok(state.group.activeTab.input instanceof TabInputCustom);
+    assert.ok(state.events.every(event => event[0] !== 'reopenActiveEditorWith'));
+    assert.ok(state.events.some(event => event[0] === 'routing-rollback'));
+    assert.ok(state.information.some(message => message.includes('editor associations still choose')));
+  });
+  it('retains the established remote switch with honest search guidance', async () => {
+    activateTab(makeTab(new Uri('vscode-remote', 'wsl+Ubuntu', '/data/check.csv'), true));
+    state.prepareRouting = async () => ({ ...transaction(), supported: false, limitation: 'Turn CSV off before Find in Files for this URI.' });
+    await toggle();
+    assert.ok(state.group.activeTab.input instanceof TabInputText);
+    assert.ok(state.events.every(event => event[0] !== 'vscode.open'));
+    assert.ok(state.information.some(message => message.includes('Turn CSV off')));
+  });
+  it('rolls back prepared routing if the user changes group before target opening', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data/check.csv'), true));
+    const original = state.group;
+    state.prepareRouting = async () => {
+      state.otherGroups = [original]; state.group = { viewColumn: 3, tabs: [], activeTab: undefined };
+      return transaction();
+    };
+    await toggle();
+    assert.ok(state.events.some(event => event[0] === 'routing-rollback'));
+    assert.ok(state.events.every(event => !['vscode.open', 'vscode.openWith', 'reopenActiveEditorWith'].includes(event[0])));
+    assert.ok(original.activeTab.input instanceof TabInputCustom);
+  });
+
+  it('waits for delayed extension-host tab events before committing Table routing', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data/check.csv'), false));
+    state.prepareRouting = async () => transaction();
+    const replace = state.replace;
+    state.replace = async viewType => {
+      setImmediate(async () => { await replace(viewType); state.tabListeners.forEach(listener => listener()); });
+    };
+    await toggle();
+    assert.ok(state.group.activeTab.input instanceof TabInputCustom);
+    assert.ok(state.events.some(event => event[0] === 'routing-commit'));
+    assert.ok(state.events.every(event => event[0] !== 'routing-rollback'));
+    assert.strictEqual(state.tabListeners.size, 0);
+  });
+
+  it('starts its tab-event timeout after a slow native command completes', async () => {
+    activateTab(makeTab(new Uri('file', '', '/data/check.csv'), false));
+    state.prepareRouting = async () => transaction();
+    const replace = state.replace;
+    let release!: () => void;
+    state.replace = async () => { await new Promise<void>(resolve => { release = resolve; }); };
+    const originalTimer = global.setTimeout;
+    const timers: Array<() => void> = [];
+    global.setTimeout = ((callback: () => void, milliseconds: number, ...args: any[]) => {
+      if (milliseconds === 5000) { timers.push(callback); return {} as any; }
+      return originalTimer(callback, milliseconds, ...args);
+    }) as typeof setTimeout;
+    try {
+      const changing = toggle();
+      while (!release) { await new Promise(resolve => setImmediate(resolve)); }
+      assert.strictEqual(timers.length, 0, 'a slow native command cannot consume the event-settlement timeout');
+      release();
+      while (!timers.length) { await new Promise(resolve => setImmediate(resolve)); }
+      await replace('csv.editor'); state.tabListeners.forEach(listener => listener());
+      await changing;
+      assert.ok(state.events.some(event => event[0] === 'routing-commit'));
+      assert.ok(state.events.every(event => event[0] !== 'routing-rollback'));
+    } finally { global.setTimeout = originalTimer; }
+  });
+
+});
diff --git a/src/test/encoding-integrity.test.ts b/src/test/encoding-integrity.test.ts
new file mode 100644
index 0000000..6b95fe3
--- /dev/null
+++ b/src/test/encoding-integrity.test.ts
@@ -0,0 +1,128 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness } from './edit-integrity-harness';
+import iconv from 'iconv-lite';
+
+describe('Explicit source decoding preserves original non-UTF8 characters', () => {
+  const original = fs.readFileSync(path.join(process.cwd(), 'src', 'test', 'fixtures', 'issue-76-products.csv'));
+  const decoded = iconv.decode(original, 'cp437');
+
+  it('keeps the reporter fixture byte-for-byte and establishes the supported decoding ambiguity', () => {
+    assert.strictEqual(original.length, 4052);
+    assert.ok(original.toString('utf8').includes('\uFFFD'));
+    assert.ok(!decoded.includes('\uFFFD'));
+    assert.strictEqual(iconv.decode(original, 'cp850'), decoded);
+    assert.deepStrictEqual(iconv.encode(decoded, 'cp437'), original);
+    for (const name of ['Knäckebröd', 'Thüringer', 'Guaraná', 'Nuß']) {
+      assert.ok(decoded.includes(name));
+    }
+  });
+
+  it('renders and edits the correctly decoded document without changing accented names', async () => {
+    const host = await createEditorHarness({ text: decoded });
+    assert.strictEqual(host.warnings.length, 0);
+    assert.ok(host.panel.webview.html.includes('Knäckebröd'));
+    const row = host.rows().findIndex(record => record[1]?.includes('Knäckebröd'));
+    await host.receive({ type: 'editCell', row, col: 5, value: '22.00' });
+    await host.receive({ type: 'save' });
+    const saved = iconv.decode(iconv.encode(host.diskText, 'cp437'), 'cp437');
+    for (const name of ['Knäckebröd', 'Thüringer', 'Guaraná', 'Nuß']) {
+      assert.ok(saved.includes(name));
+    }
+  });
+});
+
+describe('Possible decoding mismatches use an explicit encoding workflow', () => {
+  it('warns once without changing already decoded data when dismissed', async () => {
+    const host = await createEditorHarness({ rows: [['text'], ['replacement � may be intentional']] });
+    const originalText = host.document.getText();
+    assert.strictEqual(host.warnings.length, 1);
+    assert.match(host.warnings[0], /can indicate a decoding mismatch/);
+    await host.view(false, false);
+    await host.view(true, true);
+    assert.strictEqual(host.warnings.length, 1);
+    assert.strictEqual(host.executedCommands.length, 0);
+    assert.strictEqual(host.document.getText(), originalText);
+  });
+
+  it('binds the warning action to the originating document URI', async () => {
+    const host = await createEditorHarness({ rows: [['text'], ['�']], warningChoice: 'Change File Encoding' });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.deepStrictEqual(host.executedCommands, [{ name: 'csv.changeEncoding', args: [host.document.uri] }]);
+  });
+
+  it('does not act on a warning from a disposed editor', async () => {
+    let choose!: (value: string) => void;
+    const choice = new Promise<string>(resolve => { choose = resolve; });
+    const host = await createEditorHarness({ rows: [['text'], ['�']], warningChoice: choice });
+    host.dispose();
+    choose('Change File Encoding');
+    await new Promise(resolve => setImmediate(resolve));
+    assert.strictEqual(host.executedCommands.length, 0);
+  });
+
+  it('handles a rejected warning action without an unhandled promise rejection', async () => {
+    let choose!: (value: string) => void;
+    const choice = new Promise<string>(resolve => { choose = resolve; });
+    const host = await createEditorHarness({ rows: [['text'], ['�']], warningChoice: choice });
+    host.commandError = new Error('test command rejection');
+    const warnings: unknown[][] = [];
+    const originalWarn = console.warn;
+    console.warn = (...args: unknown[]) => { warnings.push(args); };
+    try {
+      choose('Change File Encoding');
+      await new Promise(resolve => setImmediate(resolve));
+      assert.strictEqual(warnings[0]?.[0], 'CSV: Encoding warning action failed');
+    } finally {
+      console.warn = originalWarn;
+    }
+  });
+
+  it('stops the encoding command when the user cancels closing a dirty document', async () => {
+    const host = await createEditorHarness();
+    await host.receive({ type: 'editCell', row: 1, col: 0, value: 'unsaved' });
+    host.closeResult = false;
+    host.registerCommands();
+    await host.commands.get('csv.changeEncoding')?.();
+    assert.strictEqual(host.executedCommands.length, 0);
+    assert.strictEqual(host.rows()[1][0], 'unsaved');
+    assert.ok(!host.diskText.includes('unsaved'));
+  });
+
+  it('opens the native encoding picker and returns to the CSV view after a successful close', async () => {
+    const host = await createEditorHarness();
+    host.registerCommands();
+    await host.commands.get('csv.changeEncoding')?.(host.document.uri);
+    assert.deepStrictEqual(host.executedCommands.map(command => command.name), [
+      'vscode.openWith', 'workbench.action.editor.changeEncoding', 'vscode.openWith'
+    ]);
+    assert.strictEqual(host.executedCommands[0].args[0], host.document.uri);
+    assert.strictEqual(host.executedCommands[2].args[1], 'csv.editor');
+  });
+
+  it('waits for the native picker command to finish before reopening the CSV view', async () => {
+    const host = await createEditorHarness();
+    let complete!: () => void;
+    host.commandWait = new Promise<void>(resolve => { complete = resolve; });
+    host.registerCommands();
+    const changing = host.commands.get('csv.changeEncoding')?.();
+    await new Promise(resolve => setImmediate(resolve));
+    assert.deepStrictEqual(host.executedCommands.map(command => command.name), ['vscode.openWith', 'workbench.action.editor.changeEncoding']);
+    complete();
+    await changing;
+    assert.strictEqual(host.executedCommands[2].name, 'vscode.openWith');
+  });
+
+  it('round-trips UTF-8 accented CSV and TSV without triggering a warning', async () => {
+    for (const separator of [',', '\t']) {
+      const host = await createEditorHarness({ separator, rows: [['name', 'value'], ['éäöüßøå', 'before']] });
+      await host.receive({ type: 'editCell', row: 1, col: 1, value: 'after' });
+      await host.receive({ type: 'save' });
+      assert.strictEqual(host.warnings.length, 0);
+      assert.strictEqual(host.rows()[1][0], 'éäöüßøå');
+      assert.ok(Buffer.from(host.diskText, 'utf8').toString('utf8').includes('éäöüßøå'));
+    }
+  });
+});
diff --git a/src/test/failed-draft-clipboard.test.ts b/src/test/failed-draft-clipboard.test.ts
new file mode 100644
index 0000000..3236eaf
--- /dev/null
+++ b/src/test/failed-draft-clipboard.test.ts
@@ -0,0 +1,23 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness } from './edit-integrity-harness';
+
+describe('clipboard mutations during failed cell recovery', () => {
+  for (const type of ['pasteFromClipboard', 'copyCells']) {
+    it(`blocks ${type} until the failed draft is resolved`, async () => {
+      const host = await createEditorHarness();
+      const before = host.rows();
+      host.failEdits('false');
+      await host.receive({ type: 'editCell', row: 1, col: 0, value: 'unapplied draft' });
+      host.failEdits(undefined);
+      host.clipboardText = 'replacement';
+      await host.receive({ type, cut: true, matrix: [['one']], rowIds: [1], startCol: 0,
+        anchorRow: 1, anchorCol: 0, selection: { rows: [1], cols: [0] } });
+      assert.deepStrictEqual(host.rows(), before);
+      assert.strictEqual(host.errors.length, 1);
+      assert.strictEqual(host.clipboardText, 'replacement', 'a blocked cut must not change the clipboard');
+      assert.ok(host.messages.some(message => message.type === 'editCellFailed' && message.retry));
+      host.dispose();
+    });
+  }
+});
diff --git a/src/test/failed-draft-recovery.test.ts b/src/test/failed-draft-recovery.test.ts
new file mode 100644
index 0000000..bb44fb4
--- /dev/null
+++ b/src/test/failed-draft-recovery.test.ts
@@ -0,0 +1,226 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+function deliver(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>) {
+  const messages = host.messages.splice(0);
+  messages.forEach(message => {
+    if (message.type === 'prepareViewRefresh') { host.messages.push(message); }
+    else { view.window.dispatchEvent(new view.window.MessageEvent('message', { data: message })); }
+  });
+}
+
+describe('unapplied ordinary cell drafts keep source row identities intact', () => {
+  for (const separator of [',', '\t']) {
+    for (const failure of ['false', 'throw'] as const) {
+      for (const recovery of ['retry', 'discard'] as const) {
+        it(`keeps a failed ${failure} draft when disabled until ${recovery} (${JSON.stringify(separator)})`, async () => {
+          const host = await createEditorHarness({ separator });
+          let view = createWebviewDom(host.panel.webview.html);
+          try {
+            view.messages.length = 0;
+            view.start(view.cell()); view.type(' failed draft'); view.cell().blur();
+            host.failEdits(failure);
+            await Promise.all(view.messages.map(message => host.receive(message)));
+            deliver(host, view);
+            const html = host.panel.webview.html;
+            const draft = view.cell().textContent;
+            const diskText = host.diskText;
+            host.setEnabled(false);
+            host.refresh();
+            assert.strictEqual(host.isOpen, true, 'the failed draft must retain its controller and panel');
+            assert.strictEqual(host.panel.webview.html, html, 'disable must retain the current DOM');
+            assert.strictEqual(view.cell().textContent, draft);
+            assert.ok(draft.includes('failed draft'));
+            assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one', 'two']]);
+            assert.strictEqual(host.diskText, diskText);
+            assert.deepStrictEqual(host.recordedCommands, [], 'disable must not open a different editor before recovery');
+            assert.match(host.errors.at(-1)!, /Retry.*Escape.*before disabling/);
+
+            host.failEdits(undefined);
+            view.messages.length = 0;
+            view.start(view.cell());
+            if (recovery === 'discard') { view.key('Escape'); }
+            else { view.cell().blur(); }
+            await Promise.all(view.messages.map(message => host.receive(message)));
+            await flushViewCommits(host, view);
+            assert.strictEqual(host.rows()[1][0], recovery === 'retry' ? 'one failed draft' : 'one');
+            assert.strictEqual(host.diskText, diskText, 'recovery must not force a save');
+            // Recovery creates a new webview session. A later disable must be
+            // acknowledged by that new DOM, never the discarded session.
+            view.close();
+            view = createWebviewDom(host.panel.webview.html);
+            host.refresh();
+            await flushViewCommits(host, view);
+            assert.strictEqual(host.isOpen, false, 'normal disable proceeds after the failed draft is resolved');
+            assert.deepStrictEqual(host.recordedCommands, [['vscode.openWith', host.document.uri, 'default', { viewColumn: host.panel.viewColumn, preserveFocus: false }]]);
+          } finally {
+            view.close();
+            if (host.isOpen) { host.panel.dispose(); }
+          }
+        });
+      }
+    }
+  }
+
+  for (const failure of ['false', 'throw'] as const) {
+    it(`blocks row deletion after an ordinary ${failure} failure until Escape discards the draft`, async () => {
+      const host = await createEditorHarness({ rows: [['name', 'value'], ['one', 'two'], ['three', 'four']] });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell()); view.type(' failed draft'); view.cell().blur();
+        host.failEdits(failure);
+        await host.receive(view.messages.find(message => message.type === 'editCell'));
+        deliver(host, view);
+        assert.ok(view.cell().textContent.includes('failed draft'));
+        assert.strictEqual(view.cell().getAttribute('contenteditable'), null, 'ordinary failure must not repeatedly steal focus');
+        host.failEdits(undefined);
+        await host.receive({ type: 'deleteRow', index: 1 });
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one', 'two'], ['three', 'four']]);
+        assert.strictEqual(host.errors.length, 1);
+        deliver(host, view);
+        assert.strictEqual(view.cell().getAttribute('contenteditable'), 'true', 'blocked mutation returns to the failed draft');
+        view.messages.length = 0;
+        view.key('Escape');
+        assert.deepStrictEqual(view.messages.map(message => message.type), ['discardCellDraft']);
+        await host.receive(view.messages[0]);
+        deliver(host, view);
+        assert.strictEqual(view.cell().textContent, 'one');
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one', 'two'], ['three', 'four']], 'discard must not write stale DOM text');
+        await host.receive({ type: 'deleteRow', index: 1 });
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], ['three', 'four']]);
+        await flushViewCommits(host, view);
+        const fresh = createWebviewDom(host.panel.webview.html);
+        try { assert.strictEqual(fresh.cell().textContent, 'three'); } finally { fresh.close(); }
+      } finally { view.close(); }
+    });
+  }
+
+  it('clears the failure when the user explicitly reverts to the original source value', async () => {
+    const host = await createEditorHarness({ rows: [['name'], ['one'], ['three']] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell()); view.type('failed'); view.cell().blur();
+      host.failEdits('false'); await host.receive(view.messages.find(message => message.type === 'editCell'));
+      deliver(host, view); host.failEdits(undefined); view.messages.length = 0;
+      view.start(view.cell()); view.cell().textContent = 'one'; view.cell().blur();
+      await host.receive(view.messages.find(message => message.type === 'editCell'));
+      deliver(host, view);
+      await host.receive({ type: 'deleteRow', index: 1 });
+      assert.deepStrictEqual(host.rows(), [['name'], ['three']]);
+      assert.strictEqual(host.errors.length, 0);
+      await flushViewCommits(host, view);
+    } finally { view.close(); }
+  });
+
+  it('keeps the rendered delimiter while a failed draft is retried after a separator change', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell()); view.type(' draft'); view.cell().blur();
+      host.failEdits('false'); await host.receive(view.messages.find(message => message.type === 'editCell'));
+      deliver(host, view); host.failEdits(undefined);
+      await host.setSeparator('|');
+      view.messages.length = 0; view.start(view.cell());
+      const pending = host.commitPendingDraft();
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: host.messages.at(-1) }));
+      await Promise.all(view.messages.filter(message => ['editCell', 'viewRefreshReady'].includes(message.type)).map(message => host.receive(message)));
+      await flushViewCommits(host, view);
+      assert.strictEqual(await pending, true);
+      assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one draft', 'two']]);
+      const fresh = createWebviewDom(host.panel.webview.html);
+      try { assert.strictEqual(fresh.window.document.getElementById('csv-root').dataset.sepcode, '124'); }
+      finally { fresh.close(); }
+    } finally { view.close(); }
+  });
+
+  for (const existingCommit of [false, true]) {
+    it(`preserves a new live B draft while recovered A applies (${existingCommit ? 'existing ACK' : 'ordinary blur'})`, async () => {
+      const host = await createEditorHarness();
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell()); view.type(' recovered'); view.cell().blur();
+        host.failEdits('false'); await host.receive(view.messages.find(message => message.type === 'editCell'));
+        deliver(host, view); host.failEdits(undefined); view.messages.length = 0;
+        view.start(view.cell());
+        host.deferEdits();
+        let commit: Promise<boolean> | undefined;
+        if (existingCommit) {
+          commit = host.commitPendingDraft();
+          view.window.dispatchEvent(new view.window.MessageEvent('message', { data: host.messages.at(-1) }));
+        } else { view.cell().blur(); }
+        const queuedA = view.messages.filter(message => ['cellEditStarted', 'editCell', 'viewRefreshReady'].includes(message.type)).map(message => host.receive(message));
+        await new Promise(resolve => setImmediate(resolve));
+        assert.strictEqual(host.pendingEdits, 1);
+        const html = host.panel.webview.html;
+        const cursor = view.messages.length;
+        view.start(view.cell(1, 1)); view.type(' SECOND-LIVE-DRAFT');
+        const startedB = view.messages.slice(cursor).map(message => host.receive(message));
+        host.resumeEdits(); host.releaseEdit();
+        await Promise.all([...queuedA, ...startedB]);
+        assert.strictEqual(host.panel.webview.html, html, 'recovery cannot replace the DOM while B remains unposted');
+        assert.ok(view.cell(1, 1).textContent.includes('SECOND-LIVE-DRAFT'));
+        assert.strictEqual(host.rows()[1][1], 'two');
+        await flushViewCommits(host, view);
+        if (commit) { assert.strictEqual(await commit, true); }
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], ['one recovered', 'two SECOND-LIVE-DRAFT']]);
+        const fresh = createWebviewDom(host.panel.webview.html);
+        try { assert.strictEqual(fresh.cell(1, 1).textContent, 'two SECOND-LIVE-DRAFT'); }
+        finally { fresh.close(); }
+      } finally { view.close(); }
+    });
+  }
+
+  it('renews a fresh recovery ACK if another draft starts while its edit is applying', async () => {
+    const host = await createEditorHarness({ rows: [['a', 'b', 'c'], ['one', 'two', 'three']] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell()); view.type(' recovered'); view.cell().blur();
+      host.failEdits('false'); await host.receive(view.messages.find(message => message.type === 'editCell'));
+      deliver(host, view); host.failEdits(undefined); view.messages.length = 0;
+      view.start(view.cell()); view.cell().blur(); host.deferEdits();
+      const queuedA = view.messages.map(message => host.receive(message));
+      await new Promise(resolve => setImmediate(resolve));
+      const html = host.panel.webview.html;
+      let cursor = view.messages.length;
+      view.start(view.cell(1, 1)); view.type(' SECOND-DRAFT');
+      const startB = view.messages.slice(cursor).map(message => host.receive(message));
+      host.releaseEdit(); await Promise.all([...queuedA, ...startB]);
+      cursor = view.messages.length;
+      const firstRequest = host.messages.find(message => message.type === 'prepareViewRefresh' && message.requestId === host.pendingDraftRequestId);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: firstRequest }));
+      const queuedB = view.messages.slice(cursor).map(message => host.receive(message));
+      await new Promise(resolve => setImmediate(resolve));
+      assert.strictEqual(host.pendingEdits, 1);
+      cursor = view.messages.length;
+      view.start(view.cell(1, 2)); view.type(' THIRD-LIVE-DRAFT');
+      const startC = view.messages.slice(cursor).map(message => host.receive(message));
+      host.resumeEdits(); host.releaseEdit();
+      await Promise.all([...queuedB, ...startC]);
+      assert.notStrictEqual(host.pendingDraftRequestId, firstRequest.requestId, 'the received new draft invalidates the earlier ACK');
+      assert.strictEqual(host.panel.webview.html, html);
+      assert.ok(view.cell(1, 2).textContent.includes('THIRD-LIVE-DRAFT'));
+      assert.strictEqual(host.rows()[1][2], 'three');
+      await flushViewCommits(host, view);
+      assert.deepStrictEqual(host.rows(), [['a', 'b', 'c'], ['one recovered', 'two SECOND-DRAFT', 'three THIRD-LIVE-DRAFT']]);
+    } finally { view.close(); }
+  });
+
+  it('discard restores the current owner after an external edit without applying the failed DOM value', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell()); view.type('failed'); view.cell().blur();
+      host.failEdits('false'); await host.receive(view.messages.find(message => message.type === 'editCell'));
+      deliver(host, view); host.failEdits(undefined);
+      await host.applyEdit('name,value\nexternal,change');
+      await host.receive({ type: 'deleteRow', index: 1 }); deliver(host, view);
+      view.messages.length = 0; view.key('Escape');
+      await host.receive(view.messages.find(message => message.type === 'discardCellDraft'));
+      assert.deepStrictEqual(host.rows(), [['name', 'value'], ['external', 'change']]);
+      await flushViewCommits(host, view);
+      const fresh = createWebviewDom(host.panel.webview.html);
+      try { assert.strictEqual(fresh.cell().textContent, 'external'); } finally { fresh.close(); }
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/filter-switch-refresh.test.ts b/src/test/filter-switch-refresh.test.ts
new file mode 100644
index 0000000..39b468b
--- /dev/null
+++ b/src/test/filter-switch-refresh.test.ts
@@ -0,0 +1,52 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+describe('inline filter refresh with a view switch', () => {
+  it('applies an accepted inline Clear all before resolving a pending draft commit and reopening', async () => {
+    const host = await createEditorHarness({ rows: [['name'], ['one'], ['two']],
+      filters: [{ column: 0, operator: 'equals', value: 'one' }] });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const document = view.window.document;
+      const table = document.querySelector('table');
+      const originalHtml = host.panel.webview.html;
+      const originalSource = host.document.getText();
+      assert.strictEqual(document.getElementById('csv-root').dataset.filtered, '1');
+      assert.strictEqual(view.cell(2, 0), null);
+      const start = view.messages.length;
+      document.getElementById('clearAllFilters').click();
+      await new Promise(resolve => setTimeout(resolve, 140));
+      const outgoing = view.messages.slice(start);
+      const request = outgoing.find(message => message.type === 'updateColumnFilters');
+      assert.ok(request, 'the inline Clear all control submits a current empty snapshot');
+      assert.strictEqual(request.filters.length, 0);
+      await Promise.all(outgoing.map(message => host.receive(message)));
+      const result = host.messages.find(message => message.type === 'columnFiltersResult' && message.revision === request.revision);
+      assert.ok(result && !result.error && !result.errors?.length);
+
+      let finished = false;
+      const pending = host.commitPendingDraft().then(success => { finished = true; return success; });
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: result }));
+      assert.strictEqual(document.querySelector('table'), table, 'live filtering preserves the delegated table');
+      assert.strictEqual(document.getElementById('csv-root').dataset.filtered, '0');
+      assert.strictEqual(view.cell(2, 0).textContent, 'two');
+      assert.strictEqual(document.getElementById('filterStatus').hidden, true);
+      assert.strictEqual(finished, false, 'the source-view commit still waits for its real webview acknowledgment');
+      await flushViewCommits(host, view);
+      assert.strictEqual(await pending, true);
+      assert.strictEqual(host.panel.webview.html, originalHtml, 'the live clear and draft-only commit do not replace the webview');
+      assert.strictEqual(host.document.getText(), originalSource);
+      assert.strictEqual(host.diskText, originalSource);
+      assert.strictEqual(host.document.version, 1);
+
+      await host.view(false, false);
+      await host.view(true, true);
+      const reopened = createWebviewDom(host.panel.webview.html);
+      try {
+        assert.strictEqual(reopened.window.document.getElementById('csv-root').dataset.filtered, '0');
+        assert.strictEqual(reopened.cell(2, 0).textContent, 'two');
+      } finally { reopened.close(); }
+    } finally { view.close(); host.dispose(); }
+  });
+});
diff --git a/src/test/filter-values.test.ts b/src/test/filter-values.test.ts
new file mode 100644
index 0000000..93adb0f
--- /dev/null
+++ b/src/test/filter-values.test.ts
@@ -0,0 +1,234 @@
+import assert from 'assert';
+import { spawnSync } from 'child_process';
+import { describe, it } from 'node:test';
+import { compareFilterDates, compareFilterNumbers, compileFilterDateComparison, compileFilterNumberComparison, parseFilterBoolean, parseFilterDate, parseFilterNumber } from '../filter-values';
+
+function assertDate(input: string, expected: string) {
+  const value = parseFilterDate(input);
+  assert.notStrictEqual(value, undefined, input);
+  assert.strictEqual(new Date(value!).toISOString(), expected, input);
+}
+
+describe('Typed filter values', () => {
+  it('parses whole finite decimal/scientific values without treating blanks as zero', () => {
+    const cases: Array<[string, number]> = [
+      ['0', 0], [' +42 ', 42], ['-.5', -0.5], ['1.', 1],
+      ['6.02e23', 6.02e23], ['-1.25E-3', -0.00125], ['.25e+2', 25],
+      ['1,234', 1234], ['12,345,678.90', 12345678.9], ['1,234e2', 123400],
+      ['1 234.50', 1234.5], ["1'234'567.5", 1234567.5],
+      ['1\u00a0234', 1234], ['1\u202f234\u202f567', 1234567]
+    ];
+    for (const [input, expected] of cases) {
+      assert.strictEqual(parseFilterNumber(input), expected, input);
+    }
+    assert.ok(Object.is(parseFilterNumber('-0'), -0));
+    for (const input of [
+      '', ' ', '\t\n', '0x10', '0b10', '0o10', '12kg', '12%', '$12', '1_000',
+      '1e', '1e+', '--1', '+ 1', '1 23', '1234,567', '1,23', '1,234,56',
+      '1,234 567', '1\u00a0234\u202f567', '1,234.5.6', 'Infinity', '-Infinity', 'NaN', '1e309', '1\n2', '1,5', '-.'
+    ]) {
+      assert.strictEqual(parseFilterNumber(input), undefined, input);
+    }
+  });
+
+  it('compares large identifiers and decimal coefficients without binary rounding', () => {
+    const pairs: Array<[string, string, -1 | 0 | 1]> = [
+      ['9007199254740992', '9007199254740993', -1],
+      ['-9007199254740993', '-9007199254740992', -1],
+      ['9007199254740993', '9.007199254740993e15', 0],
+      ['9,007,199,254,740,993', '9007199254740992', 1],
+      ['0.10000000000000001', '0.1', 1],
+      ['-0.10000000000000001', '-0.1', -1],
+      ['0001.2000', '+12e-1', 0],
+      ['.00012', '12e-5', 0],
+      ['999.999999999999999999', '1000', -1],
+      ['-999.999999999999999999', '-1000', 1],
+      ['1.000000000000000000001e-300', '1e-300', 1],
+      ['-0', '+0.000e999999999999999999999999999', 0],
+      ['-1e-400', '0', -1], ['1e-400', '0', 1],
+      ['1e-400', '1e-401', 1], ['-1e-400', '-1e-401', -1],
+      ['1e-9007199254740991', '.1e-9007199254740991', 1],
+      ['1e-9007199254740990', '10e-9007199254740991', 0],
+      ['.01e-9007199254740991', '.001e-9007199254740991', 1]
+    ];
+    for (const [first, second, expected] of pairs) {
+      assert.strictEqual(compareFilterNumbers(first, second), expected, `${first} vs ${second}`);
+      const reverse = expected === 0 ? 0 : -expected;
+      assert.strictEqual(compareFilterNumbers(second, first), reverse, `${second} vs ${first}`);
+    }
+  });
+
+  it('compiles exact numeric thresholds and rejects invalid or nonfinite comparisons', () => {
+    const compare = compileFilterNumberComparison('9,007,199,254,740,993');
+    assert.ok(compare);
+    assert.strictEqual(compare!('9007199254740992'), -1);
+    assert.strictEqual(compare!('9007199254740993'), 0);
+    assert.strictEqual(compare!('9007199254740994'), 1);
+    assert.strictEqual(compare!('9007199254740993suffix'), undefined);
+    for (const input of ['', ' ', '1,23', '1e309', 'Infinity', 'NaN', '0x10', '1e-9007199254740992']) {
+      assert.strictEqual(compileFilterNumberComparison(input), undefined, input);
+      assert.strictEqual(compareFilterNumbers(input, '1'), undefined, input);
+      assert.strictEqual(compareFilterNumbers('1', input), undefined, input);
+    }
+    assert.strictEqual(parseFilterNumber('1e-9007199254740992'), 0, 'finite conversion and exact-comparison exponent limits are distinct');
+  });
+
+  it('recognizes only the complete existing boolean vocabulary, including false', () => {
+    for (const input of ['true', 't', 'yes', 'y', 'on', '1', ' TRUE ', 'YeS']) {
+      assert.strictEqual(parseFilterBoolean(input), true, input);
+    }
+    for (const input of ['false', 'f', 'no', 'n', 'off', '0', ' FALSE ', 'oFf']) {
+      assert.strictEqual(parseFilterBoolean(input), false, input);
+    }
+    for (const input of ['', ' ', '01', '1.0', '2', '-1', 'truth', 'falsehood', 'yes please', 'null']) {
+      assert.strictEqual(parseFilterBoolean(input), undefined, input);
+    }
+  });
+
+  it('validates full year-first calendar dates, leap centuries and early years', () => {
+    for (const input of ['2024-02-29', '2024/02/29', '2024/2/29']) {
+      assertDate(input, '2024-02-29T00:00:00.000Z');
+    }
+    assertDate('2000-02-29', '2000-02-29T00:00:00.000Z');
+    assertDate('0099-01-02', '0099-01-02T00:00:00.000Z');
+    assertDate('0000-02-29', '0000-02-29T00:00:00.000Z');
+    assertDate('9999-12-31', '9999-12-31T00:00:00.000Z');
+    for (const input of [
+      '2023-02-29', '1900-02-29', '2100-02-29', '2024-04-31', '2024-00-01',
+      '2024-13-01', '2024-01-00', '2024-01-32', '2024-1/01', '-2024-01-01', '10000-01-01'
+    ]) {
+      assert.strictEqual(parseFilterDate(input), undefined, input);
+    }
+  });
+
+  it('supports clear US/EU numeric dates and consistently uses month-first for ambiguous dates', () => {
+    for (const input of ['12/31/2024', '31/12/2024', '12-31-2024', '31.12.2024']) {
+      assertDate(input, '2024-12-31T00:00:00.000Z');
+    }
+    assertDate('13/02/2024', '2024-02-13T00:00:00.000Z');
+    assertDate('03/04/2024', '2024-03-04T00:00:00.000Z');
+    assertDate('11/12/2024', '2024-11-12T00:00:00.000Z');
+    for (const input of ['13/14/2024', '02/29/2023', '29/02/2023', '04/31/2024', '00/12/2024', '31/00/2024', '1/2/24']) {
+      assert.strictEqual(parseFilterDate(input), undefined, input);
+    }
+  });
+
+  it('parses English full/abbreviated month names and checks ordinals and explicit weekdays', () => {
+    for (const input of ['February 29, 2024', '29 Feb 2024', '29-Feb-2024', 'Feb. 29th, 2024', 'Thursday, 29 February 2024', 'Thu, 29 Feb 2024']) {
+      assertDate(input, '2024-02-29T00:00:00.000Z');
+    }
+    for (const input of ['September 21st 2024', '21 Sept 2024']) {
+      assertDate(input, '2024-09-21T00:00:00.000Z');
+    }
+    for (const input of ['February 30, 2024', 'Frobuary 1, 2024', 'January 11st, 2024', '29st February 2024', 'Friday, 29 February 2024', 'Jan--2--2024']) {
+      assert.strictEqual(parseFilterDate(input), undefined, input);
+    }
+  });
+
+  it('parses seconds and fractions with deterministic UTC for naive times', () => {
+    assertDate('2024-02-29T23:59:59.9', '2024-02-29T23:59:59.900Z');
+    assertDate('2024/02/29 1:02:03.12', '2024-02-29T01:02:03.120Z');
+    assertDate('2024-02-29t01:02:03.123456789z', '2024-02-29T01:02:03.123Z');
+    assertDate('2024-02-29 01:02', '2024-02-29T01:02:00.000Z');
+    assertDate('2024-02-29 UTC', '2024-02-29T00:00:00.000Z');
+    assertDate('2024-02-29 GMT', '2024-02-29T00:00:00.000Z');
+  });
+
+  it('normalizes explicit Z/UTC/GMT and signed offsets across day/year boundaries', () => {
+    for (const zone of ['Z', ' UTC', ' GMT', '+00:00', '-0000']) {
+      assertDate(`2024-01-01T13:05:07${zone}`, '2024-01-01T13:05:07.000Z');
+    }
+    for (const zone of ['+02:30', '+0230', ' GMT+0230', ' UTC+02:30']) {
+      assertDate(`2024-01-01T00:30:45.123456${zone}`, '2023-12-31T22:00:45.123Z');
+    }
+    assertDate('2024-12-31 23:30-05:30', '2025-01-01T05:00:00.000Z');
+    assertDate('2024-01-01 13:05+05', '2024-01-01T08:05:00.000Z');
+    assertDate('2024-01-01 00:00+23:59', '2023-12-31T00:01:00.000Z');
+  });
+
+  it('handles 12-hour AM/PM including noon, midnight and fractional seconds', () => {
+    assertDate('March 4, 2024 3:05:07.12 PM UTC', '2024-03-04T15:05:07.120Z');
+    assertDate('4 Mar 2024 12am', '2024-03-04T00:00:00.000Z');
+    assertDate('4 Mar 2024 12:00 PM', '2024-03-04T12:00:00.000Z');
+    assertDate('03/04/2024 3 PM -0500', '2024-03-04T20:00:00.000Z');
+    for (const input of ['2024-01-01 0:30 AM', '2024-01-01 13:30 PM', '2024-01-01 3:60 PM', '2024-01-01 AM']) {
+      assert.strictEqual(parseFilterDate(input), undefined, input);
+    }
+  });
+
+  it('rejects impossible clocks/offsets and bare, incomplete or partially matched values', () => {
+    for (const input of [
+      '', ' ', '0', '1', '2024', '20240101', '2024-02', '02/29', 'Feb 29', 'February 2024', '1:00 PM',
+      '2024-01-01T', '2024-01-01TZ', '2024-01-01T24:00', '2024-01-01T23:60', '2024-01-01T23:59:60Z',
+      '2024-01-01T12:1', '2024-01-01T12:00:1', '2024-01-01T12:00.5', '2024-01-01T12',
+      '2024-01-01T12:00+24:00', '2024-01-01T12:00+23:60', '2024-01-01T12:00+5:30',
+      '2024-01-01T12:00+050', '2024-01-01T12:00-2500', '2024-01-01T12:00 PST',
+      '2024-01-01junk', '2024-01-01 12:00Z junk', 'January 1, 2024 extra',
+      'prefix 2024-01-01', '2024-01-010', '12/31/20240', 'true', '1e3'
+    ]) {
+      assert.strictEqual(parseFilterDate(input), undefined, input);
+    }
+  });
+
+  it('compares microsecond/nanosecond fractions exactly while preserving the millisecond parser API', () => {
+    const base = '2024-01-01T00:00:00';
+    const pairs: Array<[string, string, -1 | 0 | 1]> = [
+      [`${base}.0001Z`, `${base}.0002Z`, -1],
+      [`${base}.000100Z`, `${base}.0001Z`, 0],
+      [`${base}.123456789Z`, `${base}.123456788Z`, 1],
+      [`${base}.1230000000000000001Z`, `${base}.123Z`, 1],
+      [`${base}.00001Z`, `${base}.0001Z`, -1],
+      [`${base}.100000Z`, `${base}.1Z`, 0],
+      [`${base}.000000Z`, '2024-01-01', 0]
+    ];
+    for (const [first, second, expected] of pairs) {
+      assert.strictEqual(compareFilterDates(first, second), expected, `${first} vs ${second}`);
+      assert.strictEqual(compareFilterDates(second, first), expected === 0 ? 0 : -expected);
+    }
+    assert.strictEqual(parseFilterDate(`${base}.0001Z`), Date.UTC(2024, 0, 1));
+    assert.strictEqual(parseFilterDate(`${base}.0002Z`), Date.UTC(2024, 0, 1));
+  });
+
+  it('compiles exact date thresholds across zones/formats and rejects invalid comparisons', () => {
+    const compare = compileFilterDateComparison('2024-01-01T00:00:00.0001Z');
+    assert.ok(compare);
+    for (const input of [
+      '2024-01-01 05:30:00.000100+05:30',
+      'January 1, 2024 12:00:00.0001 AM GMT',
+      '31/12/2023 19:00:00.000100-0500'
+    ]) {
+      assert.strictEqual(compare!(input), 0, input);
+    }
+    assert.strictEqual(compare!('2024-01-01 05:30:00.0002+05:30'), 1);
+    assert.strictEqual(compare!('2024-01-01 05:30:00.00009+05:30'), -1);
+    for (const input of ['', '2024', '2023-02-29T00:00:00.0001Z', '2024-01-01T00:00:00.0001Z suffix']) {
+      assert.strictEqual(compileFilterDateComparison(input), undefined, input);
+      assert.strictEqual(compare!(input), undefined, input);
+      assert.strictEqual(compareFilterDates(input, '2024-01-01'), undefined, input);
+    }
+  });
+
+  it('orders positive fractional remainders correctly before and across the Unix epoch', () => {
+    const first = '1969-12-31T23:59:59.9998Z';
+    const second = '1969-12-31T23:59:59.9999Z';
+    assert.strictEqual(parseFilterDate(first), -1);
+    assert.strictEqual(parseFilterDate(second), -1);
+    assert.strictEqual(compareFilterDates(first, second), -1);
+    assert.strictEqual(compareFilterDates(second, '1969-12-31 18:59:59.999900-05:00'), 0);
+    assert.strictEqual(compareFilterDates(second, '1970-01-01T00:00:00Z'), -1);
+    assert.strictEqual(compareFilterDates('1969-12-31T23:59:59.0001Z', '1969-12-31T23:59:59.0002Z'), -1);
+    assert.strictEqual(compareFilterDates('1969-12-31T23:59:59.9999Z', '1970-01-01T00:00:00.0001Z'), -1);
+  });
+
+  it('keeps naive/date-only results identical across extension-host time zones', () => {
+    const script = "const {parseFilterDate}=require(process.argv[1]); process.stdout.write(JSON.stringify(['2024-03-10','2024-03-10 02:30','2024-11-03 01:30'].map(parseFilterDate)));";
+    const expected = [Date.UTC(2024, 2, 10), Date.UTC(2024, 2, 10, 2, 30), Date.UTC(2024, 10, 3, 1, 30)];
+    for (const timezone of ['UTC', 'America/Los_Angeles', 'Asia/Kolkata']) {
+      const child = spawnSync(process.execPath, ['-e', script, require.resolve('../filter-values')], {
+        env: { ...process.env, TZ: timezone }, encoding: 'utf8'
+      });
+      assert.strictEqual(child.status, 0, child.stderr);
+      assert.deepStrictEqual(JSON.parse(child.stdout), expected, timezone);
+    }
+  });
+});
diff --git a/src/test/find-shortcut-modifiers.test.ts b/src/test/find-shortcut-modifiers.test.ts
new file mode 100644
index 0000000..f39d633
--- /dev/null
+++ b/src/test/find-shortcut-modifiers.test.ts
@@ -0,0 +1,50 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+type View = ReturnType<typeof createWebviewDom>;
+function key(view: View, value: string, modifiers: Record<string, unknown>) {
+  const event = new view.window.KeyboardEvent('keydown', { key: value, bubbles: true, cancelable: true, ...modifiers });
+  view.window.document.activeElement.dispatchEvent(event);
+  return event;
+}
+
+describe('Local Find and Replace shortcut modifiers', () => {
+  for (const modifier of ['metaKey', 'ctrlKey']) {
+    for (const shortcut of ['f', 'h']) {
+      it(`opens local ${shortcut === 'f' ? 'Find' : 'Replace'} only for plain ${modifier}`, async () => {
+        const host = await createEditorHarness();
+        const view = createWebviewDom(host.panel.webview.html);
+        try {
+          const widget = view.window.document.getElementById('findReplaceWidget');
+          view.window.editingTestApi.setSingleSelection(view.cell());
+          const event = key(view, shortcut.toUpperCase(), { [modifier]: true });
+          assert.strictEqual(event.defaultPrevented, true);
+          assert.strictEqual(widget.classList.contains('open'), true);
+          assert.strictEqual(widget.classList.contains('replace-expanded'), shortcut === 'h');
+          assert.strictEqual(view.window.document.activeElement, view.window.document.getElementById('findInput'));
+          assert.strictEqual(host.document.version, 1);
+        } finally { view.close(); }
+      });
+      for (const extra of [{ shiftKey: true }, { altKey: true }, { shiftKey: true, altKey: true }]) {
+        it(`leaves native ${modifier}+${Object.keys(extra).join('+')}+${shortcut.toUpperCase()} untouched`, async () => {
+          const host = await createEditorHarness();
+          const view = createWebviewDom(host.panel.webview.html);
+          try {
+            const cell = view.cell();
+            view.start(cell);
+            cell.textContent = 'live draft';
+            const event = key(view, shortcut, { [modifier]: true, ...extra });
+            assert.strictEqual(event.defaultPrevented, false);
+            assert.strictEqual(event.cancelBubble, false);
+            assert.strictEqual(view.window.document.getElementById('findReplaceWidget').classList.contains('open'), false);
+            assert.strictEqual(view.window.document.activeElement, cell);
+            assert.strictEqual(cell.getAttribute('contenteditable'), 'true');
+            assert.ok(!view.messages.some(message => message.type === 'editCell' || message.type === 'findMatches'));
+            assert.strictEqual(host.document.version, 1);
+          } finally { view.close(); }
+        });
+      }
+    }
+  }
+});
diff --git a/src/test/fixtures/README.md b/src/test/fixtures/README.md
new file mode 100644
index 0000000..4af6753
--- /dev/null
+++ b/src/test/fixtures/README.md
@@ -0,0 +1,7 @@
+`issue-76-products.csv` is the original 4,052-byte attachment from
+https://github.com/jonaraphael/csv/issues/76, downloaded without conversion from
+https://github.com/user-attachments/files/25353528/w3schools_dbo_Products.csv.
+
+It is not valid UTF-8. CP437 and CP850 produce identical Unicode text for all
+bytes present in this particular fixture; the fixture cannot distinguish which
+encoding created it. Tests decode explicitly and do not infer or repair bytes.
diff --git a/src/test/fixtures/issue-76-products.csv b/src/test/fixtures/issue-76-products.csv
new file mode 100644
index 0000000..c5d87b3
--- /dev/null
+++ b/src/test/fixtures/issue-76-products.csv
@@ -0,0 +1,79 @@
+[ProductID],[ProductName],[SuplID],[CatID],[Unit],[Price]
+[int],[varchar(50)],[int],[int],[varchar(50)],[decimal(18, 2)]
+1,"Chais",1,1,"10 boxes x 20 bags",18.00
+2,"Chang",1,1,"24 - 12 oz bottles",19.00
+3,"Aniseed Syrup",1,2,"12 - 550 ml bottles",10.00
+4,"Chef Antons Cajun Seasoning",2,2,"48 - 6 oz jars",22.00
+5,"Chef Antons Gumbo Mix",2,2,"36 boxes",21.35
+6,"Grandmas Boysenberry Spread",3,2,"12 - 8 oz jars",25.00
+7,"Uncle Bobs Organic Dried Pears",3,7,"12 - 1 lb pkgs",30.00
+8,"Northwoods Cranberry Sauce",3,2,"12 - 12 oz jars",40.00
+9,"Mishi Kobe Niku",4,6,"18 - 500 g pkgs",97.00
+10,"Ikura",4,8,"12 - 200 ml jars",31.00
+11,"Queso Cabrales",5,4,"1 kg pkg",21.00
+12,"Queso Manchego La Pastora",5,4,"10 - 500 g pkgs",38.00
+13,"Konbu",6,8,"2 kg box",6.00
+14,"Tofu",6,7,"40 - 100 g pkgs",23.25
+15,"Genen Shouyu",6,2,"24 - 250 ml bottles",15.50
+16,"Pavlova",7,3,"32 - 500 g boxes",17.45
+17,"Alice Mutton",7,6,"20 - 1 kg tins",39.00
+18,"Carnarvon Tigers",7,8,"16 kg pkg",62.50
+19,"Teatime Chocolate Biscuits",8,3,"10 boxes x 12 pieces",9.20
+20,"Sir Rodneys Marmalade",8,3,"30 gift boxes",81.00
+21,"Sir Rodneys Scones",8,3,"24 pkgs. x 4 pieces",10.00
+22,"Gustafs Kn�ckebr�d",9,5,"24 - 500 g pkgs",21.00
+23,"Tunnbr�d",9,5,"12 - 250 g pkgs",9.00
+24,"Guaran� Fant�stica",10,1,"12 - 355 ml cans",4.50
+25,"NuNuCa Nu�-Nougat-Creme",11,3,"20 - 450 g glasses",14.00
+26,"Gumb�r Gummib�rchen",11,3,"100 - 250 g bags",31.23
+27,"Schoggi Schokolade",11,3,"100 - 100 g pieces",43.90
+28,"R�ssle Sauerkraut",12,7,"25 - 825 g cans",45.60
+29,"Th�ringer Rostbratwurst",12,6,"50 bags x 30 sausgs",123.79
+30,"Nord-Ost Matjeshering",13,8,"10 - 200 g glasses",25.89
+31,"Gorgonzola Telino",14,4,"12 - 100 g pkgs",12.50
+32,"Mascarpone Fabioli",14,4,"24 - 200 g pkgs",32.00
+33,"Geitost",15,4,"500 g",2.50
+34,"Sasquatch Ale",16,1,"24 - 12 oz bottles",14.00
+35,"Steeleye Stout",16,1,"24 - 12 oz bottles",18.00
+36,"Inlagd Sill",17,8,"24 - 250 g jars",19.00
+37,"Gravad lax",17,8,"12 - 500 g pkgs",26.00
+38,"C�te de Blaye",18,1,"12 - 75 cl bottles",263.50
+39,"Chartreuse verte",18,1,"750 cc per bottle",18.00
+40,"Boston Crab Meat",19,8,"24 - 4 oz tins",18.40
+41,"Jacks New England Clam Chowder",19,8,"12 - 12 oz cans",9.65
+42,"Singaporean Hokkien Fried Mee",20,5,"32 - 1 kg pkgs",14.00
+43,"Ipoh Coffee",20,1,"16 - 500 g tins",46.00
+44,"Gula Malacca",20,2,"20 - 2 kg bags",19.45
+45,"Rogede sild",21,8,"1k pkg",9.50
+46,"Spegesild",21,8,"4 - 450 g glasses",12.00
+47,"Zaanse koeken",22,3,"10 - 4 oz boxes",9.50
+48,"Chocolade",22,3,"10 pkgs",12.75
+49,"Maxilaku",23,3,"24 - 50 g pkgs",20.00
+50,"Valkoinen suklaa",23,3,"12 - 100 g bars",16.25
+51,"Manjimup Dried Apples",24,7,"50 - 300 g pkgs",53.00
+52,"Filo Mix",24,5,"16 - 2 kg boxes",7.00
+53,"Perth Pasties",24,6,"48 pieces",32.80
+54,"Tourti�re",25,6,"16 pies",7.45
+55,"P�t� chinois",25,6,"24 boxes x 2 pies",24.00
+56,"Gnocchi di nonna Alice",26,5,"24 - 250 g pkgs",38.00
+57,"Ravioli Angelo",26,5,"24 - 250 g pkgs",19.50
+58,"Escargots de Bourgogne",27,8,"24 pieces",13.25
+59,"Raclette Courdavault",28,4,"5 kg pkg",55.00
+60,"Camembert Pierrot",28,4,"15 - 300 g rounds",34.00
+61,"Sirop d�rable",29,2,"24 - 500 ml bottles",28.50
+62,"Tarte au sucre",29,3,"48 pies",49.30
+63,"Vegie-spread",7,2,"15 - 625 g jars",43.90
+64,"Wimmers gute Semmelkn�del",12,5,"20 bags x 4 pieces",33.25
+65,"Louisiana Fiery Hot Pepper Sauce",2,2,"32 - 8 oz bottles",21.05
+66,"Louisiana Hot Spiced Okra",2,2,"24 - 8 oz jars",17.00
+67,"Laughing Lumberjack Lager",16,1,"24 - 12 oz bottles",14.00
+68,"Scottish Longbreads",8,3,"10 boxes x 8 pieces",12.50
+69,"Gudbrandsdalsost",15,4,"10 kg pkg",36.00
+70,"Outback Lager",7,1,"24 - 355 ml bottles",15.00
+71,"Flotemysost",15,4,"10 - 500 g pkgs",21.50
+72,"Mozzarella di Giovanni",14,4,"24 - 200 g pkgs",34.80
+73,"R�d Kaviar",17,8,"24 - 150 g jars",15.00
+74,"Longlife Tofu",4,7,"5 kg pkg",10.00
+75,"Rh�nbr�u Klosterbier",12,1,"24 - 0.5 l bottles",7.75
+76,"Lakkalik��ri",23,1,"500 ml",18.00
+77,"Original Frankfurter gr�ne So�e",12,2,"12 boxes",13.00
diff --git a/src/test/frozen-pane-commands.test.ts b/src/test/frozen-pane-commands.test.ts
new file mode 100644
index 0000000..1d7733a
--- /dev/null
+++ b/src/test/frozen-pane-commands.test.ts
@@ -0,0 +1,44 @@
+import assert from 'assert';
+import Module from 'module';
+import { describe, it } from 'node:test';
+
+const commands = new Map<string, () => Promise<void>>();
+let input: string | undefined;
+let prompt: any;
+const changes: any[] = [];
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return {
+      commands: { registerCommand: (name: string, callback: () => Promise<void>) => { commands.set(name, callback); return { dispose() {} }; } },
+      window: { showInputBox: async (options: any) => { prompt = options; return input; }, showInformationMessage() {} }
+    };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { registerCsvCommands } from '../commands';
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+registerCsvCommands({ subscriptions: [] } as any);
+
+describe('Frozen-pane commands', () => {
+  it('updates the requested axis with validated counts and leaves cancellation unchanged', async () => {
+    CsvEditorProvider.currentActive = { isActive: () => true, getCurrentFrozenPanes: () => ({ rows: 3, columns: 1 }), setFrozenPanes: async (change: any) => changes.push(change) } as any;
+    input = '2';
+    await commands.get('csv.changeFrozenRows')!();
+    assert.strictEqual(prompt.value, '3');
+    assert.strictEqual(prompt.validateInput('0'), undefined);
+    assert.ok(prompt.validateInput('-1'));
+    assert.ok(prompt.validateInput('1.5'));
+    assert.deepStrictEqual(changes, [{ rows: 2 }]);
+    input = '0';
+    await commands.get('csv.changeFrozenColumns')!();
+    assert.deepStrictEqual(changes, [{ rows: 2 }, { columns: 0 }]);
+    input = undefined;
+    await commands.get('csv.changeFrozenRows')!();
+    input = 'invalid';
+    await commands.get('csv.changeFrozenRows')!();
+    assert.strictEqual(changes.length, 2);
+    CsvEditorProvider.currentActive = undefined;
+  });
+});
diff --git a/src/test/frozen-panes.test.ts b/src/test/frozen-panes.test.ts
new file mode 100644
index 0000000..bc82ca0
--- /dev/null
+++ b/src/test/frozen-panes.test.ts
@@ -0,0 +1,353 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+
+function measure(view: ReturnType<typeof createWebviewDom>, heights = [25, 60, 35, 30]) {
+  for (const row of Array.from(view.window.document.querySelectorAll('tr')) as any[]) {
+    const index = Number(row.querySelector('[data-row]')?.getAttribute('data-row'));
+    const height = () => (heights[index] ?? 30) * (parseFloat(view.window.document.body.style.fontSize) / 14 || 1);
+    row.getBoundingClientRect = () => ({ height: height() });
+    for (const cell of Array.from(row.cells) as any[]) {
+      // JSDOM cannot resolve the color variable in border shorthand. Model the
+      // browser's fixed 1px width; specific border regressions override it below.
+      cell.style.borderTopWidth = '1px';
+      const col = cell.getAttribute('data-col') === null ? -1 : Number(cell.getAttribute('data-col'));
+      const width = () => parseFloat(cell.style.width) || (col === -1 ? 30 : (col === 0 ? 90 : 140));
+      cell.getBoundingClientRect = () => ({ left: col === -1 ? 0 : 30 + col * 90, right: col === -1 ? 30 : 30 + col * 90 + width(), width: width(), height: height() });
+    }
+  }
+}
+
+// jsdom does not implement pseudo-element computed styles. Match the live
+// cell against the real rule's owner selector; browser QA checks raster paint.
+function dividerRules(view: ReturnType<typeof createWebviewDom>): any[] {
+  return (Array.from(view.window.document.styleSheets) as any[])
+    .flatMap(sheet => Array.from(sheet.cssRules) as any[])
+    .filter(rule => rule.selectorText?.includes('.csv-frozen-row') && rule.selectorText.includes('::before'));
+}
+
+function dividerRule(view: ReturnType<typeof createWebviewDom>, cell: any): any {
+  return dividerRules(view).find(rule => cell.matches(rule.selectorText.replace(/::before\b/g, '')));
+}
+
+async function fixture(options: Parameters<typeof createEditorHarness>[0] = {}) {
+  const host = await createEditorHarness({ rows: [['Name', 'Value'], ['one\nsecond line', 'a'], ['two', 'b'], ['three', 'c']], ...options });
+  const view = createWebviewDom(host.panel.webview.html);
+  measure(view);
+  return { host, view };
+}
+
+describe('Frozen panes', () => {
+  it('paints every frozen row divider, including serial and corner cells, without painting column-only or append cells', async () => {
+    for (const separator of [',', '\t']) {
+      for (const header of [true, false]) {
+        const { host, view } = await fixture({ separator, header, hiddenRows: header ? 0 : 1, frozenRows: header ? 3 : 2, frozenColumns: 1 });
+        try {
+          const document = view.window.document;
+          const accessibility = document.createElement('style');
+          accessibility.textContent = fs.readFileSync(path.join(process.cwd(), 'media', 'high-contrast.css'), 'utf8');
+          document.head.append(accessibility);
+          measure(view, [25.5, 60.25, 35.75, 30]);
+          view.window.csvFrozenPanes.layout();
+          const frozen = Array.from(document.querySelectorAll('.csv-frozen-row')) as any[];
+          assert.strictEqual(frozen.length, (header ? 3 : 2) * 3, 'every data and serial cell in every requested row is frozen');
+          if (header) { assert.ok(frozen.includes(document.querySelector('thead th')), 'the coordinate-free serial corner is included'); }
+          const firstRow = header ? 0 : 1;
+          assert.strictEqual(view.cell(firstRow, 0).style.top, '-0.5px');
+          assert.strictEqual(view.cell(2, 0).style.top, header ? '85.25px' : '59.75px', 'fractional measured row spacing is unchanged');
+          const geometry = frozen.map(cell => [cell.style.top, cell.style.left, cell.style.height, cell.style.width, cell.getBoundingClientRect().height]);
+          for (const theme of ['vscode-light', 'vscode-dark', 'vscode-high-contrast', 'vscode-high-contrast-light']) {
+            document.body.className = theme;
+            for (const cell of frozen) {
+              const rule = dividerRule(view, cell);
+              assert.ok(rule, `${theme}: ${cell.tagName} row ${cell.dataset.row ?? 'corner'} must cover its collapsed divider seam`);
+              assert.ok(rule.style.getPropertyValue('content'), 'the divider pseudo-element is generated');
+              assert.strictEqual(rule.style.getPropertyValue('position'), 'absolute');
+              assert.strictEqual(rule.style.getPropertyValue('pointer-events'), 'none', 'divider paint cannot intercept cell selection or editing');
+              assert.ok(parseFloat(rule.style.getPropertyValue('inset')) < 0, 'the seam cover extends across the collapsed edge');
+              const border = rule.style.getPropertyValue('border-block');
+              assert.ok(border.includes('--csv-contrast-border') && border.includes('--csv-table-border'), 'both divider edges follow the existing HC/table border colors');
+              assert.strictEqual(rule.style.getPropertyValue('color'), '', 'divider paint does not replace cell foregrounds');
+            }
+            for (const cell of [view.cell(3, 0), view.cell(3, 1), view.cell(4, 0), view.cell(4, -1)]) {
+              assert.ok(!cell.classList.contains('csv-frozen-row'));
+              assert.ok(!dividerRule(view, cell), 'column-only, unfrozen and virtual cells do not receive row seam paint');
+            }
+            assert.deepStrictEqual(frozen.map(cell => [cell.style.top, cell.style.left, cell.style.height, cell.style.width, cell.getBoundingClientRect().height]), geometry);
+          }
+          view.window.csvFrozenPanes.update(0, 1);
+          view.window.csvFrozenPanes.layout();
+          for (const cell of frozen) {
+            assert.ok(!cell.classList.contains('csv-frozen-row'));
+            assert.ok(!dividerRule(view, cell), 'unfreezing removes only the row divider paint');
+            assert.strictEqual(cell.style.top, '');
+          }
+          assert.strictEqual(view.cell(firstRow, 0).style.left, '30px', 'column freezing remains intact');
+          assert.strictEqual(host.document.version, 1);
+          assert.strictEqual(host.document.getText(), host.diskText);
+        } finally { view.close(); }
+      }
+    }
+  });
+
+  it('keeps frozen selection and Find surfaces, outlines, colors and geometry unchanged by the divider paint rule', async () => {
+    const { view } = await fixture({ frozenRows: 3, frozenColumns: 1 });
+    try {
+      const document = view.window.document;
+      const accessibility = document.createElement('style');
+      accessibility.textContent = fs.readFileSync(path.join(process.cwd(), 'media', 'high-contrast.css'), 'utf8');
+      document.head.append(accessibility);
+      measure(view, [25.5, 60.25, 35.75, 30]);
+      view.window.csvFrozenPanes.layout();
+      view.cell(0, 0).classList.add('selected');
+      view.cell(1, 0).classList.add('highlight');
+      view.cell(2, 0).classList.add('active-match');
+      const cells = Array.from(document.querySelectorAll('th, td')) as any[];
+      const styles = Array.from(document.querySelectorAll('style')) as any[];
+      const originalStyles = styles.map(style => style.textContent);
+      const paintRules = dividerRules(view);
+      const withoutPaint = styles.map(style => Array.from(style.sheet.cssRules)
+        .filter((rule: any) => !paintRules.includes(rule))
+        .map((rule: any) => rule.cssText).join('\n'));
+      assert.ok(paintRules.length > 0, 'the actual provider stylesheet supplies the row seam paint');
+      const snapshot = () => cells.map(cell => {
+        const computed = view.window.getComputedStyle(cell);
+        return ['background-color', 'background-image', 'outline', 'outline-offset', 'color', 'border-top-width', 'padding', 'height', 'width', 'position', 'top', 'left', 'z-index'].map(property => computed.getPropertyValue(property));
+      });
+      for (const theme of ['vscode-light', 'vscode-dark', 'vscode-high-contrast', 'vscode-high-contrast-light']) {
+        document.body.className = theme;
+        const painted = snapshot();
+        styles.forEach((style, index) => { style.textContent = withoutPaint[index]; });
+        assert.deepStrictEqual(snapshot(), painted, `${theme}: painting the seam changes no existing selection/Find surface, outline, foreground or layout property`);
+        styles.forEach((style, index) => { style.textContent = originalStyles[index]; });
+        assert.deepStrictEqual(snapshot(), painted);
+        assert.ok(view.cell(0, 0).classList.contains('selected'));
+        assert.ok(view.cell(1, 0).classList.contains('highlight'));
+        assert.ok(view.cell(2, 0).classList.contains('active-match'));
+      }
+    } finally { view.close(); }
+  });
+  it('keeps measured multiline leading rows and data columns with proper corner stacking', async () => {
+    const { view } = await fixture({ frozenRows: 3, frozenColumns: 1 });
+    try {
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(0, 0).style.top, '-0.5px');
+      assert.strictEqual(view.cell(1, 0).style.top, '24.5px');
+      assert.strictEqual(view.cell(2, 0).style.top, '84.5px');
+      assert.strictEqual(view.cell(1, -1).style.left, '0px');
+      assert.strictEqual(view.cell(1, 0).style.left, '30px');
+      assert.strictEqual(view.cell(1, 0).style.zIndex, '4');
+      assert.strictEqual(view.cell(1, 1).style.zIndex, '3');
+      assert.strictEqual(view.cell(3, 0).style.zIndex, '2');
+      assert.ok(!view.cell(3, 1).classList.contains('csv-frozen-row'));
+      assert.ok(!view.cell(4, 0).classList.contains('csv-frozen-row'), 'append row remains virtual');
+    } finally { view.close(); }
+  });
+
+  it('covers the collapsed top border once without rounding fractional row spacing', async () => {
+    const { view } = await fixture({ frozenRows: 3, frozenColumns: 1 });
+    try {
+      const table = view.window.document.querySelector('table');
+      measure(view, [25.5, 60.25, 35.75, 30]);
+      for (const [collapse, border, firstTop] of [
+        ['collapse', 1, -0.5],
+        ['collapse', 2, -1],
+        ['collapse', 0, 0],
+        ['separate', 1, 0]
+      ] as const) {
+        table.style.borderCollapse = collapse;
+        for (const cell of Array.from(table.querySelectorAll('th, td')) as any[]) {
+          cell.style.borderTopWidth = `${border}px`;
+        }
+        view.window.csvFrozenPanes.layout();
+        assert.strictEqual(view.cell(0, 0).style.top, `${firstTop}px`);
+        assert.strictEqual(view.cell(1, 0).style.top, `${firstTop + 25.5}px`);
+        assert.strictEqual(view.cell(2, 0).style.top, `${firstTop + 85.75}px`);
+        assert.strictEqual(table.rows[0].cells[0].style.top, `${firstTop}px`, 'serial corner shares the frozen row origin');
+        assert.strictEqual(view.cell(0, 0).style.left, '30px', 'horizontal offsets remain measured independently');
+      }
+    } finally { view.close(); }
+  });
+
+  it('recomputes measured offsets after zoom and column resizing', async () => {
+    const { view } = await fixture({ frozenRows: 3, frozenColumns: 2 });
+    try {
+      view.window.csvFrozenPanes.layout();
+      view.cell(1, 0).focus();
+      view.key('+', { ctrlKey: true });
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(2, 0).style.top, '93px');
+      view.cell(0, 0).style.width = '200px';
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(1, 1).style.left, '230px');
+    } finally { view.close(); }
+  });
+
+  it('supports headers off and hidden metadata without freezing the append row', async () => {
+    const { view } = await fixture({ header: false, frozenRows: 100, hiddenRows: 1 });
+    try {
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(1, 0).style.top, '-0.5px');
+      assert.strictEqual(view.cell(2, 0).style.top, '59.5px');
+      assert.ok(!view.cell(4, 0).classList.contains('csv-frozen-row'));
+    } finally { view.close(); }
+  });
+
+  it('preserves the existing default header freeze and allows explicit zero to unfreeze it', async () => {
+    const { host, view } = await fixture();
+    try {
+      view.window.csvFrozenPanes.layout();
+      assert.ok(view.cell(0, 0).classList.contains('csv-frozen-row'));
+      await host.receive({ type: 'freezePanesChanged', rows: 0, columns: 0 });
+      const update = host.messages.slice().reverse().find((message: any) => message.type === 'frozenPanes');
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: update }));
+      view.window.csvFrozenPanes.layout();
+      assert.ok(!view.cell(0, 0).classList.contains('csv-frozen-row'));
+      assert.strictEqual(view.cell(0, 0).style.top, '', 'unfreezing clears the collapsed-border correction');
+      assert.strictEqual(view.cell(1, 0).style.top, '');
+      assert.deepStrictEqual(CsvEditorProvider.getFrozenPanesForUri(host.context as any, host.document.uri as any, true), { rows: 0, columns: 0 });
+    } finally { view.close(); }
+  });
+
+  it('persists each axis by URI and retains defaults for untouched files/header modes', async () => {
+    const { host, view } = await fixture();
+    try {
+      const uri = host.document.uri as any;
+      await CsvEditorProvider.setFrozenPanesForUri(host.context as any, uri, { rows: 3 });
+      await CsvEditorProvider.setFrozenPanesForUri(host.context as any, uri, { columns: 2 });
+      assert.deepStrictEqual(CsvEditorProvider.getFrozenPanesForUri(host.context as any, uri, true), { rows: 3, columns: 2 });
+      await CsvEditorProvider.setFrozenPanesForUri(host.context as any, uri, { rows: -1, columns: Infinity });
+      assert.deepStrictEqual(CsvEditorProvider.getFrozenPanesForUri(host.context as any, uri, true), { rows: 3, columns: 2 });
+      const other = { toString: () => 'file:///other.tsv' } as any;
+      assert.deepStrictEqual(CsvEditorProvider.getFrozenPanesForUri(host.context as any, other, true), { rows: 1, columns: 0 });
+      assert.deepStrictEqual(CsvEditorProvider.getFrozenPanesForUri(host.context as any, other, false), { rows: 0, columns: 0 });
+    } finally { view.close(); }
+  });
+
+  it('updates freeze state without replacing an active multiline draft, caret or selection', async () => {
+    const { host, view } = await fixture();
+    try {
+      const cell = view.cell(1, 0);
+      view.start(cell);
+      cell.textContent = 'unsaved\nmultiline draft';
+      view.caret(cell.firstChild, 8);
+      const html = host.panel.webview.html;
+      const source = host.document.getText();
+      const selected = Array.from(view.window.document.querySelectorAll('.selected'));
+      await host.receive({ type: 'freezePanesChanged', rows: 3, columns: 1 });
+      const update = host.messages.slice().reverse().find((message: any) => message.type === 'frozenPanes');
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: update }));
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(host.panel.webview.html, html);
+      assert.strictEqual(view.cell(1, 0), cell);
+      assert.strictEqual(cell.textContent, 'unsaved\nmultiline draft');
+      assert.strictEqual(view.window.document.activeElement, cell);
+      assert.strictEqual(view.window.getSelection().anchorOffset, 8);
+      assert.deepStrictEqual(Array.from(view.window.document.querySelectorAll('.selected')), selected);
+      assert.ok(dividerRule(view, cell), 'seam paint also covers the actively edited frozen row');
+      assert.strictEqual(host.document.getText(), source);
+      assert.strictEqual(host.document.version, 1);
+    } finally { view.close(); }
+  });
+
+  it('requests and freezes leading rows extending beyond the initial remote chunk', async () => {
+    const rows = Array.from({ length: 1100 }, (_, row) => [`row${row}`, 'value']);
+    const { host, view } = await fixture({ rows, frozenRows: 1002, frozenColumns: 1 });
+    try {
+      view.window.csvFrozenPanes.layout();
+      const request = view.messages.find((message: any) => message.type === 'requestChunk');
+      assert.ok(request);
+      await host.receive(request);
+      const response = host.messages.slice().reverse().find((message: any) => message.type === 'chunkData');
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: response }));
+      view.window.csvFrozenPanes.layout();
+      view.window.csvFrozenPanes.layout();
+      assert.ok(view.cell(1001, 0).classList.contains('csv-frozen-row'));
+      assert.ok(dividerRule(view, view.cell(1001, 0)), 'remote rows inherit the same divider paint');
+      assert.ok(dividerRule(view, view.cell(1001, -1)), 'remote serial cells are painted too');
+      assert.ok(view.cell(1002, 0).classList.contains('csv-frozen-column'));
+      assert.ok(!dividerRule(view, view.cell(1002, 0)));
+      const appendRequest = view.messages.slice().reverse().find((message: any) => message.type === 'requestChunk');
+      await host.receive(appendRequest);
+      const appendResponse = host.messages.slice().reverse().find((message: any) => message.type === 'chunkData');
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: appendResponse }));
+      view.window.__csvLoadNextChunk();
+      view.window.csvFrozenPanes.layout();
+      assert.ok(!view.cell(1100, 0).classList.contains('csv-frozen-row'));
+    } finally { view.close(); }
+  });
+
+  it('freezes through a context-menu target using visible row counts and can unfreeze', async () => {
+    const { view } = await fixture({ hiddenRows: 1, header: false });
+    try {
+      const target = view.cell(2, 1);
+      const openMenu = () => {
+        target.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true }));
+        target.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true }));
+      };
+      const choose = (label: string) => {
+        const item = Array.from(view.window.document.querySelectorAll('#contextMenu div')).find((element: any) => element.textContent === label) as any;
+        assert.ok(item, label);
+        item.click();
+      };
+      openMenu();
+      choose('Freeze rows through this row');
+      openMenu();
+      choose('Freeze columns through this column');
+      view.window.csvFrozenPanes.layout();
+      assert.strictEqual(view.cell(2, 1).style.zIndex, '4');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(view.messages.filter((message: any) => message.type === 'freezePanesChanged'))), [
+        { type: 'freezePanesChanged', rows: 2, columns: 0 }, { type: 'freezePanesChanged', rows: 2, columns: 2 }
+      ]);
+      openMenu();
+      choose('Unfreeze rows');
+      view.window.csvFrozenPanes.layout();
+      assert.ok(!view.cell(2, 1).classList.contains('csv-frozen-row'));
+      assert.ok(view.cell(2, 1).classList.contains('csv-frozen-column'));
+    } finally { view.close(); }
+  });
+
+  it('observes row-height changes and recalculates sticky offsets on the next frame', async () => {
+    const { view } = await fixture({ frozenRows: 3 });
+    try {
+      view.window.csvFrozenPanes.dispose();
+      let resized = () => {};
+      let observed = 0;
+      let disconnected = false;
+      view.window.ResizeObserver = class {
+        constructor(callback: () => void) { resized = callback; }
+        observe() { observed++; }
+        disconnect() { disconnected = true; }
+      };
+      const heights = [25, 60, 35, 30];
+      measure(view, heights);
+      const manager = view.window.createFrozenPaneManager({ table: view.window.document.querySelector('table'), firstRow: 0, realRowCount: 4 });
+      manager.update(3, 0);
+      await new Promise(resolve => view.window.requestAnimationFrame(resolve));
+      assert.ok(observed > 0);
+      assert.strictEqual(view.cell(2, 0).style.top, '84.5px');
+      heights[1] = 100;
+      resized();
+      await new Promise(resolve => view.window.requestAnimationFrame(resolve));
+      assert.strictEqual(view.cell(2, 0).style.top, '124.5px');
+      manager.dispose();
+      assert.strictEqual(disconnected, true);
+    } finally { view.close(); }
+  });
+
+  it('adds documented command contributions and opaque sticky theme surfaces', () => {
+    const manifest = JSON.parse(fs.readFileSync(path.join(process.cwd(), 'package.json'), 'utf8'));
+    const readme = fs.readFileSync(path.join(process.cwd(), 'README.md'), 'utf8');
+    for (const command of ['csv.changeFrozenRows', 'csv.changeFrozenColumns']) {
+      assert.ok(manifest.contributes.commands.some((item: any) => item.command === command));
+      assert.ok(manifest.activationEvents.includes(`onCommand:${command}`));
+      assert.ok(readme.includes(command));
+    }
+    const provider = fs.readFileSync(path.join(process.cwd(), 'src', 'CsvEditorProvider.ts'), 'utf8');
+    assert.ok(provider.includes('background-color: var(--vscode-editor-background,'));
+    assert.ok(provider.includes('background-image: linear-gradient(var(--vscode-editor-selectionBackground,'));
+  });
+});
diff --git a/src/test/header-click-behavior.test.ts b/src/test/header-click-behavior.test.ts
new file mode 100644
index 0000000..804f677
--- /dev/null
+++ b/src/test/header-click-behavior.test.ts
@@ -0,0 +1,158 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['Name', 'Value', 'https://example.com'], ['one', 'two', 'three'], ['four', 'five', 'six']];
+async function fixture(separator = ',', header = true) {
+  const host = await createEditorHarness({ rows, separator, header });
+  const view = createWebviewDom(host.panel.webview.html);
+  const table = view.window.document.querySelector('table');
+  table.getBoundingClientRect = () => ({ left: 0, right: 400, top: 0, bottom: 120, width: 400, height: 120 });
+  for (const cell of Array.from(table.querySelectorAll('[data-row][data-col]')) as any[]) {
+    const col = Number(cell.dataset.col), top = Number(cell.dataset.row) * 30;
+    cell.getBoundingClientRect = () => {
+      let left = 0;
+      for (let previous = -1; previous < col; previous++) {
+        const sibling = table.querySelector(`[data-row="${cell.dataset.row}"][data-col="${previous}"]`);
+        left += Number.parseFloat(sibling?.style.width) || 100;
+      }
+      const width = Number.parseFloat(cell.style.width) || 100;
+      return { left, right: left + width, top, bottom: top + 30, width, height: 30 };
+    };
+  }
+  return { host, view };
+}
+function mouse(view: View, target: any, type: string, options: Record<string, unknown> = {}) {
+  const cell = target.closest('td, th');
+  const rect = cell.getBoundingClientRect();
+  const event = new view.window.MouseEvent(type, { button: 0, buttons: type === 'mousemove' ? 1 : 0, detail: 1, bubbles: true, cancelable: true, clientX: rect.left + rect.width / 2, clientY: rect.top + 15, ...options });
+  target.dispatchEvent(event);
+  return event;
+}
+function click(view: View, target: any, detail = 1, options: Record<string, unknown> = {}) {
+  for (const type of ['mousedown', 'mouseup', 'click']) { mouse(view, target, type, { detail, ...options }); }
+}
+function selected(view: View) { return Array.from(view.window.document.querySelectorAll('td.selected, th.selected')) as any[]; }
+function column(view: View, index: number) { return Array.from(view.window.document.querySelectorAll(`[data-col="${index}"]`)); }
+
+describe('Separate header clicks', () => {
+  for (const separator of [',', '\t']) {
+    it(`selects a new column immediately, then only its header on a second separate click (${JSON.stringify(separator)})`, async () => {
+      const { host, view } = await fixture(separator);
+      try {
+        const header = view.cell(0, 1);
+        const span = view.window.document.createElement('span');
+        span.textContent = header.textContent;
+        header.replaceChildren(span);
+        mouse(view, span, 'mousedown');
+        assert.deepStrictEqual(selected(view), column(view, 1), 'first press retains immediate whole-column selection');
+        mouse(view, span, 'mouseup'); mouse(view, span, 'click');
+        mouse(view, span, 'mousedown');
+        assert.deepStrictEqual(selected(view), column(view, 1), 'a potential reorder keeps the column selected until release');
+        mouse(view, span, 'mouseup'); mouse(view, span, 'click');
+        assert.deepStrictEqual(selected(view), [header]);
+        assert.strictEqual(view.window.document.activeElement, header);
+        assert.strictEqual(header.getAttribute('contenteditable'), null);
+        assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorRow, 0);
+        assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorCol, 1);
+        view.key('c', { metaKey: true });
+        const copy = view.messages.filter(message => message.type === 'copyCells').pop();
+        assert.deepStrictEqual(JSON.parse(JSON.stringify(copy.matrix)), [['Value']]);
+        assert.ok(!view.messages.some(message => message.type === 'reorderColumns' || message.type === 'editCell'));
+        assert.strictEqual(host.document.version, 1);
+        assert.strictEqual(host.document.getText(), host.diskText);
+      } finally { view.close(); }
+    });
+  }
+
+  it('keeps a true detail-2 double-click available for editing and committing the header', async () => {
+    const { host, view } = await fixture();
+    try {
+      const header = view.cell(0, 1);
+      click(view, header, 1);
+      click(view, header, 2);
+      assert.deepStrictEqual(selected(view), column(view, 1));
+      mouse(view, header, 'dblclick', { detail: 2 });
+      assert.strictEqual(header.getAttribute('contenteditable'), 'true');
+      header.textContent = 'Changed header';
+      header.blur();
+      const edit = view.messages.find(message => message.type === 'editCell');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(edit)), { type: 'editCell', row: 0, col: 1, value: 'Changed header' });
+      await host.receive(edit);
+      assert.strictEqual(host.rows()[0][1], 'Changed header');
+      assert.ok(!host.diskText.includes('Changed header'));
+      assert.ok(!view.messages.some(message => message.type === 'reorderColumns'));
+    } finally { view.close(); }
+  });
+
+  it('continues to reorder an already selected header instead of collapsing it during a drag', async () => {
+    const { view } = await fixture();
+    try {
+      const header = view.cell(0, 1);
+      click(view, header);
+      mouse(view, header, 'mousedown');
+      mouse(view, view.cell(0, 2), 'mousemove', { clientX: 390 });
+      mouse(view, view.cell(0, 2), 'mouseup', { clientX: 390 });
+      assert.deepStrictEqual(selected(view), column(view, 1));
+      const reorder = view.messages.find(message => message.type === 'reorderColumns');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(reorder)), { type: 'reorderColumns', indices: [1], beforeIndex: 3 });
+    } finally { view.close(); }
+  });
+
+  it('preserves Shift column groups, dragging those groups, and right-click selection', async () => {
+    const { view } = await fixture();
+    try {
+      const first = view.cell(0, 0), second = view.cell(0, 1);
+      click(view, first);
+      click(view, first, 1, { shiftKey: true });
+      assert.deepStrictEqual(selected(view), column(view, 0));
+      click(view, second, 1, { shiftKey: true });
+      const group = selected(view);
+      assert.strictEqual(group.length, column(view, 0).length + column(view, 1).length);
+      mouse(view, first, 'mousedown', { button: 2 });
+      mouse(view, first, 'mouseup', { button: 2 });
+      assert.deepStrictEqual(selected(view), group);
+      mouse(view, second, 'mousedown');
+      mouse(view, view.cell(0, 2), 'mousemove', { clientX: 390 });
+      mouse(view, view.cell(0, 2), 'mouseup', { clientX: 390 });
+      assert.deepStrictEqual(selected(view), group);
+      const reorder = view.messages.find(message => message.type === 'reorderColumns');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(reorder.indices)), [0, 1]);
+    } finally { view.close(); }
+  });
+
+  it('keeps resize boundaries ahead of repeat-click selection and double-click editing', async () => {
+    const { view } = await fixture();
+    try {
+      const header = view.cell(0, 1);
+      click(view, header);
+      mouse(view, header, 'mousedown', { clientX: 299 });
+      mouse(view, header, 'mousemove', { clientX: 339 });
+      mouse(view, header, 'mouseup', { clientX: 339 });
+      assert.strictEqual(header.style.width, '140px');
+      assert.deepStrictEqual(selected(view), column(view, 1));
+      mouse(view, header, 'dblclick', { detail: 2, clientX: 339 });
+      assert.strictEqual(header.style.width, '');
+      assert.notStrictEqual(header.getAttribute('contenteditable'), 'true');
+      assert.deepStrictEqual(selected(view), column(view, 1));
+    } finally { view.close(); }
+  });
+
+  it('leaves Cmd/Ctrl link clicks and repeated serial-index clicks unchanged', async () => {
+    const { view } = await fixture();
+    try {
+      click(view, view.cell(0, 1));
+      const before = selected(view);
+      const link = view.cell(0, 2).querySelector('.csv-link');
+      assert.ok(link);
+      click(view, link, 1, { metaKey: true });
+      assert.deepStrictEqual(selected(view), before);
+      assert.strictEqual(view.messages.filter(message => message.type === 'openLink').length, 1);
+      const index = view.cell(1, -1);
+      click(view, index); click(view, index);
+      assert.strictEqual(selected(view).length, 4);
+      assert.ok(selected(view).every(cell => cell.dataset.row === '1'));
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/header-context-menu.test.ts b/src/test/header-context-menu.test.ts
new file mode 100644
index 0000000..dd9bbe7
--- /dev/null
+++ b/src/test/header-context-menu.test.ts
@@ -0,0 +1,201 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['Name', 'Value'], ['one', 'two'], ['three', 'four']];
+const settle = () => new Promise(resolve => setTimeout(resolve, 20));
+
+function openMenu(view: View, row: number, column: number) {
+  const target = view.cell(row, column);
+  assert.ok(target);
+  target.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true }));
+  target.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true }));
+  return Array.from(view.window.document.querySelectorAll('#contextMenu div')) as any[];
+}
+
+function chooseHeader(view: View, row: number, column: number, enabled: boolean) {
+  const label = enabled ? 'Use first row as header' : 'Treat first row as data';
+  const item = openMenu(view, row, column).find(element => element.textContent === label);
+  assert.ok(item, label);
+  item.click();
+  const message = view.messages.slice().reverse().find((item: any) => item.type === 'setHeader');
+  assert.strictEqual(message.enabled, enabled);
+  return message;
+}
+
+async function finishRefresh(host: Host, view: View, start = 0) {
+  const prepare = host.messages.slice(start).reverse().find((message: any) => message.type === 'prepareViewRefresh');
+  if (prepare) {
+    const begin = view.messages.length;
+    view.window.dispatchEvent(new view.window.MessageEvent('message', { data: prepare }));
+    for (const message of view.messages.slice(begin)) { await host.receive(message); }
+  }
+  await settle();
+}
+
+async function applyHeader(host: Host, view: View, message: unknown) {
+  const start = host.messages.length;
+  await host.receive(message);
+  await finishRefresh(host, view, start);
+}
+
+describe('File header context action', () => {
+  for (const separator of [',', '\t']) {
+    for (const header of [false, true]) {
+      it(`toggles the file header from either first-row column (${JSON.stringify(separator)}, header ${header})`, async () => {
+        for (const column of [0, 1]) {
+          const host = await createEditorHarness({ rows, separator, header });
+          const view = createWebviewDom(host.panel.webview.html);
+          const source = host.document.getText();
+          const version = host.document.version;
+          try {
+            await applyHeader(host, view, chooseHeader(view, 0, column, !header));
+            const next = createWebviewDom(host.panel.webview.html);
+            try {
+              assert.strictEqual(!!next.window.document.querySelector('thead'), !header);
+              const reverse = header ? 'Use first row as header' : 'Treat first row as data';
+              assert.ok(openMenu(next, 0, column).some(item => item.textContent === reverse));
+            } finally { next.close(); }
+            assert.strictEqual(host.document.getText(), source);
+            assert.strictEqual(host.document.version, version);
+          } finally { view.close(); }
+        }
+      });
+    }
+  }
+
+  it('uses the effective detected state rather than the stored fallback', async () => {
+    const host = await createEditorHarness({ rows, header: true });
+    const initial = createWebviewDom(host.panel.webview.html);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    const context = (controller as any).context;
+    try {
+      await context.workspaceState.update(CsvEditorProvider.headerKey, {});
+      controller.refresh();
+      await finishRefresh(host, initial);
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        assert.strictEqual(view.window.document.querySelector('thead'), null);
+        await applyHeader(host, view, chooseHeader(view, 0, 1, true));
+        assert.strictEqual(CsvEditorProvider.getHeaderForUri(context, host.document.uri as any), true);
+        assert.strictEqual(CsvEditorProvider.hasHeaderOverride(context, host.document.uri as any), true);
+        const next = createWebviewDom(host.panel.webview.html);
+        try { assert.ok(next.window.document.querySelector('thead')); } finally { next.close(); }
+      } finally { view.close(); }
+    } finally { initial.close(); }
+  });
+
+  it('targets the owning file even when another CSV editor becomes active', async () => {
+    const host = await createEditorHarness({ rows, header: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    const other = await createEditorHarness({ rows, separator: '\t', header: true });
+    try {
+      await applyHeader(host, view, chooseHeader(view, 0, 1, false));
+      const next = createWebviewDom(host.panel.webview.html);
+      const untouched = createWebviewDom(other.panel.webview.html);
+      try {
+        assert.strictEqual(next.window.document.querySelector('thead'), null);
+        assert.ok(untouched.window.document.querySelector('thead'));
+      } finally { next.close(); untouched.close(); }
+    } finally { view.close(); }
+  });
+
+  it('rejects non-boolean header messages without changing the setting or view', async () => {
+    const host = await createEditorHarness({ rows, header: true });
+    const html = host.panel.webview.html;
+    for (const enabled of [undefined, null, 'false', 0, 1, {}]) {
+      await host.receive({ type: 'setHeader', enabled });
+    }
+    await settle();
+    assert.strictEqual(host.panel.webview.html, html);
+    assert.deepStrictEqual(host.rows(), rows);
+  });
+
+  it('persists the clicked anchor and scroll, including a header after hidden metadata', async () => {
+    const host = await createEditorHarness({ rows: [['metadata', ''], ...rows], header: false });
+    const initial = createWebviewDom(host.panel.webview.html);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    const context = (controller as any).context;
+    try {
+      await CsvEditorProvider.setHiddenRowsForUri(context, host.document.uri as any, 1);
+      controller.refresh();
+      await finishRefresh(host, initial);
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const container = view.window.document.querySelector('.table-container');
+        container.scrollLeft = 40;
+        container.scrollTop = 120;
+        await applyHeader(host, view, chooseHeader(view, 1, 1, true));
+        const saved = view.window.acquireVsCodeApi().getState();
+        assert.strictEqual(saved.anchorRow, 1);
+        assert.strictEqual(saved.anchorCol, 1);
+        assert.strictEqual(saved.scrollX, 40);
+        assert.strictEqual(saved.scrollY, 120);
+        const next = createWebviewDom(host.panel.webview.html);
+        try {
+          next.window.acquireVsCodeApi().setState(saved);
+          next.window.dispatchEvent(new next.window.Event('focus'));
+          await settle();
+          assert.strictEqual(next.cell(1, 1).tagName, 'TH');
+          assert.ok(next.cell(1, 1).classList.contains('selected'));
+          assert.strictEqual(next.window.document.querySelector('.table-container').scrollTop, 120);
+          assert.strictEqual(next.cell(0, 0), null);
+        } finally { next.close(); }
+        assert.deepStrictEqual(host.rows(), [['metadata', ''], ...rows]);
+      } finally { view.close(); }
+    } finally { initial.close(); }
+  });
+
+  it('can switch off an empty file header preference even without a rendered header', async () => {
+    const host = await createEditorHarness({ rows: [], header: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      assert.strictEqual(view.window.document.querySelector('thead'), null);
+      await applyHeader(host, view, chooseHeader(view, 0, 0, false));
+      const next = createWebviewDom(host.panel.webview.html);
+      try {
+        assert.ok(openMenu(next, 0, 0).some(item => item.textContent === 'Use first row as header'));
+      } finally { next.close(); }
+      assert.strictEqual(host.document.getText(), '');
+    } finally { view.close(); }
+  });
+
+  it('keeps the first displayed row actionable when hidden metadata exceeds the file length', async () => {
+    const host = await createEditorHarness({ rows, header: true });
+    const initial = createWebviewDom(host.panel.webview.html);
+    const controller = CsvEditorProvider.getActiveProvider()!;
+    const context = (controller as any).context;
+    try {
+      await CsvEditorProvider.setHiddenRowsForUri(context, host.document.uri as any, 10);
+      controller.refresh();
+      await finishRefresh(host, initial);
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        await applyHeader(host, view, chooseHeader(view, rows.length, 0, false));
+        assert.strictEqual(CsvEditorProvider.getHeaderForUri(context, host.document.uri as any), false);
+        assert.deepStrictEqual(host.rows(), rows);
+      } finally { view.close(); }
+    } finally { initial.close(); }
+  });
+
+  it('only offers the header action on first-row cells, with headers on or off', async () => {
+    for (const header of [true, false]) {
+      const host = await createEditorHarness({ rows, header });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const label = header ? 'Treat first row as data' : 'Use first row as header';
+        for (const column of [0, 1]) {
+          assert.ok(openMenu(view, 0, column).some(item => item.textContent === label));
+        }
+        for (const [row, column] of [[1, 0], [1, -1], [2, 1], [3, 1]]) {
+          const items = openMenu(view, row, column);
+          assert.ok(!items.some(item => item.textContent === label));
+          assert.ok(items.some(item => item.textContent === 'Copy'), 'later cells retain normal context actions');
+        }
+      } finally { view.close(); }
+    }
+  });
+});
diff --git a/src/test/high-contrast.test.ts b/src/test/high-contrast.test.ts
new file mode 100644
index 0000000..a017aa4
--- /dev/null
+++ b/src/test/high-contrast.test.ts
@@ -0,0 +1,271 @@
+import { TestExtensionUri } from './test-extension-uri';
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import Module from 'module';
+import Papa from 'papaparse';
+import { describe, it } from 'node:test';
+const { JSDOM } = require('jsdom');
+
+const theme = { kind: 1 };
+const kinds = { Light: 1, Dark: 2, HighContrast: 3, HighContrastLight: 4 };
+const themeClasses = ['vscode-light', 'vscode-dark', 'vscode-high-contrast', 'vscode-high-contrast-light'];
+const settings: Record<string, unknown> = {};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return {
+      ColorThemeKind: kinds,
+      window: { activeColorTheme: theme },
+      Uri: { file: (filePath: string) => ({ fsPath: filePath, toString: () => `test-resource:${filePath}` }) },
+      workspace: {
+        getConfiguration: () => ({ get: (key: string, fallback: unknown) => key === 'maxFileSizeMB' ? 0 : (settings[key] ?? fallback) }),
+        onDidChangeTextDocument: () => ({ dispose() {} }),
+        onWillSaveTextDocument: () => ({ dispose() {} })
+      }
+    };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+const accessibilityCss = fs.readFileSync(path.join(process.cwd(), 'media', 'high-contrast.css'), 'utf8');
+const palettes = ['default', 'cool', 'warm'] as const;
+const modes = ['type', 'theme'] as const;
+const rows = [
+  ['Boolean', 'Date', 'Float', 'Integer', 'String', 'Empty'],
+  ['true', '2026-03-04', '2.5', '12', 'alpha', ''],
+  ['false', '2026-04-05', '3.5', '24', 'beta', '']
+];
+
+async function render(options: {
+  rows?: string[][]; kind?: number; palette?: typeof palettes[number]; mode?: typeof modes[number];
+  separator?: string; header?: boolean; hiddenRows?: number;
+} = {}) {
+  theme.kind = options.kind ?? kinds.Light;
+  settings.columnColorMode = options.mode ?? 'type';
+  settings.columnColorPalette = options.palette ?? 'default';
+  const separator = options.separator ?? ',';
+  const uri = { fsPath: `/fixture.${separator === '\t' ? 'tsv' : 'csv'}`, toString: () => `vscode-remote://fixture/table.${separator === '\t' ? 'tsv' : 'csv'}` };
+  const values: Record<string, unknown> = {};
+  const context = {
+    extensionPath: process.cwd(), extensionUri: new TestExtensionUri(),
+    workspaceState: {
+      get: (key: string, fallback: unknown) => values[key] ?? fallback,
+      update: async (key: string, value: unknown) => { values[key] = value; }
+    }
+  };
+  await CsvEditorProvider.setHeaderForUri(context as any, uri as any, options.header ?? true);
+  await CsvEditorProvider.setHiddenRowsForUri(context as any, uri as any, options.hiddenRows ?? 0);
+  let receive: (message: unknown) => Promise<void> = async () => {};
+  const messages: any[] = [];
+  const webview = {
+    html: '', options: {}, cspSource: 'test-resource:',
+    asWebviewUri: (resource: any) => resource.toString(),
+    postMessage(message: unknown) { messages.push(message); return Promise.resolve(true); },
+    onDidReceiveMessage(listener: typeof receive) { receive = listener; }
+  };
+  const panel = { title: 'fixture', active: false, webview, onDidChangeViewState() {}, onDidDispose() {} };
+  const text = Papa.unparse(options.rows ?? rows, { delimiter: separator });
+  await new CsvEditorProvider(context as any).resolveCustomTextEditor({ uri, version: 1, getText: () => text } as any, panel as any, {} as any);
+  const dom = new JSDOM(webview.html);
+  const style = dom.window.document.createElement('style');
+  style.textContent = accessibilityCss;
+  dom.window.document.head.append(style);
+  dom.window.document.body.className = themeClasses[theme.kind - 1];
+  dom.window.document.body.style.setProperty('--vscode-editor-foreground', '#13579b');
+  dom.window.document.body.style.setProperty('--vscode-editor-background', '#102030');
+  return { dom, html: webview.html, messages, receive: (message: unknown) => receive(message) };
+}
+
+// jsdom does not resolve custom properties. Resolve the browser's declared
+// cascade here, then compare visible values rather than implementation var names.
+function declared(element: any, property: string): string {
+  let result = '';
+  let important = false;
+  for (const sheet of Array.from(element.ownerDocument.styleSheets) as any[]) {
+    for (const rule of Array.from(sheet.cssRules) as any[]) {
+      if (!rule.selectorText || !element.matches(rule.selectorText)) { continue; }
+      const source = property === 'background-color' && !rule.style.getPropertyValue(property) ? 'background' : property;
+      const value = rule.style.getPropertyValue(source);
+      const priority = rule.style.getPropertyPriority(source) === 'important';
+      if (value && (!important || priority)) { result = value; important = priority; }
+    }
+  }
+  const inline = element.style.getPropertyValue(property);
+  if (inline && (!important || element.style.getPropertyPriority(property) === 'important')) { result = inline; }
+  return result;
+}
+
+function resolved(element: any, value: string): string {
+  let output = value;
+  for (let pass = 0; pass < 12 && output.includes('var('); pass++) {
+    const next = output.replace(/var\((--[\w-]+)(?:,\s*([^()]*))?\)/g, (_match: string, name: string, fallback = '') => {
+      let ancestor = element;
+      while (ancestor) {
+        const variable = declared(ancestor, name);
+        if (variable) { return variable; }
+        ancestor = ancestor.parentElement;
+      }
+      return fallback;
+    });
+    if (next === output) { break; }
+    output = next;
+  }
+  assert.ok(!output.includes('var('), `unresolved value: ${output}`);
+  return output.trim().toLowerCase();
+}
+
+function color(cell: any): string { return resolved(cell, declared(cell, 'color')); }
+function dataCells(document: any): any[] { return Array.from(document.querySelectorAll('[data-col]:not([data-col="-1"])')); }
+
+function assertCellColors(document: any, expected: string[], mode: typeof modes[number]) {
+  for (const cell of dataCells(document)) {
+    const col = Number(cell.dataset.col);
+    assert.strictEqual(color(cell), mode === 'theme' ? '#13579b' : expected[col], `${cell.tagName} source row ${cell.dataset.row}, column ${col}`);
+  }
+}
+
+describe('High-contrast rendering', () => {
+  it('preserves all selected palettes and both color modes across header, body and append cells in CSV and TSV', async () => {
+    const firstPaletteColors = new Map<string, string[]>();
+    for (const separator of [',', '\t']) {
+      for (const palette of palettes) {
+        for (const mode of modes) {
+          for (const [ordinary, contrast] of [[kinds.Light, kinds.HighContrastLight], [kinds.Dark, kinds.HighContrast]]) {
+            const base = await render({ kind: ordinary, palette, mode, separator });
+            const expected = Array.from(base.dom.window.document.querySelectorAll('thead [data-col]') as any[]).map(color);
+            const hc = await render({ kind: contrast, palette, mode, separator });
+            assertCellColors(base.dom.window.document, expected, mode);
+            assertCellColors(hc.dom.window.document, expected, mode);
+            assert.strictEqual(dataCells(hc.dom.window.document).length, rows[0].length * (rows.length + 1));
+            if (mode === 'type') {
+              assert.ok(expected.every(value => /^#[0-9a-f]{3,6}$/.test(value)), 'type mode retains literal palette colors');
+              firstPaletteColors.set(`${ordinary}:${palette}`, expected);
+            }
+            base.dom.window.close();
+            hc.dom.window.close();
+          }
+        }
+      }
+    }
+    for (const kind of [kinds.Light, kinds.Dark]) {
+      assert.notDeepStrictEqual(firstPaletteColors.get(`${kind}:default`), firstPaletteColors.get(`${kind}:cool`));
+      assert.notDeepStrictEqual(firstPaletteColors.get(`${kind}:cool`), firstPaletteColors.get(`${kind}:warm`));
+    }
+    assert.notDeepStrictEqual(firstPaletteColors.get(`${kinds.Light}:default`), firstPaletteColors.get(`${kinds.Dark}:default`));
+  });
+
+  it('keeps the chosen palette or theme mode in serialized and remote chunks, including their final append row', async () => {
+    const longRows = [['Name', 'Count'], ...Array.from({ length: 1001 }, (_, index) => ['hello', String(index + 10)])];
+    for (const kind of [kinds.HighContrast, kinds.HighContrastLight]) {
+      for (const palette of palettes) {
+        for (const mode of modes) {
+          const view = await render({ rows: longRows, kind, palette, mode, separator: '\t' });
+          const document = view.dom.window.document;
+          const expected = Array.from(document.querySelectorAll('thead [data-col]') as any[]).map(color);
+          const serialized = CsvEditorProvider.__test.generateTableAndChunksRaw(longRows, true, true, 0, true, mode, palette);
+          assert.ok(serialized.chunks.length > 0);
+          const serializedBody = document.createElement('tbody');
+          serializedBody.innerHTML = serialized.chunks.join('');
+          document.querySelector('table').append(serializedBody);
+          assertCellColors(document, expected, mode);
+          serializedBody.remove();
+          const filterSession = JSON.parse(document.getElementById('__csvFilters').textContent).session;
+          await view.receive({ type: 'requestChunk', start: 1000, requestId: 'palette', filterEpoch: 0, session: filterSession });
+          const chunk = view.messages.find(message => message.type === 'chunkData');
+          assert.ok(chunk?.html, 'remote URI provider returns requested rows');
+          document.querySelector('tbody').insertAdjacentHTML('beforeend', chunk.html);
+          if (!chunk.done) {
+            await view.receive({ type: 'requestChunk', start: chunk.nextStart, requestId: 'append', filterEpoch: 0, session: filterSession });
+            const append = view.messages.find(message => message.requestId === 'append');
+            assert.ok(append?.done);
+            document.querySelector('tbody').insertAdjacentHTML('beforeend', append.html);
+          }
+          assert.ok(document.querySelector('[data-row="1002"][data-col="0"]'), 'final virtual row is mounted');
+          assertCellColors(document, expected, mode);
+          view.dom.window.close();
+        }
+      }
+    }
+  });
+
+  it('preserves header-off and metadata-offset data colors rather than reclassifying the visible rows', async () => {
+    for (const header of [true, false]) {
+      const view = await render({ rows: [['metadata'], ...rows], kind: kinds.HighContrastLight, palette: 'warm', header, hiddenRows: 1 });
+      const document = view.dom.window.document;
+      assert.strictEqual(!!document.querySelector('thead'), header);
+      assert.ok(!document.querySelector('[data-row="0"]'));
+      const first = document.querySelector('[data-row="1"][data-col="0"]');
+      const expected = dataCells(document).filter(cell => Number(cell.dataset.row) === 1).map(color);
+      assert.ok(first);
+      assertCellColors(document, expected, 'type');
+      view.dom.window.close();
+    }
+  });
+
+  it('loads the packaged accessibility stylesheet after generated table styles', async () => {
+    const view = await render();
+    const link = `<link rel="stylesheet" href="${new TestExtensionUri().with({ path: path.posix.join(process.cwd(), 'media', 'high-contrast.css') })}">`;
+    assert.ok(view.html.includes(link));
+    assert.ok(view.html.indexOf(link) > view.html.indexOf('</style>'));
+    assert.ok(fs.existsSync(path.join(process.cwd(), 'media', 'high-contrast.css')));
+    const extensionSource = fs.readFileSync(path.join(process.cwd(), 'src', 'extension.ts'), 'utf8');
+    assert.ok(!extensionSource.includes('onDidChangeActiveColorTheme'), 'theme changes must not force-reload an active draft');
+    view.dom.window.close();
+  });
+
+  it('leaves ordinary parent112 chrome colors unchanged and scopes accessibility overrides to HC', async () => {
+    const view = await render();
+    const document = view.dom.window.document;
+    const th = document.querySelector('th[data-col="0"]');
+    const cell = document.querySelector('td[data-col="0"]');
+    const menu = document.querySelector('#contextMenu');
+    const link = document.createElement('a');
+    link.className = 'csv-link';
+    cell.append(link);
+    const cases = [
+      { name: 'vscode-light', header: '#ffffff', border: '#ccc', selected: '#cce0ff', highlight: '#fefefe', active: '#ffffcc', link: '#0066cc', menu: '#ffffff' },
+      { name: 'vscode-dark', header: '#1e1e1e', border: '#555', selected: '#333333', highlight: '#2a2a2a', active: '#444444', link: '#6cb6ff', menu: '#2d2d2d' }
+    ];
+    const externalRules = Array.from(document.styleSheets[document.styleSheets.length - 1].cssRules) as any[];
+    const elements = [document.body, th, cell, link, menu, ...Array.from(document.querySelectorAll('#findReplaceWidget, #findReplaceWidget *'))];
+    for (const expected of cases) {
+      document.body.className = expected.name;
+      for (const state of ['', 'selected', 'highlight', 'active-match']) {
+        cell.className = state;
+        for (const element of elements) {
+          assert.ok(!externalRules.some(rule => element.matches(rule.selectorText)), `${expected.name} ${element.tagName}.${state} must not match accessibility CSS`);
+        }
+      }
+      cell.className = '';
+      assert.strictEqual(resolved(th, declared(th, 'background-color')), expected.header);
+      assert.ok(resolved(cell, declared(cell, 'border')).endsWith(expected.border));
+      assert.strictEqual(color(link), expected.link);
+      assert.strictEqual(resolved(menu, declared(menu, 'background')), expected.menu);
+      for (const [state, background] of [['selected', expected.selected], ['highlight', expected.highlight], ['active-match', expected.active]]) {
+        cell.className = state;
+        assert.strictEqual(resolved(cell, declared(cell, 'background-color')), background);
+      }
+      assert.strictEqual(declared(document.querySelector('#findReplaceWidget'), 'background'), '#171717');
+      assert.strictEqual(declared(document.querySelector('.fr-input'), 'background'), '#1c1c1c');
+    }
+    for (const kind of ['vscode-high-contrast', 'vscode-high-contrast-light']) {
+      document.body.className = kind;
+      for (const target of [th, cell]) {
+        for (const state of ['', 'selected', 'highlight', 'active-match']) {
+          target.className = state;
+          const matching = externalRules.filter(rule => target.matches(rule.selectorText));
+          assert.ok(matching.length > 0);
+          assert.ok(matching.every(rule => !rule.style.getPropertyValue('color')), `${kind} ${target.tagName}.${state} retains its configured foreground`);
+          if (state) {
+            assert.ok(matching.some(rule => rule.style.getPropertyValue('outline')), `${state} remains visibly distinguishable`);
+            assert.strictEqual(resolved(target, declared(target, 'background-color')), '#102030');
+          }
+        }
+      }
+    }
+    view.dom.window.close();
+  });
+});
diff --git a/src/test/inline-filter-integration.test.ts b/src/test/inline-filter-integration.test.ts
new file mode 100644
index 0000000..f24ec8c
--- /dev/null
+++ b/src/test/inline-filter-integration.test.ts
@@ -0,0 +1,380 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+const { JSDOM } = require('jsdom');
+
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+type View = ReturnType<typeof createWebviewDom>;
+const waitForInput = () => new Promise(resolve => setTimeout(resolve, 130));
+const saved = (host: Host) => CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any);
+function deliver(view: View, message: any) {
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: message }));
+}
+function change(view: View, input: any, value: string) {
+  input.focus();
+  input.value = value;
+  input.dispatchEvent(new view.window.Event('input', { bubbles: true }));
+}
+function menu(view: View, cell: any): any[] {
+  cell.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true }));
+  cell.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 100, clientY: 40 }));
+  return Array.from(view.window.document.querySelectorAll('#contextMenu div'));
+}
+async function applyBlankDraft(host: Host, view: View) {
+  const cursor = view.messages.length;
+  view.window.csvColumnFilters.add(0);
+  await waitForInput();
+  const request = view.messages.slice(cursor).find(message => message.type === 'updateColumnFilters');
+  assert.ok(request);
+  const before = host.messages.length;
+  await host.receive(request);
+  const result = host.messages.slice(before).find(message => message.type === 'columnFiltersResult');
+  assert.ok(result);
+  deliver(view, result);
+  return result;
+}
+
+describe('Inline filters with integrated draft and view state', () => {
+  for (const failure of ['false', 'throw'] as const) {
+    for (const recovery of ['retry', 'discard'] as const) {
+      it(`retains a delayed ${failure} cell draft and old predicates until ${recovery}`, async () => {
+        for (const separator of [',', '\t']) {
+          const previous = [{ column: 0, operator: 'contains', value: 'one' }];
+          const host = await createEditorHarness({ separator, rows: [['Name', 'Note'], ['one', 'original'], ['two', 'other']], filters: previous });
+          let view = createWebviewDom(host.panel.webview.html);
+          try {
+            const table = view.window.document.querySelector('table');
+            const cell = view.cell(1, 1);
+            const input = view.window.document.querySelector('[data-filter-value]');
+            const html = host.panel.webview.html, disk = host.diskText;
+            const cursor = view.messages.length;
+            const draft = 'pending first\nsecond line';
+            view.start(cell);
+            cell.textContent = draft;
+            const originalApply = host.applyEdit;
+            let rejectEdit = () => {};
+            let applying = false;
+            host.applyEdit = async () => new Promise<boolean>((resolve, reject) => {
+              applying = true;
+              rejectEdit = () => failure === 'false' ? resolve(false) : reject(new Error('delayed integration edit failure'));
+            });
+            change(view, input, 'o');
+            await waitForInput();
+            const outgoing = view.messages.slice(cursor).filter(message => ['cellEditStarted', 'editCell', 'updateColumnFilters'].includes(message.type));
+            assert.ok(outgoing.findIndex(message => message.type === 'editCell') < outgoing.findIndex(message => message.type === 'updateColumnFilters'));
+            const pending = outgoing.map(message => host.receive(message));
+            await new Promise(resolve => setImmediate(resolve));
+            assert.ok(applying, 'the actual queued WorkspaceEdit is still awaiting completion');
+            assert.ok(!host.messages.some(message => message.type === 'columnFiltersResult'));
+            assert.strictEqual(view.window.document.querySelector('table'), table);
+            assert.strictEqual(cell.textContent, draft);
+            assert.strictEqual(host.rows()[1][1], 'original');
+            rejectEdit();
+            await Promise.all(pending);
+            const blocked = host.messages.find(message => message.type === 'columnFiltersResult');
+            assert.ok(blocked?.error, 'the existing failed-draft guard rejects a partial redraw');
+            for (const message of host.messages.filter(message => ['editCellFailed', 'columnFiltersResult'].includes(message.type))) { deliver(view, message); }
+            assert.strictEqual(view.window.document.querySelector('table'), table);
+            assert.strictEqual(view.cell(1, 1), cell);
+            assert.strictEqual(cell.textContent, draft);
+            assert.strictEqual(host.rows()[1][1], 'original');
+            assert.deepStrictEqual(saved(host), previous);
+            assert.strictEqual(host.panel.webview.html, html);
+            assert.strictEqual(host.diskText, disk);
+            assert.strictEqual(table.getAttribute('aria-busy'), 'false');
+            host.applyEdit = originalApply;
+            const retryCursor = view.messages.length;
+            const hostCursor = host.messages.length;
+            view.start(cell);
+            if (recovery === 'discard') { view.key('Escape'); }
+            else { cell.blur(); }
+            const recoveryMessages = view.messages.slice(retryCursor);
+            assert.ok(recoveryMessages.some(message => message.type === (recovery === 'discard' ? 'discardCellDraft' : 'editCell')));
+            await Promise.all(recoveryMessages.map(message => host.receive(message)));
+            for (const message of host.messages.slice(hostCursor).filter(message => message.type === 'updateCell')) { deliver(view, message); }
+            await flushViewCommits(host, view);
+            assert.strictEqual(host.rows()[1][1], recovery === 'retry' ? draft : 'original');
+            assert.strictEqual(host.diskText, disk, 'filter recovery never saves the document');
+            assert.deepStrictEqual(saved(host), previous);
+            view.close();
+            view = createWebviewDom(host.panel.webview.html);
+            const freshInput = view.window.document.querySelector('[data-filter-value]');
+            const nextCursor = view.messages.length;
+            change(view, freshInput, 'o');
+            await waitForInput();
+            const request = view.messages.slice(nextCursor).find(message => message.type === 'updateColumnFilters');
+            assert.ok(request);
+            const responses = host.messages.length;
+            await host.receive(request);
+            const accepted = host.messages.slice(responses).find(message => message.type === 'columnFiltersResult');
+            assert.ok(accepted && !accepted.error && !accepted.errors?.length);
+            deliver(view, accepted);
+            assert.deepStrictEqual(saved(host), [{ column: 0, operator: 'contains', value: 'o' }]);
+            assert.ok(view.cell(2, 0), 'both matching source rows appear only after recovery');
+            assert.strictEqual(view.cell(1, 1).textContent, recovery === 'retry' ? draft : 'original');
+            assert.strictEqual(host.diskText, disk);
+          } finally { view.close(); host.dispose(); }
+        }
+      });
+    }
+  }
+
+  for (const separator of [',', '\t']) {
+    for (const hidden of [false, true]) {
+      it(`preserves an explicit header preference without THEAD across live redraws (${JSON.stringify(separator)}, all-hidden ${hidden})`, async () => {
+        const host = await createEditorHarness({ separator, text: hidden ? `private${separator}metadata\nmore${separator}hidden` : '', header: true, hiddenRows: hidden ? 99 : 0 });
+        let view = createWebviewDom(host.panel.webview.html);
+        const source = host.document.getText();
+        try {
+          assert.strictEqual(view.window.document.querySelector('thead'), null);
+          const first = hidden ? 2 : 0;
+          for (const enabled of [true, false]) {
+            if (!enabled) {
+              const action = menu(view, view.cell(first, 0)).find(item => item.textContent === 'Treat first row as data');
+              assert.ok(action);
+              const cursor = view.messages.length;
+              action.click();
+              const request = view.messages.slice(cursor).find(message => message.type === 'setHeader');
+              assert.deepStrictEqual(JSON.parse(JSON.stringify(request)), { type: 'setHeader', enabled: false });
+              await host.receive(request);
+              await flushViewCommits(host, view);
+              await new Promise(resolve => setTimeout(resolve, 20));
+              view.close();
+              view = createWebviewDom(host.panel.webview.html);
+            }
+            const table = view.window.document.querySelector('table');
+            const result = await applyBlankDraft(host, view);
+            assert.strictEqual(result.headerEnabled, enabled);
+            assert.strictEqual(view.window.document.querySelector('table'), table);
+            assert.strictEqual(view.window.document.querySelector('thead'), null);
+            assert.strictEqual(view.window.document.getElementById('csv-root').dataset.headerenabled, enabled ? '1' : '0');
+            const dataMenu = menu(view, view.cell(first, 0));
+            assert.ok(dataMenu.some(item => item.textContent === (enabled ? 'Treat first row as data' : 'Use first row as header')));
+            assert.ok(!dataMenu.some(item => item.textContent === 'Hide serial index column'));
+            const serialMenu = menu(view, view.cell(first, -1));
+            assert.ok(serialMenu.some(item => item.textContent === 'Hide serial index column'));
+            assert.ok(!serialMenu.some(item => /Sort|column left|column right/i.test(item.textContent)));
+            assert.strictEqual(host.document.getText(), source);
+            assert.strictEqual(host.document.version, 1);
+          }
+        } finally { view.close(); host.dispose(); }
+      });
+    }
+  }
+
+  it('updates effective automatic header context when a committed cell edit changes inference before a partial redraw', async () => {
+    const host = await createEditorHarness({ rows: [['Title'], ['word']], header: false });
+    await host.context.workspaceState.update(CsvEditorProvider.headerKey, {});
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      await applyBlankDraft(host, view);
+      assert.strictEqual(view.window.document.querySelector('thead'), null);
+      const input = view.window.document.querySelector('[data-filter-value]');
+      const cursor = view.messages.length;
+      view.start(view.cell(1, 0));
+      view.cell(1, 0).textContent = '42';
+      change(view, input, '');
+      await waitForInput();
+      const outgoing = view.messages.slice(cursor).filter(message => ['cellEditStarted', 'editCell', 'updateColumnFilters'].includes(message.type));
+      const responses = host.messages.length;
+      await Promise.all(outgoing.map(message => host.receive(message)));
+      const result = host.messages.slice(responses).find(message => message.type === 'columnFiltersResult');
+      assert.strictEqual(result.headerEnabled, true);
+      deliver(view, result);
+      assert.strictEqual(view.cell(0, 0).tagName, 'TH');
+      assert.strictEqual(view.window.document.getElementById('csv-root').dataset.headerenabled, '1');
+      assert.ok(menu(view, view.cell(0, 0)).some(item => item.textContent === 'Treat first row as data'));
+      const corner = view.window.document.querySelector('thead [data-serial-index]');
+      assert.ok(corner);
+      const cornerMenu = menu(view, corner);
+      assert.ok(cornerMenu.some(item => item.textContent === 'Hide serial index column'));
+      assert.ok(!cornerMenu.some(item => /Treat first row|Use first row|Sort/.test(item.textContent)));
+      assert.strictEqual(host.rows()[1][0], '42');
+      assert.ok(!host.diskText.includes('42'));
+    } finally { view.close(); host.dispose(); }
+  });
+
+  it('keeps newly typed filter text when an earlier queued cell edit changes membership in the active predicate', async () => {
+    for (const separator of [',', '\t']) {
+      const host = await createEditorHarness({ separator, rows: [['Name', 'Note'], ['one', 'original'], ['two', 'other']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+      let view = createWebviewDom(host.panel.webview.html);
+      try {
+        host.deferEdits();
+        const cursor = view.messages.length;
+        view.start(view.cell(1, 0));
+        view.cell(1, 0).textContent = 'changed';
+        change(view, view.window.document.querySelector('[data-filter-value]'), 'ch');
+        await waitForInput();
+        const outgoing = view.messages.slice(cursor).filter(message => ['cellEditStarted', 'editCell', 'updateColumnFilters'].includes(message.type));
+        const pending = outgoing.map(message => host.receive(message));
+        await new Promise(resolve => setImmediate(resolve));
+        assert.strictEqual(host.pendingEdits, 1);
+        host.resumeEdits(); host.releaseEdit();
+        await Promise.all(pending);
+        let hostCursor = 0, viewCursor = view.messages.length;
+        let currentHtml = host.panel.webview.html;
+        for (let round = 0; round < 6; round++) {
+          const hostMessages = host.messages.slice(hostCursor);
+          hostCursor = host.messages.length;
+          for (const message of hostMessages) {
+            const begin = view.messages.length;
+            deliver(view, message);
+            await Promise.all(view.messages.slice(begin).map(response => host.receive(response)));
+            viewCursor = view.messages.length;
+            if (host.panel.webview.html !== currentHtml) {
+              view.close();
+              currentHtml = host.panel.webview.html;
+              view = createWebviewDom(currentHtml);
+              viewCursor = 0;
+            }
+          }
+          await waitForInput();
+          const followups = view.messages.slice(viewCursor);
+          viewCursor = view.messages.length;
+          await Promise.all(followups.map(message => host.receive(message)));
+          if (hostCursor === host.messages.length && !followups.length) { break; }
+        }
+        const input = view.window.document.querySelector('[data-filter-value]');
+        assert.strictEqual(input.value, 'ch', 'a membership refresh must retain the newly typed filter draft');
+        assert.deepStrictEqual(saved(host), [{ column: 0, operator: 'contains', value: 'ch' }], 'the latest live query eventually applies without another key');
+        assert.strictEqual(view.cell(1, 0).textContent, 'changed');
+        assert.strictEqual(view.cell(2, 0), null);
+        assert.strictEqual(host.rows()[1][0], 'changed');
+        assert.strictEqual(host.document.version, 2);
+        assert.ok(!host.diskText.includes('changed'));
+      } finally { view.close(); host.dispose(); }
+    }
+  });
+
+  it('does not reveal a detached navigation target on the next frame after a live table swap', async () => {
+    const host = await createEditorHarness({ rows: Array.from({ length: 20 }, (_, row) => [`row${row}`]), header: false, serialIndex: false, frozenRows: 0 });
+    const dom = new JSDOM(host.panel.webview.html, { runScripts: 'outside-only', pretendToBeVisual: true });
+    const { window } = dom;
+    const frames = new Map<number, (time: number) => void>();
+    let frame = 0, state: any = {};
+    const messages: any[] = [], scrolls: any[] = [];
+    window.requestAnimationFrame = (callback: (time: number) => void) => { const id = ++frame; frames.set(id, callback); return id; };
+    window.cancelAnimationFrame = (id: number) => { frames.delete(id); };
+    window.IntersectionObserver = class { observe() {} disconnect() {} };
+    window.HTMLElement.prototype.scrollIntoView = () => {};
+    window.acquireVsCodeApi = () => ({ postMessage: (message: any) => messages.push(message), getState: () => state, setState: (next: any) => { state = next; } });
+    const container = window.document.querySelector('.table-container');
+    const table = container.querySelector('table');
+    Object.defineProperties(container, { clientWidth: { value: 100 }, clientHeight: { value: 80 }, clientTop: { value: 0 }, clientLeft: { value: 0 } });
+    container.getBoundingClientRect = () => ({ left: 0, top: 0, right: 100, bottom: 80, width: 100, height: 80 });
+    container.scrollTo = (position: any) => scrolls.push(position);
+    const nativeRect = window.HTMLElement.prototype.getBoundingClientRect;
+    window.HTMLElement.prototype.getBoundingClientRect = function (this: any) {
+      if (!this.hasAttribute('data-row')) { return nativeRect.call(this); }
+      const top = Number(this.dataset.row) * 24;
+      return { left: 0, right: 80, top, bottom: top + 24, width: 80, height: 24 };
+    };
+    const flush = () => {
+      for (let pass = 0; frames.size && pass < 10; pass++) {
+        const callbacks = [...frames.values()]; frames.clear();
+        callbacks.forEach(callback => callback(pass * 16));
+      }
+      assert.strictEqual(frames.size, 0);
+    };
+    try {
+      for (const script of ['frozen-panes.js', 'column-filters.js', 'main.js']) {
+        window.eval(fs.readFileSync(path.join(process.cwd(), 'media', script), 'utf8') + (script === 'main.js' ? '\nwindow.revealTestApi={select:setSingleSelection};' : ''));
+      }
+      await new Promise(resolve => setTimeout(resolve, 20)); flush(); scrolls.length = 0;
+      const old = table.querySelector('[data-row="10"][data-col="0"]');
+      window.revealTestApi.select(old);
+      assert.ok(frames.size > 0, 'selection has queued a reveal for a target beyond the viewport');
+      const cursor = messages.length;
+      window.csvColumnFilters.add(0);
+      const input = window.document.querySelector('[data-filter-value]');
+      await waitForInput();
+      const request = messages.slice(cursor).find(message => message.type === 'updateColumnFilters');
+      assert.ok(request);
+      const responses = host.messages.length;
+      await host.receive(request);
+      const result = host.messages.slice(responses).find(message => message.type === 'columnFiltersResult');
+      window.dispatchEvent(new window.MessageEvent('message', { data: result }));
+      assert.strictEqual(old.isConnected, false);
+      assert.strictEqual(window.document.querySelector('table'), table);
+      assert.notStrictEqual(table.querySelector('[data-row="10"][data-col="0"]'), old);
+      flush();
+      assert.deepStrictEqual(scrolls, [], 'the detached target cannot move the current viewport');
+      assert.strictEqual(window.document.activeElement, input);
+      assert.strictEqual(host.document.version, 1);
+    } finally { window.close(); host.dispose(); }
+  });
+
+  it('retains filter typing after its refresh ACK was captured but before the operation queue consumes it', async () => {
+    for (const separator of [',', '\t']) {
+      const source = [['Name'], ['one'], ['one more'], ['two']];
+      const host = await createEditorHarness({ separator, rows: source, filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+      let view = createWebviewDom(host.panel.webview.html);
+      let release = () => {};
+      try {
+        // Gate the actual ordered queue without a cell mutation, which would
+        // independently require a fresh cell ACK and conceal filter-only activity.
+        const gate = new Promise<void>(resolve => { release = resolve; });
+        const blocked = (host.activeController as any).enqueueOperation(() => gate) as Promise<void>;
+        await new Promise(resolve => setImmediate(resolve));
+        const originalHtml = host.panel.webview.html;
+        host.requestViewCommit();
+        const prepare = host.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+        assert.ok(prepare);
+        deliver(view, prepare);
+        const ack = view.messages.filter(message => message.type === 'viewRefreshReady').slice(-1)[0];
+        assert.strictEqual(ack.filterDraft.rows[0].value, 'one');
+        const acknowledging = host.receive(ack);
+        assert.strictEqual(host.panel.webview.html, originalHtml, 'the actual refresh ACK is still queued behind the gate');
+
+        const input = view.window.document.querySelector('[data-filter-value]');
+        const activityCursor = view.messages.length;
+        change(view, input, 'one m');
+        // Forward synchronous activity before debounce. This must invalidate the
+        // queued ACK even though the next filter snapshot has not been sent yet.
+        const activity = view.messages.slice(activityCursor).map(message => host.receive(message));
+        let viewCursor = view.messages.length;
+        let hostCursor = host.messages.length;
+        let currentHtml = originalHtml;
+        release();
+        await Promise.all([blocked, acknowledging, ...activity]);
+        const recreate = () => {
+          if (host.panel.webview.html === currentHtml) { return; }
+          view.close();
+          currentHtml = host.panel.webview.html;
+          view = createWebviewDom(currentHtml);
+          viewCursor = 0;
+        };
+        recreate();
+        for (let round = 0; round < 8; round++) {
+          const incoming = host.messages.slice(hostCursor);
+          hostCursor = host.messages.length;
+          for (const message of incoming) {
+            const start = view.messages.length;
+            deliver(view, message);
+            await Promise.all(view.messages.slice(start).map(response => host.receive(response)));
+            viewCursor = view.messages.length;
+            recreate();
+          }
+          await waitForInput();
+          const outgoing = view.messages.slice(viewCursor);
+          viewCursor = view.messages.length;
+          await Promise.all(outgoing.map(message => host.receive(message)));
+          recreate();
+          if (hostCursor === host.messages.length && !outgoing.length) { break; }
+        }
+        assert.strictEqual(view.window.document.querySelector('[data-filter-value]').value, 'one m', 'typing after ACK capture must survive the queued full refresh');
+        assert.deepStrictEqual(saved(host), [{ column: 0, operator: 'contains', value: 'one m' }]);
+        assert.strictEqual(view.cell(1, 0), null);
+        assert.strictEqual(view.cell(2, 0).textContent, 'one more');
+        assert.strictEqual(view.cell(3, 0), null);
+        assert.deepStrictEqual(host.rows(), source);
+        assert.strictEqual(host.document.version, 1);
+        assert.strictEqual(host.document.getText(), host.diskText);
+      } finally { release(); view.close(); host.dispose(); }
+    }
+  });
+
+});
diff --git a/src/test/integrated-view-refresh.test.ts b/src/test/integrated-view-refresh.test.ts
new file mode 100644
index 0000000..f5b09db
--- /dev/null
+++ b/src/test/integrated-view-refresh.test.ts
@@ -0,0 +1,67 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+describe('Integrated view refresh and save ordering', () => {
+  it('saves an active draft before applying inline Clear all without dropping hidden records', async () => {
+    const host = await createEditorHarness({
+      rows: [['protocol', 'notes'], ['TCP', 'before'], ['UDP', 'hidden']],
+      filters: [{ column: 0, operator: 'equals', value: 'TCP' }]
+    });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const document = view.window.document;
+      const table = document.querySelector('table');
+      const originalHtml = host.panel.webview.html;
+      assert.strictEqual(view.cell(2, 0), null, 'the UDP source record starts outside the filtered view');
+      const start = view.messages.length;
+      const cell = view.cell(1, 1);
+      view.start(cell);
+      cell.textContent = 'unsaved\nmultiline';
+      host.deferEdits();
+      view.key('s', { ctrlKey: true });
+      const saveMessages = view.messages.slice(start);
+      const operations = saveMessages.filter(message => ['editCell', 'save'].includes(message.type));
+      assert.deepStrictEqual(operations.map(message => message.type), ['editCell', 'save']);
+      const pending = saveMessages.map(message => host.receive(message));
+      for (let attempt = 0; attempt < 10 && host.pendingEdits === 0; attempt++) {
+        await new Promise<void>(resolve => setImmediate(resolve));
+      }
+      assert.strictEqual(host.pendingEdits, 1);
+      assert.ok(!host.diskText.includes('multiline'));
+
+      const clearStart = view.messages.length;
+      document.getElementById('clearAllFilters').click();
+      await new Promise(resolve => setTimeout(resolve, 140));
+      const clearMessages = view.messages.slice(clearStart);
+      const request = clearMessages.find(message => message.type === 'updateColumnFilters');
+      assert.ok(request && request.filters.length === 0);
+      pending.push(...clearMessages.map(message => host.receive(message)));
+      assert.ok(!host.messages.some(message => message.type === 'columnFiltersResult'), 'live filtering stays behind the pending source edit and save');
+      assert.ok(!host.diskText.includes('multiline'));
+      host.releaseEdit();
+      await Promise.all(pending);
+      const result = host.messages.find(message => message.type === 'columnFiltersResult' && message.revision === request.revision);
+      assert.ok(result && !result.error && !result.errors?.length);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: result }));
+
+      assert.strictEqual(host.rows()[1][1], 'unsaved\nmultiline');
+      assert.deepStrictEqual(host.rows()[2], ['UDP', 'hidden']);
+      assert.ok(host.diskText.includes('unsaved\nmultiline'));
+      assert.ok(host.diskText.includes('UDP,hidden'));
+      assert.strictEqual(host.diskText, host.document.getText());
+      assert.strictEqual(document.querySelector('table'), table, 'the accepted filter snapshot only replaces table children');
+      assert.strictEqual(host.panel.webview.html, originalHtml, 'save and inline filtering keep the current webview');
+      assert.strictEqual(view.cell(1, 1).textContent, 'unsaved\nmultiline');
+      assert.strictEqual(view.cell(2, 0).textContent, 'UDP');
+      assert.strictEqual(document.getElementById('csv-root').dataset.filtered, '0');
+      assert.strictEqual(document.getElementById('filterStatus').hidden, true, 'the persistent filter region becomes hidden when conditions are cleared');
+    } finally { view.close(); host.dispose(); }
+  });
+
+  it('does not suggest a file-decoding repair for newly typed untitled replacement characters', async () => {
+    const host = await createEditorHarness({ untitled: true, rows: [['name'], ['literal �']] });
+    assert.deepStrictEqual(host.warnings, []);
+    host.dispose();
+  });
+});
diff --git a/src/test/large-file-preview.test.ts b/src/test/large-file-preview.test.ts
new file mode 100644
index 0000000..80a0e20
--- /dev/null
+++ b/src/test/large-file-preview.test.ts
@@ -0,0 +1,190 @@
+import assert from 'assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness } from './edit-integrity-harness';
+import { LargeFilePreviewProvider, renderPreviewRows } from '../large-file-preview';
+import { activate } from '../extension';
+const { JSDOM } = require('jsdom');
+
+async function previewFixture(run: (fixture: any) => Promise<void>) {
+  const host = await createEditorHarness();
+  host.configuration.largeFilePreviewRows = 1;
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'csv-preview-'));
+  const file = path.join(directory, 'preview.csv');
+  fs.writeFileSync(file, 'name,value\none,two\nthree,four\n');
+  const Uri = host.document.uri.constructor as any;
+  const provider = new LargeFilePreviewProvider({ extensionPath: process.cwd(), workspaceState: { get: (_key: string, fallback: unknown) => fallback } } as any);
+  const document = await provider.openCustomDocument(new Uri(file));
+  const messages: any[] = [];
+  let receive!: (message: unknown) => Promise<void>;
+  let dispose!: () => void;
+  const panel = {
+    webview: {
+      html: '', options: {},
+      asWebviewUri: (uri: unknown) => String(uri),
+      postMessage: (message: unknown) => { messages.push(message); return Promise.resolve(true); },
+      onDidReceiveMessage: (listener: typeof receive) => { receive = listener; }
+    },
+    onDidDispose: (listener: () => void) => { dispose = listener; }
+  };
+  try {
+    await provider.resolveCustomEditor(document, panel as any, { isCancellationRequested: false } as any);
+    await run({ host, file, provider, document, panel, messages, receive: (message: unknown) => receive(message), dispose: () => dispose() });
+  } finally {
+    document.dispose();
+    fs.rmSync(directory, { recursive: true, force: true });
+  }
+}
+
+describe('Read-only large file provider', () => {
+  it('pages complete records, reports source changes and reloads on explicit Start', async () => {
+    await previewFixture(async fixture => {
+      await fixture.receive({ type: 'ready' });
+      assert.ok(fixture.messages.at(-1).html.includes('name'));
+      await fixture.receive({ type: 'next' });
+      assert.ok(fixture.messages.at(-1).html.includes('one'));
+      assert.ok(!fixture.messages.at(-1).html.includes('name'));
+      fs.appendFileSync(fixture.file, 'changed,row\n');
+      await fixture.receive({ type: 'next' });
+      assert.match(fixture.messages.at(-1).error, /file changed/);
+      assert.strictEqual(fixture.messages.at(-1).html, '');
+      await fixture.receive({ type: 'previous' });
+      assert.match(fixture.messages.at(-1).error, /file changed/);
+      await fixture.receive({ type: 'start' });
+      assert.strictEqual(fixture.messages.at(-1).error, '');
+      assert.ok(fixture.messages.at(-1).html.includes('name'));
+    });
+  });
+
+  it('does not read or post after panel/document disposal and rejects remote file providers', async () => {
+    await previewFixture(async fixture => {
+      fixture.dispose();
+      await fixture.receive({ type: 'ready' });
+      assert.strictEqual(fixture.messages.length, 0);
+      const Uri = fixture.host.document.uri.constructor;
+      await assert.rejects(fixture.provider.openCustomDocument(new Uri('/remote/file.csv', 'vscode-remote')), /host-local/);
+    });
+  });
+
+  it('respects csv.enabled before any preview data read', async () => {
+    await previewFixture(async fixture => {
+      fixture.host.configuration.enabled = false;
+      await fixture.receive({ type: 'ready' });
+      assert.match(fixture.messages.at(-1).error, /CSV is disabled/);
+      assert.strictEqual(fixture.messages.at(-1).html, '');
+    });
+  });
+
+  it('rejects unsupported automatic separator mode explicitly rather than displaying wrong columns', async () => {
+    await previewFixture(async fixture => {
+      fixture.host.configuration.separatorMode = 'auto';
+      await fixture.receive({ type: 'ready' });
+      assert.match(fixture.messages.at(-1).error, /does not support automatic separator detection/);
+      assert.match(fixture.messages.at(-1).error, /csv.separatorMode/);
+      assert.strictEqual(fixture.messages.at(-1).html, '');
+      fixture.host.configuration.separatorMode = 'extension';
+      await fixture.receive({ type: 'start' });
+      assert.strictEqual(fixture.messages.at(-1).error, '');
+      assert.ok(fixture.messages.at(-1).html.includes('name'));
+    });
+  });
+
+  it('opens directly as a readonly custom document and never writes saved bytes', async () => {
+    await previewFixture(async fixture => {
+      fixture.host.registerCommands();
+      const before = fs.readFileSync(fixture.file);
+      await fixture.host.commands.get('csv.openLargeFilePreview')(fixture.document.uri);
+      assert.strictEqual(fixture.host.executedCommands.at(-1).name, 'vscode.openWith');
+      assert.strictEqual(fixture.host.executedCommands.at(-1).args[1], LargeFilePreviewProvider.viewType);
+      await fixture.receive({ type: 'ready' });
+      await fixture.receive({ type: 'editCell', row: 0, col: 0, value: 'attempted mutation' });
+      await fixture.receive({ type: 'next' });
+      assert.deepStrictEqual(fs.readFileSync(fixture.file), before);
+    });
+  });
+
+  it('keeps a readonly preview from upgrading to a full text document when CSV is enabled', async () => {
+    await previewFixture(async fixture => {
+      fixture.host.tabGroups = [{ tabs: [{ input: { uri: fixture.document.uri, viewType: LargeFilePreviewProvider.viewType } }] }];
+      await activate(fixture.host.context as any);
+      assert.deepStrictEqual(fixture.host.errors, [], 'activation must complete routing recovery without fixture errors');
+      await fixture.host.configurationListeners[0]({ affectsConfiguration: (key: string) => key === 'csv.enabled' });
+      await new Promise(resolve => setImmediate(resolve));
+      assert.strictEqual(fixture.host.executedCommands.length, 0);
+      assert.ok(fixture.host.providers.includes(LargeFilePreviewProvider.viewType));
+    });
+  });
+
+  it('shows malformed records as errors without displaying partial data', async () => {
+    await previewFixture(async fixture => {
+      fs.writeFileSync(fixture.file, 'name,value\n"unfinished');
+      await fixture.receive({ type: 'ready' });
+      await fixture.receive({ type: 'next' });
+      assert.match(fixture.messages.at(-1).error, /Unterminated quoted record/);
+      assert.strictEqual(fixture.messages.at(-1).html, '');
+      assert.strictEqual(fixture.messages.at(-1).canNext, false);
+    });
+  });
+
+  it('closes an in-flight read when its document is disposed and posts no late data', async () => {
+    await previewFixture(async fixture => {
+      const originalOpen = fs.promises.open;
+      let release!: () => void;
+      let reading!: () => void;
+      const gate = new Promise<void>(resolve => { release = resolve; });
+      const started = new Promise<void>(resolve => { reading = resolve; });
+      let closed = 0;
+      (fs.promises as any).open = async (...args: Parameters<typeof fs.promises.open>) => {
+        const handle = await originalOpen(...args);
+        return new Proxy(handle, {
+          get(target, key) {
+            if (key === 'read') {
+              return async (...readArgs: any[]) => { reading(); await gate; return (target.read as any)(...readArgs); };
+            }
+            if (key === 'close') {
+              return async () => { closed++; await target.close(); };
+            }
+            const value = Reflect.get(target, key);
+            return typeof value === 'function' ? value.bind(target) : value;
+          }
+        });
+      };
+      try {
+        const pending = fixture.receive({ type: 'ready' });
+        await started;
+        fixture.document.dispose();
+        release();
+        await pending;
+        assert.strictEqual(closed, 1);
+        assert.strictEqual(fixture.messages.length, 0);
+      } finally {
+        release();
+        fs.promises.open = originalOpen;
+      }
+    });
+  });
+
+  it('renders escaped values and replaces rather than accumulating DOM pages', async () => {
+    await previewFixture(async fixture => {
+      const dom = new JSDOM(fixture.panel.webview.html, { runScripts: 'outside-only' });
+      const messages: unknown[] = [];
+      dom.window.acquireVsCodeApi = () => ({ postMessage: (message: unknown) => messages.push(message) });
+      dom.window.eval(fs.readFileSync(path.join(process.cwd(), 'media', 'large-preview.js'), 'utf8'));
+      const payload = '<img src="https://example.test/secret" onerror="bad()"> & "quoted"';
+      for (let page = 0; page < 100; page++) {
+        dom.window.dispatchEvent(new dom.window.MessageEvent('message', { data: {
+          type: 'page', html: renderPreviewRows([[payload, String(page)]], page), status: 'Read-only', canBack: true, canNext: true
+        } }));
+      }
+      assert.strictEqual(dom.window.document.querySelectorAll('#records tbody tr').length, 1);
+      assert.strictEqual(dom.window.document.querySelectorAll('#records img, #records script').length, 0);
+      assert.ok(dom.window.document.getElementById('records').textContent.includes(payload));
+      assert.strictEqual(dom.window.document.querySelectorAll('[contenteditable]').length, 0);
+      dom.window.document.getElementById('next').click();
+      assert.deepStrictEqual(messages.map((message: any) => message.type), ['ready', 'next']);
+      dom.window.close();
+    });
+  });
+});
diff --git a/src/test/modified-arrow-filtered.test.ts b/src/test/modified-arrow-filtered.test.ts
new file mode 100644
index 0000000..00e8f22
--- /dev/null
+++ b/src/test/modified-arrow-filtered.test.ts
@@ -0,0 +1,54 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+const rows = [['metadata', '', ''], ['alpha', 'a', 'keep'], ['hidden', 'b', 'drop'], ['beta', 'c', 'keep'], ['gamma', 'd', 'keep']];
+async function fixture(separator = ',') {
+  const host = await createEditorHarness({ rows, separator, header: false, hiddenRows: 1, filters: [{ column: 2, operator: 'equals', value: 'keep' }] });
+  const view = createWebviewDom(host.panel.webview.html);
+  view.window.document.querySelector('.table-container').scrollTo = () => {};
+  return { host, view };
+}
+function selected(view: ReturnType<typeof createWebviewDom>) {
+  return Array.from(view.window.document.querySelectorAll('td.selected, th.selected'))
+    .map((cell: any) => `${cell.getAttribute('data-row')}:${cell.getAttribute('data-col')}`);
+}
+
+describe('Modified arrows in the combined filtered editor', () => {
+  for (const separator of [',', '\t']) {
+    it(`extends across visible source rows and copies the same range in ${separator === ',' ? 'CSV' : 'TSV'}`, async () => {
+      const { host, view } = await fixture(separator);
+      try {
+        const source = host.document.getText();
+        view.window.editingTestApi.setSingleSelection(view.cell(3, 1));
+        view.key('ArrowUp', { shiftKey: true });
+        assert.deepStrictEqual(selected(view), ['1:1', '3:1']);
+        view.key('ArrowRight', { metaKey: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), ['1:1', '1:2', '3:1', '3:2']);
+        assert.strictEqual(view.window.document.activeElement, view.cell(3, 1));
+        view.key('c', { metaKey: true });
+        const copy = view.messages.slice().reverse().find((message: any) => message.type === 'copyCells');
+        assert.deepStrictEqual(Array.from(copy.rowIds), [1, 3]);
+        assert.deepStrictEqual(JSON.parse(JSON.stringify(copy.matrix)), [['a', 'keep'], ['c', 'keep']]);
+        assert.strictEqual(host.document.getText(), source);
+      } finally { view.close(); }
+    });
+  }
+
+  it('leaves modified arrows on filter controls outside the grid handler', async () => {
+    const { view } = await fixture();
+    try {
+      view.window.editingTestApi.setSingleSelection(view.cell(3, 1));
+      const before = selected(view);
+      view.window.document.getElementById('clearAllFilters').focus();
+      for (const modifier of ['metaKey', 'ctrlKey']) {
+        for (const key of ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown']) {
+          const event = new view.window.KeyboardEvent('keydown', { key, [modifier]: true, shiftKey: true, bubbles: true, cancelable: true });
+          view.window.document.activeElement.dispatchEvent(event);
+          assert.strictEqual(event.defaultPrevented, false);
+          assert.deepStrictEqual(selected(view), before);
+        }
+      }
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/modified-arrow-selection.test.ts b/src/test/modified-arrow-selection.test.ts
new file mode 100644
index 0000000..7ad5556
--- /dev/null
+++ b/src/test/modified-arrow-selection.test.ts
@@ -0,0 +1,228 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['A', 'B', 'C', 'D'], ['a1', 'a2', 'a3', 'a4'], ['b1', 'b2', 'b3', 'b4'], ['c1', 'c2', 'c3', 'c4'], ['d1', 'd2', 'd3', 'd4']];
+
+async function fixture(options: Parameters<typeof createEditorHarness>[0] = {}) {
+  const host = await createEditorHarness({ rows, ...options });
+  const view = createWebviewDom(host.panel.webview.html);
+  const container = view.window.document.querySelector('.table-container');
+  container.scrollTo = (position: { left?: number; top?: number }) => {
+    if (position.left !== undefined) { container.scrollLeft = position.left; }
+    if (position.top !== undefined) { container.scrollTop = position.top; }
+  };
+  view.window.scrollTo = () => {};
+  return { host, view };
+}
+
+function select(view: View, row = 2, column = 1) {
+  view.window.editingTestApi.setSingleSelection(view.cell(row, column));
+}
+function selected(view: View, includeIndex = false): number[][] {
+  return Array.from(view.window.document.querySelectorAll('td.selected, th.selected'))
+    .filter((cell: any) => cell.hasAttribute('data-row') && Number(cell.getAttribute('data-col')) >= (includeIndex ? -1 : 0))
+    .map((cell: any) => [Number(cell.getAttribute('data-row')), Number(cell.getAttribute('data-col'))]);
+}
+function rectangle(minRow: number, maxRow: number, minColumn: number, maxColumn: number) {
+  return Array.from({ length: maxRow - minRow + 1 }, (_, row) =>
+    Array.from({ length: maxColumn - minColumn + 1 }, (_, column) => [minRow + row, minColumn + column])
+  ).flat();
+}
+function mouseSelect(view: View, row: number, column: number) {
+  const cell = view.cell(row, column);
+  const left = (column + 1) * 100;
+  cell.getBoundingClientRect = () => ({ left, right: left + 100, top: row * 30, bottom: row * 30 + 30, width: 100, height: 30 });
+  cell.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 0, clientX: left + 50, clientY: row * 30 + 15, bubbles: true, cancelable: true }));
+  cell.dispatchEvent(new view.window.MouseEvent('mouseup', { button: 0, bubbles: true }));
+}
+function dispatch(view: View, key: string, options: Record<string, unknown>) {
+  const event = new view.window.KeyboardEvent('keydown', { key, bubbles: true, cancelable: true, ...options });
+  view.window.document.activeElement.dispatchEvent(event);
+  return event;
+}
+
+describe('Modified arrow range selection', () => {
+  for (const modifier of ['metaKey', 'ctrlKey']) {
+    for (const [key, bounds] of [
+      ['ArrowLeft', [2, 2, 0, 1]], ['ArrowRight', [2, 2, 1, 3]],
+      ['ArrowUp', [1, 2, 1, 1]], ['ArrowDown', [2, 5, 1, 1]]
+    ] as const) {
+      it(`extends from a fixed anchor with ${modifier} + Shift + ${key}`, async () => {
+        const { host, view } = await fixture();
+        const source = host.document.getText();
+        try {
+          select(view);
+          const anchor = view.cell(2, 1);
+          const event = dispatch(view, key, { [modifier]: true, shiftKey: true });
+          assert.strictEqual(event.defaultPrevented, true);
+          assert.deepStrictEqual(selected(view), rectangle(bounds[0], bounds[1], bounds[2], bounds[3]));
+          assert.strictEqual(view.window.document.activeElement, anchor);
+          assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorRow, 2);
+          assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorCol, 1);
+          assert.strictEqual(host.document.getText(), source);
+          assert.ok(!view.messages.some((message: any) => message.type === 'editCell'));
+        } finally { view.close(); }
+      });
+    }
+
+    it(`continues and shrinks a rectangle from its endpoint with ${modifier}`, async () => {
+      const { view } = await fixture();
+      try {
+        select(view);
+        view.key('ArrowDown', { shiftKey: true });
+        view.key('ArrowRight', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(2, 3, 1, 3));
+        view.key('ArrowLeft', { shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(2, 3, 1, 2));
+        view.key('ArrowLeft', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(2, 3, 0, 1));
+        view.key('ArrowUp', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(1, 2, 0, 1));
+        assert.strictEqual(view.window.document.activeElement, view.cell(2, 1));
+      } finally { view.close(); }
+    });
+
+    it(`retains whole-column groups during horizontal and vertical extension with ${modifier}`, async () => {
+      const { view } = await fixture();
+      try {
+        mouseSelect(view, 0, 1);
+        view.key('ArrowRight', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(0, 5, 1, 3));
+        view.key('ArrowDown', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(0, 5, 1, 3));
+        view.key('ArrowLeft', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(0, 5, 0, 1));
+        assert.strictEqual(view.window.document.activeElement, view.cell(0, 1));
+      } finally { view.close(); }
+    });
+
+    it(`retains whole-row groups during vertical and horizontal extension with ${modifier}`, async () => {
+      const { view } = await fixture();
+      try {
+        mouseSelect(view, 2, -1);
+        view.key('ArrowDown', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view, true), rectangle(2, 5, -1, 3));
+        view.key('ArrowRight', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view, true), rectangle(2, 5, -1, 3));
+        view.key('ArrowUp', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view, true), rectangle(1, 2, -1, 3));
+        assert.strictEqual(view.window.document.activeElement, view.cell(2, -1));
+      } finally { view.close(); }
+    });
+
+    it(`keeps a backwards drag anchor through repeated and mixed jumps with ${modifier}`, async () => {
+      const { view } = await fixture();
+      try {
+        mouseSelect(view, 3, 2);
+        view.cell(3, 2).dispatchEvent(new view.window.MouseEvent('mousedown', { button: 0, clientX: 350, clientY: 105, bubbles: true }));
+        view.cell(1, 0).dispatchEvent(new view.window.MouseEvent('mousemove', { buttons: 1, bubbles: true }));
+        view.cell(1, 0).dispatchEvent(new view.window.MouseEvent('mouseup', { button: 0, bubbles: true }));
+        assert.deepStrictEqual(selected(view), rectangle(1, 3, 0, 2));
+        for (let repeat = 0; repeat < 2; repeat++) {
+          view.key('ArrowRight', { [modifier]: true, shiftKey: true });
+          assert.deepStrictEqual(selected(view), rectangle(1, 3, 2, 3));
+        }
+        view.key('ArrowDown', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(3, 5, 2, 3));
+        view.key('ArrowLeft', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(3, 5, 0, 2));
+        view.key('ArrowUp', { shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(3, 4, 0, 2));
+        view.key('ArrowUp', { [modifier]: true, shiftKey: true });
+        assert.deepStrictEqual(selected(view), rectangle(1, 3, 0, 2));
+        assert.strictEqual(view.window.document.activeElement, view.cell(3, 2));
+      } finally { view.close(); }
+    });
+
+    it(`preserves Select All after a stale range endpoint with ${modifier}`, async () => {
+      const { host, view } = await fixture();
+      try {
+        select(view);
+        view.key('ArrowDown', { shiftKey: true });
+        const corner = view.window.document.querySelector('thead th:not([data-col])');
+        corner.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 0, bubbles: true }));
+        corner.dispatchEvent(new view.window.MouseEvent('mouseup', { button: 0, bubbles: true }));
+        const all = selected(view, true);
+        assert.ok(all.length > 1);
+        for (const key of ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown']) {
+          view.key(key, { [modifier]: true, shiftKey: true });
+          assert.deepStrictEqual(selected(view, true), all);
+        }
+        assert.deepStrictEqual(host.rows(), rows);
+      } finally { view.close(); }
+    });
+
+    it(`preserves plain ${modifier} jump behavior without Shift`, async () => {
+      const { view } = await fixture();
+      try {
+        select(view);
+        view.key('ArrowRight', { [modifier]: true });
+        assert.deepStrictEqual(selected(view), [[2, 3]]);
+        assert.strictEqual(view.window.document.activeElement, view.cell(2, 3));
+        view.key('ArrowDown', { [modifier]: true });
+        assert.deepStrictEqual(selected(view), [[5, 3]]);
+      } finally { view.close(); }
+    });
+  }
+
+  it('extends to the existing loaded-row boundary in a chunked table', async () => {
+    const source = [['A', 'B'], ...Array.from({ length: 1100 }, (_, row) => [`row${row}`, String(row)])];
+    const { host, view } = await fixture({ rows: source });
+    try {
+      const rendered = Array.from(view.window.document.querySelectorAll('tbody td[data-col="1"]')) as any[];
+      const lastRow = Number(rendered[rendered.length - 1].getAttribute('data-row'));
+      assert.ok(lastRow < source.length - 1, 'fixture must retain unloaded source rows');
+      select(view, lastRow - 2, 1);
+      view.key('ArrowDown', { metaKey: true, shiftKey: true });
+      assert.deepStrictEqual(selected(view), rectangle(lastRow - 2, lastRow, 1, 1));
+      assert.strictEqual(view.window.document.activeElement, view.cell(lastRow - 2, 1));
+      assert.deepStrictEqual(host.rows(), source);
+    } finally { view.close(); }
+  });
+
+  it('copies the entire extended rectangle rather than only its edge cell', async () => {
+    const { view } = await fixture();
+    try {
+      select(view);
+      view.key('ArrowDown', { shiftKey: true });
+      view.key('ArrowRight', { metaKey: true, shiftKey: true });
+      view.key('c', { metaKey: true });
+      const copy = view.messages.slice().reverse().find((message: any) => message.type === 'copyCells');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(copy.matrix)), [['b2', 'b3', 'b4'], ['c2', 'c3', 'c4']]);
+    } finally { view.close(); }
+  });
+
+  it('supports headers off and Home/End aliases without losing the anchor', async () => {
+    const { view } = await fixture({ header: false, separator: '\t' });
+    try {
+      select(view);
+      view.key('End', { metaKey: true, shiftKey: true });
+      assert.deepStrictEqual(selected(view), rectangle(2, 2, 1, 3));
+      view.key('Home', { metaKey: true, shiftKey: true });
+      assert.deepStrictEqual(selected(view), rectangle(2, 2, 0, 1));
+      view.key('ArrowUp', { metaKey: true, shiftKey: true });
+      assert.deepStrictEqual(selected(view), rectangle(0, 2, 0, 1));
+    } finally { view.close(); }
+  });
+
+  it('leaves native selection in Find, Replace and cell text edits outside the grid handler', async () => {
+    const { view } = await fixture();
+    try {
+      select(view);
+      const before = selected(view);
+      for (const id of ['findInput', 'replaceInput']) {
+        view.window.document.getElementById(id).focus();
+        for (const key of ['ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown']) {
+          assert.strictEqual(dispatch(view, key, { metaKey: true, shiftKey: true }).defaultPrevented, false);
+        }
+        assert.deepStrictEqual(selected(view), before);
+      }
+      view.start(view.cell(2, 1));
+      for (const key of ['ArrowLeft', 'ArrowRight']) {
+        assert.strictEqual(dispatch(view, key, { metaKey: true, shiftKey: true }).defaultPrevented, false);
+      }
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/mouse-selection.test.ts b/src/test/mouse-selection.test.ts
new file mode 100644
index 0000000..cb72c06
--- /dev/null
+++ b/src/test/mouse-selection.test.ts
@@ -0,0 +1,140 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['Name', 'Value', 'Note'], ['one', 'two', 'three'], ['four', 'five', 'six'], ['seven', 'eight', 'nine']];
+const mouse = (view: View, target: any, type: string, options: Record<string, unknown> = {}) =>
+  target.dispatchEvent(new view.window.MouseEvent(type, { button: 0, bubbles: true, cancelable: true, clientX: 60, clientY: 45, ...options }));
+const selected = (view: View) => Array.from(view.window.document.querySelectorAll('td.selected, th.selected')) as any[];
+const coordinates = (view: View) => selected(view).map(cell => [Number(cell.dataset.row), Number(cell.dataset.col)]).sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+
+async function fixture(separator = ',') {
+  const host = await createEditorHarness({ rows, separator });
+  return { host, view: createWebviewDom(host.panel.webview.html) };
+}
+
+describe('Immediate mouse selection', () => {
+  for (const separator of [',', '\t']) {
+    it(`selects a body cell on mousedown and replaces the old selection on a new target (${JSON.stringify(separator)})`, async () => {
+      const { host, view } = await fixture(separator);
+      try {
+        const first = view.cell(1, 0);
+        mouse(view, first, 'mousedown');
+        assert.strictEqual(first.classList.contains('selected'), true, 'selection color must apply before mouseup');
+        assert.deepStrictEqual(coordinates(view), [[1, 0]]);
+        mouse(view, first, 'mouseup');
+        const next = view.cell(2, 1);
+        mouse(view, next, 'mousedown');
+        assert.deepStrictEqual(coordinates(view), [[2, 1]], 'a new press must immediately replace the prior selection');
+        assert.strictEqual(view.window.document.activeElement, next);
+        mouse(view, next, 'mouseup');
+        assert.deepStrictEqual(coordinates(view), [[2, 1]]);
+        assert.deepStrictEqual(host.rows(), rows);
+        assert.strictEqual(host.document.version, 1);
+        assert.strictEqual(host.document.getText(), host.diskText);
+      } finally { view.close(); }
+    });
+  }
+
+  it('expands and shrinks a held body drag without retaining cells outside its current rectangle', async () => {
+    const { view } = await fixture();
+    try {
+      mouse(view, view.cell(1, 0), 'mousedown');
+      assert.deepStrictEqual(coordinates(view), [[1, 0]]);
+      mouse(view, view.cell(3, 2), 'mousemove');
+      assert.strictEqual(selected(view).length, 9);
+      mouse(view, view.cell(2, 1), 'mousemove');
+      assert.deepStrictEqual(coordinates(view), [[1, 0], [1, 1], [2, 0], [2, 1]]);
+      mouse(view, view.cell(2, 1), 'mouseup');
+      assert.deepStrictEqual(coordinates(view), [[1, 0], [1, 1], [2, 0], [2, 1]]);
+    } finally { view.close(); }
+  });
+
+  it('selects the full new header column on mousedown before a column drag', async () => {
+    const { view } = await fixture();
+    try {
+      const column = view.cell(0, 1);
+      mouse(view, column, 'mousedown');
+      assert.deepStrictEqual(selected(view), Array.from(view.window.document.querySelectorAll('[data-col="1"]')));
+      mouse(view, view.cell(0, 2), 'mousemove');
+      assert.ok(selected(view).every(cell => cell.dataset.col === '1' || cell.dataset.col === '2'));
+      assert.strictEqual(selected(view).length, view.window.document.querySelectorAll('[data-col="1"], [data-col="2"]').length);
+      mouse(view, column, 'mousemove');
+      mouse(view, column, 'mouseup');
+      assert.deepStrictEqual(selected(view), Array.from(view.window.document.querySelectorAll('[data-col="1"]')));
+    } finally { view.close(); }
+  });
+
+  it('selects the full new serial row on mousedown before a row drag', async () => {
+    const { view } = await fixture();
+    try {
+      const row = view.cell(1, -1);
+      mouse(view, row, 'mousedown');
+      assert.deepStrictEqual(selected(view), Array.from(view.window.document.querySelectorAll('[data-row="1"]')));
+      mouse(view, view.cell(3, -1), 'mousemove');
+      assert.strictEqual(selected(view).length, 12);
+      mouse(view, view.cell(2, -1), 'mousemove');
+      assert.strictEqual(selected(view).length, 8);
+      mouse(view, view.cell(2, -1), 'mouseup');
+      assert.ok(selected(view).every(cell => cell.dataset.row === '1' || cell.dataset.row === '2'));
+    } finally { view.close(); }
+  });
+
+  it('preserves Shift range extension and an existing range on right-click', async () => {
+    const { view } = await fixture();
+    try {
+      mouse(view, view.cell(1, 0), 'mousedown');
+      mouse(view, view.cell(1, 0), 'mouseup');
+      mouse(view, view.cell(3, 2), 'mousedown', { shiftKey: true });
+      assert.strictEqual(selected(view).length, 9);
+      const before = coordinates(view);
+      mouse(view, view.cell(2, 1), 'mousedown', { button: 2 });
+      assert.deepStrictEqual(coordinates(view), before);
+    } finally { view.close(); }
+  });
+
+  it('commits edited A and copies only newly pressed B before and after mouseup', async () => {
+    const { host, view } = await fixture();
+    try {
+      const first = view.cell(1, 0);
+      const next = view.cell(2, 1);
+      view.start(first);
+      first.textContent = 'committed draft\nsecond line';
+      const cursor = view.messages.length;
+      mouse(view, next, 'mousedown');
+      const edit = view.messages.slice(cursor).find(message => message.type === 'editCell');
+      assert.ok(edit, 'pressing a different cell must still commit the active edit');
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(edit)), { type: 'editCell', row: 1, col: 0, value: 'committed draft\nsecond line' });
+      next.dispatchEvent(new view.window.Event('copy', { bubbles: true, cancelable: true }));
+      const beforeMouseup = view.messages.slice(cursor).filter(message => message.type === 'copyCells').slice(-1)[0];
+      assert.ok(beforeMouseup);
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(beforeMouseup.matrix)), [['five']], 'only B may be copied while the mouse is held');
+      assert.deepStrictEqual(Array.from(beforeMouseup.rowIds), [2]);
+      mouse(view, next, 'mouseup');
+      next.dispatchEvent(new view.window.Event('copy', { bubbles: true, cancelable: true }));
+      const afterMouseup = view.messages.slice(cursor).filter(message => message.type === 'copyCells').slice(-1)[0];
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(afterMouseup.matrix)), [['five']], 'mouseup must retain the same single-cell copy');
+      assert.deepStrictEqual(Array.from(afterMouseup.rowIds), [2]);
+      await host.receive(edit);
+      assert.strictEqual(host.rows()[1][0], 'committed draft\nsecond line');
+      assert.strictEqual(host.rows()[2][1], 'five');
+      assert.ok(!host.diskText.includes('committed draft'));
+    } finally { view.close(); }
+  });
+
+  it('keeps native text editing when mousedown stays inside the active edited cell', async () => {
+    const { host, view } = await fixture();
+    try {
+      const cell = view.cell(1, 0);
+      view.start(cell);
+      const event = new view.window.MouseEvent('mousedown', { button: 0, bubbles: true, cancelable: true, clientX: 60, clientY: 45 });
+      cell.dispatchEvent(event);
+      assert.strictEqual(event.defaultPrevented, false);
+      assert.strictEqual(cell.getAttribute('contenteditable'), 'true');
+      assert.strictEqual(cell.classList.contains('selected'), false);
+      assert.strictEqual(view.messages.some(message => message.type === 'editCell'), false);
+      assert.strictEqual(host.document.version, 1);
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/provider-clipboard.test.ts b/src/test/provider-clipboard.test.ts
new file mode 100644
index 0000000..ab84de4
--- /dev/null
+++ b/src/test/provider-clipboard.test.ts
@@ -0,0 +1,138 @@
+import { TestExtensionUri } from './test-extension-uri';
+import assert from 'assert';
+import Module from 'module';
+import Papa from 'papaparse';
+import { describe, it } from 'node:test';
+
+let writeClipboard: (text: string) => Promise<void>;
+let readClipboard: () => Promise<string>;
+let applyEdit: (edit: any) => Promise<boolean>;
+const errors: string[] = [];
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return {
+      Uri: { file: (filePath: string) => ({ fsPath: filePath, toString: () => filePath }) },
+      Range: class {},
+      WorkspaceEdit: class { text = ''; replace(_uri: any, _range: any, text: string) { this.text = text; } },
+      env: { clipboard: { writeText: (text: string) => writeClipboard(text), readText: () => readClipboard() } },
+      window: { activeColorTheme: { kind: 1 }, showErrorMessage: (message: string) => errors.push(message) },
+      ColorThemeKind: { Dark: 1 },
+      workspace: {
+        getConfiguration: () => ({ get: (key: string, fallback: any) => key === 'maxFileSizeMB' ? 0 : fallback }),
+        onDidChangeTextDocument: () => ({ dispose() {} }),
+        onWillSaveTextDocument: () => ({ dispose() {} }),
+        applyEdit: (edit: any) => applyEdit(edit)
+      }
+    };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+async function createEditor(initial: string, extension = 'csv') {
+  let text = initial;
+  let version = 1;
+  let receive: (message: any) => Promise<void> = async () => {};
+  const clipboardWrites: string[] = [];
+  const events: string[] = [];
+  const messages: any[] = [];
+  errors.length = 0;
+  writeClipboard = async value => { clipboardWrites.push(value); events.push('write'); };
+  readClipboard = async () => clipboardWrites[clipboardWrites.length - 1] || '';
+  applyEdit = async edit => { events.push('edit'); text = edit.text; version++; return true; };
+  const uri = { fsPath: `/test.${extension}`, toString: () => `file:///test.${extension}` };
+  const document = {
+    uri, getText: () => text, get version() { return version; },
+    get lineCount() { return text.split('\n').length; }, lineAt: (index: number) => ({ text: text.split('\n')[index] })
+  };
+  const webview = {
+    html: '', cspSource: 'test:', options: {}, asWebviewUri: (value: any) => value.toString(),
+    postMessage: (message: any) => { messages.push(message); return Promise.resolve(true); },
+    onDidReceiveMessage: (callback: any) => { receive = callback; }
+  };
+  const panel = { active: true, title: 'test', webview, onDidChangeViewState() {}, onDidDispose() {} };
+  const context = { extensionPath: process.cwd(), extensionUri: new TestExtensionUri(), workspaceState: { get: (_key: string, fallback: any) => fallback } };
+  await new CsvEditorProvider(context as any).resolveCustomTextEditor(document as any, panel as any, { isCancellationRequested: false } as any);
+  return {
+    receive: (message: any) => receive(message), clipboardWrites, events, messages,
+    get text() { return text; }, mutate: () => { text = 'newer,value'; version++; }
+  };
+}
+
+describe('Provider system clipboard integration', () => {
+  it('writes an ordinary cell without CSV wrapper quotes and pastes it without changing source quoting', async () => {
+    for (const extension of ['csv', 'tsv']) {
+      const delimiter = extension === 'csv' ? ',' : '\t';
+      const source = `name${delimiter}value\nhello world${delimiter}before`;
+      const editor = await createEditor(source, extension);
+      await editor.receive({ type: 'copyCells', matrix: [['hello world']], rowIds: [1], startRow: 1, startCol: 0, cut: false });
+      assert.deepStrictEqual(editor.clipboardWrites, ['hello world']);
+      assert.strictEqual(editor.text, source);
+      await editor.receive({ type: 'pasteFromClipboard', anchorRow: 1, anchorCol: 1 });
+      assert.strictEqual(editor.text, `name${delimiter}value\nhello world${delimiter}hello world`);
+    }
+  });
+
+  it('writes a mixed column with plain neighbors unquoted and real blanks explicit', async () => {
+    for (const extension of ['csv', 'tsv']) {
+      const editor = await createEditor('Name,Other\nplain,1\n"with,comma",2\nlast,3', extension);
+      await editor.receive({ type: 'copyCells', matrix: [['Name'], ['plain'], ['with,comma'], [''], ['last']], rowIds: [0, 1, 2, 3, 4], startCol: 0, cut: false });
+      assert.deepStrictEqual(editor.clipboardWrites, ['Name\r\nplain\r\n"with,comma"\r\n""\r\nlast']);
+      assert.strictEqual(editor.events.includes('edit'), false);
+    }
+  });
+
+  it('writes quoted CSV/TSV to the system clipboard and round-trips paste through the document', async () => {
+    for (const extension of ['csv', 'tsv']) {
+      const delimiter = extension === 'csv' ? ',' : '\t';
+      const editor = await createEditor(`old${delimiter}old\nold${delimiter}old`, extension);
+      const matrix = [['literal,comma', 'line\nvalue'], ['"quote"', '']];
+      await editor.receive({ type: 'copyCells', matrix, rowIds: [0, 1], startCol: 0, cut: false });
+      assert.strictEqual(editor.clipboardWrites.length, 1);
+      assert.deepStrictEqual(Papa.parse(editor.clipboardWrites[0], { delimiter }).data, matrix);
+      assert.strictEqual(editor.text, `old${delimiter}old\nold${delimiter}old`);
+      await editor.receive({ type: 'pasteFromClipboard', anchorRow: 0, anchorCol: 0 });
+      assert.deepStrictEqual(Papa.parse(editor.text, { delimiter }).data, matrix);
+      assert.strictEqual(editor.messages[editor.messages.length - 1].type, 'pasteApplied');
+    }
+  });
+
+  it('clears cut cells in one batch only after the clipboard write succeeds', async () => {
+    const editor = await createEditor('one,two\nthree,four');
+    let finishWrite: () => void = () => {};
+    let signalWriteStarted: () => void = () => {};
+    const writeStarted = new Promise<void>(resolve => { signalWriteStarted = resolve; });
+    writeClipboard = async () => {
+      const pendingWrite = new Promise<void>(resolve => { finishWrite = resolve; });
+      signalWriteStarted();
+      await pendingWrite;
+      editor.events.push('write');
+    };
+    const cut = editor.receive({ type: 'copyCells', matrix: [['one', 'two']], rowIds: [0], startCol: 0, cut: true });
+    await writeStarted;
+    assert.strictEqual(editor.text, 'one,two\nthree,four');
+    finishWrite();
+    await cut;
+    assert.deepStrictEqual(editor.events, ['write', 'edit']);
+    assert.deepStrictEqual(Papa.parse(editor.text).data, [['', ''], ['three', 'four']]);
+  });
+
+  it('keeps cut data when the clipboard write fails', async () => {
+    const editor = await createEditor('one,two');
+    writeClipboard = async () => { throw new Error('clipboard unavailable'); };
+    await editor.receive({ type: 'copyCells', matrix: [['one']], rowIds: [0], startCol: 0, cut: true });
+    assert.strictEqual(editor.text, 'one,two');
+    assert.deepStrictEqual(editor.events, []);
+    assert.strictEqual(errors.length, 1);
+  });
+
+  it('keeps newer document contents if a cut write completes after another edit', async () => {
+    const editor = await createEditor('one,two');
+    writeClipboard = async () => { editor.mutate(); };
+    await editor.receive({ type: 'copyCells', matrix: [['one']], rowIds: [0], startCol: 0, cut: true });
+    assert.strictEqual(editor.text, 'newer,value');
+    assert.deepStrictEqual(editor.events, []);
+  });
+});
diff --git a/src/test/provider-state.test.ts b/src/test/provider-state.test.ts
index 42cd074..82af308 100644
--- a/src/test/provider-state.test.ts
+++ b/src/test/provider-state.test.ts
@@ -8,7 +8,8 @@ Module.prototype.require = function (id: string) {
   if (id === 'vscode') {
     return {
       window: { activeColorTheme: { kind: 1 } },
-      ColorThemeKind: { Dark: 1 }
+      ColorThemeKind: { Dark: 1 },
+      workspace: { getConfiguration: () => ({ get: (_key: string, fallback: unknown) => fallback }) }
     } as any;
   }
   return originalRequire.apply(this, arguments as any);
diff --git a/src/test/resize-hit-testing.test.ts b/src/test/resize-hit-testing.test.ts
new file mode 100644
index 0000000..85349e5
--- /dev/null
+++ b/src/test/resize-hit-testing.test.ts
@@ -0,0 +1,218 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+type Rect = { left: number; right: number; top: number; bottom: number; width: number; height: number };
+
+async function fixture(header = true, widths = [100, 17, 100], separator = ',') {
+  const host = await createEditorHarness({ rows: [['name', '', 'value'], ['one', '', 'three']], header, separator });
+  const view = createWebviewDom(host.panel.webview.html);
+  const { window } = view;
+  const table = window.document.querySelector('table');
+  const cells = Array.from(table.querySelectorAll('[data-row][data-col]')) as any[];
+  const fixed = new Map<any, Rect>();
+  let probes = 0;
+  let border: number | undefined;
+  let cover: any;
+  const rect = (cell: any): Rect => {
+    if (fixed.has(cell)) { return fixed.get(cell)!; }
+    const row = Number(cell.dataset.row), column = Number(cell.dataset.col);
+    const widthOf = (col: number) => Number.parseFloat(view.cell(row, col)?.style.width) || widths[col];
+    const left = column < 0 ? 0 : 30 + widths.slice(0, column).reduce((sum, _width, col) => sum + widthOf(col), 0);
+    const width = column < 0 ? 30 : widthOf(column);
+    return { left, right: left + width, top: row * 30, bottom: row * 30 + 30, width, height: 30 };
+  };
+  for (const cell of cells) { cell.getBoundingClientRect = () => rect(cell); }
+  window.document.elementFromPoint = (x: number, y: number) => {
+    probes++;
+    const contains = (cell: any) => {
+      const box = rect(cell);
+      return box.width > 0 && box.height > 0 && x >= box.left && x <= box.right && y >= box.top && y <= box.bottom;
+    };
+    if (cover && contains(cover)) { return cover; }
+    const hit = cells.slice().reverse().find(contains);
+    if (border !== undefined && Math.abs(x - border) < 0.2) { return hit?.parentElement ?? table; }
+    return hit ?? table;
+  };
+  const mouse = (target: any, type: string, x: number, y = 15) => {
+    const event = new window.MouseEvent(type, { bubbles: true, cancelable: true, button: 0, clientX: x, clientY: y });
+    target.dispatchEvent(event);
+    return event;
+  };
+  return { ...view, table, fixed, rect, mouse, setBorder: (x: number) => { border = x; }, setCover: (cell: any) => { cover = cell; }, get probes() { return probes; } };
+}
+
+describe('Resize boundary event hit testing', () => {
+  for (const header of [true, false]) {
+    for (const separator of [',', '\t']) {
+      it(`leaves a blank 17px cell center selectable and editable (header ${header}, ${JSON.stringify(separator)})`, async () => {
+        const view = await fixture(header, [100, 17, 100], separator);
+        try {
+          const cell = view.cell(0, 1);
+          const x = view.rect(cell).left + 8.5;
+          view.mouse(cell, 'mousemove', x);
+          assert.strictEqual(view.table.style.cursor, '');
+          view.mouse(cell, 'mousedown', x);
+          view.mouse(cell, 'mouseup', x);
+          assert.ok(cell.classList.contains('selected'));
+          view.mouse(cell, 'dblclick', x);
+          assert.strictEqual(cell.getAttribute('contenteditable'), 'true');
+          assert.ok(!view.messages.some(message => message.type === 'columnSizesChanged'));
+        } finally { view.close(); }
+      });
+    }
+  }
+
+  it('shrinks both boundaries further on 8px cells while preserving their center', async () => {
+    const view = await fixture(false, [100, 8, 100]);
+    try {
+      const cell = view.cell(0, 1);
+      for (const x of [132.1, 134, 135.9]) {
+        view.mouse(cell, 'mousemove', x);
+        assert.strictEqual(view.table.style.cursor, '');
+      }
+      for (const x of [130, 131.9, 136.1, 138]) {
+        view.mouse(cell, 'mousemove', x);
+        assert.strictEqual(view.table.style.cursor, 'col-resize');
+      }
+    } finally { view.close(); }
+  });
+
+  for (const targetKind of ['row', 'table', 'previous', 'next']) {
+    it(`shares hover/drag/reset at a fractional border targeted as ${targetKind}`, async () => {
+      const view = await fixture(false);
+      try {
+        const first = view.cell(0, 0), next = view.cell(0, 1);
+        view.fixed.set(first, { left: 30, right: 130.25, top: 0, bottom: 30, width: 100.25, height: 30 });
+        view.fixed.set(next, { left: 130.75, right: 147.75, top: 0, bottom: 30, width: 17, height: 30 });
+        view.setBorder(130.5);
+        const target = targetKind === 'row' ? first.parentElement : targetKind === 'table' ? view.table : targetKind === 'previous' ? first : next;
+        view.mouse(target, 'mousemove', 130.5);
+        assert.strictEqual(view.table.style.cursor, 'col-resize');
+        assert.strictEqual(view.mouse(target, 'mousedown', 130.5).defaultPrevented, true);
+        view.mouse(target, 'mousemove', 150.5);
+        view.mouse(target, 'mouseup', 150.5);
+        assert.strictEqual(first.style.width, '120px');
+        assert.strictEqual(first.style.boxSizing, 'border-box');
+        assert.strictEqual(next.style.width, '');
+        assert.deepStrictEqual({ ...view.messages.filter(message => message.type === 'columnSizesChanged').at(-1).columnSizes }, { '0': 120 });
+        assert.strictEqual(view.mouse(target, 'dblclick', 130.5).defaultPrevented, true);
+        assert.strictEqual(first.style.width, '');
+        assert.strictEqual(first.style.boxSizing, '');
+        assert.deepStrictEqual({ ...view.messages.filter(message => message.type === 'columnSizesChanged').at(-1).columnSizes }, {});
+      } finally { view.close(); }
+    });
+  }
+
+  it('resolves the painted frozen neighbor rather than an occluded logical predecessor', async () => {
+    const view = await fixture(false);
+    try {
+      const frozen = view.cell(0, 0), covered = view.cell(0, 1), visible = view.cell(0, 2);
+      view.fixed.set(frozen, { left: 100, right: 150, top: 0, bottom: 30, width: 50, height: 30 });
+      view.fixed.set(covered, { left: 130, right: 147, top: 0, bottom: 30, width: 17, height: 30 });
+      view.fixed.set(visible, { left: 150, right: 250, top: 0, bottom: 30, width: 100, height: 30 });
+      view.setCover(frozen);
+      view.mouse(covered, 'mousemove', 143);
+      assert.strictEqual(view.table.style.cursor, '', 'covered source boundary cannot resize');
+      view.mouse(visible, 'mousemove', 150);
+      assert.strictEqual(view.table.style.cursor, 'col-resize');
+      view.mouse(visible, 'mousedown', 150);
+      view.mouse(visible, 'mousemove', 170);
+      view.mouse(visible, 'mouseup', 170);
+      assert.strictEqual(frozen.style.width, '70px');
+      assert.strictEqual(covered.style.width, '');
+      assert.deepStrictEqual({ ...view.messages.filter(message => message.type === 'columnSizesChanged').at(-1).columnSizes }, { '0': 70 });
+    } finally { view.close(); }
+  });
+
+  for (const x of [149, 151]) {
+    it(`shares hover/drag/reset on either side of a partially occluded frozen seam at ${x}`, async () => {
+      const view = await fixture(false);
+      try {
+        const frozen = view.cell(0, 0), covered = view.cell(0, 1), visible = view.cell(0, 2);
+        view.fixed.set(frozen, { left: 100, right: 150, top: 0, bottom: 30, width: 50, height: 30 });
+        view.fixed.set(covered, { left: 120, right: 145, top: 0, bottom: 30, width: 25, height: 30 });
+        view.fixed.set(visible, { left: 140, right: 250, top: 0, bottom: 30, width: 110, height: 30 });
+        view.setCover(frozen);
+        const target = x < 150 ? frozen : visible;
+        view.mouse(target, 'mousemove', x);
+        assert.strictEqual(view.table.style.cursor, 'col-resize');
+        assert.strictEqual(view.mouse(target, 'mousedown', x).defaultPrevented, true);
+        view.mouse(target, 'mousemove', x + 20);
+        view.mouse(target, 'mouseup', x + 20);
+        assert.strictEqual(frozen.style.width, '70px');
+        assert.strictEqual(covered.style.width, '');
+        assert.strictEqual(visible.style.width, '');
+        assert.deepStrictEqual({ ...view.messages.filter(message => message.type === 'columnSizesChanged').at(-1).columnSizes }, { '0': 70 });
+        assert.strictEqual(view.mouse(target, 'dblclick', x).defaultPrevented, true);
+        assert.strictEqual(frozen.style.width, '');
+        assert.strictEqual(frozen.style.boxSizing, '');
+        assert.deepStrictEqual({ ...view.messages.filter(message => message.type === 'columnSizesChanged').at(-1).columnSizes }, {});
+      } finally { view.close(); }
+    });
+  }
+
+  it('keeps the painted center of a partially covered narrow cell selectable', async () => {
+    const view = await fixture(false);
+    try {
+      const frozen = view.cell(0, 0), covered = view.cell(0, 1), visible = view.cell(0, 2);
+      view.fixed.set(frozen, { left: 100, right: 150, top: 0, bottom: 30, width: 50, height: 30 });
+      view.fixed.set(covered, { left: 120, right: 145, top: 0, bottom: 30, width: 25, height: 30 });
+      view.fixed.set(visible, { left: 140, right: 158, top: 0, bottom: 30, width: 18, height: 30 });
+      view.setCover(frozen);
+      for (const x of [152.1, 154, 155.9]) {
+        view.mouse(visible, 'mousemove', x);
+        assert.strictEqual(view.table.style.cursor, '');
+      }
+      view.mouse(visible, 'mousedown', 154);
+      view.mouse(visible, 'mouseup', 154);
+      assert.ok(visible.classList.contains('selected'));
+      assert.ok(!view.messages.some(message => message.type === 'columnSizesChanged'));
+      for (const x of [150, 151.9, 156.1, 158]) {
+        view.mouse(x < 150 ? frozen : visible, 'mousemove', x);
+        assert.strictEqual(view.table.style.cursor, 'col-resize');
+      }
+    } finally { view.close(); }
+  });
+
+  it('ignores links, controls, hidden columns and active editors', async () => {
+    const view = await fixture(false);
+    try {
+      const cell = view.cell(0, 0);
+      for (const tag of ['a', 'button', 'input']) {
+        const control = view.window.document.createElement(tag);
+        cell.appendChild(control);
+        view.mouse(control, 'mousemove', 130);
+        assert.strictEqual(view.table.style.cursor, '');
+        control.remove();
+      }
+      const hidden = view.cell(0, 1);
+      view.fixed.set(hidden, { left: 140, right: 140, top: 0, bottom: 30, width: 0, height: 30 });
+      view.mouse(hidden, 'mousemove', 140);
+      assert.strictEqual(view.table.style.cursor, '');
+      view.start(cell);
+      view.mouse(cell, 'mousemove', 130);
+      assert.strictEqual(view.table.style.cursor, '');
+    } finally { view.close(); }
+  });
+
+  it('keeps hover work bounded to painted points and leaves row-index resizing unchanged', async () => {
+    const view = await fixture(false);
+    try {
+      const cell = view.cell(0, 1);
+      const query = view.table.querySelectorAll;
+      view.table.querySelectorAll = () => { throw new Error('hover must not scan rendered cells'); };
+      view.mouse(cell, 'mousemove', 130);
+      assert.strictEqual(view.table.style.cursor, 'col-resize');
+      assert.ok(view.probes <= 10);
+      view.table.querySelectorAll = query;
+      const index = view.cell(0, -1);
+      view.mouse(index, 'mousemove', 15, 29);
+      assert.strictEqual(view.table.style.cursor, 'row-resize');
+      view.mouse(index, 'mousedown', 15, 29);
+      view.mouse(index, 'mousemove', 15, 39);
+      view.mouse(index, 'mouseup', 15, 39);
+      assert.strictEqual(index.style.height, '40px');
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/saved-disable-draft.test.ts b/src/test/saved-disable-draft.test.ts
new file mode 100644
index 0000000..cba3db8
--- /dev/null
+++ b/src/test/saved-disable-draft.test.ts
@@ -0,0 +1,158 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+const nextTurn = () => new Promise(resolve => setImmediate(resolve));
+function prepare(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>) {
+  const request = host.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+  assert.ok(request);
+  const cursor = view.messages.length;
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+  return { request, outgoing: view.messages.slice(cursor) };
+}
+
+describe('File-backed disable preserves active drafts', () => {
+  for (const separator of [',', '\t']) {
+    it(`commits the live multiline draft before one native handoff (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell());
+        view.cell().textContent = 'latest\nunsaved';
+        const disk = host.diskText;
+        host.deferEdits();
+        host.setEnabled(false);
+        host.refresh();
+        assert.strictEqual(host.panel.disposed, false);
+        assert.strictEqual(host.recordedCommands.length, 0);
+        const { outgoing } = prepare(host, view);
+        const pending = outgoing.map(message => host.receive(message));
+        await nextTurn();
+        assert.strictEqual(host.pendingEdits, 1);
+        assert.strictEqual(host.recordedCommands.length, 0);
+        assert.strictEqual(host.panel.disposed, false);
+        host.releaseEdit();
+        await Promise.all(pending);
+        await flushViewCommits(host, view);
+        assert.strictEqual(host.rows()[1][0], 'latest\nunsaved');
+        assert.strictEqual(host.diskText, disk, 'disabling does not force a save');
+        assert.strictEqual(host.panel.disposed, true);
+        assert.deepStrictEqual(host.recordedCommands, [['vscode.openWith', host.document.uri, 'default', { viewColumn: 2, preserveFocus: false }]]);
+      } finally { view.close(); host.dispose(); }
+    });
+  }
+
+  for (const failure of ['false', 'throw'] as const) {
+    it(`keeps a failed ${failure} disable draft and pending handoff until retry succeeds`, async () => {
+      const host = await createEditorHarness();
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell());
+        view.cell().textContent = 'not applied';
+        const original = host.document.getText();
+        host.failEdits(failure);
+        host.setEnabled(false);
+        const { outgoing } = prepare(host, view);
+        await Promise.all(outgoing.map(message => host.receive(message)));
+        assert.strictEqual(host.panel.disposed, false);
+        assert.strictEqual(host.document.getText(), original);
+        assert.strictEqual(host.recordedCommands.length, 0);
+        assert.strictEqual(view.cell().textContent, 'not applied');
+        host.failEdits(undefined);
+        view.start(view.cell());
+        const cursor = view.messages.length;
+        view.cell().blur();
+        await Promise.all(view.messages.slice(cursor).map(message => host.receive(message)));
+        await flushViewCommits(host, view);
+        assert.strictEqual(host.rows()[1][0], 'not applied');
+        assert.strictEqual(host.panel.disposed, true);
+        assert.strictEqual(host.recordedCommands.length, 1);
+        assert.strictEqual(host.diskText, original);
+      } finally { view.close(); host.dispose(); }
+    });
+  }
+
+  it('requires a fresh ACK after a newer live edit and cancels teardown after rapid re-enable', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      host.setEnabled(false);
+      const old = prepare(host, view);
+      const ack = old.outgoing.find(message => message.type === 'viewRefreshReady');
+      // Gate the ordered queue so the old ACK is received before a new edit starts,
+      // then ensure the raw activity invalidates that queued authorization.
+      let release!: () => void;
+      const gate = new Promise<void>(resolve => { release = resolve; });
+      (host.activeController as any).pendingOperation = gate;
+      const stale = host.receive(ack);
+      view.start(view.cell());
+      view.cell().textContent = 'newest draft';
+      const activity = view.messages.filter(message => message.type === 'cellEditStarted').slice(-1)[0];
+      const observing = host.receive(activity);
+      release();
+      await Promise.all([stale, observing]);
+      assert.strictEqual(host.panel.disposed, false);
+      assert.strictEqual(host.recordedCommands.length, 0);
+      assert.notStrictEqual(host.pendingDraftRequestId, old.request.requestId);
+      host.setEnabled(true);
+      await flushViewCommits(host, view);
+      assert.strictEqual(host.rows()[1][0], 'newest draft');
+      assert.strictEqual(host.panel.disposed, false);
+      assert.strictEqual(host.recordedCommands.length, 0);
+      assert.ok(host.panel.webview.html.includes('<table>'));
+    } finally { view.close(); host.dispose(); }
+  });
+  for (const activity of ['cell', 'filter'] as const) {
+    it(`requests a fresh ACK for newer ${activity} activity while another native handoff holds the queue`, async () => {
+      const host = await createEditorHarness();
+      const view = createWebviewDom(host.panel.webview.html);
+      const Controller = host.activeController!.constructor as any;
+      let release!: () => void;
+      const gate = new Promise<void>(resolve => { release = resolve; });
+      Controller.nativeHandoffQueue = gate;
+      try {
+        host.setEnabled(false);
+        const original = prepare(host, view);
+        const pending = Promise.all(original.outgoing.map(message => host.receive(message)));
+        await nextTurn();
+        assert.strictEqual(host.recordedCommands.length, 0);
+        const cursor = view.messages.length;
+        if (activity === 'cell') {
+          view.start(view.cell());
+          view.cell().textContent = 'new draft after queued ACK';
+        } else {
+          (view.window as any).csvColumnFilters.add(0);
+          const input = view.window.document.querySelector('[data-filter-value]') as HTMLInputElement;
+          input.value = 'one';
+          input.dispatchEvent(new view.window.Event('input', { bubbles: true }));
+        }
+        const observed = view.messages.slice(cursor).filter(message => message.type === 'cellEditStarted' || message.type === 'filterDraftChanged');
+        assert.ok(observed.length, 'the shipped webview reports new raw activity immediately');
+        const activityOperations = observed.map(message => host.receive(message));
+        let newerCommitResolved = false;
+        const newerCommit = host.commitPendingDraft().then(result => { newerCommitResolved = true; return result; });
+        release();
+        await pending;
+        await Promise.all(activityOperations);
+        assert.strictEqual(host.panel.disposed, false);
+        await nextTurn();
+        assert.strictEqual(newerCommitResolved, false, 'the old finish cannot authorize a newer commit waiter before its fresh ACK');
+        assert.strictEqual(host.recordedCommands.length, 0, 'a stale ACK never authorizes native open or disposal');
+        assert.notStrictEqual(host.pendingDraftRequestId, original.request.requestId);
+        if (activity === 'cell') { assert.strictEqual(view.cell().textContent, 'new draft after queued ACK'); }
+        else { assert.strictEqual((view.window.document.querySelector('[data-filter-value]') as HTMLInputElement).value, 'one'); }
+        await flushViewCommits(host, view);
+        assert.strictEqual(await newerCommit, false, 'native handoff disposes the controller only after the fresh ACK');
+        assert.strictEqual(host.panel.disposed, true);
+        assert.strictEqual(host.recordedCommands.length, 1);
+        if (activity === 'cell') { assert.strictEqual(host.rows()[1][0], 'new draft after queued ACK'); }
+        assert.strictEqual(host.diskText.includes('new draft after queued ACK'), false);
+      } finally {
+        release();
+        view.close(); host.dispose();
+        await Controller.nativeHandoffQueue;
+      }
+    });
+  }
+
+});
diff --git a/src/test/serial-index-context-menu.test.ts b/src/test/serial-index-context-menu.test.ts
new file mode 100644
index 0000000..3679c55
--- /dev/null
+++ b/src/test/serial-index-context-menu.test.ts
@@ -0,0 +1,286 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+type View = ReturnType<typeof createWebviewDom>;
+const rows = [['Name', 'Value'], ['one', 'two'], ['three', 'four']];
+const settle = () => new Promise(resolve => setTimeout(resolve, 20));
+
+function openMenu(view: View, target: any) {
+  assert.ok(target);
+  target.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true, clientX: 100, clientY: 100 }));
+  const event = new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 100, clientY: 100 });
+  target.dispatchEvent(event);
+  return { event, items: Array.from(view.window.document.querySelectorAll('#contextMenu div')) as any[] };
+}
+
+function chooseHide(view: View, target: any) {
+  const item = openMenu(view, target).items.find(element => element.textContent === 'Hide serial index column');
+  assert.ok(item);
+  item.click();
+  const message = view.messages.slice().reverse().find(item => item.type === 'setSerialIndex');
+  assert.strictEqual(message.enabled, false);
+  return message;
+}
+
+async function finishRefresh(host: Host, view: View, start = 0) {
+  let cursor = start;
+  for (let guard = 0; guard < 5; guard++) {
+    const pending = host.messages.slice(cursor).filter((item: any) => item.type === 'prepareViewRefresh');
+    cursor = host.messages.length;
+    if (!pending.length) { break; }
+    for (const prepare of pending) {
+      const begin = view.messages.length;
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: prepare }));
+      for (const item of view.messages.slice(begin)) { await host.receive(item); }
+    }
+  }
+  await settle();
+}
+
+async function applySerialIndex(host: Host, view: View, message: unknown) {
+  const start = host.messages.length;
+  await host.receive(message);
+  await finishRefresh(host, view, start);
+}
+
+async function mountThrough(view: View, host: Host, row: number) {
+  let begin = 0;
+  for (let guard = 0; !view.cell(row, -1) && guard < 10; guard++) {
+    view.window.__csvLoadNextChunk();
+    const pending = view.messages.slice(begin).filter(message => message.type === 'requestChunk');
+    begin = view.messages.length;
+    for (const request of pending) {
+      await host.receive(request);
+      const response = host.messages.slice().reverse().find((message: any) => message.type === 'chunkData' && message.requestId === request.requestId);
+      view.window.dispatchEvent(new view.window.MessageEvent('message', { data: response }));
+    }
+  }
+  assert.ok(view.cell(row, -1), `serial cell in row ${row} should be mounted`);
+}
+
+describe('Serial index context action', () => {
+  for (const separator of [',', '\t']) {
+    for (const header of [false, true]) {
+      it(`hides only the serial column without changing source (${JSON.stringify(separator)}, header ${header})`, async () => {
+        const host = await createEditorHarness({ rows, separator, header });
+        const view = createWebviewDom(host.panel.webview.html);
+        const source = host.document.getText(), version = host.document.version, disk = host.diskText;
+        try {
+          for (const row of [1, 2, 3]) {
+            assert.ok(openMenu(view, view.cell(row, -1)).items.some(item => item.textContent === 'Hide serial index column'));
+          }
+          for (const row of [0, 1, 3]) {
+            for (const column of [0, 1]) {
+              assert.ok(!openMenu(view, view.cell(row, column)).items.some(item => item.textContent === 'Hide serial index column'));
+            }
+          }
+          await applySerialIndex(host, view, chooseHide(view, view.cell(1, -1)));
+          const next = createWebviewDom(host.panel.webview.html);
+          try {
+            assert.strictEqual(next.window.document.querySelector('[data-col="-1"], [data-serial-index]'), null);
+            assert.ok(!openMenu(next, next.cell(1, 0)).items.some(item => item.textContent === 'Hide serial index column'));
+          } finally { next.close(); }
+          assert.strictEqual(CsvEditorProvider.getSerialIndexForUri(host.context as any, host.document.uri as any), false);
+          assert.strictEqual(host.document.getText(), source);
+          assert.strictEqual(host.document.version, version);
+          assert.strictEqual(host.diskText, disk);
+          // The existing command uses this setter and refresh route to restore the column.
+          await CsvEditorProvider.setSerialIndexForUri(host.context as any, host.document.uri as any, true);
+          CsvEditorProvider.getActiveProvider()!.refresh();
+          await settle();
+          const restored = createWebviewDom(host.panel.webview.html);
+          try { assert.ok(restored.cell(1, -1)); } finally { restored.close(); }
+        } finally { view.close(); }
+      });
+    }
+  }
+
+  it('offers the corner action while preserving Select All and excluding invalid data actions', async () => {
+    const host = await createEditorHarness({ rows });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      const corner = view.window.document.querySelector('thead th[data-serial-index]');
+      assert.ok(corner);
+      assert.ok(!corner.hasAttribute('data-row') && !corner.hasAttribute('data-col'));
+      corner.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 0, bubbles: true, cancelable: true }));
+      assert.strictEqual(view.window.document.querySelectorAll('td.selected, th.selected').length, view.window.document.querySelectorAll('td, th').length);
+      const menu = openMenu(view, corner);
+      assert.strictEqual(menu.event.defaultPrevented, true);
+      assert.ok(menu.items.some(item => item.textContent === 'Hide serial index column'));
+      assert.ok(!menu.items.some(item => /Sort:|COLUMN:|Delete COLUMN|first row as/.test(item.textContent)));
+      await applySerialIndex(host, view, chooseHide(view, corner));
+      assert.ok(!host.panel.webview.html.includes('data-serial-index'));
+      assert.deepStrictEqual(host.rows(), rows);
+    } finally { view.close(); }
+  });
+
+  it('hides an empty/header-off serial column and accepts a boolean restore idempotently', async () => {
+    const host = await createEditorHarness({ rows: [], header: false });
+    let view = createWebviewDom(host.panel.webview.html);
+    try {
+      await applySerialIndex(host, view, chooseHide(view, view.cell(0, -1)));
+      assert.ok(!host.panel.webview.html.includes('data-col="-1"'));
+      // A full refresh creates a new webview session; its script owns the next ACK.
+      view.close();
+      view = createWebviewDom(host.panel.webview.html);
+      await applySerialIndex(host, view, { type: 'setSerialIndex', enabled: true });
+      const restored = createWebviewDom(host.panel.webview.html);
+      try { assert.ok(restored.cell(0, -1)); } finally { restored.close(); }
+      const html = host.panel.webview.html;
+      await applySerialIndex(host, view, { type: 'setSerialIndex', enabled: true });
+      assert.strictEqual(host.panel.webview.html, html);
+      assert.strictEqual(host.document.getText(), '');
+      assert.strictEqual(host.document.version, 1);
+    } finally { view.close(); }
+  });
+
+  it('targets its owner URI and refreshes every view of that URI, even with another active file', async () => {
+    const host = await createEditorHarness({ rows });
+    const view = createWebviewDom(host.panel.webview.html);
+    const second = await createEditorHarness({ rows });
+    const secondView = createWebviewDom(second.panel.webview.html);
+    second.context.workspaceState = host.context.workspaceState;
+    const other = await createEditorHarness({ rows, separator: '\t' });
+    const otherHtml = other.panel.webview.html;
+    try {
+      await applySerialIndex(host, view, chooseHide(view, view.cell(1, -1)));
+      assert.ok(!host.panel.webview.html.includes('data-col="-1"'));
+      await finishRefresh(second, secondView);
+      assert.ok(!second.panel.webview.html.includes('data-col="-1"'));
+      assert.strictEqual(other.panel.webview.html, otherHtml);
+      assert.strictEqual(CsvEditorProvider.getSerialIndexForUri(other.context as any, other.document.uri as any), true);
+      assert.deepStrictEqual(host.rows(), rows);
+      assert.deepStrictEqual(second.rows(), rows);
+    } finally { view.close(); secondView.close(); }
+  });
+
+  it('rejects malformed preferences and ignores repeated requests without extra writes or reloads', async () => {
+    const host = await createEditorHarness({ rows });
+    const view = createWebviewDom(host.panel.webview.html);
+    const update = host.context.workspaceState.update.bind(host.context.workspaceState);
+    let serialWrites = 0;
+    host.context.workspaceState.update = async (key: string, value: unknown) => {
+      if (key === CsvEditorProvider.serialKey) { serialWrites++; }
+      await update(key, value);
+    };
+    try {
+      const original = host.panel.webview.html;
+      for (const enabled of [undefined, null, 'false', 0, 1, {}, []]) {
+        await applySerialIndex(host, view, { type: 'setSerialIndex', enabled });
+      }
+      assert.strictEqual(host.panel.webview.html, original);
+      assert.strictEqual(serialWrites, 0);
+      await applySerialIndex(host, view, chooseHide(view, view.cell(1, -1)));
+      const hidden = host.panel.webview.html;
+      await applySerialIndex(host, view, { type: 'setSerialIndex', enabled: false });
+      assert.strictEqual(host.panel.webview.html, hidden);
+      assert.strictEqual(serialWrites, 1);
+      assert.strictEqual(host.document.version, 1);
+    } finally { view.close(); }
+  });
+
+  for (const corner of [false, true]) {
+    it(`preserves scroll and a surviving data anchor with hidden metadata (corner ${corner})`, async () => {
+      const host = await createEditorHarness({ rows: [['metadata', ''], ...rows], header: true });
+      await CsvEditorProvider.setHiddenRowsForUri(host.context as any, host.document.uri as any, 1);
+      CsvEditorProvider.getActiveProvider()!.refresh();
+      await settle();
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const container = view.window.document.querySelector('.table-container');
+        container.scrollLeft = 40;
+        container.scrollTop = 120;
+        const target = corner ? view.window.document.querySelector('[data-serial-index]') : view.cell(2, -1);
+        const message = chooseHide(view, target);
+        view.window.dispatchEvent(new view.window.Event('blur'));
+        view.window.dispatchEvent(new view.window.Event('focus'));
+        await settle();
+        view.window.dispatchEvent(new view.window.Event('blur'));
+        await applySerialIndex(host, view, message);
+        const state = view.window.acquireVsCodeApi().getState();
+        assert.strictEqual(state.anchorRow, corner ? 1 : 2);
+        assert.strictEqual(state.anchorCol, 0);
+        assert.strictEqual(state.scrollX, 40);
+        assert.strictEqual(state.scrollY, 120);
+        const next = createWebviewDom(host.panel.webview.html);
+        try {
+          next.window.acquireVsCodeApi().setState(state);
+          next.window.dispatchEvent(new next.window.Event('focus'));
+          await settle();
+          assert.ok(next.cell(state.anchorRow, 0).classList.contains('selected'));
+          assert.strictEqual(next.window.document.querySelector('.table-container').scrollLeft, 40);
+          assert.strictEqual(next.window.document.querySelector('.table-container').scrollTop, 120);
+        } finally { next.close(); }
+      } finally { view.close(); }
+    });
+  }
+
+  it('retains an existing data anchor when the selected serial cell opens the menu', async () => {
+    const host = await createEditorHarness({ rows });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.window.editingTestApi.setSingleSelection(view.cell(1, 1));
+      view.key('a', { ctrlKey: true });
+      assert.ok(view.cell(1, -1).classList.contains('selected'));
+      const message = chooseHide(view, view.cell(1, -1));
+      view.window.dispatchEvent(new view.window.Event('blur'));
+      const state = view.window.acquireVsCodeApi().getState();
+      assert.strictEqual(state.anchorRow, 1);
+      assert.strictEqual(state.anchorCol, 1);
+      await applySerialIndex(host, view, message);
+      assert.deepStrictEqual(host.rows(), rows);
+    } finally { view.close(); }
+  });
+
+  it('keeps remote later-chunk index cells actionable and preserves the source', async () => {
+    const data = [['Name', 'Value'], ...Array.from({ length: 1100 }, (_, row) => [`row-${row}`, 'value'])];
+    const host = await createEditorHarness({ rows: data, remote: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      await mountThrough(view, host, 1050);
+      await applySerialIndex(host, view, chooseHide(view, view.cell(1050, -1)));
+      assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorRow, 1050);
+      assert.strictEqual(view.window.acquireVsCodeApi().getState().anchorCol, 0);
+      const metadataMatch = /<script id="__csvFilters"[^>]*>([\s\S]*?)<\/script>/.exec(host.panel.webview.html);
+      assert.ok(metadataMatch);
+      const metadata = JSON.parse(metadataMatch[1]);
+      await host.receive({ type: 'requestChunk', start: 1001, requestId: 99, session: metadata.session, filterEpoch: metadata.revision });
+      const response = host.messages.slice().reverse().find((message: any) => message.type === 'chunkData' && message.requestId === 99);
+      assert.ok(response);
+      assert.ok(!response.html.includes('data-col="-1"'));
+      assert.deepStrictEqual(host.rows(), data);
+      assert.strictEqual(host.document.version, 1);
+    } finally { view.close(); }
+  });
+
+  it('retains native context menus while editing and drains queued multiline edits before refresh', async () => {
+    const host = await createEditorHarness({ rows });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell(1, 0));
+      view.type('draft\nline');
+      const menu = openMenu(view, view.cell(1, -1));
+      assert.strictEqual(menu.event.defaultPrevented, false);
+      assert.ok(!menu.items.some(item => item.textContent === 'Hide serial index column'));
+      view.cell(1, 0).blur();
+      const editMessage = view.messages.find(message => message.type === 'editCell');
+      assert.ok(editMessage);
+      host.deferEdits();
+      const edit = host.receive(editMessage);
+      await new Promise(resolve => setImmediate(resolve));
+      assert.strictEqual(host.pendingEdits, 1);
+      const hide = host.receive({ type: 'setSerialIndex', enabled: false });
+      assert.ok(host.panel.webview.html.includes('data-col="-1"'));
+      host.releaseEdit();
+      await edit;
+      await hide;
+      await finishRefresh(host, view);
+      assert.strictEqual(host.rows()[1][0], editMessage.value);
+      assert.ok(!host.panel.webview.html.includes('data-col="-1"'));
+      assert.ok(!host.diskText.includes('draft'));
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/serial-index-refresh.test.ts b/src/test/serial-index-refresh.test.ts
new file mode 100644
index 0000000..d372697
--- /dev/null
+++ b/src/test/serial-index-refresh.test.ts
@@ -0,0 +1,220 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+type View = ReturnType<typeof createWebviewDom>;
+const settle = () => new Promise<void>(resolve => setImmediate(resolve));
+
+function dispatchHostMessage(view: View, message: unknown) {
+  const cursor = view.messages.length;
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: message }));
+  return view.messages.slice(cursor);
+}
+
+async function startDraft(host: Host, view: View, value: string) {
+  const cursor = view.messages.length;
+  view.start(view.cell());
+  view.cell().textContent = value;
+  await Promise.all(view.messages.slice(cursor).map(message => host.receive(message)));
+}
+
+async function requestHide(host: Host) {
+  const html = host.panel.webview.html;
+  await host.receive({ type: 'setSerialIndex', enabled: false });
+  assert.strictEqual(host.panel.webview.html, html, 'hide must wait for the live view acknowledgment');
+  assert.ok(Number.isInteger(host.pendingDraftRequestId), 'serial changes must request the existing draft handshake');
+  const request = host.messages.find(message => message.type === 'prepareViewRefresh' && message.requestId === host.pendingDraftRequestId);
+  assert.ok(request);
+  return { html, request };
+}
+
+function assertHidden(host: Host) {
+  assert.strictEqual(CsvEditorProvider.getSerialIndexForUri(host.context as any, host.document.uri as any), false);
+  const next = createWebviewDom(host.panel.webview.html);
+  try {
+    assert.strictEqual(next.window.document.querySelector('[data-col="-1"]'), null);
+    assert.ok(next.cell(1, 0), 'data cells remain available after hiding the presentation index');
+  } finally { next.close(); }
+}
+
+describe('Serial index refresh preserves integrated document ownership', () => {
+  for (const separator of [',', '\t']) {
+    it(`commits an unposted multiline draft before hiding the index (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      const disk = host.diskText;
+      const draft = 'unsaved first\nsecond line';
+      try {
+        await startDraft(host, view, draft);
+        const { html } = await requestHide(host);
+        assert.strictEqual(view.cell().getAttribute('contenteditable'), 'true');
+        assert.strictEqual(host.rows()[1][0], 'one', 'the active draft has not reached its document yet');
+        assert.ok(view.cell(1, -1));
+        assert.strictEqual(host.panel.webview.html, html);
+        await flushViewCommits(host, view);
+        assert.deepStrictEqual(host.rows(), [['name', 'value'], [draft, 'two']]);
+        assert.strictEqual(host.diskText, disk, 'changing presentation must not save');
+        assert.strictEqual(host.isOpen, true);
+        assertHidden(host);
+        const next = createWebviewDom(host.panel.webview.html);
+        try { assert.strictEqual(next.cell().textContent, draft); } finally { next.close(); }
+      } finally { view.close(); host.dispose(); }
+    });
+  }
+
+  it('retains the old DOM and index until a delayed edit and its acknowledgment complete', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    const disk = host.diskText;
+    try {
+      await startDraft(host, view, 'delayed\nserial draft');
+      host.deferEdits();
+      const { html, request } = await requestHide(host);
+      const messages = dispatchHostMessage(view, request);
+      assert.deepStrictEqual(messages.map(message => message.type), ['editCell', 'viewRefreshReady']);
+      const pending = messages.map(message => host.receive(message));
+      await settle();
+      assert.strictEqual(host.pendingEdits, 1);
+      assert.strictEqual(host.panel.webview.html, html);
+      assert.strictEqual(view.cell().textContent, 'delayed\nserial draft');
+      assert.ok(view.cell(1, -1));
+      assert.strictEqual(host.rows()[1][0], 'one');
+      host.resumeEdits(); host.releaseEdit();
+      await Promise.all(pending);
+      await flushViewCommits(host, view);
+      assert.strictEqual(host.rows()[1][0], 'delayed\nserial draft');
+      assert.strictEqual(host.diskText, disk);
+      assertHidden(host);
+    } finally { view.close(); host.dispose(); }
+  });
+
+  for (const failure of ['false', 'throw'] as const) {
+    for (const recovery of ['retry', 'discard'] as const) {
+      it(`retains a failed ${failure} draft until ${recovery} before applying the hidden index`, async () => {
+        const host = await createEditorHarness();
+        const view = createWebviewDom(host.panel.webview.html);
+        const disk = host.diskText;
+        const draft = 'failed first\nsecond line';
+        try {
+          await startDraft(host, view, draft);
+          const { html, request } = await requestHide(host);
+          host.failEdits(failure);
+          await Promise.all(dispatchHostMessage(view, request).map(message => host.receive(message)));
+          assert.strictEqual(host.panel.webview.html, html, 'an unapplied draft must retain its DOM');
+          assert.strictEqual(view.cell().textContent, draft);
+          assert.ok(view.cell(1, -1));
+          assert.strictEqual(host.rows()[1][0], 'one');
+          assert.strictEqual(host.diskText, disk);
+          assert.strictEqual(host.isOpen, true);
+          const failed = host.messages.find(message => message.type === 'editCellFailed');
+          assert.ok(failed);
+          await Promise.all(dispatchHostMessage(view, failed).map(message => host.receive(message)));
+          assert.strictEqual(view.cell().getAttribute('contenteditable'), 'true');
+          host.failEdits(undefined);
+          const cursor = view.messages.length;
+          if (recovery === 'discard') { view.key('Escape'); }
+          else { view.cell().blur(); }
+          const recovered = view.messages.slice(cursor);
+          assert.deepStrictEqual(recovered.map(message => message.type), [recovery === 'discard' ? 'discardCellDraft' : 'editCell']);
+          await Promise.all(recovered.map(message => host.receive(message)));
+          await flushViewCommits(host, view);
+          assert.strictEqual(host.rows()[1][0], recovery === 'retry' ? draft : 'one');
+          assert.strictEqual(host.diskText, disk, 'neither retry nor discard may force a save');
+          assertHidden(host);
+        } finally { view.close(); host.dispose(); }
+      });
+    }
+  }
+
+  for (const separator of [',', '\t']) {
+    for (const targetKind of ['body index', 'corner'] as const) {
+      it(`keeps the Hide-click data anchor through the safe-refresh acknowledgment (${targetKind}, ${JSON.stringify(separator)})`, async () => {
+        const rows = [['metadata', 'private'], ['Name', 'State'], ['one', 'keep'], ['hidden', 'drop'], ['three', 'KEEP']];
+        const host = await createEditorHarness({ rows, separator, hiddenRows: 1,
+          filters: [{ column: 1, operator: 'equals', value: 'keep' }] });
+        const view = createWebviewDom(host.panel.webview.html);
+        try {
+          const container = view.window.document.querySelector('.table-container');
+          container.scrollLeft = 37;
+          const target = targetKind === 'corner'
+            ? view.window.document.querySelector('thead [data-serial-index]') : view.cell(4, -1);
+          assert.ok(target);
+          const expectedRow = targetKind === 'corner' ? 1 : 4;
+          target.dispatchEvent(new view.window.MouseEvent('mousedown', { button: 2, bubbles: true, cancelable: true, clientX: 120, clientY: 60 }));
+          target.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 120, clientY: 60 }));
+          const hide = Array.from(view.window.document.querySelectorAll('#contextMenu div')).find((item: any) => /^hide serial index column$/i.test(item.textContent)) as any;
+          assert.ok(hide);
+          hide.click();
+          const message = view.messages.slice().reverse().find(message => message.type === 'setSerialIndex');
+          assert.ok(message);
+          await host.receive(message);
+          await flushViewCommits(host, view);
+          const saved = view.window.acquireVsCodeApi().getState();
+          assert.strictEqual(saved.anchorCol, 0, 'the ACK must persist the remapped in-memory anchor, not the removed index');
+          assert.strictEqual(saved.anchorRow, expectedRow);
+          assert.strictEqual(saved.scrollX, 37);
+          const next = createWebviewDom(host.panel.webview.html);
+          try {
+            let attemptedChunks = 0;
+            const load = next.window.__csvLoadNextChunk;
+            next.window.__csvLoadNextChunk = (...args: unknown[]) => { attemptedChunks++; return load(...args); };
+            next.window.acquireVsCodeApi().setState(saved);
+            next.window.dispatchEvent(new next.window.Event('focus'));
+            await new Promise(resolve => setTimeout(resolve, 20));
+            assert.ok(next.cell(expectedRow, 0).classList.contains('selected'));
+            assert.strictEqual(next.window.document.activeElement, next.cell(expectedRow, 0));
+            assert.strictEqual(next.window.document.querySelector('[data-col="-1"]'), null);
+            assert.strictEqual(attemptedChunks, 0, 'restoring a valid data anchor must not search chunks for a removed index');
+            assert.ok(!next.messages.some(message => message.type === 'requestChunk'));
+          } finally { next.close(); }
+          assert.deepStrictEqual(host.rows(), rows);
+        } finally { view.close(); host.dispose(); }
+      });
+    }
+  }
+
+  for (const separator of [',', '\t']) {
+    it(`preserves metadata, filtered gaps and absolute source IDs across a serial refresh (${JSON.stringify(separator)})`, async () => {
+      const text = [
+        ['"metadata"', '"private"'].join(separator),
+        ['"Name"', '"State"'].join(separator),
+        ['"one"', '"keep"'].join(separator),
+        ['"hidden"', '"drop"'].join(separator),
+        ['"three"', '"KEEP"'].join(separator)
+      ].join('\r\n');
+      const host = await createEditorHarness({ text, separator, hiddenRows: 1,
+        filters: [{ column: 1, operator: 'equals', value: 'keep' }], frozenRows: 2, frozenColumns: 1 });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const version = host.document.version;
+        const order = view.window.document.getElementById('csv-root').dataset.roworder;
+        assert.strictEqual(view.cell(2, 0).textContent, 'one');
+        assert.strictEqual(view.cell(4, 0).textContent, 'three');
+        assert.strictEqual(view.cell(3, 0), null);
+        assert.strictEqual(view.cell(0, 0), null);
+        await requestHide(host);
+        await flushViewCommits(host, view);
+        const next = createWebviewDom(host.panel.webview.html);
+        try {
+          assert.strictEqual(next.window.document.querySelector('[data-col="-1"]'), null);
+          assert.strictEqual(next.window.document.getElementById('csv-root').dataset.roworder, order);
+          assert.strictEqual(next.cell(1, 0).tagName, 'TH');
+          assert.strictEqual(next.cell(2, 0).textContent, 'one');
+          assert.strictEqual(next.cell(4, 0).textContent, 'three');
+          assert.strictEqual(next.cell(3, 0), null);
+          assert.strictEqual(next.cell(0, 0), null);
+          assert.ok(next.window.document.getElementById('filterStatus'));
+        } finally { next.close(); }
+        assert.strictEqual(host.document.getText(), text, 'a view-only change must preserve exact quoting and CRLF bytes');
+        assert.strictEqual(host.document.version, version);
+        assert.strictEqual(host.diskText, text);
+        await host.receive({ type: 'findMatches', requestId: 70, query: 'three', options: {} });
+        const found = host.messages.slice().reverse().find(message => message.type === 'findMatchesResult' && message.requestId === 70);
+        assert.ok(found);
+        assert.deepStrictEqual(found.matches.map((match: any) => match.row), [4]);
+      } finally { view.close(); host.dispose(); }
+    });
+  }
+});
diff --git a/src/test/structural-formatting.test.ts b/src/test/structural-formatting.test.ts
new file mode 100644
index 0000000..0a41811
--- /dev/null
+++ b/src/test/structural-formatting.test.ts
@@ -0,0 +1,72 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import Papa from 'papaparse';
+import { createEditorHarness } from './edit-integrity-harness';
+
+describe('Structural edits preserve CSV source conventions', () => {
+  it('appends a pasted row using the body column quote convention without rewriting prior rows', async () => {
+    const text = 'id,label,note\r\n1,"alpha",""\r\n2,"beta",""\r\n';
+    const host = await createEditorHarness({ text });
+    await host.receive({ type: 'pasteCells', text: '3,gamma,plain', anchorRow: 3, anchorCol: 0 });
+    assert.strictEqual(host.document.getText(), `${text}3,"gamma","plain"\r\n`);
+  });
+
+  it('extends a row with pasted columns while keeping untouched tokens and CRLF records', async () => {
+    const text = 'a,"b"\r\n"left","right"\r\nend,last';
+    const host = await createEditorHarness({ text });
+    await host.receive({ type: 'pasteCells', text: 'extra', anchorRow: 1, anchorCol: 2 });
+    assert.strictEqual(host.document.getText(), 'a,"b"\r\n"left","right",extra\r\nend,last');
+  });
+
+  it('moves raw column fields including explicitly quoted and unquoted empty fields', async () => {
+    const host = await createEditorHarness({ text: '"id",name,"tail"\r\n"1","alpha",""\r\n"2",beta,\r\n' });
+    await host.receive({ type: 'reorderColumns', indices: [1], beforeIndex: 0 });
+    assert.strictEqual(host.document.getText(), 'name,"id","tail"\r\n"alpha","1",""\r\nbeta,"2",\r\n');
+  });
+
+  it('moves rows without normalizing their raw quoting', async () => {
+    const host = await createEditorHarness({ text: 'h,v\n"1",a\n2,"b"\n' });
+    await host.receive({ type: 'reorderRows', indices: [2], beforeIndex: 1 });
+    assert.strictEqual(host.document.getText(), 'h,v\n2,"b"\n"1",a\n');
+  });
+
+  it('preserves a UTF-8 BOM when editing a quoted first field or appending data', async () => {
+    const host = await createEditorHarness({ text: '\uFEFF"a",b\n"one",two\n' });
+    await host.receive({ type: 'editCell', row: 0, col: 0, value: 'header' });
+    assert.strictEqual(host.document.getText(), '\uFEFF"header",b\n"one",two\n');
+    await host.receive({ type: 'pasteCells', text: 'next,last', anchorRow: 2, anchorCol: 0 });
+    assert.strictEqual(host.document.getText(), '\uFEFF"header",b\n"one",two\n"next",last\n');
+  });
+
+  it('keeps trailing empty source records and escaped multiline values', async () => {
+    const text = 'id,"text"\n1,"line 1\nline ""2"""\n\n';
+    const host = await createEditorHarness({ text });
+    await host.receive({ type: 'pasteCells', text: '2,"another\nline"', anchorRow: 2, anchorCol: 0 });
+    assert.strictEqual(host.document.getText(), 'id,"text"\n1,"line 1\nline ""2"""\n2,"another\nline"\n');
+  });
+
+  it('appends a typed value in the virtual row without normalizing prior fields', async () => {
+    const text = 'id,"text"\n1,"alpha"\n';
+    const host = await createEditorHarness({ text });
+    await host.receive({ type: 'editCell', row: 2, col: 0, value: '2' });
+    assert.strictEqual(host.document.getText(), `${text}2`);
+  });
+
+  it('fills an existing empty record once instead of duplicating it after the paste', async () => {
+    const host = await createEditorHarness({ text: 'id,"text"\n1,"alpha"\n,' });
+    await host.receive({ type: 'pasteCells', text: '2,beta', anchorRow: 2, anchorCol: 0 });
+    assert.deepStrictEqual(host.rows(), [['id', 'text'], ['1', 'alpha'], ['2', 'beta']]);
+    assert.ok(host.document.getText().startsWith('id,"text"\n1,"alpha"\n'));
+  });
+
+  for (const separator of [',', '\t']) {
+    it(`round-trips ragged rows with delimiters, quotes and newlines after reordering (${JSON.stringify(separator)})`, async () => {
+      const data = [['id', 'text', 'last'], ['1', `inside${separator}value`, ''], ['2', 'two\nlines', 'tail'], ['3', '"quoted"']];
+      const text = Papa.unparse(data, { delimiter: separator, quotes: true, newline: '\n' });
+      const host = await createEditorHarness({ text, separator });
+      await host.receive({ type: 'reorderColumns', indices: [2], beforeIndex: 0 });
+      assert.deepStrictEqual(host.rows(), [['last', 'id', 'text'], ['', '1', `inside${separator}value`], ['tail', '2', 'two\nlines'], ['', '3', '"quoted"']]);
+      assert.ok(host.document.getText().includes(`"tail"${separator}"2"${separator}"two\nlines"`));
+    });
+  }
+});
diff --git a/src/test/table-comparison.test.ts b/src/test/table-comparison.test.ts
new file mode 100644
index 0000000..28c4255
--- /dev/null
+++ b/src/test/table-comparison.test.ts
@@ -0,0 +1,285 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness } from './edit-integrity-harness';
+import { compareFilesAsTable, TableComparison } from '../table-comparison';
+import { comparisonLimits } from '../csv-table-diff';
+const { JSDOM } = require('jsdom');
+
+async function comparisonFixture(before = 'id,value\n1,old\n2,same', after = 'id,value\n1,new\n2,same') {
+  const host = await createEditorHarness();
+  const Uri = host.document.uri.constructor as any;
+  const original = { uri: new Uri('/test/original <img>.csv'), isClosed: false, getText: () => before };
+  const modified = { uri: new Uri('/test/modified &.csv', 'vscode-remote'), isClosed: false, getText: () => after };
+  const messages: any[] = [];
+  let receive!: (message: unknown) => void;
+  let dispose!: () => void;
+  const panel = {
+    webview: {
+      html: '', options: {}, asWebviewUri: (uri: unknown) => String(uri),
+      postMessage: (message: unknown) => { messages.push(message); return Promise.resolve(true); },
+      onDidReceiveMessage: (listener: typeof receive) => { receive = listener; }
+    },
+    onDidDispose: (listener: () => void) => { dispose = listener; }
+  };
+  const context = { extensionPath: process.cwd(), workspaceState: { get: (_key: string, fallback: unknown) => fallback } };
+  const comparison = new TableComparison(context as any, original as any, modified as any, panel as any);
+  host.sourceDocuments.set(original.uri.toString(), original);
+  host.sourceDocuments.set(modified.uri.toString(), modified);
+  return { host, original, modified, messages, panel, context, comparison, receive: (message: unknown) => receive(message), dispose: () => dispose() };
+}
+
+describe('Readonly table comparison provider and command', () => {
+  it('renders actual cell changes, escapes names/values and never exposes editable controls', async () => {
+    const value = '<img src="https://example.test/secret" onerror="bad()"> & text';
+    const fixture = await comparisonFixture('id,value\n1,old', `id,value\n1,${value}`);
+    try {
+      const dom = new JSDOM(fixture.panel.webview.html);
+      const payload = fixture.messages.at(-1);
+      dom.window.document.getElementById('original').innerHTML = payload.originalHtml;
+      dom.window.document.getElementById('modified').innerHTML = payload.modifiedHtml;
+      assert.strictEqual(dom.window.document.querySelectorAll('img, [contenteditable], input, textarea').length, 0);
+      assert.ok(dom.window.document.querySelector('#modified td.added').textContent.includes(value));
+      assert.strictEqual(dom.window.document.querySelectorAll('#original td.removed').length, 1);
+      assert.ok(dom.window.document.querySelector('h2').textContent.includes('original <img>.csv'));
+      assert.strictEqual(dom.window.document.querySelector('h2').title, 'original <img>.csv');
+      for (const heading of dom.window.document.querySelectorAll('h2')) {
+        const style = dom.window.getComputedStyle(heading);
+        assert.strictEqual(style.whiteSpace, 'nowrap');
+        assert.strictEqual(style.overflow, 'hidden');
+        assert.strictEqual(style.textOverflow, 'ellipsis');
+      }
+      assert.ok(!fixture.panel.webview.html.includes('https://example.test/secret'));
+      assert.deepStrictEqual(Object.keys(fixture.context.workspaceState), ['get']);
+      assert.strictEqual(fixture.host.openedDocuments.length, 0);
+      dom.window.close();
+    } finally { fixture.dispose(); }
+  });
+
+  it('refreshes unsaved source documents including a reopened document object, and clears errors', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      const reopened = { ...fixture.modified, getText: () => 'id,value\n1,old\n2,same' };
+      fixture.host.changeListeners.forEach(listener => listener({ document: reopened }));
+      await new Promise(resolve => setTimeout(resolve, 190));
+      assert.match(fixture.messages.at(-1).status, /Changed 0/);
+      reopened.getText = () => '"unfinished';
+      fixture.comparison.refresh();
+      assert.match(fixture.messages.at(-1).error, /malformed/);
+      assert.strictEqual(fixture.messages.at(-1).originalHtml, '');
+      fixture.receive({ type: 'change', direction: 1 });
+      assert.match(fixture.messages.at(-1).error, /malformed/);
+      reopened.getText = () => 'id,value\n1,recovered';
+      fixture.comparison.refresh();
+      assert.strictEqual(fixture.messages.at(-1).error, '');
+      assert.ok(fixture.messages.at(-1).modifiedHtml.includes('recovered'));
+      assert.strictEqual(fixture.host.executedCommands.length, 0);
+    } finally { fixture.dispose(); }
+  });
+
+  it('navigates pages and differences, and responds when a queued change disappears', async () => {
+    const original = Array.from({ length: 450 }, (_, index) => `${index},same`).join('\n');
+    const modified = original.replace('410,same', '410,changed');
+    const fixture = await comparisonFixture(original, modified);
+    try {
+      fixture.receive({ type: 'change', direction: 1 });
+      assert.strictEqual(fixture.messages.at(-1).page, 2);
+      assert.strictEqual(fixture.messages.at(-1).focusRecord, 410);
+      const count = fixture.messages.length;
+      fixture.receive({ type: 'change', direction: 1 });
+      assert.strictEqual(fixture.messages.length, count + 1);
+      assert.strictEqual(fixture.messages.at(-1).canNextChange, false);
+      fixture.modified.getText = () => original;
+      fixture.comparison.refresh();
+      const refreshed = fixture.messages.length;
+      fixture.receive({ type: 'change', direction: 1 });
+      assert.strictEqual(fixture.messages.length, refreshed + 1);
+      assert.strictEqual(fixture.messages.at(-1).canPreviousChange, false);
+      fixture.receive({ type: 'page', index: -100 });
+      assert.strictEqual(fixture.messages.at(-1).page, 0);
+      fixture.receive({ type: 'page', index: 100 });
+      assert.strictEqual(fixture.messages.at(-1).page, 2);
+    } finally { fixture.dispose(); }
+  });
+
+  it('stops delayed refreshes and messages after disposal', async () => {
+    const fixture = await comparisonFixture();
+    fixture.host.changeListeners.forEach(listener => listener({ document: fixture.modified }));
+    const count = fixture.messages.length;
+    fixture.dispose();
+    fixture.receive({ type: 'ready' });
+    await new Promise(resolve => setTimeout(resolve, 190));
+    assert.strictEqual(fixture.messages.length, count);
+  });
+
+  it('uses TSV separators and reports disabled or decoded-size-limited documents', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      const Uri = fixture.original.uri.constructor as any;
+      fixture.original.uri = new Uri('/test/original.tsv');
+      fixture.modified.uri = new Uri('/test/modified.tsv');
+      fixture.original.getText = () => 'id\tvalue\n1\told';
+      fixture.modified.getText = () => 'id\tvalue\n1\tnew';
+      fixture.comparison.refresh();
+      assert.ok(fixture.messages.at(-1).modifiedHtml.includes('data-columns="2"'));
+      fixture.host.configuration.enabled = false;
+      fixture.comparison.refresh();
+      assert.match(fixture.messages.at(-1).error, /disabled/);
+      fixture.host.configuration.enabled = true;
+      fixture.modified.getText = () => 'é'.repeat(comparisonLimits.textBytes / 2 + 1);
+      fixture.comparison.refresh();
+      assert.match(fixture.messages.at(-1).error, /5 MiB/);
+      assert.strictEqual(fixture.messages.at(-1).modifiedHtml, '');
+    } finally { fixture.dispose(); }
+  });
+
+  it('opens a known Explorer pair, respecting dirty already-open text without mutation', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      let panels = 0;
+      fixture.host.existingDocuments = [fixture.original, fixture.modified];
+      fixture.host.createPanel = () => { panels++; return fixture.panel; };
+      await compareFilesAsTable(fixture.context as any, fixture.modified.uri as any, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.strictEqual(panels, 1);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+      assert.deepStrictEqual(fixture.host.executedCommands, []);
+      assert.deepStrictEqual(fixture.host.errors, []);
+    } finally { fixture.dispose(); }
+  });
+
+  it('rejects huge saved sources before openTextDocument even with maxFileSizeMB=0', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      fixture.host.configuration.maxFileSizeMB = 0;
+      fixture.host.statSize = comparisonLimits.sourceBytes + 1;
+      await compareFilesAsTable(fixture.context as any, undefined, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.match(fixture.host.errors.at(-1)!, /10 MiB of saved bytes/);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+    } finally { fixture.dispose(); }
+  });
+
+  it('refuses stat-less unopened sources, but permits bounded already-open remote documents', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      fixture.host.statError = new Error('No stat provider');
+      await compareFilesAsTable(fixture.context as any, undefined, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.match(fixture.host.errors.at(-1)!, /Open it in a normal editor first/);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+      fixture.host.existingDocuments = [fixture.original, fixture.modified];
+      let panels = 0;
+      fixture.host.createPanel = () => { panels++; return fixture.panel; };
+      await compareFilesAsTable(fixture.context as any, undefined, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.strictEqual(panels, 1);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+      fixture.modified.getText = () => 'é'.repeat(comparisonLimits.textBytes / 2 + 1);
+      await compareFilesAsTable(fixture.context as any, undefined, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.match(fixture.host.errors.at(-1)!, /5 MiB/);
+      assert.strictEqual(panels, 1);
+    } finally { fixture.dispose(); }
+  });
+
+  it('opens bounded file documents through VS Code, honors soft limit and supports picker cancellation', async () => {
+    const fixture = await comparisonFixture();
+    try {
+      fixture.host.activeTextDocument = fixture.original;
+      fixture.host.dialogResults.push([fixture.modified.uri]);
+      fixture.host.createPanel = () => fixture.panel;
+      await compareFilesAsTable(fixture.context as any);
+      assert.deepStrictEqual(fixture.host.openedDocuments, [fixture.original.uri.toString(), fixture.modified.uri.toString()]);
+      fixture.host.openedDocuments.length = 0;
+      fixture.host.configuration.maxFileSizeMB = 1;
+      fixture.host.statSize = 2 * 1024 * 1024;
+      await compareFilesAsTable(fixture.context as any, undefined, [fixture.original.uri, fixture.modified.uri] as any);
+      assert.match(fixture.host.errors.at(-1)!, /maxFileSizeMB/);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+      fixture.host.dialogResults.push(undefined);
+      await compareFilesAsTable(fixture.context as any);
+      assert.deepStrictEqual(fixture.host.openedDocuments, []);
+    } finally { fixture.dispose(); }
+  });
+});
+
+describe('Table comparison frontend', () => {
+  it('positions a focused change below the sticky header using actual pane geometry', async () => {
+    const fixture = await comparisonFixture();
+    const dom = new JSDOM(fixture.panel.webview.html, { runScripts: 'outside-only', pretendToBeVisual: true });
+    const { window } = dom;
+    let align!: () => void;
+    window.requestAnimationFrame = (callback: () => void) => { align = callback; return 1; };
+    window.cancelAnimationFrame = () => {};
+    window.acquireVsCodeApi = () => ({ postMessage() {} });
+    try {
+      window.eval(fs.readFileSync(path.join(process.cwd(), 'media', 'table-comparison.js'), 'utf8'));
+      window.dispatchEvent(new window.MessageEvent('message', { data: { ...fixture.messages.at(-1), focusRecord: 1 } }));
+      const panes = ['original', 'modified'].map(id => window.document.getElementById(id));
+      for (const pane of panes) {
+        pane.scrollTop = 140;
+        pane.getBoundingClientRect = () => ({ top: 115.5, height: 600 });
+        Object.defineProperty(pane, 'clientTop', { value: 1 });
+        pane.querySelector('thead').getBoundingClientRect = () => ({ height: 47 });
+        const row = pane.querySelector('[data-align="1"]');
+        Object.defineProperty(row, 'offsetTop', { value: 179 });
+        row.getBoundingClientRect = () => ({ top: 350.5 - pane.scrollTop, height: 50 });
+      }
+      align();
+      for (const pane of panes) {
+        assert.strictEqual(pane.scrollTop, 187);
+        assert.strictEqual(pane.querySelector('[data-align="1"]').getBoundingClientRect().top, 163.5);
+        assert.ok(pane.querySelector('[data-align="1"]').classList.contains('focused'));
+      }
+    } finally { dom.window.close(); fixture.dispose(); }
+  });
+
+  it('synchronizes both scroll axes, aligns multiline row heights, replaces pages and recovers controls', async () => {
+    const fixture = await comparisonFixture('id,value\n1,"one\ntwo"\n2,old', 'id,value\n1,short\n2,new');
+    const dom = new JSDOM(fixture.panel.webview.html, { runScripts: 'outside-only', pretendToBeVisual: true });
+    const { window } = dom;
+    const requests: any[] = [];
+    let writes = 0;
+    const frames = new Map<number, () => void>();
+    let frame = 0;
+    window.requestAnimationFrame = (callback: () => void) => { frames.set(++frame, callback); return frame; };
+    window.cancelAnimationFrame = (id: number) => frames.delete(id);
+    window.acquireVsCodeApi = () => ({ postMessage: (message: unknown) => requests.push(message) });
+    window.HTMLElement.prototype.getBoundingClientRect = function () {
+      return { height: this.closest('#original') ? 50 : 25 };
+    };
+    const left = window.document.getElementById('original');
+    const right = window.document.getElementById('modified');
+    for (const pane of [left, right]) {
+      let top = 0, horizontal = 0;
+      Object.defineProperty(pane, 'scrollTop', { get: () => top, set: (value: number) => { top = value; writes++; pane.dispatchEvent(new window.Event('scroll')); } });
+      Object.defineProperty(pane, 'scrollLeft', { get: () => horizontal, set: (value: number) => { horizontal = value; writes++; pane.dispatchEvent(new window.Event('scroll')); } });
+    }
+    try {
+      window.eval(fs.readFileSync(path.join(process.cwd(), 'media', 'table-comparison.js'), 'utf8'));
+      assert.strictEqual(requests[0].type, 'ready');
+      const send = () => window.dispatchEvent(new window.MessageEvent('message', { data: fixture.messages.at(-1) }));
+      for (let page = 0; page < 30; page++) { send(); }
+      for (const callback of frames.values()) { callback(); }
+      assert.strictEqual(left.querySelectorAll('tbody tr').length, 3);
+      assert.strictEqual(left.querySelector('tbody tr').style.height, '50px');
+      assert.strictEqual(right.querySelector('tbody tr').style.height, '50px');
+      const before = writes;
+      left.scrollTop = 140;
+      left.scrollLeft = 180;
+      assert.strictEqual(right.scrollTop, 140);
+      assert.strictEqual(right.scrollLeft, 180);
+      right.scrollTop = 20;
+      right.scrollLeft = 30;
+      assert.strictEqual(left.scrollTop, 20);
+      assert.strictEqual(left.scrollLeft, 30);
+      assert.ok(writes - before < 30, 'scrolling must not recursively bounce between panes');
+      window.document.getElementById('nextChange').click();
+      assert.strictEqual(requests.at(-1).type, 'change');
+      assert.ok(Array.from(window.document.querySelectorAll('button')).every((button: any) => button.disabled));
+      fixture.receive(requests.at(-1)); send();
+      fixture.receive({ type: 'change', direction: 1 }); send();
+      assert.ok(!window.document.getElementById('previousChange').disabled);
+      assert.ok(window.document.getElementById('nextChange').disabled);
+      assert.strictEqual(window.document.querySelectorAll('[contenteditable]').length, 0);
+      assert.strictEqual(window.document.querySelectorAll('tbody tr').length, 6);
+    } finally { dom.window.close(); fixture.dispose(); }
+  });
+});
diff --git a/src/test/test-extension-uri.ts b/src/test/test-extension-uri.ts
new file mode 100644
index 0000000..6a52efe
--- /dev/null
+++ b/src/test/test-extension-uri.ts
@@ -0,0 +1,6 @@
+export class TestExtensionUri {
+  constructor(public readonly path = process.cwd(), public readonly scheme = 'file', public readonly authority = '') {}
+  get fsPath() { return this.path; }
+  with(changes: { path: string }) { return new TestExtensionUri(changes.path, this.scheme, this.authority); }
+  toString() { return `${this.scheme}://${this.authority}${this.path}`; }
+}
diff --git a/src/test/test-memento.ts b/src/test/test-memento.ts
new file mode 100644
index 0000000..530c271
--- /dev/null
+++ b/src/test/test-memento.ts
@@ -0,0 +1,15 @@
+// VS Code Mementos serialize writes and return the supplied default for absent keys.
+export function createTestMemento() {
+  const values = new Map<string, unknown>();
+  const clone = <T>(value: T): T => value === undefined ? value : JSON.parse(JSON.stringify(value));
+  return {
+    keys: () => [...values.keys()],
+    get<T>(key: string, fallback?: T): T | undefined {
+      return values.has(key) ? clone(values.get(key) as T) : fallback;
+    },
+    async update(key: string, value: unknown): Promise<void> {
+      if (value === undefined) { values.delete(key); }
+      else { values.set(key, clone(value)); }
+    }
+  };
+}
diff --git a/src/test/theme-transition.test.ts b/src/test/theme-transition.test.ts
new file mode 100644
index 0000000..d1bdf1f
--- /dev/null
+++ b/src/test/theme-transition.test.ts
@@ -0,0 +1,125 @@
+import { TestExtensionUri } from './test-extension-uri';
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import Module from 'module';
+import { it } from 'node:test';
+const { JSDOM } = require('jsdom');
+
+const kinds = { Light: 1, Dark: 2, HighContrast: 3, HighContrastLight: 4 };
+const theme = { kind: kinds.HighContrast };
+const settings: Record<string, unknown> = {};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') {
+    return {
+      ColorThemeKind: kinds, window: { activeColorTheme: theme },
+      Uri: { file: (filePath: string) => ({ fsPath: filePath, toString: () => `test:${filePath}` }) },
+      workspace: {
+        getConfiguration: () => ({ get: (key: string, fallback: unknown) => key === 'maxFileSizeMB' ? 0 : (settings[key] ?? fallback) }),
+        onDidChangeTextDocument: () => ({ dispose() {} }), onWillSaveTextDocument: () => ({ dispose() {} })
+      }
+    };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+import { CsvEditorProvider } from '../CsvEditorProvider';
+Module.prototype.require = originalRequire;
+
+async function createLiveView(mode: string, palette: string) {
+  settings.columnColorMode = mode;
+  settings.columnColorPalette = palette;
+  const uri = { fsPath: '/draft.csv', toString: () => 'file:///draft.csv' };
+  const values: Record<string, unknown> = {};
+  const context = {
+    extensionPath: process.cwd(), extensionUri: new TestExtensionUri(), workspaceState: {
+      get: (key: string, fallback: unknown) => values[key] ?? fallback,
+      update: async (key: string, value: unknown) => { values[key] = value; }
+    }
+  };
+  await CsvEditorProvider.setHeaderForUri(context as any, uri as any, true);
+  const webview = { html: '', options: {}, cspSource: 'test:', asWebviewUri: (resource: any) => resource.toString(), postMessage() {}, onDidReceiveMessage() {} };
+  const panel = { title: 'draft.csv', active: true, webview, onDidChangeViewState() {}, onDidDispose() {} };
+  const text = 'Name,Count\nalpha,12\nbeta,24';
+  const document = { uri, version: 1, getText: () => text };
+  await new CsvEditorProvider(context as any).resolveCustomTextEditor(document as any, panel as any, {} as any);
+  const dom = new JSDOM(webview.html, { runScripts: 'outside-only', pretendToBeVisual: true });
+  const style = dom.window.document.createElement('style');
+  style.textContent = fs.readFileSync(path.join(process.cwd(), 'media', 'high-contrast.css'), 'utf8');
+  dom.window.document.head.append(style);
+  const messages: any[] = [];
+  let state = {};
+  dom.window.acquireVsCodeApi = () => ({ postMessage: (message: unknown) => messages.push(message), getState: () => state, setState: (value: object) => { state = value; } });
+  dom.window.HTMLElement.prototype.scrollIntoView = () => {};
+  dom.window.IntersectionObserver = class { observe() {} disconnect() {} };
+  dom.window.eval(`${fs.readFileSync(path.join(process.cwd(), 'media', 'main.js'), 'utf8')}\nwindow.themeTestApi = { editCell, setSingleSelection };`);
+  return { dom, messages, document };
+}
+
+// Resolve only inherited custom-property values: jsdom leaves CSS var() colors
+// unevaluated, while the declarations and real browser DOM remain executable.
+function cellColor(cell: any): string {
+  const document = cell.ownerDocument;
+  const variables = new Map<string, string>([['--vscode-editor-foreground', '#13579b']]);
+  for (const sheet of Array.from(document.styleSheets) as any[]) {
+    for (const rule of Array.from(sheet.cssRules) as any[]) {
+      if (rule.selectorText && document.body.matches(rule.selectorText)) {
+        for (let index = 0; index < rule.style.length; index++) {
+          const property = rule.style[index];
+          if (property.startsWith('--')) { variables.set(property, rule.style.getPropertyValue(property)); }
+        }
+      }
+    }
+  }
+  return cell.style.color.replace(/var\((--[\w-]+)(?:,\s*([^()]*))?\)/g, (_: string, name: string, fallback = '') => variables.get(name) ?? fallback).trim().toLowerCase();
+}
+
+it('changes all four theme classes without replacing, committing or recoloring an active multiline draft outside the chosen mode', async () => {
+  for (const palette of ['default', 'cool', 'warm']) {
+    for (const mode of ['type', 'theme']) {
+      const { dom, messages, document: owner } = await createLiveView(mode, palette);
+      const { document } = dom.window;
+      const cell = document.querySelector('[data-row="1"][data-col="0"]');
+      const header = document.querySelector('th[data-col="0"]');
+      const append = document.querySelector('[data-row="3"][data-col="0"]');
+      dom.window.themeTestApi.setSingleSelection(cell);
+      dom.window.themeTestApi.editCell(cell);
+      cell.textContent = 'unsaved first line\nsecond line';
+      const selection = dom.window.getSelection();
+      const range = document.createRange();
+      range.setStart(cell.firstChild, 8);
+      range.collapse(true);
+      selection.removeAllRanges();
+      selection.addRange(range);
+      assert.strictEqual(document.activeElement, cell);
+      const colors = new Map<string, string>();
+      messages.length = 0;
+      for (const themeClass of ['vscode-high-contrast', 'vscode-light', 'vscode-high-contrast-light', 'vscode-dark', 'vscode-light']) {
+        document.body.className = themeClass;
+        const visibleColor = cellColor(cell);
+        colors.set(themeClass, visibleColor);
+        assert.strictEqual(cellColor(header), visibleColor);
+        assert.strictEqual(cellColor(append), visibleColor);
+        assert.strictEqual(document.querySelector('[data-row="1"][data-col="0"]'), cell);
+        assert.strictEqual(cell.textContent, 'unsaved first line\nsecond line');
+        assert.strictEqual(cell.getAttribute('contenteditable'), 'true');
+        assert.strictEqual(document.activeElement, cell);
+        assert.strictEqual(selection.anchorNode, cell.firstChild);
+        assert.strictEqual(selection.anchorOffset, 8);
+        assert.ok(cell.classList.contains('editing'));
+        assert.ok(!messages.some(message => ['editCell', 'save', 'saveAs'].includes(message.type)), 'class changes do not commit or save a draft');
+        assert.strictEqual(owner.getText(), 'Name,Count\nalpha,12\nbeta,24');
+        assert.strictEqual(owner.version, 1);
+      }
+      assert.strictEqual(colors.get('vscode-high-contrast'), colors.get('vscode-dark'));
+      assert.strictEqual(colors.get('vscode-high-contrast-light'), colors.get('vscode-light'));
+      if (mode === 'type') {
+        assert.notStrictEqual(colors.get('vscode-light'), colors.get('vscode-dark'));
+        assert.ok(Array.from(colors.values()).every(value => /^#[0-9a-f]{6}$/.test(value)));
+      } else {
+        assert.ok(Array.from(colors.values()).every(value => value === '#13579b'));
+      }
+      dom.window.close();
+    }
+  }
+});
diff --git a/src/test/typed-filter-provider.test.ts b/src/test/typed-filter-provider.test.ts
new file mode 100644
index 0000000..f5b9cb0
--- /dev/null
+++ b/src/test/typed-filter-provider.test.ts
@@ -0,0 +1,486 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+const { CsvEditorProvider } = require('../CsvEditorProvider') as typeof import('../CsvEditorProvider');
+const { JSDOM } = require('jsdom');
+
+type Host = Awaited<ReturnType<typeof createEditorHarness>>;
+const sharedOperators = ['contains', 'notContains', 'regex', 'equals', 'notEquals', 'empty', 'notEmpty'];
+const orderedOperators = ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual'];
+const saved = (host: Host) => CsvEditorProvider.getColumnFiltersForUri(host.context as any, host.document.uri as any);
+function metadata(host: Host): any {
+  const dom = new JSDOM(host.panel.webview.html);
+  try { return JSON.parse(dom.window.document.getElementById('__csvFilters').textContent); }
+  finally { dom.window.close(); }
+}
+function rowIds(html: string): number[] {
+  const dom = new JSDOM(html);
+  try { return Array.from(dom.window.document.querySelectorAll('tbody tr')).map((row: any) => Number(row.querySelector('[data-row]').dataset.row)); }
+  finally { dom.window.close(); }
+}
+async function update(host: Host, revision: number, filters: unknown, session = metadata(host).session) {
+  const start = host.messages.length;
+  await host.receive({ type: 'updateColumnFilters', revision, filters, session });
+  return host.messages.slice(start).find(message => message.type === 'columnFiltersResult');
+}
+
+describe('Inline typed filter provider', () => {
+  for (const separator of [',', '\t']) {
+    it(`provides full-source inferred columns and operators without native popups (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ rows: [['Text', 'Amount', 'When', 'Enabled'], ['hello', '2', '2026-01-01', 'yes'], ['world', '10.5', '2026-02-01', 'OFF']], separator });
+      const initial = metadata(host);
+      assert.strictEqual(initial.revision, 0);
+      assert.ok(typeof initial.session === 'string' && initial.session.length > 0);
+      assert.ok(initial.maxFilters > 0);
+      for (const [column, type] of ['string', 'number', 'date', 'boolean'].entries()) {
+        const info = initial.columns[column];
+        assert.strictEqual(info.column, column);
+        assert.strictEqual(info.dataType, type);
+        assert.ok(info.label);
+        for (const operator of sharedOperators) { assert.ok(info.operators.some((item: any) => item.operator === operator)); }
+        for (const operator of orderedOperators) {
+          assert.strictEqual(info.operators.some((item: any) => item.operator === operator), type === 'number' || type === 'date');
+        }
+      }
+      const dom = new JSDOM(host.panel.webview.html);
+      try {
+        const region = dom.window.document.getElementById('filterStatus');
+        assert.strictEqual(region.getAttribute('aria-label'), 'Column filters');
+        assert.strictEqual(region.getAttribute('role'), null, 'interactive filter region is not a live status container');
+        assert.strictEqual(region.childElementCount, 0, 'the UI module owns input DOM');
+        assert.strictEqual(region.hidden, true);
+        const scripts = Array.from(dom.window.document.querySelectorAll('script[src]')).map((script: any) => script.src);
+        assert.ok(scripts.findIndex((src: any) => src.endsWith('/column-filters.js')) < scripts.findIndex((src: any) => src.endsWith('/main.js')));
+      } finally { dom.window.close(); }
+      assert.deepStrictEqual(saved(host), []);
+      assert.strictEqual(host.quickPickCalls.length, 0);
+      assert.strictEqual(host.inputBoxCalls.length, 0);
+      assert.strictEqual(host.document.version, 1);
+    });
+  }
+
+  it('infers from original body rows excluding metadata/header, regardless of other filters', async () => {
+    const rows = [['metadata', 'ignored'], ['Amount', 'Group'], ['2', 'show'], ['not numeric', 'hide']];
+    const host = await createEditorHarness({ rows, header: true, hiddenRows: 1, filters: [{ column: 1, operator: 'equals', value: 'show' }] });
+    const initial = metadata(host);
+    assert.strictEqual(initial.columns[0].dataType, 'string');
+    assert.ok(!initial.columns[0].operators.some((item: any) => item.operator === 'greaterThan'));
+    const result = await update(host, 1, []);
+    assert.deepStrictEqual(result.columns, initial.columns);
+    assert.strictEqual(result.firstVisibleRow, 1);
+    assert.strictEqual(result.totalRows, 2);
+    const numeric = await createEditorHarness({ rows: [['not numeric metadata'], ['Amount'], ['2'], ['10.5']], hiddenRows: 1 });
+    assert.strictEqual(metadata(numeric).columns[0].dataType, 'number');
+  });
+
+  it('promotes complete mixed-format date cells only for filters and respects header-off/automatic header semantics', async () => {
+    const values = ['2026-01-01', 'February 1, 2026 12:00 UTC', '03/01/2026'];
+    const host = await createEditorHarness({ rows: [['When'], ...values.map(value => [value]), ['']] });
+    assert.strictEqual(metadata(host).columns[0].dataType, 'date');
+    assert.strictEqual(CsvEditorProvider.__test.isDate('1/2/2024'), false);
+    assert.strictEqual(CsvEditorProvider.__test.estimateColumnDataType(values), 'string');
+    const noHeader = await createEditorHarness({ rows: [['Amount'], ['2'], ['10']], header: false });
+    assert.strictEqual(metadata(noHeader).columns[0].dataType, 'string');
+    await noHeader.context.workspaceState.update(CsvEditorProvider.headerKey, {});
+    assert.strictEqual((await update(noHeader, 1, [])).columns[0].dataType, 'number');
+    for (const value of ['2026', '12345678', 'not a date']) {
+      const plain = await createEditorHarness({ rows: [['Value'], [value]] });
+      assert.notStrictEqual(metadata(plain).columns[0].dataType, 'date');
+    }
+  });
+
+  for (const separator of [',', '\t']) {
+    it(`persists independent same-column AND predicates and returns source IDs without replacing HTML (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ rows: [['Amount', 'Name'], ['2', 'low'], ['10', 'equal'], ['15', 'high'], ['25', 'over']], separator });
+      const source = host.document.getText(), disk = host.diskText, html = host.panel.webview.html;
+      const predicates = [{ column: 0, operator: 'greaterThanOrEqual', value: '1e1', dataType: 'string' }, { column: 0, operator: 'lessThan', value: '20', dataType: 'boolean' }];
+      const result = await update(host, 1, predicates);
+      assert.strictEqual(result.error, undefined);
+      assert.strictEqual(result.errors, undefined);
+      assert.strictEqual(result.filterEpoch, 1);
+      assert.strictEqual(result.session, metadata(host).session);
+      assert.deepStrictEqual(rowIds(result.tableHtml), [2, 3, 5]);
+      assert.deepStrictEqual(result.visibleRowIds, [0, 2, 3, 5]);
+      assert.strictEqual(result.matchedRows, 2);
+      assert.strictEqual(result.totalRows, 4);
+      assert.ok(typeof result.colorCss === 'string');
+      assert.deepStrictEqual(saved(host), predicates.map(filter => ({ ...filter, dataType: 'number' })), 'server inference overrides forged valid type hints');
+      const removed = await update(host, 2, [predicates[1]]);
+      assert.deepStrictEqual(rowIds(removed.tableHtml), [1, 2, 3, 5]);
+      assert.strictEqual(saved(host).length, 1, 'removing one condition retains the other same-column condition');
+      assert.strictEqual(host.panel.webview.html, html, 'live filtering never replaces the webview');
+      assert.strictEqual(host.document.getText(), source);
+      assert.strictEqual(host.diskText, disk);
+      assert.strictEqual(host.document.version, 1);
+      assert.strictEqual(host.quickPickCalls.length + host.inputBoxCalls.length, 0);
+    });
+  }
+
+  it('uses typed equality, inequality, boolean vocabulary and broad explicit dates', async () => {
+    const numeric = await createEditorHarness({ rows: [['Amount', 'Name'], ['10', 'one'], ['10.0', 'two'], ['', 'blank'], ['20', 'other']] });
+    const inequality = await update(numeric, 1, [{ column: 0, operator: 'notEquals', value: '10' }]);
+    assert.deepStrictEqual(rowIds(inequality.tableHtml), [4, 5]);
+    assert.strictEqual(saved(numeric)[0].dataType, 'number');
+    const host = await createEditorHarness({ rows: [['When', 'Enabled'], ['2026-02-01T12:00Z', 'yes'], ['2026-02-02T12:00Z', 'OFF'], ['2026-01-31T12:00Z', 'true']] });
+    const result = await update(host, 1, [{ column: 1, operator: 'equals', value: 'ON' }, { column: 0, operator: 'greaterThanOrEqual', value: 'February 1, 2026 12:00 UTC' }]);
+    assert.deepStrictEqual(rowIds(result.tableHtml), [1, 4]);
+    assert.deepStrictEqual(saved(host).map(filter => filter.dataType), ['boolean', 'date']);
+  });
+
+  it('keeps text operators untyped, retains literal spaces and omits only zero-length draft values', async () => {
+    const host = await createEditorHarness({ rows: [['Value', 'Name'], ['two words', 'a'], ['single', 'b']] });
+    const space = await update(host, 1, [{ column: 0, operator: 'contains', value: ' ', dataType: 'number' }]);
+    assert.deepStrictEqual(rowIds(space.tableHtml), [1, 3]);
+    assert.deepStrictEqual(saved(host), [{ column: 0, operator: 'contains', value: ' ' }]);
+    const blank = await update(host, 2, [{ column: 0, operator: 'equals', value: '' }]);
+    assert.deepStrictEqual(blank.filters, []);
+    assert.deepStrictEqual(saved(host), []);
+    const numeric = await createEditorHarness({ rows: [['Amount'], ['2'], ['10']] });
+    for (const [index, operator] of ['contains', 'notContains', 'regex', 'empty', 'notEmpty'].entries()) {
+      const result = await update(numeric, index + 1, [{ column: 0, operator, value: operator === 'empty' || operator === 'notEmpty' ? '' : '2', dataType: 'number' }]);
+      assert.ok(!result.errors);
+      assert.ok(!Object.prototype.hasOwnProperty.call(saved(numeric)[0], 'dataType'));
+    }
+    assert.ok((await update(numeric, 6, [{ column: 0, operator: 'greaterThan', value: ' ' }])).errors);
+  });
+
+  it('rejects the entire invalid snapshot and returns the current accepted epoch/render for stale-success recovery', async () => {
+    const host = await createEditorHarness({ rows: [['Amount'], ['2'], ['10']] });
+    const accepted = await update(host, 1, [{ column: 0, operator: 'greaterThan', value: '3' }]);
+    const previous = saved(host), source = host.document.getText(), html = host.panel.webview.html;
+    for (const [index, bad] of [
+      [{ column: 0, operator: 'greaterThan', value: '10junk' }],
+      [{ column: 0, operator: 'equals', value: 'Infinity' }],
+      [{ column: 0, operator: 'regex', value: '[' }],
+      [{ column: 0, operator: 'notEmpty', value: '' }, { column: 0, operator: 'regex', value: '[' }],
+      [{ column: 0, operator: 'regex', value: '(?=one)' }],
+      [{ column: 0, operator: 'regex', value: '/one/g' }],
+      [{ column: 0, operator: 'contains', value: 'x'.repeat(4097) }],
+      [{ column: '0', operator: 'contains', value: '2' }],
+      [{ column: 0, operator: 'unknown', value: '2' }],
+      [{ column: 0, operator: 'equals', value: '2', dataType: {} }],
+      [{ column: 0, operator: 'equals', value: '2', extra: true }],
+      [null], {}, Array.from({ length: metadata(host).maxFilters + 1 }, () => ({ column: 0, operator: 'notEmpty', value: '' }))
+    ].entries()) {
+      const result = await update(host, index + 2, bad);
+      assert.ok(result.error || result.errors?.length);
+      assert.strictEqual(result.filterEpoch, 1);
+      assert.strictEqual(result.tableHtml, accepted.tableHtml);
+      assert.deepStrictEqual(result.filters, previous);
+      assert.deepStrictEqual(saved(host), previous);
+      assert.strictEqual(host.panel.webview.html, html);
+      assert.strictEqual(host.document.getText(), source);
+      assert.strictEqual(host.document.version, 1);
+    }
+  });
+
+  it('escapes raw metadata strings and preserves invalid saved queries for inline correction', async () => {
+    const label = '</script><img src=x onerror=alert(1)> & "Name"';
+    const host = await createEditorHarness({ rows: [[label], ['one']], filters: [{ column: 0, operator: 'regex', value: '[' }] });
+    const initial = metadata(host);
+    assert.strictEqual(initial.columns[0].label, label);
+    assert.strictEqual(initial.filters[0].value, '[');
+    const dom = new JSDOM(host.panel.webview.html);
+    try {
+      assert.strictEqual(dom.window.document.querySelector('img'), null);
+      assert.strictEqual(dom.window.document.querySelectorAll('#__csvFilters').length, 1);
+      assert.deepStrictEqual(rowIds(host.panel.webview.html), [2]);
+    } finally { dom.window.close(); }
+  });
+
+  it('coalesces queued revisions after preceding document edits and keeps the newest source text unsaved', async () => {
+    const host = await createEditorHarness({ rows: [['Amount', 'Note'], ['2', 'one'], ['10', 'two']] });
+    host.deferEdits();
+    const pendingEdit = host.receive({ type: 'editCell', row: 1, col: 1, value: 'unposted\nmultiline' });
+    await new Promise(resolve => setImmediate(resolve));
+    const session = metadata(host).session;
+    const old = host.receive({ type: 'updateColumnFilters', revision: 1, session, filters: [{ column: 0, operator: 'greaterThan', value: '0' }] });
+    const newest = host.receive({ type: 'updateColumnFilters', revision: 2, session, filters: [{ column: 0, operator: 'greaterThan', value: '5' }] });
+    host.releaseEdit();
+    await Promise.all([pendingEdit, old, newest]);
+    const replies = host.messages.filter(message => message.type === 'columnFiltersResult');
+    assert.deepStrictEqual(replies.map(message => message.revision), [2]);
+    assert.deepStrictEqual(rowIds(replies[0].tableHtml), [2, 3]);
+    assert.strictEqual(host.rows()[1][1], 'unposted\nmultiline');
+    assert.ok(!host.diskText.includes('multiline'));
+  });
+
+  it('rolls back a superseded preference write before validating the newest snapshot', async () => {
+    const host = await createEditorHarness({ rows: [['Amount'], ['2'], ['10']] });
+    const state = host.context.workspaceState;
+    const originalUpdate = state.update.bind(state);
+    let release = () => {};
+    let held = false;
+    state.update = async (key, value) => {
+      if (key === CsvEditorProvider.columnFiltersKey && !held) {
+        held = true;
+        await new Promise<void>(resolve => { release = resolve; });
+      }
+      await originalUpdate(key, value);
+    };
+    const session = metadata(host).session;
+    const old = host.receive({ type: 'updateColumnFilters', revision: 1, session, filters: [{ column: 0, operator: 'greaterThan', value: '3' }] });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.ok(held);
+    const newest = host.receive({ type: 'updateColumnFilters', revision: 2, session, filters: [{ column: 0, operator: 'regex', value: '[' }] });
+    release();
+    await Promise.all([old, newest]);
+    assert.deepStrictEqual(saved(host), []);
+    const replies = host.messages.filter(message => message.type === 'columnFiltersResult');
+    assert.deepStrictEqual(replies.map(message => message.revision), [2]);
+    assert.ok(replies[0].errors);
+    assert.strictEqual(replies[0].filterEpoch, 0);
+    assert.deepStrictEqual(rowIds(replies[0].tableHtml), [1, 2, 3]);
+  });
+
+  it('does not relabel an old-session asynchronous storage error as a new-view response', async () => {
+    const host = await createEditorHarness({ rows: [['Amount'], ['2'], ['10']] });
+    const state = host.context.workspaceState;
+    const originalUpdate = state.update.bind(state);
+    let reject = () => {};
+    state.update = async () => new Promise<void>((_resolve, fail) => { reject = () => fail(new Error('test storage rejection')); });
+    const oldSession = metadata(host).session;
+    const pending = host.receive({ type: 'updateColumnFilters', revision: 1, session: oldSession, filters: [{ column: 0, operator: 'greaterThan', value: '3' }] });
+    await new Promise(resolve => setImmediate(resolve));
+    CsvEditorProvider.getActiveProvider()!.refresh();
+    await new Promise(resolve => setTimeout(resolve, 20));
+    const fresh = metadata(host);
+    assert.notStrictEqual(fresh.session, oldSession);
+    reject();
+    await pending;
+    assert.ok(!host.messages.some(message => message.type === 'columnFiltersResult'));
+    state.update = originalUpdate;
+    const accepted = await update(host, 1, [], fresh.session);
+    assert.strictEqual(accepted.session, fresh.session);
+    assert.strictEqual(accepted.filterEpoch, 1);
+  });
+
+  it('rejects redraw after false or thrown WorkspaceEdit and accepts a successful retry of that cell', async () => {
+    for (const failure of ['false', 'throw']) {
+      const host = await createEditorHarness({ rows: [['Amount', 'Note'], ['2', 'one'], ['10', 'two']] });
+      const apply = host.applyEdit;
+      host.applyEdit = async () => { if (failure === 'throw') { throw new Error('test edit rejection'); } return false; };
+      await host.receive({ type: 'editCell', row: 1, col: 1, value: 'unapplied draft' });
+      const blocked = await update(host, 1, [{ column: 0, operator: 'greaterThan', value: '0' }]);
+      assert.ok(blocked.error.includes('failed cell edit'));
+      assert.strictEqual(blocked.filterEpoch, 0);
+      assert.deepStrictEqual(saved(host), []);
+      host.applyEdit = apply;
+      await host.receive({ type: 'editCell', row: 1, col: 1, value: 'retry draft' });
+      const view = createWebviewDom(host.panel.webview.html);
+      try { await flushViewCommits(host, view); }
+      finally { view.close(); }
+      const result = await update(host, 2, [{ column: 0, operator: 'greaterThan', value: '0' }]);
+      assert.strictEqual(result.error, undefined);
+      assert.strictEqual(result.filterEpoch, 2);
+      assert.strictEqual(host.rows()[1][1], 'retry draft');
+    }
+  });
+
+  it('scopes chunks and revisions to the accepted epoch and current webview session', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ...Array.from({ length: 1001 }, (_, index) => [`row${index}`])], remote: true });
+    const initial = metadata(host), html = host.panel.webview.html;
+    const accepted = await update(host, 1, [{ column: 0, operator: 'notEmpty', value: '' }]);
+    const cursor = host.messages.length;
+    for (const request of [{ filterEpoch: 0, session: initial.session }, { filterEpoch: 1, session: 'old-view' }, { session: initial.session }]) {
+      await host.receive({ type: 'requestChunk', start: 1000, requestId: 'old', ...request });
+    }
+    assert.strictEqual(host.messages.length, cursor, 'stale/malformed chunk requests cannot append an obsolete result');
+    await host.receive({ type: 'requestChunk', start: 1000, requestId: 'current', filterEpoch: 1, session: initial.session });
+    const chunk = host.messages.at(-1)!;
+    assert.strictEqual(chunk.filterEpoch, accepted.filterEpoch);
+    assert.strictEqual(chunk.session, initial.session);
+    assert.ok(chunk.html.includes('data-row="1001"'));
+    await host.view(false, false); await host.view(true, true);
+    const next = metadata(host);
+    assert.notStrictEqual(next.session, initial.session);
+    assert.strictEqual(next.revision, 0);
+    const afterRefresh = host.messages.length;
+    await update(host, 100, [], initial.session);
+    assert.strictEqual(host.messages.length, afterRefresh);
+    const reset = await update(host, 1, [], next.session);
+    assert.strictEqual(reset.filterEpoch, 1);
+    assert.strictEqual(reset.session, next.session);
+    assert.notStrictEqual(host.panel.webview.html, html, 'only the unrelated full refresh replaces HTML');
+  });
+});
+
+
+describe('Volatile inline filter draft handoff', () => {
+  function draftFor(host: Host, rows = [{ column: 0, operator: 'contains', value: 'volatile draft' }]): any {
+    const initial = metadata(host);
+    return {
+      session: initial.session,
+      filterColumnsRevision: initial.filterColumnsRevision,
+      columns: initial.columns.map((column: any) => ({ column: column.column, label: column.label })),
+      rows
+    };
+  }
+  async function acknowledge(host: Host, filterDraft: unknown, session = metadata(host).session) {
+    await host.receive({ type: 'viewRefreshReady', session, filterDraft });
+    return metadata(host);
+  }
+
+  for (const separator of [',', '\t']) {
+    it(`carries blank/invalid rows and caret once without storing drafts or changing source (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ rows: [['Name'], ['one'], ['two']], separator, filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+      const previous = JSON.stringify(host.context.workspaceState.values);
+      const source = host.document.getText();
+      const draft = draftFor(host, [{ column: 0, operator: 'regex', value: 'volatile-[' }, { column: 0, operator: 'contains', value: '' }]);
+      draft.focus = { row: 0, field: 'value', selectionStart: 1, selectionEnd: 4, selectionDirection: 'backward' };
+      const next = await acknowledge(host, draft);
+      assert.deepStrictEqual(next.filterDraft, draft);
+      assert.notStrictEqual(next.session, draft.session);
+      assert.strictEqual(next.filterColumnsRevision, draft.filterColumnsRevision);
+      assert.strictEqual(JSON.stringify(host.context.workspaceState.values), previous);
+      assert.strictEqual(host.document.getText(), source);
+      assert.strictEqual(host.diskText, source);
+      assert.strictEqual(host.document.version, 1);
+      assert.strictEqual((await acknowledge(host, undefined)).filterDraft, undefined, 'a later refresh does not replay the consumed draft');
+    });
+  }
+
+  it('renews a queued ACK for current-session typing and ignores stale-session activity', async () => {
+    for (const stale of [false, true]) {
+      const host = await createEditorHarness({ rows: [['Name'], ['one']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+      const controller = CsvEditorProvider.getActiveProvider() as any;
+      let release = () => {};
+      const gate = new Promise<void>(resolve => { release = resolve; });
+      const blocked = controller.enqueueOperation(() => gate) as Promise<void>;
+      try {
+        await new Promise(resolve => setImmediate(resolve));
+        const original = host.panel.webview.html;
+        const draft = draftFor(host, [{ column: 0, operator: 'contains', value: 'one' }]);
+        controller.refreshViewSafely();
+        const request = host.messages.filter(message => message.type === 'prepareViewRefresh').at(-1)!;
+        const cursor = host.messages.length;
+        const acknowledging = host.receive({ type: 'viewRefreshReady', session: draft.session, requestId: request.requestId, filterDraft: draft });
+        await host.receive({ type: 'filterDraftChanged', session: stale ? 'previous-view' : draft.session });
+        assert.strictEqual(host.panel.webview.html, original);
+        release();
+        await Promise.all([blocked, acknowledging]);
+        const renewed = host.messages.slice(cursor).find(message => message.type === 'prepareViewRefresh');
+        if (stale) {
+          assert.strictEqual(renewed, undefined, 'old-view activity cannot renew a current ACK');
+          assert.strictEqual(metadata(host).filterDraft.rows[0].value, 'one');
+        } else {
+          assert.ok(renewed, 'typing received while an ACK waits must request a newer snapshot');
+          assert.strictEqual(host.panel.webview.html, original, 'the stale snapshot cannot replace the live view');
+          draft.rows[0].value = 'one m';
+          await host.receive({ type: 'viewRefreshReady', session: draft.session, requestId: renewed.requestId, filterDraft: draft });
+          assert.strictEqual(metadata(host).filterDraft.rows[0].value, 'one m');
+        }
+        assert.strictEqual(host.document.version, 1);
+        assert.strictEqual(host.document.getText(), host.diskText);
+      } finally { release(); }
+    }
+  });
+
+  it('roundtrips only validated true IME markers without saving unfinished text', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ['one']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+    const stored = JSON.stringify(host.context.workspaceState.values);
+    const draft = draftFor(host);
+    draft.rows = [{ column: 0, operator: 'contains', value: 'unfinished IME', composing: true }, { column: 0, operator: 'regex', value: '[', composing: false }];
+    const next = await acknowledge(host, draft);
+    assert.deepStrictEqual(next.filterDraft.rows, [{ column: 0, operator: 'contains', value: 'unfinished IME', composing: true }, { column: 0, operator: 'regex', value: '[' }]);
+    assert.strictEqual(JSON.stringify(host.context.workspaceState.values), stored);
+    assert.strictEqual(host.document.getText(), host.diskText);
+    for (const marker of ['true', 1, null, {}]) {
+      const invalid = draftFor(host);
+      invalid.rows[0].composing = marker;
+      assert.strictEqual((await acknowledge(host, invalid)).filterDraft, undefined);
+      assert.strictEqual(JSON.stringify(host.context.workspaceState.values), stored);
+    }
+  });
+
+  it('retains current intent after a newer valid filter was accepted in the same session', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ['one'], ['two']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+    const draft = draftFor(host, [{ column: 0, operator: 'contains', value: 'ch' }]);
+    draft.focus = { row: 0, field: 'value', selectionStart: 1, selectionEnd: 2, selectionDirection: 'none' };
+    const accepted = await update(host, 1, [{ column: 0, operator: 'contains', value: 'two' }]);
+    assert.strictEqual(accepted.filterEpoch, 1);
+    const refreshed = await acknowledge(host, draft);
+    assert.strictEqual(refreshed.filters[0].value, 'two', 'last accepted conditions remain persisted');
+    assert.strictEqual(refreshed.filterDraft.rows[0].value, 'ch', 'an undelivered response cannot replace the newer raw draft');
+    assert.deepStrictEqual(refreshed.filterDraft.focus, draft.focus);
+  });
+
+  it('carries a pending Clear all as an empty draft without prematurely changing preferences', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ['one']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+    const cleared = draftFor(host, []);
+    const next = await acknowledge(host, cleared);
+    assert.deepStrictEqual(next.filterDraft.rows, []);
+    assert.strictEqual(saved(host).length, 1);
+    await update(host, 1, [], next.session);
+    assert.deepStrictEqual(saved(host), []);
+    assert.strictEqual(host.document.getText(), host.diskText);
+  });
+
+  it('rejects malformed, oversized and stale draft state without persisting any draft data', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ['one']] });
+    const malformed: Array<(draft: any) => void> = [
+      draft => { draft.session = 'previous-view'; },
+      draft => { delete draft.filterColumnsRevision; },
+      draft => { draft.filterColumnsRevision += 1; },
+      draft => { draft.rows = {}; },
+      draft => { draft.rows = Array.from({ length: metadata(host).maxFilters + 1 }, () => ({ column: 0, operator: 'contains', value: '' })); },
+      draft => { draft.rows[0].column = 1; },
+      draft => { draft.rows[0].column = '0'; },
+      draft => { draft.rows[0].operator = 'unknown'; },
+      draft => { draft.rows[0].value = 'x'.repeat(4097); },
+      draft => { draft.columns[0].label = 'another column'; },
+      draft => { draft.columns = []; },
+      draft => { draft.focus = { row: 1, field: 'value' }; },
+      draft => { draft.focus = { row: 0, field: 'unknown' }; },
+      draft => { draft.focus = { row: 0, field: 'value', selectionStart: 0, selectionEnd: 100, selectionDirection: 'none' }; },
+      draft => { draft.focus = { row: 0, field: 'value', selectionStart: 2, selectionEnd: 1, selectionDirection: 'none' }; },
+      draft => { draft.focus = { row: 0, field: 'value', selectionStart: 0, selectionEnd: 1, selectionDirection: 'unknown' }; }
+    ];
+    const stored = JSON.stringify(host.context.workspaceState.values);
+    for (const mutate of malformed) {
+      const draft = draftFor(host);
+      mutate(draft);
+      assert.strictEqual((await acknowledge(host, draft)).filterDraft, undefined);
+      assert.strictEqual(JSON.stringify(host.context.workspaceState.values), stored);
+    }
+    const oldSession = metadata(host).session;
+    await acknowledge(host, undefined);
+    const html = host.panel.webview.html;
+    await acknowledge(host, draftFor(host), oldSession);
+    assert.strictEqual(host.panel.webview.html, html, 'an old ACK cannot refresh the new view');
+  });
+
+  it('invalidates duplicate-label column reordering while preserving no-op mapping revisions', async () => {
+    const host = await createEditorHarness({ rows: [['Same', 'Same'], ['left', 'right']] });
+    const initial = metadata(host), stale = draftFor(host);
+    assert.strictEqual(initial.filterColumnsRevision, 0);
+    await host.receive({ type: 'reorderColumns', indices: [0], beforeIndex: 1 });
+    assert.strictEqual(metadata(host).filterColumnsRevision, initial.filterColumnsRevision);
+    await host.receive({ type: 'reorderColumns', indices: [0], beforeIndex: 2 });
+    const reordered = metadata(host);
+    assert.deepStrictEqual(reordered.columns.map((column: any) => column.label), ['Same', 'Same']);
+    assert.strictEqual(reordered.filterColumnsRevision, initial.filterColumnsRevision + 1);
+    assert.deepStrictEqual(host.rows()[1], ['right', 'left']);
+    stale.session = reordered.session;
+    assert.strictEqual((await acknowledge(host, stale)).filterDraft, undefined, 'identical labels do not authorize a draft from the old column mapping');
+    await host.receive({ type: 'insertColumn', index: 1 });
+    const inserted = metadata(host);
+    assert.strictEqual(inserted.filterColumnsRevision, reordered.filterColumnsRevision + 1);
+    await host.receive({ type: 'deleteColumn', index: 1 });
+    assert.strictEqual(metadata(host).filterColumnsRevision, inserted.filterColumnsRevision + 1);
+  });
+
+  it('drops drafts when column labels change or the rendered owner URI has rebound', async () => {
+    const host = await createEditorHarness({ rows: [['Name'], ['one']] });
+    const renamedDraft = draftFor(host);
+    await host.receive({ type: 'editCell', row: 0, col: 0, value: 'Renamed' });
+    assert.strictEqual((await acknowledge(host, renamedDraft)).filterDraft, undefined, 'changed semantic labels invalidate the old draft');
+    const reboundDraft = draftFor(host);
+    const OldUri = host.document.uri.constructor as new (path: string) => typeof host.document.uri;
+    host.document.uri = new OldUri('/test/rebound.csv');
+    const rebound = await acknowledge(host, reboundDraft);
+    assert.strictEqual(rebound.filterDraft, undefined, 'a session belongs to its original URI even when the live owner changes before ACK');
+    assert.strictEqual(host.rows()[0][0], 'Renamed');
+    assert.ok(!host.diskText.includes('Renamed'));
+  });
+});
diff --git a/src/test/untitled-draft-close.test.ts b/src/test/untitled-draft-close.test.ts
new file mode 100644
index 0000000..76152d5
--- /dev/null
+++ b/src/test/untitled-draft-close.test.ts
@@ -0,0 +1,53 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+describe('untitled grid closes after its final active draft commits', () => {
+  for (const separator of [',', '\t']) {
+    it(`preserves the active multiline draft when disabled (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ separator, untitled: true });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell());
+        view.key('Enter', { shiftKey: true });
+        view.type('latest draft');
+        host.deferEdits();
+        host.revealSourceAfterCommit();
+        const request = host.messages.find(message => message.type === 'prepareViewRefresh');
+        assert.ok(request);
+        assert.strictEqual(host.panel.disposed, false);
+        view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+        const operations = view.messages.filter(message => message.type === 'editCell' || message.type === 'viewRefreshReady');
+        assert.deepStrictEqual(operations.map(message => message.type), ['editCell', 'viewRefreshReady']);
+        const pending = operations.map(message => host.receive(message));
+        await new Promise(resolve => setImmediate(resolve));
+        assert.strictEqual(host.pendingEdits, 1);
+        assert.strictEqual(host.panel.disposed, false);
+        assert.strictEqual(host.sourceReveals.length, 0);
+        host.releaseEdit();
+        await Promise.all(pending);
+        assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+        assert.strictEqual(host.sourceReveals[0], host.document.getText());
+        assert.strictEqual(host.panel.disposed, true);
+      } finally {
+        view.close();
+      }
+    });
+  }
+  it('closes an unsupported-language table after a fresh draft ACK while CSV remains enabled', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell());
+      view.cell().textContent = 'language change draft';
+      host.rebindDocument('plaintext');
+      host.activeController!.revealSourceAfterCommit('language');
+      await flushViewCommits(host, view);
+      assert.strictEqual(host.rows()[1][0], 'language change draft');
+      assert.strictEqual(host.panel.disposed, true);
+      assert.strictEqual(host.sourceReveals.at(-1), host.document.getText());
+      assert.strictEqual(host.diskText.includes('language change draft'), false);
+    } finally { view.close(); host.dispose(); }
+  });
+
+});
diff --git a/src/test/untitled-draft-lifecycle.test.ts b/src/test/untitled-draft-lifecycle.test.ts
new file mode 100644
index 0000000..5238ca9
--- /dev/null
+++ b/src/test/untitled-draft-lifecycle.test.ts
@@ -0,0 +1,196 @@
+import assert from 'assert';
+import Papa from 'papaparse';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+const nextTurn = () => new Promise(resolve => setImmediate(resolve));
+function currentFilterSession(host: Awaited<ReturnType<typeof createEditorHarness>>): string {
+  const metadata = /<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(host.panel.webview.html);
+  assert.ok(metadata);
+  return JSON.parse(metadata[1]).session;
+}
+
+function sendPrepare(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>) {
+  const request = host.messages.filter(message => message.type === 'prepareViewRefresh').at(-1);
+  assert.ok(request);
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+  return view.messages.filter(message => message.type === 'editCell' || message.type === 'viewRefreshReady')
+    .map(message => host.receive(message));
+}
+function startMultiline(view: ReturnType<typeof createWebviewDom>) {
+  view.start(view.cell());
+  view.key('Enter', { shiftKey: true });
+  view.type('latest draft');
+}
+
+describe('untitled controller and webview draft lifecycle', () => {
+  for (const separator of [',', '\t']) {
+    const nextLanguage = separator === ',' ? 'tsv' : 'csv';
+    const nextSeparator = separator === ',' ? '\t' : ',';
+    it(`commits a live multiline draft using the original grammar before ${nextLanguage} rebind`, async () => {
+      const host = await createEditorHarness({ separator, untitled: true });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        startMultiline(view);
+        const html = host.panel.webview.html;
+        host.deferEdits();
+        const replacement = host.rebindDocument(nextLanguage);
+        host.document.isClosed = true;
+        host.document.getText = () => { throw new Error('old TextDocument is closed'); };
+        assert.strictEqual(host.panel.webview.html, html, 'no reload may destroy the active DOM draft');
+        assert.strictEqual(host.getCurrentSeparator(), separator);
+        const operations = sendPrepare(host, view);
+        await nextTurn();
+        assert.strictEqual(host.pendingEdits, 1);
+        assert.strictEqual(host.panel.webview.html, html);
+        host.releaseEdit();
+        await Promise.all(operations);
+        assert.strictEqual(Papa.parse<string[]>(replacement.getText(), { delimiter: separator }).data[1][0], 'one\nlatest draft');
+        assert.strictEqual(host.getCurrentSeparator(), nextSeparator, 'language owns logical extension in both directions');
+        assert.strictEqual(host.panel.disposed, false);
+      } finally { view.close(); }
+    });
+
+    it(`keeps the grid after rapid disable/re-enable while ${nextLanguage} rebind is pending`, async () => {
+      const host = await createEditorHarness({ separator, untitled: true });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        startMultiline(view);
+        host.rebindDocument(nextLanguage);
+        host.revealSourceAfterCommit();
+        host.setEnabled(true);
+        await Promise.all(sendPrepare(host, view));
+        assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+        assert.strictEqual(host.getCurrentSeparator(), nextSeparator);
+        assert.strictEqual(host.panel.disposed, false);
+        assert.strictEqual(host.sourceReveals.length, 0);
+      } finally { view.close(); }
+    });
+
+    it(`keeps deliberate disable priority over a pending language rebind (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ separator, untitled: true });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        startMultiline(view);
+        host.revealSourceAfterCommit();
+        const replacement = host.rebindDocument(nextLanguage);
+        host.saveUntitledAfterCommit();
+        await Promise.all(sendPrepare(host, view));
+        assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+        assert.strictEqual(host.sourceReveals[0], replacement.getText());
+        assert.strictEqual(host.nativeSaveCommands.length, 0);
+        assert.strictEqual(host.panel.disposed, true);
+      } finally { view.close(); }
+    });
+  }
+
+  it('retains explicit separator overrides across associated-path language changes', async () => {
+    const host = await createEditorHarness({ separator: '\t', untitled: true, fileName: '/data.tsv', separatorOverride: '|' });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      host.rebindDocument('csv');
+      await Promise.all(sendPrepare(host, view));
+      assert.strictEqual(host.getCurrentSeparator(), '|');
+    } finally { view.close(); }
+  });
+
+  it('cancels stale disable teardown when re-enabled before acknowledgment', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      startMultiline(view);
+      host.revealSourceAfterCommit();
+      host.setEnabled(true);
+      await Promise.all(sendPrepare(host, view));
+      assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+      assert.strictEqual(host.panel.disposed, false);
+      assert.strictEqual(host.sourceReveals.length, 0);
+    } finally { view.close(); }
+  });
+
+  it('ignores stale acknowledgments and resends a pending commit when a webview finishes loading', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const original = host.panel.webview.html;
+    host.rebindDocument('tsv');
+    const request = host.messages.at(-1);
+    await host.receive({ type: 'webviewReady' });
+    assert.deepStrictEqual(host.messages.at(-1), request);
+    await host.receive({ type: 'viewRefreshReady', session: currentFilterSession(host), requestId: request.requestId - 1 });
+    assert.strictEqual(host.panel.webview.html, original);
+    assert.strictEqual(host.getCurrentSeparator(), ',');
+    await host.receive({ type: 'viewRefreshReady', session: currentFilterSession(host), requestId: request.requestId });
+    assert.strictEqual(host.getCurrentSeparator(), '\t');
+    const current = host.panel.webview.html;
+    await host.receive({ type: 'viewRefreshReady', session: currentFilterSession(host), requestId: request.requestId });
+    assert.strictEqual(host.panel.webview.html, current);
+  });
+
+  it('does not register a controller or touch the webview after immediate panel cancellation', async () => {
+    const host = await createEditorHarness({ untitled: true, cancelInitialization: true });
+    assert.strictEqual(host.panel.disposed, true);
+    assert.strictEqual(host.panel.webview.html, '');
+    assert.strictEqual(host.messages.length, 0);
+    assert.ok(!host.activeController || host.activeController.getDocumentUri() !== host.document.uri);
+  });
+
+  it('does not register a controller after the owner closes during initialization', async () => {
+    const host = await createEditorHarness({ untitled: true, closeDuringInitialization: true });
+    assert.strictEqual(host.panel.webview.html, '');
+    assert.strictEqual(host.messages.length, 0);
+    assert.ok(!host.activeController || host.activeController.getDocumentUri() !== host.document.uri);
+  });
+
+  it('waits for the active draft before revealing the native owner for Save As', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      startMultiline(view);
+      host.deferEdits();
+      host.saveUntitledAfterCommit();
+      const pending = sendPrepare(host, view);
+      await nextTurn();
+      assert.strictEqual(host.pendingEdits, 1);
+      assert.strictEqual(host.sourceReveals.length, 0);
+      assert.strictEqual(host.nativeSaveCommands.length, 0);
+      host.releaseEdit();
+      await Promise.all(pending);
+      assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+      assert.strictEqual(host.diskText, host.document.getText());
+      assert.deepStrictEqual(host.nativeSaveCommands, ['workbench.action.files.save']);
+    } finally { view.close(); }
+  });
+
+  it('preserves a saved-document save received while a view refresh is awaiting its draft', async () => {
+    const host = await createEditorHarness();
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      startMultiline(view);
+      // Exercise the shared handshake without importing the separate filter PR.
+      host.requestViewCommit();
+      await host.receive({ type: 'save' });
+      await Promise.all(sendPrepare(host, view));
+      assert.strictEqual(host.rows()[1][0], 'one\nlatest draft');
+      assert.strictEqual(host.diskText, host.document.getText());
+      assert.strictEqual(host.sourceReveals.length, 0);
+    } finally { view.close(); }
+  });
+
+  for (const modifier of ['ctrlKey', 'metaKey']) {
+    for (const editing of [false, true]) {
+      it(`routes ${modifier}+S from ${editing ? 'editing' : 'selection'} mode to the native owner`, async () => {
+        const host = await createEditorHarness({ untitled: true });
+        const view = createWebviewDom(host.panel.webview.html);
+        try {
+          if (editing) { startMultiline(view); }
+          view.key('s', { [modifier]: true });
+          const operations = view.messages.filter(message => message.type === 'editCell' || message.type === 'save');
+          assert.deepStrictEqual(operations.map(message => message.type), editing ? ['editCell', 'save'] : ['save']);
+          await Promise.all(operations.map(message => host.receive(message)));
+          assert.strictEqual(host.nativeSaveCommands.length, 1);
+          assert.strictEqual(host.diskText, host.document.getText());
+          if (editing) { assert.strictEqual(host.rows()[1][0], 'one\nlatest draft'); }
+        } finally { view.close(); }
+      });
+    }
+  }
+});
diff --git a/src/test/untitled-editors.test.ts b/src/test/untitled-editors.test.ts
new file mode 100644
index 0000000..194979c
--- /dev/null
+++ b/src/test/untitled-editors.test.ts
@@ -0,0 +1,420 @@
+import assert from 'assert';
+import Module from 'module';
+import { afterEach, beforeEach, describe, it } from 'node:test';
+
+function event<T>() {
+  const listeners = new Set<(value: T) => void>();
+  return {
+    listen: (callback: (value: T) => void) => {
+      listeners.add(callback);
+      return { dispose: () => listeners.delete(callback) };
+    },
+    fire: (value: T) => { listeners.forEach(callback => callback(value)); },
+    clear: () => listeners.clear(),
+    get size() { return listeners.size; }
+  };
+}
+const activeEvent = event<any>();
+const openEvent = event<any>();
+const closeEvent = event<any>();
+const configEvent = event<any>();
+const state = {
+  enabled: true,
+  activeTextEditor: undefined as any,
+  groupOverride: undefined as any,
+  visibleOverride: undefined as any[] | undefined,
+  documents: [] as any[],
+  panels: [] as any[],
+  resolutions: [] as any[],
+  subscriptions: [] as any[],
+  tokens: [] as any[],
+  failResolve: false,
+  resolveWait: undefined as Promise<void> | undefined,
+  nativeReveals: 0,
+  commitResult: true,
+  commitWait: undefined as Promise<boolean> | undefined,
+  commitRequests: 0,
+  saveRequests: 0,
+  commands: new Map<string, (...args: any[]) => any>(),
+  information: [] as string[]
+};
+class TabInputText { constructor(public uri: any) {} }
+class FakeProvider {
+  static viewType = 'csv.editor';
+  static editors: any[] = [];
+  static currentActive: any;
+  static getActiveProvider() { return FakeProvider.currentActive; }
+  async resolveCustomTextEditor(document: any, panel: any, token: any) {
+    state.resolutions.push({ document, panel, token });
+    if (state.resolveWait) { await state.resolveWait; }
+    if (token.isCancellationRequested) { return; }
+    if (state.failResolve) { throw new Error('resolve failed'); }
+    const controller = {
+      document,
+      getDocumentUri: () => controller.document.uri,
+      isActive: () => panel.active,
+      getViewColumn: () => panel.viewColumn,
+      commitPendingDraft: () => { state.commitRequests++; return state.commitWait ?? Promise.resolve(state.commitResult); },
+      saveUntitledAfterCommit: () => { state.saveRequests += 1; },
+      updateDocumentReference: (replacement: any) => { controller.document = replacement; },
+      revealSourceAfterCommit: async () => {
+        await vscode.window.showTextDocument(controller.document, { viewColumn: panel.viewColumn });
+        panel.dispose();
+      }
+    };
+    FakeProvider.editors.push(controller);
+    FakeProvider.currentActive = controller;
+    panel.onDidDispose(() => {
+      FakeProvider.editors = FakeProvider.editors.filter(candidate => candidate !== controller);
+      if (FakeProvider.currentActive === controller) { FakeProvider.currentActive = undefined; }
+    });
+  }
+}
+function createPanel(viewType: string, title: string, viewColumn: number) {
+  const disposeEvent = event<void>();
+  state.panels.forEach(panel => { panel.active = false; });
+  state.activeTextEditor = undefined;
+  const panel = {
+    viewType, title, viewColumn, active: true, disposed: false,
+    onDidDispose: disposeEvent.listen,
+    reveal: (column?: number) => {
+      state.panels.forEach(other => { other.active = false; });
+      panel.active = true;
+      panel.viewColumn = column ?? panel.viewColumn;
+      state.activeTextEditor = undefined;
+    },
+    dispose: () => {
+      if (!panel.disposed) {
+        panel.disposed = true;
+        panel.active = false;
+        disposeEvent.fire();
+      }
+    }
+  };
+  state.panels.push(panel);
+  return panel;
+}
+const vscode = {
+  Uri: class {},
+  TabInputText,
+  ViewColumn: { Active: -1 },
+  CancellationTokenSource: class {
+    token = { isCancellationRequested: false };
+    disposed = false;
+    constructor() { state.tokens.push(this); }
+    cancel() { this.token.isCancellationRequested = true; }
+    dispose() { this.disposed = true; }
+  },
+  window: {
+    tabGroups: { get activeTabGroup() { return state.groupOverride ?? { viewColumn: state.activeTextEditor?.viewColumn ?? 2,
+      activeTab: state.activeTextEditor ? { input: new TabInputText(state.activeTextEditor.document.uri) } : undefined }; } },
+    get activeTextEditor() { return state.activeTextEditor; },
+    get visibleTextEditors() { return state.visibleOverride ?? (state.activeTextEditor ? [state.activeTextEditor] : []); },
+    onDidChangeActiveTextEditor: activeEvent.listen,
+    createWebviewPanel: createPanel,
+    showTextDocument: async (document: any, options: any) => {
+      state.nativeReveals++;
+      state.panels.forEach(panel => { panel.active = false; });
+      state.activeTextEditor = { document, viewColumn: options.viewColumn };
+      activeEvent.fire(state.activeTextEditor);
+      return state.activeTextEditor;
+    },
+    showErrorMessage() {},
+    showInformationMessage(message: string) { state.information.push(message); }
+  },
+  commands: {
+    registerCommand: (name: string, callback: (...args: any[]) => any) => {
+      state.commands.set(name, callback);
+      return { dispose() {} };
+    }
+  },
+  workspace: {
+    get textDocuments() { return state.documents; },
+    getConfiguration: () => ({ get: () => state.enabled }),
+    onDidOpenTextDocument: openEvent.listen,
+    onDidCloseTextDocument: closeEvent.listen,
+    onDidChangeConfiguration: configEvent.listen
+  }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') { return vscode; }
+  if (id === 'font-list') { return { getFonts: async () => [] }; }
+  if (id === './CsvEditorProvider') { return { CsvEditorProvider: FakeProvider }; }
+  return originalRequire.apply(this, arguments as any);
+};
+import { getActiveUntitledCsvEditor, isUntitledCsv, openUntitledCsvEditor, registerUntitledCsvEditors } from '../untitled-editors';
+import { toggleCsvEditor } from '../editor-switch';
+import { registerCsvCommands } from '../commands';
+Module.prototype.require = originalRequire;
+
+function document(languageId = 'csv', scheme = 'untitled', name = 'Untitled-1'): any {
+  return {
+    uri: { scheme, path: name, toString: () => `${scheme}:${name}` },
+    languageId,
+    fileName: name,
+    isClosed: false,
+    isDirty: true,
+    getText: () => 'name,value\nalready typed,42'
+  };
+}
+function activate(document: any) {
+  state.documents = [document];
+  state.activeTextEditor = { document, viewColumn: 2 };
+  activeEvent.fire(state.activeTextEditor);
+}
+const settle = () => new Promise(resolve => setTimeout(resolve, 5));
+
+beforeEach(() => {
+  state.enabled = true;
+  state.activeTextEditor = undefined; state.groupOverride = undefined; state.visibleOverride = undefined;
+  state.documents = [];
+  state.panels = [];
+  state.resolutions = [];
+  state.subscriptions = [];
+  state.tokens = [];
+  state.failResolve = false;
+  state.resolveWait = undefined; state.nativeReveals = 0;
+  state.commitResult = true;
+  state.commitWait = undefined;
+  state.commitRequests = 0;
+  state.saveRequests = 0;
+  state.commands.clear();
+  state.information = [];
+  FakeProvider.editors = [];
+  FakeProvider.currentActive = undefined;
+  registerUntitledCsvEditors({ subscriptions: state.subscriptions } as any);
+});
+afterEach(() => { state.subscriptions.forEach(subscription => subscription.dispose()); });
+
+describe('untitled CSV document ownership and routing', () => {
+  for (const language of ['csv', 'tsv']) {
+    it(`opens a standalone ${language.toUpperCase()} table against the already typed original document`, async () => {
+      const original = document(language);
+      activate(original);
+      await settle();
+      assert.strictEqual(state.panels.length, 1);
+      assert.strictEqual(state.panels[0].viewType, 'csv.untitledEditor');
+      assert.strictEqual(state.panels[0].viewColumn, 2);
+      assert.strictEqual(state.resolutions[0].document, original);
+      assert.strictEqual(original.getText(), 'name,value\nalready typed,42');
+      assert.strictEqual(original.isDirty, true);
+      assert.strictEqual(getActiveUntitledCsvEditor()?.document, original);
+    });
+  }
+
+  it('does not open tables for unshown buffers, saved files, or unrelated languages', async () => {
+    openEvent.fire(document());
+    activate(document('plaintext'));
+    activate(document('csv', 'file'));
+    await settle();
+    assert.strictEqual(state.panels.length, 0);
+    assert.strictEqual(isUntitledCsv(document('json')), false);
+  });
+
+  it('recognizes changing language on an existing active untitled buffer', async () => {
+    const original = document('plaintext');
+    activate(original);
+    original.languageId = 'csv';
+    openEvent.fire(original);
+    await settle();
+    assert.strictEqual(state.resolutions[0].document, original);
+  });
+
+  it('commits before replacing the untitled table with its native owner and recreates on return', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    const panel = state.panels[0];
+    let finish!: (success: boolean) => void;
+    state.commitWait = new Promise(resolve => { finish = resolve; });
+    const switching = toggleCsvEditor();
+    await settle();
+    assert.strictEqual(panel.disposed, false);
+    assert.strictEqual(panel.active, true);
+    assert.strictEqual(state.activeTextEditor, undefined);
+    assert.strictEqual(state.commitRequests, 1);
+    finish(true);
+    await switching;
+    assert.strictEqual((state.activeTextEditor as any).document, original);
+    await settle();
+    assert.strictEqual(panel.disposed, true);
+    assert.strictEqual(original.isClosed, false);
+    assert.strictEqual(original.isDirty, true);
+    assert.strictEqual(state.saveRequests, 0);
+    await toggleCsvEditor();
+    assert.strictEqual(state.panels[1].active, true);
+    assert.strictEqual(state.panels.length, 2);
+    assert.strictEqual(state.resolutions.length, 2);
+    assert.strictEqual(state.resolutions[1].document, original);
+  });
+
+  it('keeps the standalone panel and native owner intact when the draft cannot commit', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    state.commitResult = false;
+    await toggleCsvEditor();
+    assert.strictEqual(state.panels[0].disposed, false);
+    assert.strictEqual(state.panels[0].active, true);
+    assert.strictEqual(state.activeTextEditor, undefined);
+    assert.strictEqual(original.isClosed, false);
+    assert.strictEqual(original.getText(), 'name,value\nalready typed,42');
+    assert.strictEqual(state.saveRequests, 0);
+  });
+
+  it('ignores a completed commit after its standalone panel is disposed', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    let finish!: (success: boolean) => void;
+    state.commitWait = new Promise(resolve => { finish = resolve; });
+    const switching = toggleCsvEditor();
+    state.panels[0].dispose();
+    finish(true);
+    await switching;
+    assert.strictEqual(state.activeTextEditor, undefined);
+    assert.strictEqual(original.isClosed, false);
+  });
+
+  it('respects disabled state and opens the current buffer when explicitly re-enabled', async () => {
+    state.enabled = false;
+    activate(document());
+    await settle();
+    assert.strictEqual(state.panels.length, 0);
+    state.enabled = true;
+    configEvent.fire({ affectsConfiguration: () => true });
+    await settle();
+    assert.strictEqual(state.panels.length, 1);
+  });
+
+  it('returns to the unchanged native source when disabled from settings', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    state.enabled = false;
+    configEvent.fire({ affectsConfiguration: () => true });
+    await settle();
+    assert.strictEqual(state.panels[0].disposed, true);
+    assert.strictEqual(state.activeTextEditor.document, original);
+    assert.strictEqual(original.getText(), 'name,value\nalready typed,42');
+    assert.strictEqual(FakeProvider.currentActive, undefined);
+  });
+
+  it('cancels an initializing grid without opening its retained native owner over a newer file', async () => {
+    let finish!: () => void;
+    state.resolveWait = new Promise<void>(resolve => { finish = resolve; });
+    const original = document('tsv');
+    activate(original);
+    await settle();
+    assert.strictEqual(FakeProvider.editors.length, 0);
+    const newer = document('plaintext', 'file', 'newer.txt');
+    state.activeTextEditor = { document: newer, viewColumn: 3 };
+    state.enabled = false;
+    configEvent.fire({ affectsConfiguration: () => true });
+    assert.strictEqual(state.panels[0].disposed, true);
+    assert.strictEqual(state.nativeReveals, 0);
+    assert.strictEqual(state.activeTextEditor.document, newer);
+    assert.strictEqual(original.isClosed, false);
+    assert.strictEqual(original.getText(), 'name,value\nalready typed,42');
+    finish();
+    await settle();
+    assert.strictEqual(FakeProvider.editors.length, 0);
+  });
+
+  it('keeps an intentionally closed table closed until explicitly requested', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    state.panels[0].dispose();
+    activate(original);
+    await settle();
+    assert.strictEqual(state.panels.length, 1);
+    await openUntitledCsvEditor(original, 2);
+    assert.strictEqual(state.panels.length, 2);
+    assert.strictEqual(state.tokens[0].token.isCancellationRequested, true);
+    assert.strictEqual(state.tokens[0].disposed, true);
+  });
+
+  it('rebinds a language-change replacement at the same URI without losing the table', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    const replacement = document('tsv');
+    original.isClosed = true;
+    state.documents = [replacement];
+    closeEvent.fire(original);
+    openEvent.fire(replacement);
+    await settle();
+    assert.strictEqual(state.panels[0].disposed, false);
+    assert.strictEqual(getActiveUntitledCsvEditor()?.document, replacement);
+    assert.strictEqual(FakeProvider.editors[0].document, replacement);
+  });
+
+  it('closes the temporary grid when Save As closes its original owner without guessing a saved URI', async () => {
+    const original = document();
+    activate(original);
+    await settle();
+    original.isClosed = true;
+    state.documents = [document('csv', 'file', '/saved.csv')];
+    closeEvent.fire(original);
+    await settle();
+    assert.strictEqual(state.panels[0].disposed, true);
+    assert.strictEqual(FakeProvider.currentActive, undefined);
+    assert.strictEqual(getActiveUntitledCsvEditor(), undefined);
+  });
+
+  it('routes the registered untitled Save As action to the active owner controller', async () => {
+    activate(document());
+    await settle();
+    registerCsvCommands({ subscriptions: [] } as any);
+    await state.commands.get('csv.saveUntitled')!();
+    assert.strictEqual(state.saveRequests, 1);
+    await toggleCsvEditor();
+    await state.commands.get('csv.saveUntitled')!();
+    assert.strictEqual(state.saveRequests, 1, 'source/native save owns text editor focus');
+  });
+
+  it('requires saving before encoding commands can close or reopen an untitled owner', async () => {
+    activate(document());
+    await settle();
+    registerCsvCommands({ subscriptions: [] } as any);
+    await state.commands.get('csv.changeEncoding')!();
+    assert.strictEqual(state.panels[0].disposed, false);
+    assert.strictEqual(state.information.length, 1);
+    assert.match(state.information[0], /Save this document/);
+  });
+
+  it('cleans up a rejected initialization and allows a subsequent explicit retry', async () => {
+    state.failResolve = true;
+    const original = document();
+    await assert.rejects(openUntitledCsvEditor(original, 2), /resolve failed/);
+    assert.strictEqual(state.panels[0].disposed, true);
+    assert.strictEqual(state.tokens[0].disposed, true);
+    state.failResolve = false;
+    await openUntitledCsvEditor(original, 2);
+    assert.strictEqual(state.panels[1].active, true);
+  });
+
+  it('disposes event subscriptions and panels with the extension context', async () => {
+    activate(document());
+    await settle();
+    state.subscriptions.forEach(subscription => subscription.dispose());
+    assert.strictEqual(state.panels[0].disposed, true);
+    assert.strictEqual(activeEvent.size + openEvent.size + closeEvent.size + configEvent.size, 0);
+    assert.strictEqual(FakeProvider.currentActive, undefined);
+  });
+  it('reopens the invoking untitled owner rather than a stale global text editor on enable', async () => {
+    const original = document('tsv'), other = document('csv', 'file', '/old.csv');
+    state.enabled = false;
+    state.documents = [original, other]; state.activeTextEditor = { document: other, viewColumn: 1 };
+    state.groupOverride = { viewColumn: 3, activeTab: { input: new TabInputText(original.uri) } };
+    state.visibleOverride = [{ document: original, viewColumn: 3 }, state.activeTextEditor];
+    state.enabled = true; configEvent.fire({ affectsConfiguration: (key: string) => key === 'csv.enabled' });
+    await settle();
+    assert.strictEqual(getActiveUntitledCsvEditor()?.document, original);
+    assert.strictEqual(state.panels.at(-1).viewColumn, 3);
+    assert.strictEqual(original.isClosed, false);
+  });
+
+});
diff --git a/src/test/untitled-enable-routing.test.ts b/src/test/untitled-enable-routing.test.ts
new file mode 100644
index 0000000..6796bdc
--- /dev/null
+++ b/src/test/untitled-enable-routing.test.ts
@@ -0,0 +1,56 @@
+import assert from 'assert';
+import { createTestMemento } from './test-memento';
+import Module from 'module';
+import { describe, it } from 'node:test';
+
+class Uri {
+  constructor(public fsPath: string, public scheme: string) {}
+  toString() { return `${this.scheme}:${this.fsPath}`; }
+}
+const state = { listeners: [] as any[], tabs: [] as any[], calls: [] as any[][], errors: [] as string[] };
+const vscode = {
+  Uri,
+  ConfigurationTarget: { Global: 1, Workspace: 2 },
+  workspace: {
+    getConfiguration: (section: string) => ({
+      get: (key: string, fallback: unknown) => section === 'csv' && key === 'enabled' ? true : fallback,
+      inspect: (key: string) => section === 'csv' && key === 'enabled' ? { defaultValue: true } : undefined
+    }),
+    onDidChangeConfiguration: (callback: any) => { state.listeners.push(callback); return { dispose() {} }; }
+  },
+  window: {
+    showErrorMessage: (message: string) => { state.errors.push(message); },
+    tabGroups: {
+      get all() { return [{ viewColumn: 1, tabs: state.tabs }]; },
+      close: async (tabs: any) => { state.calls.push(['close', tabs]); return true; }
+    },
+    registerCustomEditorProvider: () => ({ dispose() {} })
+  },
+  commands: { executeCommand: async (...args: any[]) => { state.calls.push(args); } }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') { return vscode; }
+  if (id === './CsvEditorProvider') { return { CsvEditorProvider: class { static viewType = 'csv.editor'; static editors = []; } }; }
+  if (id === './commands') { return { registerCsvCommands() {} }; }
+  if (id === './untitled-editors') { return { registerUntitledCsvEditors() {} }; }
+  return originalRequire.apply(this, arguments as any);
+};
+import { activate } from '../extension';
+Module.prototype.require = originalRequire;
+
+describe('enabling the saved-file editor preserves untitled owners', () => {
+  it('never closes or openWith-routes associated-path CSV/TSV untitled tabs', async () => {
+    const csv = { input: { uri: new Uri('/workspace/data.csv', 'untitled') }, isActive: true };
+    const tsv = { input: { uri: new Uri('/workspace/data.tsv', 'untitled') }, isActive: false };
+    state.tabs = [csv, tsv];
+    state.calls = [];
+    state.listeners = [];
+    await activate({ subscriptions: [], globalState: createTestMemento(), workspaceState: createTestMemento() } as any);
+    await state.listeners[0]({ affectsConfiguration: (key: string) => key === 'csv.enabled' });
+    await new Promise(resolve => setImmediate(resolve));
+    assert.deepStrictEqual(state.errors, [], 'activation and enablement routing must complete');
+    assert.deepStrictEqual(state.calls, []);
+    assert.deepStrictEqual(state.tabs, [csv, tsv]);
+  });
+});
diff --git a/src/test/untitled-switch-commit.test.ts b/src/test/untitled-switch-commit.test.ts
new file mode 100644
index 0000000..755bef9
--- /dev/null
+++ b/src/test/untitled-switch-commit.test.ts
@@ -0,0 +1,190 @@
+import assert from 'assert';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom, flushViewCommits } from './edit-integrity-harness';
+
+const turn = () => new Promise(resolve => setImmediate(resolve));
+function currentFilterSession(host: Awaited<ReturnType<typeof createEditorHarness>>): string {
+  const metadata = /<script id="__csvFilters"[^>]*>(.*?)<\/script>/s.exec(host.panel.webview.html);
+  assert.ok(metadata);
+  return JSON.parse(metadata[1]).session;
+}
+
+function deliver(host: Awaited<ReturnType<typeof createEditorHarness>>, view: ReturnType<typeof createWebviewDom>) {
+  const request = host.messages.filter(message => message.type === 'prepareViewRefresh').at(-1);
+  assert.ok(request);
+  const start = view.messages.length;
+  view.window.dispatchEvent(new view.window.MessageEvent('message', { data: request }));
+  return Promise.all(view.messages.slice(start).map(message => host.receive(message)))
+    .then(() => flushViewCommits(host, view));
+}
+
+describe('awaitable untitled draft commit', () => {
+  for (const separator of [',', '\t']) {
+    it(`waits for a real multiline DOM draft and delayed WorkspaceEdit without saving (${JSON.stringify(separator)})`, async () => {
+      const host = await createEditorHarness({ untitled: true, separator });
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        view.start(view.cell());
+        view.key('Enter', { shiftKey: true });
+        view.type('pending draft');
+        host.deferEdits();
+        const html = host.panel.webview.html;
+        const disk = host.diskText;
+        let finished = false;
+        const commit = host.commitPendingDraft().then(success => { finished = true; return success; });
+        const operation = deliver(host, view);
+        await turn();
+        assert.strictEqual(host.pendingEdits, 1);
+        assert.strictEqual(finished, false);
+        assert.strictEqual(host.panel.webview.html, html);
+        host.releaseEdit();
+        await operation;
+        assert.strictEqual(await commit, true);
+        assert.strictEqual(host.rows()[1][0], 'one\npending draft');
+        assert.strictEqual(host.panel.webview.html, html, 'commit helper must not replace its live view');
+        assert.strictEqual(host.diskText, disk);
+        assert.deepStrictEqual(host.sourceReveals, []);
+        assert.deepStrictEqual(host.nativeSaveCommands, []);
+        assert.strictEqual(host.activeController!.getViewColumn(), 2);
+      } finally { view.close(); host.panel.dispose(); }
+    });
+  }
+
+  for (const failure of ['false', 'throw']) {
+    it(`rejects an edit returning ${failure}, retains the DOM draft, and permits an explicit same-cell retry`, async () => {
+      const host = await createEditorHarness({ untitled: true });
+      const view = createWebviewDom(host.panel.webview.html);
+      const apply = host.applyEdit;
+      try {
+        view.start(view.cell());
+        view.key('Enter', { shiftKey: true });
+        view.type('retained draft');
+        const html = host.panel.webview.html;
+        host.applyEdit = async () => { if (failure === 'throw') { throw new Error('fixture edit rejected'); } return false; };
+        const commit = host.commitPendingDraft();
+        await deliver(host, view);
+        assert.strictEqual(await commit, false);
+        assert.strictEqual(view.cell().textContent, 'one\nretained draft');
+        assert.strictEqual(host.panel.webview.html, html);
+        assert.strictEqual(host.panel.disposed, false);
+        assert.strictEqual(host.rows()[1][0], 'one');
+        assert.deepStrictEqual(host.nativeSaveCommands, []);
+        host.applyEdit = apply;
+        view.start(view.cell());
+        const retry = host.commitPendingDraft();
+        await deliver(host, view);
+        assert.strictEqual(await retry, true);
+        assert.strictEqual(host.rows()[1][0], 'one\nretained draft');
+      } finally { view.close(); host.panel.dispose(); }
+    });
+  }
+
+  it('resolves false on disposal and ignores its late acknowledgment', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const commit = host.commitPendingDraft();
+    const request = host.messages.at(-1);
+    host.panel.dispose();
+    assert.strictEqual(await commit, false);
+    assert.strictEqual(await host.commitPendingDraft(), false);
+    await host.receive({ type: 'viewRefreshReady', session: currentFilterSession(host), requestId: request.requestId });
+    assert.deepStrictEqual(host.sourceReveals, []);
+  });
+
+  it('returns false when the commit request cannot reach the webview', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const post = host.panel.webview.postMessage;
+    try {
+      host.panel.webview.postMessage = async () => { throw new Error('panel unavailable'); };
+      assert.strictEqual(await host.commitPendingDraft(), false);
+      assert.strictEqual(host.panel.disposed, false);
+      host.panel.webview.postMessage = post;
+      const view = createWebviewDom(host.panel.webview.html);
+      try {
+        const retry = host.commitPendingDraft();
+        await deliver(host, view);
+        assert.strictEqual(await retry, true);
+      } finally { view.close(); }
+    } finally { host.panel.dispose(); }
+  });
+
+  it('times out without discarding a draft or opening another view', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    const type = host.activeController!.constructor as any;
+    const timeout = type.DRAFT_COMMIT_TIMEOUT_MS;
+    type.DRAFT_COMMIT_TIMEOUT_MS = 10;
+    try {
+      view.start(view.cell());
+      view.type('still editing');
+      assert.strictEqual(await host.commitPendingDraft(), false);
+      assert.strictEqual(view.cell().textContent, 'onestill editing');
+      assert.ok(view.cell().isContentEditable || view.cell().getAttribute('contenteditable') === 'true');
+      assert.strictEqual(host.panel.disposed, false);
+      assert.deepStrictEqual(host.sourceReveals, []);
+    } finally { type.DRAFT_COMMIT_TIMEOUT_MS = timeout; view.close(); host.panel.dispose(); }
+  });
+
+  it('drains already pending edits for a hidden view and keeps an explicitly pending save action', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    host.deferEdits();
+    const edit = host.receive({ type: 'editCell', row: 1, col: 0, value: 'queued' });
+    await turn();
+    host.panel.visible = false;
+    let done = false;
+    const commit = host.commitPendingDraft().then(success => { done = true; return success; });
+    await turn();
+    assert.strictEqual(done, false);
+    host.releaseEdit();
+    await edit;
+    assert.strictEqual(await commit, true);
+    assert.strictEqual(host.rows()[1][0], 'queued');
+    assert.deepStrictEqual(host.nativeSaveCommands, []);
+    host.panel.visible = true;
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      host.saveUntitledAfterCommit();
+      const pending = host.commitPendingDraft();
+      await deliver(host, view);
+      assert.strictEqual(await pending, true);
+      assert.deepStrictEqual(host.nativeSaveCommands, ['workbench.action.files.save']);
+    } finally { view.close(); host.panel.dispose(); }
+  });
+
+  it('discards a failed draft against the live language-rebound owner before updating its grammar', async () => {
+    const host = await createEditorHarness({ untitled: true });
+    const view = createWebviewDom(host.panel.webview.html);
+    try {
+      view.start(view.cell());
+      view.key('Enter', { shiftKey: true });
+      view.type('unapplied draft');
+      const replacement = host.rebindDocument('tsv');
+      host.document.isClosed = true;
+      host.document.getText = () => { throw new Error('captured owner is closed'); };
+      host.failEdits('false');
+      const start = host.messages.length;
+      const commit = host.commitPendingDraft();
+      await deliver(host, view);
+      assert.strictEqual(await commit, false);
+      assert.strictEqual(host.getCurrentSeparator(), ',');
+      for (const message of host.messages.slice(start)) {
+        if (message.type === 'editCellFailed') {
+          view.window.dispatchEvent(new view.window.MessageEvent('message', { data: message }));
+        }
+      }
+      const beforeEscape = view.messages.length;
+      view.key('Escape');
+      const discarded = view.messages.slice(beforeEscape);
+      assert.ok(discarded.some(message => message.type === 'discardCellDraft'));
+      assert.ok(!discarded.some(message => message.type === 'editCell'));
+      for (const message of discarded) { await host.receive(message); }
+      assert.strictEqual(replacement.getText(), 'name,value\r\none,two');
+      assert.deepStrictEqual(host.nativeSaveCommands, []);
+      host.failEdits(undefined);
+      const retry = host.commitPendingDraft();
+      await deliver(host, view);
+      assert.strictEqual(await retry, true);
+      assert.strictEqual(host.getCurrentSeparator(), '\t');
+      assert.ok(!host.panel.webview.html.includes('unapplied draft'));
+    } finally { view.close(); host.panel.dispose(); }
+  });
+});
diff --git a/src/test/untitled-toggle-routing.test.ts b/src/test/untitled-toggle-routing.test.ts
new file mode 100644
index 0000000..591cba0
--- /dev/null
+++ b/src/test/untitled-toggle-routing.test.ts
@@ -0,0 +1,62 @@
+import assert from 'assert';
+import Module from 'module';
+import { describe, it } from 'node:test';
+
+class Uri {
+  constructor(public scheme: string, public path: string) {}
+  toString() { return `${this.scheme}:${this.path}`; }
+}
+class TabInputText { constructor(public uri: Uri) {} }
+class TabInputCustom { constructor(public uri: Uri, public viewType: string) {} }
+const owner = { uri: new Uri('untitled', 'Untitled-1'), languageId: 'csv' };
+const group = { viewColumn: 1, activeTab: undefined as any };
+const opened: unknown[] = [];
+const vscode = {
+  TabInputText, TabInputCustom, version: '1.142.0',
+  window: { activeTextEditor: { document: owner, viewColumn: 2 },
+    visibleTextEditors: [{ document: owner, viewColumn: 1 }],
+    tabGroups: { activeTabGroup: group }, showInformationMessage() {}, showErrorMessage() {} },
+  workspace: { getConfiguration: () => ({ get: () => true }) },
+  commands: { getCommands: async () => [] }
+};
+const originalRequire = Module.prototype.require;
+Module.prototype.require = function (id: string) {
+  if (id === 'vscode') { return vscode; }
+  if (id === './CsvEditorProvider') { return { CsvEditorProvider: { viewType: 'csv.editor' } }; }
+  if (id === './untitled-editors') {
+    return { getActiveUntitledCsvEditor: () => undefined,
+      isUntitledCsv: (document: typeof owner) => document.uri.scheme === 'untitled',
+      openUntitledCsvEditor: async (document: unknown, column: number) => { opened.push({ document, column }); } };
+  }
+  return originalRequire.apply(this, arguments as any);
+};
+const { toggleCsvEditor } = require('../editor-switch') as typeof import('../editor-switch');
+Module.prototype.require = originalRequire;
+
+describe('untitled switch routing across editor groups', () => {
+  it('ignores another group’s untitled text owner while switching a saved table', async () => {
+    opened.length = 0;
+    group.activeTab = { input: new TabInputCustom(new Uri('file', '/saved.csv'), 'csv.editor') };
+    await toggleCsvEditor();
+    assert.deepStrictEqual(opened, []);
+  });
+  it('ignores another group’s untitled text owner while switching saved text', async () => {
+    opened.length = 0;
+    group.activeTab = { input: new TabInputText(new Uri('file', '/saved.csv')) };
+    await toggleCsvEditor();
+    assert.deepStrictEqual(opened, []);
+  });
+  it('opens the untitled grid when its native owner is the active tab', async () => {
+    opened.length = 0;
+    group.activeTab = { input: new TabInputText(owner.uri) };
+    await toggleCsvEditor();
+    assert.deepStrictEqual(opened, [{ document: owner, column: 1 }]);
+  });
+  it('uses the visible untitled owner when the global active text editor points elsewhere', async () => {
+    opened.length = 0;
+    vscode.window.activeTextEditor = { document: { ...owner, uri: new Uri('file', '/other.csv') }, viewColumn: 2 };
+    group.activeTab = { input: new TabInputText(owner.uri) };
+    await toggleCsvEditor();
+    assert.deepStrictEqual(opened, [{ document: owner, column: 1 }]);
+  });
+});
diff --git a/src/test/webview-clipboard.test.ts b/src/test/webview-clipboard.test.ts
new file mode 100644
index 0000000..c86618f
--- /dev/null
+++ b/src/test/webview-clipboard.test.ts
@@ -0,0 +1,280 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import vm from 'vm';
+import { describe, it } from 'node:test';
+import { serializeClipboardMatrix } from '../clipboard';
+
+type Listener = { callback: (event: any) => void; capture: boolean };
+
+// Execute the complete shipped script. The small DOM model supplies selection,
+// focus and event propagation; it does not reimplement clipboard behavior.
+function createWebview() {
+  class Element {
+    listeners = new Map<string, Listener[]>();
+    attributes = new Map<string, string>();
+    classes = new Set<string>();
+    children: Element[] = [];
+    parentElement: Element | null = null;
+    style: Record<string, string> = {};
+    dataset: Record<string, string> = {};
+    textContent = '';
+    value = '';
+    isContentEditable = false;
+    isConnected = true;
+    classList = {
+      add: (...names: string[]) => names.forEach(name => this.classes.add(name)),
+      remove: (...names: string[]) => names.forEach(name => this.classes.delete(name)),
+      contains: (name: string) => this.classes.has(name),
+      toggle: (name: string, force?: boolean) => {
+        const next = force ?? !this.classes.has(name);
+        if (next) { this.classes.add(name); } else { this.classes.delete(name); }
+        return next;
+      }
+    };
+    constructor(public tagName = 'DIV', public id = '') {}
+    addEventListener(type: string, callback: (event: any) => void, options?: any) {
+      const listeners = this.listeners.get(type) || [];
+      listeners.push({ callback, capture: options === true });
+      this.listeners.set(type, listeners);
+    }
+    removeEventListener() {}
+    setAttribute(name: string, value: string) { this.attributes.set(name, value); }
+    getAttribute(name: string) { return this.attributes.get(name) ?? null; }
+    get tBodies() { return this.children.filter(child => child.tagName === 'TBODY'); }
+    hasAttribute(name: string) { return this.attributes.has(name); }
+    appendChild(child: Element) { child.parentElement = this; this.children.push(child); }
+    contains(other: Element): boolean { return other === this || this.children.some(child => child.contains(other)); }
+    focus() { document.activeElement = this; }
+    scrollIntoView() {}
+    getBoundingClientRect() { return { width: 200, height: 300 }; }
+    matches(selector: string): boolean {
+      if (selector.endsWith(':last-child')) {
+        return this === this.parentElement?.children[this.parentElement.children.length - 1] && this.matches(selector.slice(0, -':last-child'.length));
+      }
+      if (selector.includes(' ')) {
+        const [ancestor, child] = selector.split(' ');
+        return this.matches(child) && !!this.parentElement?.closest(ancestor);
+      }
+      if (selector.startsWith('#')) { return this.id === selector.slice(1); }
+      const tag = selector.match(/^[a-z]+/i)?.[0];
+      if (tag && this.tagName !== tag.toUpperCase()) { return false; }
+      if (selector.includes('.')) { return selector.split('.').slice(1).every(name => this.classes.has(name)); }
+      for (const match of selector.matchAll(/\[([^=\]]+)(?:="([^"]*)")?\]/g)) {
+        if (match[2] === undefined ? !this.hasAttribute(match[1]) : this.getAttribute(match[1]) !== match[2]) { return false; }
+      }
+      return true;
+    }
+    closest(selector: string): Element | null {
+      if (selector.split(',').some(part => this.matches(part.trim()))) { return this; }
+      return this.parentElement?.closest(selector) ?? null;
+    }
+    querySelectorAll(selector: string): Element[] {
+      const descendants = this.children.flatMap(child => [child, ...child.querySelectorAll('*')]);
+      return descendants.filter(child => selector === '*' || selector.split(',').some(part => child.matches(part.trim())));
+    }
+    querySelector(selector: string) { return this.querySelectorAll(selector)[0] ?? null; }
+    get innerHTML() { return ''; }
+    set innerHTML(_value: string) { this.children = []; }
+    get innerText() { return this.textContent; }
+    set innerText(value: string) { this.textContent = value; }
+  }
+  const document = new Element('DOCUMENT') as Element & { body: Element; activeElement: Element | null; getElementById: (id: string) => Element };
+  document.body = new Element('BODY');
+  document.activeElement = null;
+  document.appendChild(document.body);
+  const elements = new Map<string, Element>();
+  const byId = (id: string) => {
+    if (!elements.has(id)) {
+      const el = new Element(id.endsWith('Input') ? 'INPUT' : 'DIV', id);
+      elements.set(id, el);
+      document.body.appendChild(el);
+    }
+    return elements.get(id)!;
+  };
+  document.getElementById = byId;
+  const root = byId('csv-root');
+  root.dataset.realrowcount = '2';
+  const table = new Element('TABLE');
+  const head = new Element('THEAD');
+  const body = new Element('TBODY');
+  table.appendChild(head);
+  table.appendChild(body);
+  root.appendChild(table);
+  byId('__csvChunks').textContent = '[]';
+  const widget = byId('findReplaceWidget');
+  for (const id of ['findInput', 'replaceInput']) {
+    const input = byId(id);
+    document.body.children = document.body.children.filter(el => el !== input);
+    widget.appendChild(input);
+  }
+  const window = new Element('WINDOW') as any;
+  window.getComputedStyle = () => ({ fontSize: '14px' });
+  window.innerWidth = 1024;
+  window.innerHeight = 768;
+  const messages: any[] = [];
+  class IntersectionObserver {
+    private readonly observed = new Set<Element>();
+    observe(target: Element) { this.observed.add(target); }
+    unobserve(target: Element) { this.observed.delete(target); }
+    disconnect() { this.observed.clear(); }
+    takeRecords() { return []; }
+  }
+  const context = vm.createContext({
+    document, window, Element, Node: Element, IntersectionObserver,
+    acquireVsCodeApi: () => ({ getState: () => ({}), setState: () => {}, postMessage: (message: any) => messages.push(JSON.parse(JSON.stringify(message))) }),
+    setTimeout: () => 0, clearTimeout: () => {}, requestAnimationFrame: () => 0,
+    console
+  });
+  (document as any).createElement = (tag: string) => new Element(tag.toUpperCase());
+  vm.runInContext(fs.readFileSync(path.join(process.cwd(), 'media', 'main.js'), 'utf8'), context);
+  // Interaction assertions begin after the independent initialization handshake.
+  messages.length = 0;
+  const rows = new Map<string, Element>();
+  const cell = (row: number, col: number, value: string, header = false) => {
+    const el = new Element(header ? 'TH' : 'TD');
+    el.setAttribute('data-row', String(row));
+    el.setAttribute('data-col', String(col));
+    el.textContent = value;
+    const key = `${header}:${row}`;
+    if (!rows.has(key)) {
+      const tr = new Element('TR');
+      (header ? head : body).appendChild(tr);
+      rows.set(key, tr);
+    }
+    rows.get(key)!.appendChild(el);
+    return el;
+  };
+  const dispatch = (target: Element, type: string, options: any = {}) => {
+    const event: any = {
+      type, target, defaultPrevented: false, stopped: false, immediate: false,
+      preventDefault() { this.defaultPrevented = true; },
+      stopPropagation() { this.stopped = true; },
+      stopImmediatePropagation() { this.stopped = true; this.immediate = true; },
+      ...options
+    };
+    const invoke = (el: Element, capture: boolean) => {
+      for (const listener of el.listeners.get(type) || []) {
+        if (listener.capture === capture && !event.immediate) { listener.callback(event); }
+      }
+    };
+    invoke(document, true);
+    if (!event.stopped) { invoke(target, false); }
+    for (let parent = target.parentElement; parent && !event.stopped; parent = parent.parentElement) { invoke(parent, false); }
+    return event;
+  };
+  return { context, cell, byId, document, table, messages, dispatch, select: (startRow: number, startCol: number, endRow = startRow, endCol = startCol) => {
+    vm.runInContext(`selectRange({ row: ${startRow}, col: ${startCol} }, { row: ${endRow}, col: ${endCol} }); anchorCell = currentSelection[0];`, context);
+  }};
+}
+
+describe('Shipped webview clipboard interactions', () => {
+  it('exports plain single-cell text for native paste into Search', () => {
+    const view = createWebview();
+    const cell = view.cell(1, 0, 'hello world');
+    view.select(1, 0);
+    view.dispatch(cell, 'copy');
+    const clipboardText = serializeClipboardMatrix(view.messages[0].matrix, ',');
+    assert.strictEqual(clipboardText, 'hello world');
+    const input = view.byId('findInput');
+    input.focus();
+    const event = view.dispatch(input, 'paste', { clipboardData: { getData: () => clipboardText } });
+    assert.strictEqual(event.defaultPrevented, false, 'Search must retain native text paste');
+    assert.strictEqual(view.messages.length, 1, 'Search paste must not become a grid paste');
+  });
+
+  it('copies headers and multiline values without serial indices or trimmed blanks', () => {
+    const view = createWebview();
+    view.cell(0, -1, '#', true);
+    view.cell(0, 0, 'Header', true);
+    view.cell(0, 1, '', true);
+    view.cell(1, -1, '1');
+    const target = view.cell(1, 0, 'literal,comma\nand newline');
+    view.cell(1, 1, '  ');
+    view.select(0, -1, 1, 1);
+    const event = view.dispatch(target, 'copy');
+    assert.strictEqual(event.defaultPrevented, true);
+    assert.deepStrictEqual(view.messages, [{ type: 'copyCells', matrix: [['Header', ''], ['literal,comma\nand newline', '  ']], rowIds: [0, 1], startCol: 0, cut: false }]);
+  });
+
+  it('routes grid Ctrl/Cmd+C and X through system clipboard messages', () => {
+    for (const modifier of ['ctrlKey', 'metaKey']) {
+      for (const key of ['c', 'x']) {
+        const view = createWebview();
+        const target = view.cell(1, 0, 'value');
+        view.select(1, 0);
+        const event = view.dispatch(target, 'keydown', { key, [modifier]: true });
+        assert.strictEqual(event.defaultPrevented, true);
+        assert.strictEqual(view.messages[0].cut, key === 'x');
+        assert.strictEqual(target.textContent, 'value', 'cut must wait for the clipboard write');
+      }
+    }
+  });
+
+  it('provides Cut, Copy and Paste actions for the preserved right-click selection', () => {
+    const view = createWebview();
+    const first = view.cell(1, 0, 'one');
+    const second = view.cell(1, 1, 'two');
+    view.select(1, 0, 1, 1);
+    view.dispatch(second, 'mousedown', { button: 2 });
+    view.dispatch(second, 'contextmenu', { clientX: 10, clientY: 20 });
+    const menu = view.byId('contextMenu');
+    for (const label of ['Copy', 'Cut', 'Paste']) {
+      const item = menu.children.find(child => child.textContent === label)!;
+      assert.ok(item);
+      view.dispatch(item, 'click');
+    }
+    assert.deepStrictEqual(view.messages.map(message => message.type), ['copyCells', 'copyCells', 'pasteFromClipboard']);
+    assert.deepStrictEqual(view.messages[0].matrix, [['one', 'two']]);
+    assert.strictEqual(view.messages[1].cut, true);
+    assert.strictEqual(view.messages[2].anchorCol, 0);
+    assert.strictEqual(first.textContent, 'one');
+  });
+
+  it('allows native text clipboard shortcuts and paste in Find and Replace', () => {
+    for (const id of ['findInput', 'replaceInput']) {
+      for (const modifier of ['ctrlKey', 'metaKey']) {
+        const view = createWebview();
+        view.cell(1, 0, 'selected grid value');
+        view.select(1, 0);
+        const input = view.byId(id);
+        for (const key of ['a', 'c', 'x', 'v']) {
+          const event = view.dispatch(input, 'keydown', { key, [modifier]: true });
+          assert.strictEqual(event.defaultPrevented, false, `${id} ${key} default`);
+          assert.strictEqual(event.stopped, false, `${id} ${key} must reach the VS Code webview bridge`);
+        }
+        for (const type of ['copy', 'cut', 'paste']) {
+          const event = view.dispatch(input, type, { clipboardData: { getData: () => 'SKU-123' } });
+          assert.strictEqual(event.defaultPrevented, false);
+        }
+        assert.deepStrictEqual(view.messages, []);
+      }
+    }
+  });
+
+  it('keeps native text copy, cut, paste and context menus while editing a cell', () => {
+    const view = createWebview();
+    const target = view.cell(1, 0, 'text edit');
+    view.select(1, 0);
+    vm.runInContext('editingCell = currentSelection[0];', view.context);
+    target.isContentEditable = true;
+    for (const type of ['copy', 'cut', 'paste', 'contextmenu']) {
+      const event = view.dispatch(target, type, { clipboardData: { getData: () => 'text' } });
+      assert.strictEqual(event.defaultPrevented, false);
+    }
+    const event = view.dispatch(target, 'keydown', { key: 'c', metaKey: true });
+    assert.strictEqual(event.defaultPrevented, false);
+    assert.deepStrictEqual(view.messages, []);
+  });
+
+  it('posts a grid paste while leaving the selected cell contents to the host', () => {
+    const view = createWebview();
+    const target = view.cell(1, 0, 'before');
+    view.select(1, 0);
+    const event = view.dispatch(target, 'paste', { clipboardData: { getData: () => '"with,comma"' } });
+    assert.strictEqual(event.defaultPrevented, true);
+    assert.strictEqual(view.messages[0].type, 'pasteCells');
+    assert.strictEqual(view.messages[0].text, '"with,comma"');
+    assert.strictEqual(target.textContent, 'before');
+  });
+});
diff --git a/src/test/webview-column-filters.test.ts b/src/test/webview-column-filters.test.ts
new file mode 100644
index 0000000..407f1f5
--- /dev/null
+++ b/src/test/webview-column-filters.test.ts
@@ -0,0 +1,480 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createEditorHarness, createWebviewDom } from './edit-integrity-harness';
+
+const wait = () => new Promise(resolve => setTimeout(resolve, 130));
+const rows = [['Name', 'Score'], ['alpha', '10'], ['beta', '20'], ['alphabet', '30']];
+const fixture = async (options: Parameters<typeof createEditorHarness>[0] = {}) => {
+  const host = await createEditorHarness({ rows, ...options });
+  const view = createWebviewDom(host.panel.webview.html);
+  await new Promise(resolve => setTimeout(resolve, 20));
+  const document = view.window.document;
+  const conditions = () => Array.from(document.querySelectorAll('.column-filter-row')) as any[];
+  const input = (row = 0) => conditions()[row].querySelector('[data-filter-value]') as any;
+  const change = (element: any, value: string, event = 'input') => {
+    element.value = value;
+    element.dispatchEvent(new view.window.Event(event, { bubbles: true }));
+  };
+  const add = (column = 0) => {
+    const cell = view.cell(1, column);
+    cell.dispatchEvent(new view.window.MouseEvent('contextmenu', { bubbles: true, cancelable: true, clientX: 100, clientY: 40 }));
+    const action = Array.from(document.querySelectorAll('#contextMenu div')).find((item: any) => item.textContent === 'Filter this column…') as any;
+    assert.ok(action);
+    action.click();
+    return input(conditions().length - 1);
+  };
+  let cursor = 0;
+  const submit = async () => {
+    await wait();
+    const pending = view.messages.slice(cursor);
+    cursor = view.messages.length;
+    for (const message of pending) {
+      if (['editCell', 'updateColumnFilters', 'findMatches', 'filterDraftChanged'].includes(message.type)) {
+        await host.receive(message);
+      }
+    }
+    const request = pending.filter(message => message.type === 'updateColumnFilters').slice(-1)[0];
+    assert.ok(request, 'the inline controls submit one latest full snapshot');
+    const result = host.messages.filter(message => message.type === 'columnFiltersResult' && message.revision === request.revision).slice(-1)[0];
+    assert.ok(result, 'the host replies to the live snapshot');
+    return { request, result };
+  };
+  const deliver = (result: any) => view.window.dispatchEvent(new view.window.MessageEvent('message', { data: result }));
+  const apply = async () => { const sent = await submit(); deliver(sent.result); return sent; };
+  return { host, view, document, conditions, input, change, add, submit, deliver, apply };
+};
+
+// These execute the shipped module and main script against the real provider.
+describe('Inline column filters', () => {
+  it('puts filtering before clipboard actions and adds independent same-column AND conditions', async () => {
+    const f = await fixture();
+    try {
+      const first = f.add();
+      const menu = f.document.querySelector('#contextMenu');
+      assert.strictEqual(menu.firstElementChild.textContent, 'Filter this column…');
+      f.change(first, 'alpha');
+      await f.apply();
+      const second = f.add();
+      f.change(second, 'bet');
+      const { request } = await f.apply();
+      assert.strictEqual(request.filters.length, 2);
+      assert.deepStrictEqual(Array.from(request.filters, (filter: any) => filter.column), [0, 0]);
+      assert.ok(f.conditions()[1].textContent.includes('AND'));
+      assert.ok(f.view.cell(3, 0));
+      assert.strictEqual(f.view.cell(1, 0), null);
+      assert.strictEqual(f.view.cell(2, 0), null);
+      assert.strictEqual(f.host.quickPickCalls.length, 0);
+      assert.strictEqual(f.host.inputBoxCalls.length, 0);
+      assert.strictEqual(f.host.document.getText(), f.host.diskText);
+    } finally { f.view.close(); }
+  });
+
+  it('keeps input identity, focus, selection and literal spaces through live results; blank drafts expand the table', async () => {
+    const f = await fixture();
+    try {
+      const input = f.add();
+      f.change(input, 'alpha');
+      input.setSelectionRange(2, 4);
+      const table = f.document.querySelector('table');
+      await f.apply();
+      assert.strictEqual(f.document.querySelector('table'), table);
+      assert.strictEqual(f.input(), input);
+      assert.strictEqual(f.document.activeElement, input);
+      assert.deepStrictEqual([input.selectionStart, input.selectionEnd], [2, 4]);
+      f.change(input, ' ');
+      const spaced = await f.apply();
+      assert.strictEqual(spaced.request.filters[0].value, ' ');
+      f.change(input, '');
+      const cleared = await f.apply();
+      assert.strictEqual(cleared.request.filters.length, 0);
+      assert.strictEqual(f.conditions().length, 1, 'empty draft stays editable');
+      assert.ok(f.view.cell(1, 0));
+      assert.ok(f.view.cell(2, 0));
+      assert.ok(f.view.cell(3, 0));
+      assert.strictEqual(table.getAttribute('aria-busy'), 'false');
+    } finally { f.view.close(); }
+  });
+
+  it('ignores replies immediately after typing and aligns last-valid epoch on the latest invalid query', async () => {
+    const f = await fixture();
+    try {
+      const input = f.add();
+      f.change(input, 'alpha');
+      const first = await f.submit();
+      const operator = f.conditions()[0].querySelector('[data-filter-operator]');
+      f.change(operator, 'regex', 'change');
+      f.change(input, '(');
+      f.deliver(first.result);
+      assert.ok(f.view.cell(2, 0), 'stale success cannot repaint during a newer debounce');
+      const invalid = await f.submit();
+      assert.ok(invalid.result.errors.length);
+      f.deliver(invalid.result);
+      assert.strictEqual(f.input(), input);
+      assert.strictEqual(input.value, '(');
+      assert.strictEqual(input.getAttribute('aria-invalid'), 'true');
+      assert.ok(f.conditions()[0].querySelector('.column-filter-error').textContent);
+      assert.ok(f.document.querySelector('[data-filter-error]').textContent.includes('Showing the last valid results.'));
+      assert.strictEqual(f.view.cell(2, 0), null, 'latest error aligns the last valid table accepted by the host');
+      assert.ok(f.view.cell(1, 0));
+      assert.strictEqual(f.document.querySelector('table').getAttribute('aria-busy'), 'false');
+      f.change(input, 'beta');
+      const valid = await f.submit();
+      f.deliver(invalid.result);
+      assert.strictEqual(input.getAttribute('aria-invalid'), null, 'stale errors cannot attach to new text');
+      f.deliver(valid.result);
+      assert.ok(f.view.cell(2, 0));
+      assert.strictEqual(f.view.cell(1, 0), null);
+    } finally { f.view.close(); }
+  });
+
+  it('does not submit partial IME composition or replace the composing input with older results', async () => {
+    const f = await fixture();
+    try {
+      const input = f.add();
+      const beforeTyping = f.view.messages.length;
+      f.change(input, 'a');
+      const immediate = f.view.messages.slice(beforeTyping);
+      assert.strictEqual(immediate[0]?.type, 'filterDraftChanged', 'typing reports activity synchronously before debounce');
+      assert.strictEqual(typeof immediate[0]?.session, 'string');
+      assert.strictEqual(immediate.some(message => message.type === 'updateColumnFilters'), false);
+      const first = await f.submit();
+      const beforeComposition = f.view.messages.length;
+      input.dispatchEvent(new f.view.window.CompositionEvent('compositionstart', { bubbles: true }));
+      assert.strictEqual(f.view.messages[beforeComposition]?.type, 'filterDraftChanged', 'composition start reports activity immediately');
+      f.change(input, 'アルファ');
+      assert.strictEqual(f.view.messages[beforeComposition + 1]?.type, 'filterDraftChanged', 'each composing input reports its own activity');
+      const count = f.view.messages.filter(message => message.type === 'updateColumnFilters').length;
+      await wait();
+      assert.strictEqual(f.view.messages.filter(message => message.type === 'updateColumnFilters').length, count);
+      f.deliver(first.result);
+      assert.strictEqual(f.input(), input);
+      assert.strictEqual(input.value, 'アルファ');
+      assert.ok(f.view.cell(2, 0));
+      input.dispatchEvent(new f.view.window.CompositionEvent('compositionend', { bubbles: true }));
+      const complete = await f.apply();
+      assert.strictEqual(complete.request.filters[0].value, 'アルファ');
+      assert.strictEqual(f.document.activeElement, input);
+    } finally { f.view.close(); }
+  });
+
+  it('keeps filter keyboard and clipboard events native, including Escape, and blocks grid mutations while pending', async () => {
+    const f = await fixture();
+    try {
+      const selected = f.view.cell(1, 0);
+      f.view.window.editingTestApi.setSingleSelection(selected);
+      const input = f.add();
+      await f.apply();
+      const selection = Array.from(f.document.querySelectorAll('td.selected, th.selected'));
+      for (const key of ['ArrowDown', 'Escape', 'a', 'c', 'x', 'v', 'f', '+']) {
+        const event = new f.view.window.KeyboardEvent('keydown', { key, metaKey: key.length === 1, bubbles: true, cancelable: true });
+        input.dispatchEvent(event);
+        assert.strictEqual(event.defaultPrevented, false, `${key} stays native in a filter input`);
+      }
+      for (const type of ['copy', 'cut', 'paste']) {
+        const event = new f.view.window.Event(type, { bubbles: true, cancelable: true });
+        input.dispatchEvent(event);
+        assert.strictEqual(event.defaultPrevented, false);
+      }
+      assert.deepStrictEqual(Array.from(f.document.querySelectorAll('td.selected, th.selected')), selection);
+      const staleDelete = Array.from(f.document.querySelectorAll('#contextMenu div')).find((item: any) => item.textContent === 'Delete ROW') as any;
+      f.change(input, 'alpha');
+      const deletes = f.view.messages.filter(message => message.type === 'deleteRow').length;
+      staleDelete.click();
+      assert.strictEqual(f.view.messages.filter(message => message.type === 'deleteRow').length, deletes, 'stale menu callbacks cannot bypass the pending table gate');
+      f.deliver({ type: 'pasteApplied', startRow: 1, startCol: 0, endRow: 1, endCol: 0 });
+      f.deliver({ type: 'focus' });
+      assert.strictEqual(f.document.activeElement, input, 'late grid messages cannot steal filter focus');
+      const cell = f.view.cell(1, 0);
+      const click = new f.view.window.MouseEvent('dblclick', { bubbles: true, cancelable: true });
+      cell.dispatchEvent(click);
+      assert.strictEqual(click.defaultPrevented, true);
+      assert.strictEqual(cell.hasAttribute('contenteditable'), false);
+      const cut = new f.view.window.Event('cut', { bubbles: true, cancelable: true });
+      cell.dispatchEvent(cut);
+      assert.strictEqual(cut.defaultPrevented, true);
+      await f.apply();
+    } finally { f.view.close(); }
+  });
+
+  it('commits an unposted live edit before submitting the first filter snapshot', async () => {
+    const f = await fixture();
+    try {
+      const input = f.add();
+      await f.apply();
+      const cell = f.view.cell(1, 0);
+      f.view.start(cell);
+      cell.textContent = 'changed alpha';
+      f.change(input, 'changed');
+      const { request } = await f.apply();
+      const editIndex = f.view.messages.findIndex(message => message.type === 'editCell');
+      const filterIndex = f.view.messages.findIndex(message => message === request);
+      assert.ok(editIndex >= 0 && editIndex < filterIndex);
+      assert.strictEqual(f.host.rows()[1][0], 'changed alpha');
+      assert.strictEqual(f.view.cell(1, 0).textContent, 'changed alpha');
+      assert.strictEqual(f.view.cell(2, 0), null);
+    } finally { f.view.close(); }
+  });
+
+  it('switches operators/types inline, keeps unary conditions active, and removes conditions independently', async () => {
+    const f = await fixture();
+    try {
+      f.add(1);
+      const row = f.conditions()[0];
+      const operator = row.querySelector('[data-filter-operator]');
+      assert.ok(Array.from(operator.options).some((option: any) => option.value === 'greaterThan'));
+      f.change(operator, 'greaterThan', 'change');
+      f.change(f.input(), '15');
+      const numeric = await f.apply();
+      assert.strictEqual(numeric.request.filters[0].dataType, 'number');
+      assert.strictEqual(f.view.cell(1, 0), null);
+      f.document.querySelector('#addColumnFilter').click();
+      const second = f.conditions()[1];
+      f.change(second.querySelector('[data-filter-column]'), '0', 'change');
+      f.change(second.querySelector('[data-filter-operator]'), 'notEmpty', 'change');
+      const unary = await f.apply();
+      assert.strictEqual(unary.request.filters.length, 2);
+      assert.strictEqual(second.querySelector('[data-filter-value]').hidden, true);
+      row.querySelector('[data-remove-filter]').click();
+      const removed = await f.apply();
+      assert.strictEqual(removed.request.filters.length, 1);
+      assert.strictEqual(removed.request.filters[0].operator, 'notEmpty');
+      f.document.querySelector('#clearAllFilters').click();
+      await f.apply();
+      assert.strictEqual(f.conditions().length, 0);
+      assert.strictEqual(f.document.querySelector('#filterStatus').hidden, true);
+    } finally { f.view.close(); }
+  });
+
+  it('rejects stale remote chunks after filters change and can load new chunks after an initially unchunked view', async () => {
+    const f = await fixture({ remote: true });
+    try {
+      const input = f.add();
+      f.change(input, 'alpha');
+      const current = await f.submit();
+      const response = { ...current.result, chunksJson: '[]', nextChunkStart: 2, hasRemoteChunks: true };
+      f.deliver(response);
+      const before = f.document.querySelector('tbody').innerHTML;
+      f.deliver({ type: 'chunkData', session: current.result.session, filterEpoch: 0, requestId: 1, start: 0, html: '<tr><td data-row="777" data-col="0">old</td></tr>', done: true });
+      assert.strictEqual(f.document.querySelector('tbody').innerHTML, before);
+      f.view.window.__csvLoadNextChunk();
+      const request = f.view.messages.filter(message => message.type === 'requestChunk').slice(-1)[0];
+      assert.strictEqual(request.filterEpoch, current.result.filterEpoch);
+      f.deliver({ type: 'chunkData', session: current.result.session, filterEpoch: current.result.filterEpoch, requestId: request.requestId, start: 2, html: '<tr><td data-row="888" data-col="0">new</td></tr>', done: true });
+      f.view.window.__csvLoadNextChunk();
+      assert.ok(f.view.cell(888, 0));
+      assert.strictEqual(f.view.cell(777, 0), null);
+    } finally { f.view.close(); }
+  });
+
+  it('handles more source row IDs than the JavaScript argument limit and rejects another session', async () => {
+    const f = await fixture();
+    try {
+      f.change(f.add(), 'alpha');
+      const sent = await f.submit();
+      const order = Array.from({ length: 160000 }, (_value, index) => index);
+      f.deliver({ ...sent.result, session: 'an-older-webview', visibleRowIds: order });
+      assert.ok(f.view.cell(2, 0), 'another full view cannot affect the current table');
+      f.deliver({ ...sent.result, visibleRowIds: order, realRowCount: 160000 });
+      const stored = JSON.parse(f.document.querySelector('#csv-root').dataset.roworder);
+      assert.strictEqual(stored.length, 160000);
+      assert.strictEqual(stored[159999], 159999);
+      assert.strictEqual(f.document.querySelector('table').getAttribute('aria-busy'), 'false');
+    } finally { f.view.close(); }
+  });
+
+  it('updates inferred metadata without changing an unsupported operator or replacing its focused input', async () => {
+    const f = await fixture();
+    try {
+      const input = f.add(1);
+      const row = f.conditions()[0];
+      f.change(row.querySelector('[data-filter-operator]'), 'greaterThan', 'change');
+      f.change(input, '15');
+      input.setSelectionRange(1, 2);
+      const sent = await f.submit();
+      const columns = sent.result.columns.map((column: any) => column.column === 1 ? {
+        ...column, dataType: 'string', operators: column.operators.filter((choice: any) => !choice.operator.startsWith('greater') && !choice.operator.startsWith('less'))
+      } : column);
+      f.deliver({ ...sent.result, columns });
+      assert.strictEqual(f.input(), input);
+      assert.strictEqual(f.document.activeElement, input);
+      assert.deepStrictEqual([input.selectionStart, input.selectionEnd], [1, 2]);
+      const operator = row.querySelector('[data-filter-operator]');
+      assert.strictEqual(operator.value, 'greaterThan', 'the displayed query remains the actual condition');
+      assert.ok(operator.selectedOptions[0].textContent.includes('unsupported'));
+      assert.ok(row.querySelector('.column-filter-error').textContent);
+      assert.strictEqual(row.querySelector('.column-filter-type').textContent, 'text');
+      f.change(operator, 'contains', 'change');
+      await f.apply();
+      assert.strictEqual(operator.value, 'contains');
+      assert.strictEqual(input.getAttribute('aria-invalid'), null);
+    } finally { f.view.close(); }
+  });
+
+  it('preserves CSV/TSV source row identities, metadata and frozen-row order after partial refresh', async () => {
+    for (const separator of [',', '\t']) {
+      const source = [['metadata', 'untouched'], ...rows];
+      const f = await fixture({ separator, rows: source, hiddenRows: 1, frozenRows: 2, frozenColumns: 1 });
+      try {
+        const input = f.add();
+        f.change(input, 'alpha');
+        const table = f.document.querySelector('table');
+        await f.apply();
+        assert.strictEqual(f.document.querySelector('table'), table);
+        assert.ok(f.view.cell(1, 0), 'the source header remains');
+        assert.ok(f.view.cell(2, 0));
+        assert.ok(f.view.cell(4, 0));
+        assert.strictEqual(f.view.cell(0, 0), null);
+        assert.strictEqual(f.view.cell(3, 0), null);
+        f.view.window.csvFrozenPanes.layout();
+        assert.ok(f.view.cell(2, 0).classList.contains('csv-frozen-row'));
+        assert.ok(!f.view.cell(4, 0).classList.contains('csv-frozen-row'));
+        assert.strictEqual(f.host.document.getText(), f.host.diskText);
+        const order = JSON.parse(f.document.querySelector('#csv-root').dataset.roworder);
+        assert.deepStrictEqual(order, [1, 2, 4, 5]);
+      } finally { f.view.close(); }
+    }
+  });
+  it('hands off blank and invalid raw drafts, focus and caret without persisting their text', async () => {
+    const f = await fixture({ filters: [{ column: 0, operator: 'contains', value: 'alpha' }] });
+    let restored: ReturnType<typeof createWebviewDom> | undefined;
+    try {
+      const input = f.input();
+      f.change(f.conditions()[0].querySelector('[data-filter-operator]'), 'regex', 'change');
+      f.change(input, 'volatile-invalid-[');
+      f.document.querySelector('#addColumnFilter').click();
+      input.focus();
+      input.setSelectionRange(2, 8, 'backward');
+      f.deliver({ type: 'prepareViewRefresh' });
+      const ack = f.view.messages.filter(message => message.type === 'viewRefreshReady').slice(-1)[0];
+      assert.strictEqual(ack.session, ack.filterDraft.session);
+      assert.deepStrictEqual(Array.from(ack.filterDraft.rows, (row: any) => row.value), ['volatile-invalid-[', '']);
+      assert.deepStrictEqual(JSON.parse(JSON.stringify(ack.filterDraft.focus)), { row: 0, field: 'value', selectionStart: 2, selectionEnd: 8, selectionDirection: 'backward' });
+      assert.ok(!JSON.stringify(f.view.state()).includes('volatile-invalid-['));
+      assert.ok(!JSON.stringify(f.host.context.workspaceState.values).includes('volatile-invalid-['));
+      await f.host.receive(ack);
+      restored = createWebviewDom(f.host.panel.webview.html);
+      await new Promise(resolve => setTimeout(resolve, 20));
+      const inputs = Array.from(restored.window.document.querySelectorAll('[data-filter-value]')) as any[];
+      assert.strictEqual(inputs.length, 2);
+      assert.strictEqual(inputs[0].value, 'volatile-invalid-[');
+      assert.strictEqual(inputs[1].value, '');
+      assert.strictEqual(restored.window.document.activeElement, inputs[0]);
+      assert.deepStrictEqual([inputs[0].selectionStart, inputs[0].selectionEnd, inputs[0].selectionDirection], [2, 8, 'backward']);
+      await wait();
+      const retry = restored.messages.filter(message => message.type === 'updateColumnFilters').slice(-1)[0];
+      assert.ok(retry);
+      assert.notStrictEqual(retry.session, ack.session);
+      assert.strictEqual(retry.filters.length, 1, 'blank condition remains a local draft');
+      assert.strictEqual(retry.filters[0].value, 'volatile-invalid-[');
+      await f.host.receive(retry);
+      const result = f.host.messages.filter(message => message.type === 'columnFiltersResult' && message.session === retry.session).slice(-1)[0];
+      restored.window.dispatchEvent(new restored.window.MessageEvent('message', { data: result }));
+      assert.strictEqual(inputs[0].getAttribute('aria-invalid'), 'true');
+      assert.ok(!JSON.stringify(f.host.context.workspaceState.values).includes('volatile-invalid-['));
+      assert.ok(!JSON.stringify(restored.state()).includes('volatile-invalid-['));
+    } finally { restored?.close(); f.view.close(); }
+  });
+
+  it('keeps the latest raw query when a deferred membership edit refreshes after a newer host filter was accepted', async () => {
+    const f = await fixture({ rows: [['Name', 'Score'], ['one', '10'], ['two', '20']], filters: [{ column: 0, operator: 'contains', value: 'one' }] });
+    let restored: ReturnType<typeof createWebviewDom> | undefined;
+    try {
+      f.host.deferEdits();
+      const cell = f.view.cell(1, 0);
+      f.view.start(cell);
+      cell.textContent = 'changed';
+      const input = f.input();
+      f.change(input, 'ch');
+      input.focus();
+      input.setSelectionRange(1, 2);
+      const edit = f.view.messages.find(message => message.type === 'editCell');
+      const writing = f.host.receive(edit);
+      await new Promise(resolve => setImmediate(resolve));
+      assert.strictEqual(f.host.pendingEdits, 1);
+      await wait();
+      const request = f.view.messages.filter(message => message.type === 'updateColumnFilters').slice(-1)[0];
+      const filtering = f.host.receive(request);
+      f.host.releaseEdit();
+      await writing;
+      await filtering;
+      const prepare = f.host.messages.filter(message => message.type === 'prepareViewRefresh').slice(-1)[0];
+      assert.ok(prepare, 'changing filter membership requests a safe full view refresh');
+      // Do not deliver the already-accepted result: the visible module still has
+      // the old applied view while its raw query is newer.
+      f.deliver(prepare);
+      const ack = f.view.messages.filter(message => message.type === 'viewRefreshReady').slice(-1)[0];
+      await f.host.receive(ack);
+      restored = createWebviewDom(f.host.panel.webview.html);
+      await new Promise(resolve => setTimeout(resolve, 20));
+      const restoredInput = restored.window.document.querySelector('[data-filter-value]');
+      assert.strictEqual(restoredInput.value, 'ch');
+      assert.strictEqual(restored.window.document.activeElement, restoredInput);
+      assert.deepStrictEqual([restoredInput.selectionStart, restoredInput.selectionEnd], [1, 2]);
+      await wait();
+      const retry = restored.messages.filter(message => message.type === 'updateColumnFilters').slice(-1)[0];
+      assert.notStrictEqual(retry.session, request.session);
+      assert.strictEqual(retry.filters[0].value, 'ch');
+      await f.host.receive(retry);
+      const result = f.host.messages.filter(message => message.type === 'columnFiltersResult' && message.session === retry.session).slice(-1)[0];
+      restored.window.dispatchEvent(new restored.window.MessageEvent('message', { data: result }));
+      assert.strictEqual(restored.cell(1, 0).textContent, 'changed');
+      assert.strictEqual(f.host.rows()[1][0], 'changed');
+      assert.strictEqual(f.host.diskText.includes('changed'), false);
+      assert.strictEqual(restoredInput.value, 'ch');
+    } finally { restored?.close(); f.view.close(); }
+  });
+
+  it('restores interrupted IME text without submitting it or blocking the last-valid grid until that condition is completed', async () => {
+    for (const completion of ['input', 'compositionend']) {
+      const f = await fixture({ filters: [{ column: 0, operator: 'contains', value: 'alpha' }] });
+      let restored: ReturnType<typeof createWebviewDom> | undefined;
+      try {
+        const input = f.input();
+        input.focus();
+        input.dispatchEvent(new f.view.window.CompositionEvent('compositionstart', { bubbles: true }));
+        f.change(input, '未確定');
+        f.deliver({ type: 'prepareViewRefresh' });
+        const ack = f.view.messages.filter(message => message.type === 'viewRefreshReady').slice(-1)[0];
+        assert.strictEqual(ack.filterDraft.rows[0].composing, true);
+        await f.host.receive(ack);
+        restored = createWebviewDom(f.host.panel.webview.html);
+        await wait();
+        const document = restored.window.document;
+        const incomplete = document.querySelector('[data-filter-value]');
+        assert.strictEqual(incomplete.value, '未確定');
+        assert.strictEqual(restored.messages.filter(message => message.type === 'updateColumnFilters').length, 0);
+        assert.strictEqual(document.querySelector('table').hasAttribute('inert'), false);
+        assert.strictEqual(document.querySelector('table').getAttribute('aria-busy'), 'false');
+        assert.ok(document.querySelector('.column-filter-error').textContent.includes('Finish editing'));
+        assert.ok(restored.cell(1, 0));
+        assert.ok(!restored.cell(2, 0), 'the current last-valid alpha filter remains displayed');
+        document.querySelector('#addColumnFilter').click();
+        const other = Array.from(document.querySelectorAll('[data-filter-value]'))[1] as any;
+        other.value = 'a';
+        other.dispatchEvent(new restored.window.Event('input', { bubbles: true }));
+        await wait();
+        assert.strictEqual(restored.messages.filter(message => message.type === 'updateColumnFilters').length, 0, 'editing another AND condition cannot commit interrupted composition');
+        assert.strictEqual(document.querySelector('table').hasAttribute('inert'), false);
+        assert.strictEqual(restored.window.csvColumnFilters.captureDraft().rows[0].composing, true);
+        incomplete.focus();
+        incomplete.value = 'alpha';
+        incomplete.dispatchEvent(completion === 'input'
+          ? new restored.window.Event('input', { bubbles: true })
+          : new restored.window.CompositionEvent('compositionend', { bubbles: true }));
+        await wait();
+        const request = restored.messages.filter(message => message.type === 'updateColumnFilters').slice(-1)[0];
+        assert.ok(request, 'explicitly completing the interrupted condition resumes live filtering');
+        assert.strictEqual(request.filters.length, 2);
+        assert.strictEqual(request.filters[0].value, 'alpha');
+        assert.strictEqual('composing' in request.filters[0], false, 'the volatile marker is never a persisted ColumnFilter');
+        await f.host.receive(request);
+        const result = f.host.messages.filter(message => message.type === 'columnFiltersResult' && message.session === request.session).slice(-1)[0];
+        restored.window.dispatchEvent(new restored.window.MessageEvent('message', { data: result }));
+        assert.strictEqual(document.querySelector('table').getAttribute('aria-busy'), 'false');
+        assert.strictEqual(restored.window.csvColumnFilters.captureDraft().rows[0].composing, undefined);
+        assert.ok(!JSON.stringify(f.host.context.workspaceState.values).includes('未確定'));
+      } finally { restored?.close(); f.view.close(); }
+    }
+  });
+
+});
diff --git a/src/test/webview-navigation-scroll.test.ts b/src/test/webview-navigation-scroll.test.ts
new file mode 100644
index 0000000..a2d844d
--- /dev/null
+++ b/src/test/webview-navigation-scroll.test.ts
@@ -0,0 +1,327 @@
+import assert from 'assert';
+import fs from 'fs';
+import path from 'path';
+import { describe, it } from 'node:test';
+import { createEditorHarness } from './edit-integrity-harness';
+const { JSDOM } = require('jsdom');
+
+type Position = { left?: number; top?: number; behavior?: string };
+
+// This geometry model runs the shipped script. Smooth native scrolls remain
+// pending until explicitly completed; immediate scrolls cancel them, even at
+// zero delta. Keyboard animation frames are controlled independently.
+async function fixture(options: { separator?: string; rowCount?: number; columnCount?: number } = {}) {
+  const rowCount = options.rowCount ?? 40, columnCount = options.columnCount ?? 12;
+  const rows = Array.from({ length: rowCount }, (_, row) => Array.from({ length: columnCount }, (_, column) => `r${row}c${column}`));
+  const host = await createEditorHarness({ rows, separator: options.separator, header: false, serialIndex: false });
+  const dom = new JSDOM(host.panel.webview.html, { runScripts: 'outside-only', pretendToBeVisual: true });
+  const { window } = dom;
+  const container = window.document.querySelector('.table-container');
+  const table = container.querySelector('table');
+  const width = 240, height = 120, cellWidth = 80, cellHeight = 24;
+  const viewport = { left: 37.5, top: 29.25, right: 277.5, bottom: 149.25, width, height };
+  let scrollLeft = 0, scrollTop = 0, state: any = {};
+  let pendingSmooth: { left: number; top: number } | undefined;
+  let clock = 0, nextFrame = 1, nextTimer = 1;
+  const frames = new Map<number, (time: number) => void>();
+  const timers = new Map<number, () => void>();
+  const messages: any[] = [];
+  const scrollCalls: Array<Position> = [];
+  const focusCalls: Array<{ cell: any; options: any }> = [];
+  const renderedHeight = () => (Number(table.querySelector('tr:last-child [data-row]')?.getAttribute('data-row') ?? 0) + 1) * cellHeight;
+  const clamp = (value: number, maximum: number) => Math.max(0, Math.min(value, Math.max(0, maximum)));
+  const notifyScroll = () => container.dispatchEvent(new window.Event('scroll'));
+  const instant = (position: Position) => {
+    pendingSmooth = undefined;
+    if (position.left !== undefined) { scrollLeft = clamp(position.left, columnCount * cellWidth - width); }
+    if (position.top !== undefined) { scrollTop = clamp(position.top, renderedHeight() - height); }
+    notifyScroll();
+  };
+  const scroll = (position: Position) => {
+    scrollCalls.push({ ...position });
+    const left = clamp(position.left ?? scrollLeft, columnCount * cellWidth - width);
+    const top = clamp(position.top ?? scrollTop, renderedHeight() - height);
+    if (position.behavior === 'smooth') {
+      // A no-op smooth reveal does not cancel an already running native scroll.
+      if (left !== scrollLeft || top !== scrollTop) { pendingSmooth = { left, top }; }
+    } else { instant({ left, top }); }
+  };
+  Object.defineProperties(container, {
+    clientWidth: { get: () => width }, clientHeight: { get: () => height },
+    clientLeft: { get: () => 0 }, clientTop: { get: () => 0 },
+    scrollWidth: { get: () => columnCount * cellWidth }, scrollHeight: { get: renderedHeight },
+    scrollLeft: { get: () => scrollLeft, set: (value: number) => instant({ left: value }) },
+    scrollTop: { get: () => scrollTop, set: (value: number) => instant({ top: value }) }
+  });
+  container.getBoundingClientRect = () => ({ ...viewport });
+  container.scrollTo = scroll;
+  window.scrollTo = scroll;
+  window.requestAnimationFrame = (callback: (time: number) => void) => { const id = nextFrame++; frames.set(id, callback); return id; };
+  window.cancelAnimationFrame = (id: number) => { frames.delete(id); };
+  window.setTimeout = (callback: () => void) => { const id = nextTimer++; timers.set(id, callback); return id; };
+  window.clearTimeout = (id: number) => { timers.delete(id); };
+  window.IntersectionObserver = class { observe() {} disconnect() {} };
+  window.acquireVsCodeApi = () => ({ postMessage: (message: any) => messages.push(message), getState: () => state, setState: (value: any) => { state = value; } });
+  const nativeRect = window.HTMLElement.prototype.getBoundingClientRect;
+  window.HTMLElement.prototype.getBoundingClientRect = function (this: any) {
+    if (!this.hasAttribute('data-row') || !this.hasAttribute('data-col')) { return nativeRect.call(this); }
+    const row = Number(this.getAttribute('data-row')), column = Number(this.getAttribute('data-col'));
+    let left = column * cellWidth - scrollLeft, top = row * cellHeight - scrollTop;
+    if (this.style.position === 'sticky') {
+      if (this.style.left !== '') { left = Math.max(left, Number.parseFloat(this.style.left)); }
+      if (this.style.top !== '') { top = Math.max(top, Number.parseFloat(this.style.top)); }
+    }
+    left += viewport.left;
+    top += viewport.top;
+    return { left, top, right: left + cellWidth, bottom: top + cellHeight, width: cellWidth, height: cellHeight };
+  };
+  window.HTMLElement.prototype.scrollIntoView = function (this: any, settings: any = {}) {
+    const rect = this.getBoundingClientRect();
+    const nearest = (start: number, end: number, low: number, high: number) => start < low ? start - low : end > high ? end - high : 0;
+    scroll({
+      left: scrollLeft + (settings.inline === 'center' ? (rect.left + rect.right - viewport.left - viewport.right) / 2 : nearest(rect.left, rect.right, viewport.left, viewport.right)),
+      top: scrollTop + (settings.block === 'center' ? (rect.top + rect.bottom - viewport.top - viewport.bottom) / 2 : nearest(rect.top, rect.bottom, viewport.top, viewport.bottom)),
+      behavior: settings.behavior
+    });
+  };
+  const nativeFocus = window.HTMLElement.prototype.focus;
+  window.HTMLElement.prototype.focus = function (this: any, settings: any) {
+    focusCalls.push({ cell: this, options: settings });
+    nativeFocus.call(this, settings);
+  };
+  const flush = () => {
+    for (let guard = 0; (frames.size || timers.size) && guard < 20; guard++) {
+      const pendingTimers = [...timers.values()];
+      timers.clear();
+      pendingTimers.forEach(callback => callback());
+      const callbacks = [...frames.values()];
+      frames.clear();
+      clock += 16;
+      callbacks.forEach(callback => callback(clock));
+    }
+    assert.ok(!frames.size && !timers.size, 'scheduled work settles without another key');
+  };
+  const finishSmooth = () => {
+    if (!pendingSmooth) { return; }
+    const position = pendingSmooth;
+    instant(position);
+  };
+  const scriptPath = process.env.CSV_NAVIGATION_TEST_SCRIPT || path.join(process.cwd(), 'media/main.js');
+  window.eval(`${fs.readFileSync(scriptPath, 'utf8')}\nwindow.navigationTestApi = { select: setSingleSelection, anchor: () => anchorCell, endpoint: () => rangeEndCell };`);
+  flush();
+  const cell = (row: number, column: number) => table.querySelector(`[data-row="${row}"][data-col="${column}"]`);
+  const select = (row: number, column: number) => {
+    window.navigationTestApi.select(cell(row, column));
+    flush();
+    finishSmooth(); // settle only the explicit starting selection, before held keys
+    scrollCalls.length = 0;
+    focusCalls.length = 0;
+  };
+  const key = (name: string, settings: Record<string, unknown> = {}) => {
+    const event = new window.KeyboardEvent('keydown', { key: name, bubbles: true, cancelable: true, ...settings });
+    window.document.activeElement.dispatchEvent(event);
+    return event;
+  };
+  const visible = (target: any, topInset = 0, leftInset = 0) => {
+    const rect = target.getBoundingClientRect();
+    assert.ok(rect.top >= viewport.top + topInset && rect.bottom <= viewport.bottom, `row ${target.getAttribute('data-row')} must remain in the usable viewport`);
+    assert.ok(rect.left >= viewport.left + leftInset && rect.right <= viewport.right, `column ${target.getAttribute('data-col')} must remain in the usable viewport`);
+  };
+  return { host, window, container, table, messages, scrollCalls, focusCalls, cell, select, key, flush, finishSmooth, visible,
+    get state() { return state; }, get pendingSmooth() { return pendingSmooth; }, get frameCount() { return frames.size; },
+    anchor: () => window.navigationTestApi.anchor(), endpoint: () => window.navigationTestApi.endpoint(),
+    close: () => window.close() };
+}
+
+describe('Keyboard navigation viewport reveal', () => {
+  for (const separator of [',', '\t']) {
+    it(`keeps held vertical arrows revealed at every paint without a fresh key (${JSON.stringify(separator)})`, async () => {
+      const view = await fixture({ separator });
+      try {
+        view.select(0, 0);
+        for (let row = 1; row <= 16; row++) {
+          assert.strictEqual(view.key('ArrowDown', { repeat: row > 1 }).defaultPrevented, true);
+          view.flush();
+          assert.strictEqual(view.window.document.activeElement, view.cell(row, 0));
+          view.visible(view.cell(row, 0));
+        }
+        assert.strictEqual(view.pendingSmooth, undefined);
+        assert.ok(view.scrollCalls.every(call => call.behavior !== 'smooth'));
+        assert.deepStrictEqual(view.host.rows()[0][0], 'r0c0');
+        assert.strictEqual(view.host.document.version, 1);
+      } finally { view.close(); }
+    });
+  }
+
+  it('coalesces a burst to its newest horizontal target and reveals reversals', async () => {
+    const view = await fixture();
+    try {
+      view.select(1, 0);
+      for (let column = 1; column <= 10; column++) { view.key('ArrowRight', { repeat: true }); }
+      assert.strictEqual(view.window.document.activeElement, view.cell(1, 10));
+      assert.strictEqual(view.frameCount, 1, 'one pending reveal for the newest target');
+      view.flush();
+      assert.strictEqual(view.scrollCalls.length, 1);
+      view.visible(view.cell(1, 10));
+      for (let column = 9; column >= 1; column--) {
+        view.key('ArrowLeft', { repeat: true });
+        view.flush();
+        view.visible(view.cell(1, column));
+      }
+      assert.strictEqual(view.window.document.activeElement, view.cell(1, 1));
+      assert.strictEqual(view.pendingSmooth, undefined);
+    } finally { view.close(); }
+  });
+
+  it('cancels an older native smooth scroll even when the new target is already visible', async () => {
+    const view = await fixture();
+    try {
+      view.select(0, 0);
+      view.container.scrollTo({ top: 700, left: 700, behavior: 'smooth' });
+      assert.ok(view.pendingSmooth);
+      view.key('ArrowRight');
+      view.flush();
+      assert.strictEqual(view.pendingSmooth, undefined);
+      view.finishSmooth();
+      assert.strictEqual(view.container.scrollTop, 0);
+      assert.strictEqual(view.container.scrollLeft, 0);
+      view.visible(view.cell(0, 1));
+    } finally { view.close(); }
+  });
+
+  it('keeps the Shift endpoint revealed while focus and persisted anchor remain fixed', async () => {
+    const view = await fixture();
+    try {
+      view.select(1, 1);
+      for (let row = 2; row <= 15; row++) {
+        view.key('ArrowDown', { shiftKey: true, repeat: true });
+        view.flush();
+        view.visible(view.cell(row, 1));
+        assert.strictEqual(view.window.document.activeElement, view.cell(1, 1));
+      }
+      for (let column = 2; column <= 8; column++) {
+        view.key('ArrowRight', { shiftKey: true, repeat: true });
+        view.flush();
+        view.visible(view.cell(15, column));
+      }
+      assert.strictEqual(view.endpoint(), view.cell(15, 8));
+      assert.strictEqual(view.anchor(), view.cell(1, 1));
+      assert.strictEqual(view.state.anchorRow, 1);
+      assert.strictEqual(view.state.anchorCol, 1);
+      assert.strictEqual(view.window.document.querySelectorAll('td.selected').length, 15 * 8);
+      assert.ok(view.focusCalls.every(call => call.options?.preventScroll === true));
+    } finally { view.close(); }
+  });
+
+  it('reveals a quick-edit commit and subsequent repeat navigation without saving or re-entering edit', async () => {
+    const view = await fixture();
+    try {
+      view.select(3, 1);
+      view.key('x');
+      assert.strictEqual(view.cell(3, 1).getAttribute('contenteditable'), 'true');
+      for (let row = 4; row <= 14; row++) {
+        view.key('ArrowDown', { repeat: row > 4 });
+        view.flush();
+        view.visible(view.cell(row, 1));
+      }
+      const edits = view.messages.filter(message => message.type === 'editCell');
+      assert.strictEqual(edits.length, 1);
+      assert.strictEqual(edits[0].value, 'x');
+      assert.strictEqual(view.window.document.activeElement, view.cell(14, 1));
+      assert.strictEqual(view.window.document.querySelector('[contenteditable="true"]'), null);
+      assert.ok(!view.messages.some(message => message.type === 'save'));
+    } finally { view.close(); }
+  });
+
+  it('persists final scroll/focus after repetition and restores without viewport drift', async () => {
+    const view = await fixture();
+    try {
+      view.select(0, 0);
+      for (let index = 0; index < 12; index++) { view.key('ArrowDown', { repeat: true }); }
+      for (let index = 0; index < 7; index++) { view.key('ArrowRight', { repeat: true }); }
+      view.flush();
+      const top = view.container.scrollTop, left = view.container.scrollLeft;
+      assert.ok(top > 0 && left > 0);
+      view.window.dispatchEvent(new view.window.Event('blur'));
+      assert.strictEqual(view.state.scrollY, top);
+      assert.strictEqual(view.state.scrollX, left);
+      assert.strictEqual(view.state.anchorRow, 12);
+      assert.strictEqual(view.state.anchorCol, 7);
+      view.window.dispatchEvent(new view.window.Event('focus'));
+      view.flush();
+      assert.strictEqual(view.container.scrollTop, top);
+      assert.strictEqual(view.container.scrollLeft, left);
+      assert.strictEqual(view.window.document.activeElement, view.cell(12, 7));
+      view.visible(view.cell(12, 7));
+      assert.ok(view.focusCalls.every(call => call.options?.preventScroll === true));
+    } finally { view.close(); }
+  });
+
+  it('reveals a modified jump and a following reversal from the latest target', async () => {
+    const view = await fixture();
+    try {
+      view.select(3, 1);
+      view.key('ArrowRight', { metaKey: true });
+      view.flush();
+      view.visible(view.cell(3, 11));
+      assert.strictEqual(view.window.document.activeElement, view.cell(3, 11));
+      view.key('ArrowLeft', { repeat: true });
+      view.key('ArrowUp', { repeat: true });
+      view.flush();
+      view.visible(view.cell(2, 10));
+      assert.strictEqual(view.pendingSmooth, undefined);
+    } finally { view.close(); }
+  });
+
+  it('keeps navigation visible at the existing loaded-chunk boundary without mutating rows', async () => {
+    const view = await fixture({ rowCount: 1100, columnCount: 2 });
+    try {
+      const last = Number(view.table.querySelector('tr:last-child [data-row]').getAttribute('data-row'));
+      assert.ok(last < 1099);
+      view.select(last - 2, 1);
+      for (let index = 0; index < 6; index++) { view.key('ArrowDown', { repeat: true }); view.flush(); }
+      assert.strictEqual(view.window.document.activeElement, view.cell(last, 1));
+      view.visible(view.cell(last, 1));
+      assert.strictEqual(view.host.rows().length, 1100);
+      assert.strictEqual(view.host.document.version, 1);
+      assert.ok(!view.messages.some(message => message.type === 'editCell'));
+    } finally { view.close(); }
+  });
+
+  it('reveals ordinary endpoints beyond sticky rows and columns without scrolling a frozen axis', async () => {
+    const view = await fixture();
+    try {
+      for (const row of Array.from(view.table.rows) as any[]) {
+        for (const cell of Array.from(row.cells) as any[]) {
+          const r = Number(cell.getAttribute('data-row')), column = Number(cell.getAttribute('data-col'));
+          if (r < 2) { cell.classList.add('csv-frozen-row'); cell.style.position = 'sticky'; cell.style.top = `${r * 24}px`; }
+          if (column === 0) { cell.classList.add('csv-frozen-column'); cell.style.position = 'sticky'; cell.style.left = '0px'; }
+        }
+      }
+      view.select(2, 1);
+      for (let index = 0; index < 12; index++) { view.key('ArrowDown', { repeat: true }); }
+      for (let index = 0; index < 7; index++) { view.key('ArrowRight', { repeat: true }); }
+      view.flush();
+      view.visible(view.cell(14, 8), 48, 80);
+      const frozenTop = view.container.scrollTop, frozenLeft = view.container.scrollLeft;
+      assert.ok(frozenTop > 0 && frozenLeft > 0);
+      view.window.navigationTestApi.select(view.cell(1, 8));
+      view.flush();
+      assert.strictEqual(view.container.scrollTop, frozenTop, 'frozen row selection keeps the scrolled vertical axis');
+      view.window.navigationTestApi.select(view.cell(14, 0));
+      view.flush();
+      assert.strictEqual(view.container.scrollLeft, frozenLeft, 'frozen column selection keeps the scrolled horizontal axis');
+      view.window.navigationTestApi.select(view.cell(14, 8));
+      view.flush();
+      for (let index = 0; index < 12; index++) { view.key('ArrowUp', { repeat: true }); }
+      for (let index = 0; index < 7; index++) { view.key('ArrowLeft', { repeat: true }); }
+      view.flush();
+      view.visible(view.cell(2, 1), 48, 80);
+      const top = view.container.scrollTop;
+      view.key('ArrowUp');
+      view.flush();
+      assert.strictEqual(view.container.scrollTop, top, 'a frozen target retains its own vertical axis');
+      view.visible(view.cell(1, 1));
+    } finally { view.close(); }
+  });
+});
diff --git a/src/test/webview-size-persistence.test.ts b/src/test/webview-size-persistence.test.ts
index 4399f1e..3ecdddd 100644
--- a/src/test/webview-size-persistence.test.ts
+++ b/src/test/webview-size-persistence.test.ts
@@ -13,7 +13,7 @@ describe('Webview size persistence', () => {
   });
 
   it('restores and reapplies size state after render/chunk loads', () => {
-    assert.ok(source.includes('columnSizeState = normalizeSizeState(st.columnSizes, 40);'));
+    assert.ok(source.includes('columnSizeState = normalizeSizeState(st.columnSizes ?? persistedColumnSizes, 40);'));
     assert.ok(source.includes('rowSizeState = normalizeSizeState(st.rowSizes, getMinRowHeight());'));
     assert.ok(source.includes('setZoomScale(restoredZoom ?? 1, false);'));
     assert.ok(source.includes('applySizeStateToRenderedCells();'));
diff --git a/src/untitled-editors.ts b/src/untitled-editors.ts
new file mode 100644
index 0000000..af1a629
--- /dev/null
+++ b/src/untitled-editors.ts
@@ -0,0 +1,189 @@
+import * as vscode from 'vscode';
+import { CsvEditorProvider } from './CsvEditorProvider';
+
+export const untitledCsvViewType = 'csv.untitledEditor';
+
+type UntitledEditor = {
+  document: vscode.TextDocument;
+  panel: vscode.WebviewPanel;
+};
+const editors = new Map<string, UntitledEditor>();
+const opened = new Set<string>();
+const switchingToSource = new Set<string>();
+let extensionContext: vscode.ExtensionContext | undefined;
+
+export function isUntitledCsv(document: vscode.TextDocument): boolean {
+  return document.uri.scheme === 'untitled' && (document.languageId === 'csv' || document.languageId === 'tsv');
+}
+
+export function getActiveUntitledCsvEditor(): UntitledEditor | undefined {
+  return Array.from(editors.values()).find(editor => editor.panel.active && !editor.document.isClosed);
+}
+
+export function saveActiveUntitledCsvEditor(): void {
+  const editor = getActiveUntitledCsvEditor();
+  if (!editor) {
+    return;
+  }
+  CsvEditorProvider.editors.find(controller => controller.getDocumentUri().toString() === editor.document.uri.toString())
+    ?.saveUntitledAfterCommit();
+}
+
+export async function showActiveUntitledCsvSource(): Promise<void> {
+  const editor = getActiveUntitledCsvEditor();
+  if (!editor) {
+    return;
+  }
+  const key = editor.document.uri.toString();
+  if (switchingToSource.has(key)) {
+    return;
+  }
+  const controller = CsvEditorProvider.editors.find(candidate => candidate.getDocumentUri().toString() === key);
+  if (!controller) {
+    return;
+  }
+  switchingToSource.add(key);
+  try {
+    if (!await controller.commitPendingDraft() || editors.get(key) !== editor || editor.document.isClosed) {
+      return;
+    }
+    const source = await vscode.window.showTextDocument(editor.document, {
+      viewColumn: controller.getViewColumn() ?? editor.panel.viewColumn, preview: false
+    });
+    if (source.document === editor.document && editors.get(key) === editor) {
+      // The native owner remains open. Only its temporary standalone table closes.
+      editor.panel.dispose();
+    }
+  } catch (error) {
+    console.error('CSV: could not reveal the untitled source', error);
+    void vscode.window.showErrorMessage('CSV: Could not switch the untitled table to text.');
+  } finally {
+    switchingToSource.delete(key);
+  }
+}
+
+export async function openUntitledCsvEditor(document: vscode.TextDocument, viewColumn?: vscode.ViewColumn): Promise<void> {
+  if (!extensionContext || document.isClosed || !isUntitledCsv(document) ||
+    !vscode.workspace.getConfiguration('csv', document.uri).get<boolean>('enabled', true)) {
+    return;
+  }
+  const key = document.uri.toString();
+  const existing = editors.get(key);
+  if (existing) {
+    existing.panel.reveal(viewColumn);
+    return;
+  }
+  opened.add(key);
+  // A plain webview keeps the native untitled document as its owner. Asking
+  // vscode.openWith for an untitled custom text editor can reset that document.
+  const panel = vscode.window.createWebviewPanel(
+    untitledCsvViewType,
+    `${document.fileName.split(/[\\/]/).pop() || 'Untitled'} — CSV`,
+    viewColumn ?? vscode.ViewColumn.Active,
+    { enableScripts: true }
+  );
+  const tokenSource = new vscode.CancellationTokenSource();
+  editors.set(key, { document, panel });
+  panel.onDidDispose(() => {
+    editors.delete(key);
+    tokenSource.cancel();
+    tokenSource.dispose();
+    const active = CsvEditorProvider.currentActive;
+    if (active?.getDocumentUri().toString() === key) {
+      CsvEditorProvider.currentActive = undefined;
+    }
+  });
+  try {
+    await new CsvEditorProvider(extensionContext).resolveCustomTextEditor(document, panel, tokenSource.token);
+  } catch (error) {
+    opened.delete(key);
+    panel.dispose();
+    throw error;
+  }
+}
+
+export function registerUntitledCsvEditors(context: vscode.ExtensionContext): void {
+  extensionContext = context;
+  const maybeOpen = (document?: vscode.TextDocument) => {
+    const group = vscode.window.tabGroups.activeTabGroup;
+    const input = group?.activeTab?.input;
+    if (!(input instanceof vscode.TabInputText)) { return; }
+    const active = vscode.window.visibleTextEditors.find(editor => editor.viewColumn === group.viewColumn &&
+      editor.document.uri.toString() === input.uri.toString());
+    const owner = active?.document;
+    if (!owner || (document && owner.uri.toString() !== document.uri.toString()) ||
+        !isUntitledCsv(owner) || opened.has(owner.uri.toString())) { return; }
+    void openUntitledCsvEditor(owner, group.viewColumn).catch(error => {
+      console.error('CSV: could not open the untitled table', error);
+      vscode.window.showErrorMessage('CSV: Could not open the untitled document in the table view.');
+    });
+  };
+  context.subscriptions.push(
+    vscode.window.onDidChangeActiveTextEditor(editor => maybeOpen(editor?.document)),
+    vscode.workspace.onDidOpenTextDocument(document => {
+      if (document.uri.scheme !== 'untitled') {
+        return;
+      }
+      if (!isUntitledCsv(document)) {
+        opened.delete(document.uri.toString());
+      }
+      maybeOpen(document);
+    }),
+    vscode.workspace.onDidCloseTextDocument(document => {
+      const key = document.uri.toString();
+      if (!editors.has(key) && !opened.has(key)) {
+        return;
+      }
+      // Changing language also closes/reopens a TextDocument at the same URI.
+      setTimeout(() => {
+        const replacement = vscode.workspace.textDocuments.find(candidate => candidate.uri.toString() === key && !candidate.isClosed);
+        const editor = editors.get(key);
+        if (replacement) {
+          if (editor) {
+            editor.document = replacement;
+            CsvEditorProvider.editors.filter(controller => controller.getDocumentUri().toString() === key)
+              .forEach(controller => {
+                controller.updateDocumentReference(replacement);
+                if (!isUntitledCsv(replacement)) {
+                  controller.revealSourceAfterCommit('language');
+                }
+              });
+          }
+          return;
+        }
+        editor?.panel.dispose();
+        opened.delete(key);
+      }, 0);
+    }),
+    vscode.workspace.onDidChangeConfiguration(event => {
+      if (!event.affectsConfiguration('csv.enabled')) {
+        return;
+      }
+      if (!vscode.workspace.getConfiguration('csv').get<boolean>('enabled', true)) {
+        editors.forEach(editor => {
+          const controller = CsvEditorProvider.editors.find(candidate => candidate.getDocumentUri().toString() === editor.document.uri.toString());
+          if (controller) {
+            controller.revealSourceAfterCommit();
+            return;
+          }
+          // Its native owner was retained when the temporary grid opened.
+          // No controller/draft exists yet, so cancel initialization without
+          // racing committed handoffs with a second native open.
+          editor.panel.dispose();
+        });
+        return;
+      }
+      opened.clear();
+      editors.forEach((_editor, key) => opened.add(key));
+      maybeOpen();
+    }),
+    { dispose: () => {
+      editors.forEach(editor => editor.panel.dispose());
+      editors.clear();
+      opened.clear();
+      switchingToSource.clear();
+      extensionContext = undefined;
+    } }
+  );
+  maybeOpen();
+}