diff --git a/README.md b/README.md
index 262e4a9..08a0ae9 100644
--- a/README.md
+++ b/README.md
@@ -69,6 +69,8 @@ npm test
 
 ## Shortcuts
 
+The toolbar **Shortcuts** button lets you replace command and grid-scrolling shortcuts or restore each shortcut to its default. Assigning an occupied key moves it to the new command and removes it from the previous command. Changes are applied only after choosing **Save** in the shortcut window; **Cancel** discards them.
+
 - `Ctrl+O`: open file
 - `Ctrl+S`: save
 - `Ctrl+Shift+S`: save as
@@ -87,6 +89,9 @@ npm test
 - `Ctrl+Plus`: zoom in
 - `Ctrl+Minus`: zoom out
 - `Ctrl+0`: reset zoom
+- `PageUp` / `PageDown`: scroll one grid page vertically
+- `Home` / `End`: scroll to the top or bottom of the grid
+- `Shift+Home` / `Shift+End`: scroll to the left or right edge of the grid
 - `Enter` / `F2`: edit cell
 - `Escape`: cancel edit
 - `Tab` / `Shift+Tab`: move horizontally after edit
diff --git a/index.html b/index.html
index 062f541..a65c085 100644
--- a/index.html
+++ b/index.html
@@ -45,6 +45,7 @@
             <button class="toggle-button" data-command="toggle-freeze-row">Freeze Row</button>
             <button class="toggle-button" data-command="toggle-freeze-column">Freeze Column</button>
             <button data-command="open-app-settings">Settings</button>
+            <button data-command="open-shortcut-settings">Shortcuts</button>
           </section>
           <section id="gridHost" class="grid-host" tabindex="0" aria-label="Virtual table editor">
             <canvas id="gridCanvas"></canvas>
@@ -79,7 +80,7 @@
     <div id="searchPanel" class="modal-backdrop search-backdrop hidden" role="dialog" aria-modal="true" aria-labelledby="searchTitle">
       <div class="modal search-modal">
         <h2 id="searchTitle">Find</h2>
-        <input id="searchInput" class="modal-input" placeholder="Search in current table" />
+        <input id="searchInput" class="modal-input" type="search" placeholder="Search in current table" autocomplete="off" spellcheck="false" />
         <fieldset class="search-scope" aria-label="Search scope">
           <label><input type="radio" name="searchScope" value="all" checked /> All cells</label>
           <label><input type="radio" name="searchScope" value="column-titles" /> Column only</label>
diff --git a/src/app.js b/src/app.js
index d34fb28..53571af 100644
--- a/src/app.js
+++ b/src/app.js
@@ -45,6 +45,7 @@ import { createLegacyLintController } from "./ui/controllers/legacy-lint-control
 import { createLspController } from "./ui/controllers/lsp-controller.js";
 import { createSearchController } from "./ui/controllers/search-controller.js";
 import { createSettingsController } from "./ui/controllers/settings-controller.js";
+import { createShortcutSettingsController } from "./ui/controllers/shortcut-settings-controller.js";
 import { createShellController } from "./ui/controllers/shell-controller.js";
 const { state, savedTheme, savedGridFont, savedPanelState } = createInitialAppState({ storage: localStorage });
 const {
@@ -235,6 +236,13 @@ const settingsController = createSettingsController({
   showError,
   escapeHtml
 });
+const shortcutSettingsController = createShortcutSettingsController({
+  state,
+  els,
+  storage: localStorage,
+  showToast,
+  escapeHtml
+});
 const documentController = createDocumentController({
   state,
   els,
@@ -331,6 +339,7 @@ const commandController = createCommandController({
     toggleSidebar,
     toggleTheme: settingsController.toggleTheme,
     showAppSettings: settingsController.showAppSettings,
+    showShortcutSettings: shortcutSettingsController.showShortcutSettings,
     showSettings: settingsController.showSettings,
     goToDefinition: lspController.goToDefinition,
     loadFixture: documentController.loadFixture,
@@ -388,6 +397,7 @@ const eventController = createAppEventController({
   grid,
   commands,
   documentController,
+  hasOpenDocument,
   searchController,
   syncDockLayout,
   wirePaneResizers,
@@ -410,7 +420,8 @@ const eventController = createAppEventController({
   showPalette,
   copySelection,
   cutSelection,
-  pasteSelection
+  pasteSelection,
+  selectAll
 });
 renderChrome();
 eventController.wireEvents();
diff --git a/src/styles.css b/src/styles.css
index a2c8f58..18d2262 100644
--- a/src/styles.css
+++ b/src/styles.css
@@ -1609,6 +1609,119 @@ details:not([open]) .problem-file-header::before {
   width: min(520px, calc(100vw - 32px));
 }
 
+.shortcut-modal {
+  width: min(720px, calc(100vw - 32px));
+  max-height: min(760px, calc(100vh - 32px));
+  display: flex;
+  flex-direction: column;
+}
+
+.shortcut-settings-hint {
+  margin: 4px 0 12px;
+  color: var(--muted);
+  font-size: 12px;
+}
+
+.shortcut-settings-list {
+  flex: 1 1 auto;
+  min-height: 0;
+  overflow: auto;
+  border: 1px solid var(--line-soft);
+  border-radius: 7px;
+  background: var(--surface-1);
+}
+
+.shortcut-group h3 {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+  margin: 0;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--line-soft);
+  background: var(--surface-3);
+  color: var(--text-strong);
+  font-size: 12px;
+  font-weight: 600;
+}
+
+.shortcut-row {
+  display: grid;
+  grid-template-columns: minmax(180px, 1fr) minmax(190px, 1.2fr) 64px;
+  align-items: center;
+  gap: 8px;
+  min-height: 42px;
+  padding: 5px 10px;
+  border-bottom: 1px solid var(--line-soft);
+}
+
+.shortcut-group:last-child .shortcut-row:last-child {
+  border-bottom: 0;
+}
+
+.shortcut-command-label {
+  min-width: 0;
+  overflow: hidden;
+  color: var(--text);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.shortcut-capture,
+.shortcut-default {
+  height: 30px;
+  border: 1px solid var(--button-border);
+  border-radius: 5px;
+  background: var(--button-bg);
+  color: var(--text);
+}
+
+.shortcut-capture {
+  padding: 0 10px;
+  overflow: hidden;
+  font-family: var(--grid-font);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.shortcut-capture.recording {
+  border-color: var(--accent);
+  outline: 1px solid var(--accent);
+  color: var(--text-strong);
+}
+
+.shortcut-row-message {
+  grid-column: 1 / -1;
+  margin: -1px 0 3px;
+  color: var(--warningText, #d7a56d);
+  font-size: 12px;
+  line-height: 1.35;
+}
+
+.toolbar button:disabled {
+  cursor: default;
+  opacity: .45;
+}
+
+.shortcut-modal-actions {
+  align-items: center;
+  flex: 0 0 auto;
+  padding-top: 10px;
+}
+
+.shortcut-actions-spacer {
+  flex: 1;
+}
+
+@media (max-width: 620px) {
+  .shortcut-row {
+    grid-template-columns: 1fr 64px;
+  }
+
+  .shortcut-command-label {
+    grid-column: 1 / -1;
+  }
+}
+
 .settings-stack {
   display: grid;
   gap: 12px;
diff --git a/src/ui/app-startup-state.js b/src/ui/app-startup-state.js
index e5af259..76f6d6a 100644
--- a/src/ui/app-startup-state.js
+++ b/src/ui/app-startup-state.js
@@ -18,6 +18,7 @@ import {
 import { initialSearchState } from "./search-policy.js";
 import { normaliseGridFont } from "./app-settings-policy.js";
 import { readJsonStorage } from "./app-runtime-utils.js";
+import { loadShortcutBindings } from "./shortcut-policy.js";
 
 export function createInitialAppState({ storage = localStorage } = {}) {
   const savedTheme = storage.getItem("txteditor.theme") === "light" ? "light" : "dark";
@@ -29,7 +30,7 @@ export function createInitialAppState({ storage = localStorage } = {}) {
   const savedLegacyLintSettings = normalizeLintSettings(readJsonStorage("txteditor.legacyLint.settings", createDefaultLintSettings()));
   const savedDockLayout = normalizeDockLayout(readJsonStorage(DOCK_LAYOUT_KEY, DEFAULT_DOCK_LAYOUT));
   const savedPanelState = panelStateFromStorage(storage, savedDockLayout);
-  const savedFreeze = readJsonStorage("txteditor.freeze", {});
+  const savedShortcuts = loadShortcutBindings(storage);
   const state = {
     docs: [],
     active: 0,
@@ -43,8 +44,8 @@ export function createInitialAppState({ storage = localStorage } = {}) {
     problemsWidth: savedPanelState.problemsWidth,
     problemsHeight: savedPanelState.problemsHeight,
     dockLayout: savedPanelState.dockLayout,
-    freezeRow: savedFreeze.row ?? false,
-    freezeColumn: savedFreeze.column ?? false,
+    freezeRow: false,
+    freezeColumn: false,
     contextHit: null,
     contextMenuActiveGroup: "",
     contextMenuOpen: false,
@@ -52,6 +53,7 @@ export function createInitialAppState({ storage = localStorage } = {}) {
     gridFont: savedGridFont,
     colorizeColumns: savedColorize,
     vectorLspHover: savedVectorLspHover,
+    shortcuts: savedShortcuts,
     lint: {
       engine: savedLintEngine,
       enabled: savedLintEnabled,
diff --git a/src/ui/canvas-grid.js b/src/ui/canvas-grid.js
index 4bd63f9..b401a48 100644
--- a/src/ui/canvas-grid.js
+++ b/src/ui/canvas-grid.js
@@ -4,7 +4,7 @@ import { boundedTableExtent, classifyGridHit, classifyPanePoint, classifyResizeH
 import { GridMetrics } from "./grid-metrics.js";
 import { cellBackground, cellTextColor, createGridRenderStats, initialColumnFitWidth, syncGridThemeFromStyle } from "./grid-render-policy.js";
 import { applyColumnSelection, applyRowSelection, applySelectionForHit, hasFullColumnRange, hasFullRowRange, keyboardSelectionTarget } from "./grid-selection-policy.js";
-import { applyGridScrollBounds, applyResizeDragState, centeredCellScrollState, centeredScrollOffset as centeredScrollOffsetPolicy, edgeCellScrollState } from "./grid-viewport-policy.js";
+import { applyGridScrollBounds, applyResizeDragState, centeredCellScrollState, centeredScrollOffset as centeredScrollOffsetPolicy, clampedGridScrollOffsets, edgeCellScrollState, wheelScrollOffsets } from "./grid-viewport-policy.js";
 import { drawGrid, drawGridActiveRowHeaderChrome, drawGridCell, drawGridDiagnosticMarker, drawGridRowHeader, fillGridText } from "./grid/grid-renderer.js";
 import {
   isGridHoverAllowed,
@@ -580,16 +580,6 @@ export class CanvasGrid {
   onKeyDown(event) {
     if (event.target === this.editor || this.editing) return;
     const key = event.key;
-    if (event.ctrlKey && key === "=") return this.zoomByKey(event, 0.1);
-    if (event.ctrlKey && (key === "+" || key === "Add")) return this.zoomByKey(event, 0.1);
-    if (event.ctrlKey && (key === "-" || key === "Subtract")) return this.zoomByKey(event, -0.1);
-    if (event.ctrlKey && key === "0") return this.zoomReset(event);
-    if (event.ctrlKey && key.toLowerCase() === "a") {
-      this.selection.selectAll(this.doc.rowCount, this.doc.columnCount);
-      event.preventDefault();
-      this.draw();
-      return;
-    }
     const editStart = keyboardEditStartAction(event);
     if (editStart.action === "start-edit") {
       event.preventDefault();
@@ -639,16 +629,6 @@ export class CanvasGrid {
     return next;
   }
 
-  zoomByKey(event, delta) {
-    event.preventDefault();
-    this.setZoom(this.doc.zoom + delta);
-  }
-
-  zoomReset(event) {
-    event.preventDefault();
-    this.setZoom(1);
-  }
-
   setZoom(value) {
     this.doc.zoom = clamp(Math.round(value * 10) / 10, 0.1, 8);
     this.layout();
@@ -793,7 +773,7 @@ export class CanvasGrid {
     if ("scrollTop" in scrollState && !options.preserveScrollTop) this.host.scrollTop = scrollState.scrollTop;
   }
 
-  scrollCellToCenter(row, column) {
+  scrollCellToCenter(row, column, options = {}) {
     const scrollState = centeredCellScrollState({
       row,
       column,
@@ -808,8 +788,56 @@ export class CanvasGrid {
       scrollableWidth: this.scrollableColumnWidth(),
       scrollableHeight: this.scrollableRowsHeight()
     });
-    if ("scrollLeft" in scrollState) this.host.scrollLeft = scrollState.scrollLeft;
-    if ("scrollTop" in scrollState) this.host.scrollTop = scrollState.scrollTop;
+    if ("scrollLeft" in scrollState && !options.preserveScrollLeft) this.host.scrollLeft = scrollState.scrollLeft;
+    if ("scrollTop" in scrollState && !options.preserveScrollTop) this.host.scrollTop = scrollState.scrollTop;
+  }
+
+  scrollByWheel(event = {}) {
+    this.scrollToOffsets(wheelScrollOffsets(event, { scrollLeft: this.host.scrollLeft, scrollTop: this.host.scrollTop, lineSize: this.rowHeight, pageWidth: this.host.clientWidth, pageHeight: this.gridPageHeight() }));
+  }
+  scrollToTop() {
+    this.scrollToOffsets({ scrollTop: 0 });
+  }
+
+  scrollToBottom() {
+    this.scrollToOffsets({ scrollTop: Number.MAX_SAFE_INTEGER });
+  }
+
+  scrollToLeft() {
+    this.scrollToOffsets({ scrollLeft: 0 });
+  }
+
+  scrollToRight() {
+    this.scrollToOffsets({ scrollLeft: Number.MAX_SAFE_INTEGER });
+  }
+
+  scrollPageUp() {
+    this.scrollToOffsets({ scrollTop: this.host.scrollTop - this.gridPageHeight() });
+  }
+
+  scrollPageDown() {
+    this.scrollToOffsets({ scrollTop: this.host.scrollTop + this.gridPageHeight() });
+  }
+
+  gridPageHeight() {
+    return Math.max(1, this.host.clientHeight - this.headerHeight - this.frozenRowHeight());
+  }
+
+  scrollToOffsets({ scrollLeft = this.host.scrollLeft, scrollTop = this.host.scrollTop }) {
+    const next = clampedGridScrollOffsets({
+      scrollLeft,
+      scrollTop,
+      rowHeaderWidth: this.rowHeaderWidth,
+      headerHeight: this.headerHeight,
+      frozenColumnWidth: this.frozenColumnWidth(),
+      frozenRowHeight: this.frozenRowHeight(),
+      scrollableColumnWidth: this.scrollableColumnWidth(),
+      scrollableRowsHeight: this.scrollableRowsHeight(),
+      viewportWidth: this.host.clientWidth,
+      viewportHeight: this.host.clientHeight
+    });
+    this.host.scrollLeft = next.scrollLeft;
+    this.host.scrollTop = next.scrollTop;
   }
 
   statusText() {
diff --git a/src/ui/command-registry.js b/src/ui/command-registry.js
index ecae3a6..28fa82c 100644
--- a/src/ui/command-registry.js
+++ b/src/ui/command-registry.js
@@ -47,6 +47,7 @@ export const COMMAND_LABELS_BASE = [
   ["toggle-sidebar", "Toggle Explorer"],
   ["toggle-theme", "Toggle Light/Dark Mode"],
   ["open-app-settings", "Settings"],
+  ["open-shortcut-settings", "Keyboard Shortcuts"],
   ["open-settings", "Lint Options"]
 ];
 
@@ -60,6 +61,7 @@ export const COMMANDS_AVAILABLE_WITHOUT_DOCUMENT = new Set([
   "open-folder",
   "open-settings",
   "open-app-settings",
+  "open-shortcut-settings",
   "toggle-sidebar",
   "toggle-theme",
   "toggle-colorize",
@@ -124,6 +126,7 @@ const COMMAND_ACTIONS = new Map([
   ["toggle-sidebar", { type: "handler", name: "toggleSidebar" }],
   ["toggle-theme", { type: "handler", name: "toggleTheme" }],
   ["open-app-settings", { type: "handler", name: "showAppSettings" }],
+  ["open-shortcut-settings", { type: "handler", name: "showShortcutSettings" }],
   ["open-settings", { type: "handler", name: "showSettings" }],
   ["go-to-definition", { type: "handler", name: "goToDefinition" }]
 ]);
diff --git a/src/ui/controllers/app-event-controller.js b/src/ui/controllers/app-event-controller.js
index 7a41699..7154f05 100644
--- a/src/ui/controllers/app-event-controller.js
+++ b/src/ui/controllers/app-event-controller.js
@@ -1,5 +1,5 @@
 import { isTauriRuntime } from "../../core/io.js";
-import { globalShortcutAction } from "../global-shortcut-policy.js";
+import { globalShortcutAction, gridScrollShortcutAction } from "../global-shortcut-policy.js";
 import { isTextInputTarget } from "../search-policy.js";
 
 export function createAppEventController({
@@ -8,6 +8,7 @@ export function createAppEventController({
   grid,
   commands,
   documentController,
+  hasOpenDocument,
   searchController,
   syncDockLayout,
   wirePaneResizers,
@@ -30,7 +31,8 @@ export function createAppEventController({
   showPalette,
   copySelection,
   cutSelection,
-  pasteSelection
+  pasteSelection,
+  selectAll
 }) {
   function wireEvents() {
     document.addEventListener("click", (event) => {
@@ -97,12 +99,33 @@ export function createAppEventController({
       els.host.focus();
       return;
     }
-    const shortcutAction = globalShortcutAction(event, { editingCell });
+    if (!editingCell && !isGridScrollShortcutBlocked(event.target)) {
+      const scrollAction = gridScrollShortcutAction(event, { shortcuts: state.shortcuts });
+      if (scrollAction && hasOpenDocument?.()) return runGridScrollShortcutAction(event, scrollAction);
+    }
+    const shortcutAction = globalShortcutAction(event, { editingCell, shortcuts: state.shortcuts });
     if (editingCell && !shortcutAction) return;
     if (!editingCell && isTextInputTarget(event.target)) return;
     if (shortcutAction) return runGlobalShortcutAction(event, shortcutAction);
   }
 
+  function isGridScrollShortcutBlocked(target) {
+    if (isTextInputTarget(target)) return true;
+    const ElementCtor = globalThis.Element;
+    if (!ElementCtor || !(target instanceof ElementCtor)) return false;
+    return Boolean(target.closest(".modal, .modal-backdrop, .palette"));
+  }
+
+  function runGridScrollShortcutAction(event, action) {
+    if (action === "scroll-top") return prevent(event, () => grid.scrollToTop());
+    if (action === "scroll-bottom") return prevent(event, () => grid.scrollToBottom());
+    if (action === "scroll-left") return prevent(event, () => grid.scrollToLeft());
+    if (action === "scroll-right") return prevent(event, () => grid.scrollToRight());
+    if (action === "scroll-page-up") return prevent(event, () => grid.scrollPageUp());
+    if (action === "scroll-page-down") return prevent(event, () => grid.scrollPageDown());
+    return undefined;
+  }
+
   function runGlobalShortcutAction(event, action) {
     if (action === "zoom-in") return prevent(event, () => runCommand("zoom-in"));
     if (action === "zoom-out") return prevent(event, () => runCommand("zoom-out"));
@@ -121,6 +144,7 @@ export function createAppEventController({
     if (action === "copy") return prevent(event, copySelection);
     if (action === "cut") return prevent(event, cutSelection);
     if (action === "paste") return prevent(event, pasteSelection);
+    if (action === "select-all") return prevent(event, selectAll);
     if (action === "clear-selection") return prevent(event, () => runCommand("clear-selection"));
     return undefined;
   }
diff --git a/src/ui/controllers/command-surface-controller.js b/src/ui/controllers/command-surface-controller.js
index c43bf19..4695f79 100644
--- a/src/ui/controllers/command-surface-controller.js
+++ b/src/ui/controllers/command-surface-controller.js
@@ -10,6 +10,7 @@ import {
   contextMenuHiddenState,
   contextMenuOpenTransition
 } from "../context-menu-policy.js";
+import { shortcutDisplayForAction } from "../shortcut-policy.js";
 
 export function createCommandSurfaceController({
   state,
@@ -60,9 +61,9 @@ export function createCommandSurfaceController({
       { type: "submenu", label: "Fill", items: fillCommandItems() },
       { type: "submenu", label: "Math", items: mathCommandItems() },
       { id: "go-to-definition", label: "Go To Definition", disabled: !cellHasReference(focusRow, focusCol) },
-      { id: "cut", label: "Cut", shortcut: "Ctrl+X" },
-      { id: "copy", label: "Copy", shortcut: "Ctrl+C" },
-      { id: "paste", label: "Paste", shortcut: "Ctrl+V" }
+      { id: "cut", label: "Cut", shortcut: shortcutDisplayForAction("cut", state.shortcuts) },
+      { id: "copy", label: "Copy", shortcut: shortcutDisplayForAction("copy", state.shortcuts) },
+      { id: "paste", label: "Paste", shortcut: shortcutDisplayForAction("paste", state.shortcuts) }
     ];
     els.contextMenu.innerHTML = entries.map(menuEntry).join("");
     for (const button of els.contextMenu.querySelectorAll("button[data-run]")) {
diff --git a/src/ui/controllers/document-controller.js b/src/ui/controllers/document-controller.js
index 3d9e5ac..60ce787 100644
--- a/src/ui/controllers/document-controller.js
+++ b/src/ui/controllers/document-controller.js
@@ -104,8 +104,13 @@ export function createDocumentController({
       state.active = plan.activeIndex;
       grid.setDocument(activeDoc());
       renderChrome();
+      focusGrid();
       return;
     }
+    if (!state.docs.length) {
+      state.freezeRow = false;
+      state.freezeColumn = false;
+    }
     resetUndoManagerForDocument(doc);
     doc.zoom = 1;
     state.docs.push(doc);
@@ -126,6 +131,7 @@ export function createDocumentController({
     }
     renderChrome();
     scrollProblemsToActiveFile();
+    focusGrid();
     if (doc.largeFileMode) return;
     if (documentOpenSyncRoute(state.lint.engine) === "vector-open") {
       lspOpenDoc(doc).catch((error) => reportLspOpenFailure(doc, error, "document-open"));
@@ -310,6 +316,8 @@ export function createDocumentController({
     state.docs.splice(index, 1);
     if (!state.docs.length) {
       state.active = -1;
+      state.freezeRow = false;
+      state.freezeColumn = false;
       grid.setDocument(emptyDoc);
     } else {
       state.active = activeIndexAfterTabClose({
@@ -336,6 +344,10 @@ export function createDocumentController({
     grid.commitEdit?.();
   }
 
+  function focusGrid() {
+    els.host?.focus?.();
+  }
+
   async function showOpeningFeedback(message) {
     state.lint.status = message;
     renderChrome();
diff --git a/src/ui/controllers/grid-command-controller.js b/src/ui/controllers/grid-command-controller.js
index 85ea5c0..0aa7c29 100644
--- a/src/ui/controllers/grid-command-controller.js
+++ b/src/ui/controllers/grid-command-controller.js
@@ -26,7 +26,6 @@ export function createGridCommandController({
     if (!hasOpenDocument()) return;
     if (kind === "row") state.freezeRow = !state.freezeRow;
     if (kind === "column") state.freezeColumn = !state.freezeColumn;
-    localStorage.setItem("txteditor.freeze", JSON.stringify({ row: state.freezeRow, column: state.freezeColumn }));
     applyFreezeToDoc(activeDoc());
     grid.layout();
     renderChrome();
diff --git a/src/ui/controllers/search-controller.js b/src/ui/controllers/search-controller.js
index 649113d..5f9f2e8 100644
--- a/src/ui/controllers/search-controller.js
+++ b/src/ui/controllers/search-controller.js
@@ -42,7 +42,7 @@ export function createSearchController({ state, els, grid, activeDoc, updateActi
     Object.assign(state.search, searchStateAfterFind(query, scope));
     state.selection.set(target.row, target.column);
     saveSelectionState();
-    grid.scrollCellIntoView(target.row, target.column, searchScrollOptionsForScope(scope));
+    grid.scrollCellToCenter(target.row, target.column, searchScrollOptionsForScope(scope));
     grid.draw();
     updateActiveProblemHighlight();
     els.searchStatus.textContent = searchStatusText(scope, found, target);
@@ -75,6 +75,11 @@ export function createSearchController({ state, els, grid, activeDoc, updateActi
     els.searchPanel.addEventListener("click", (event) => {
       if (event.target === els.searchPanel || event.target.closest("[data-search-close]")) closeSearch();
     });
+    els.searchPanel.addEventListener("wheel", (event) => {
+      if (event.ctrlKey) return;
+      event.preventDefault();
+      grid.scrollByWheel(event);
+    }, { passive: false });
   }
 
   return {
diff --git a/src/ui/controllers/shell-controller.js b/src/ui/controllers/shell-controller.js
index 5fb2094..a5ba773 100644
--- a/src/ui/controllers/shell-controller.js
+++ b/src/ui/controllers/shell-controller.js
@@ -33,6 +33,7 @@ export function createShellController({
 
   function renderChrome() {
     const started = perfNow();
+    const documentOpen = hasOpenDocument();
     bindExplorerFilter();
     syncDockLayout();
     els.shell.classList.toggle("sidebar-hidden", !state.sidebarVisible);
@@ -44,7 +45,7 @@ export function createShellController({
     }
     if (els.problemsList) els.problemsList.classList.toggle("hidden", state.bottomTab !== "problems");
     if (els.logList) els.logList.classList.toggle("hidden", state.bottomTab !== "log");
-    els.emptyState.classList.toggle("hidden", hasOpenDocument());
+    els.emptyState.classList.toggle("hidden", documentOpen);
     updateGridDiagnostics();
     for (const button of documentRef.querySelectorAll("[data-command='show-explorer']")) {
       button.classList.toggle("active", state.sidebarVisible);
@@ -63,10 +64,12 @@ export function createShellController({
       button.title = state.lint.diagnostics.length ? `Problems (${state.lint.diagnostics.length})` : "Problems";
     }
     for (const button of documentRef.querySelectorAll("[data-command='toggle-freeze-row']")) {
-      button.classList.toggle("active", state.freezeRow);
+      button.disabled = !documentOpen;
+      button.classList.toggle("active", documentOpen && state.freezeRow);
     }
     for (const button of documentRef.querySelectorAll("[data-command='toggle-freeze-column']")) {
-      button.classList.toggle("active", state.freezeColumn);
+      button.disabled = !documentOpen;
+      button.classList.toggle("active", documentOpen && state.freezeColumn);
     }
     for (const button of documentRef.querySelectorAll("[data-command='toggle-colorize']")) {
       button.classList.toggle("active", state.colorizeColumns);
@@ -136,6 +139,7 @@ export function createShellController({
     renderChrome();
     scrollProblemsToActiveFile();
     scheduleHoverPrewarm("tab-switch");
+    els.host?.focus?.();
   }
 
   function bindExplorerFilter() {
diff --git a/src/ui/controllers/shortcut-settings-controller.js b/src/ui/controllers/shortcut-settings-controller.js
new file mode 100644
index 0000000..1d41319
--- /dev/null
+++ b/src/ui/controllers/shortcut-settings-controller.js
@@ -0,0 +1,190 @@
+import {
+  SHORTCUT_DEFINITIONS,
+  cloneShortcutBindings,
+  defaultShortcutBindings,
+  saveShortcutBindings,
+  shortcutChordFromEvent,
+  shortcutConflicts,
+  shortcutDisplayForAction,
+  validateShortcutChord
+} from "../shortcut-policy.js";
+
+export function createShortcutSettingsController({
+  state,
+  els,
+  storage = localStorage,
+  showToast = () => {},
+  escapeHtml
+}) {
+  function showShortcutSettings() {
+    let draft = cloneShortcutBindings(state.shortcuts);
+    let recordingAction = null;
+    let closed = false;
+    const rowMessages = new Map();
+    const definitionByAction = new Map(SHORTCUT_DEFINITIONS.map((definition) => [definition.action, definition]));
+    const defaults = defaultShortcutBindings();
+
+    const backdrop = document.createElement("div");
+    backdrop.className = "modal-backdrop";
+    backdrop.innerHTML = `
+      <div class="modal shortcut-modal" role="dialog" aria-modal="true" aria-labelledby="shortcutSettingsTitle">
+        <h2 id="shortcutSettingsTitle">Keyboard Shortcuts</h2>
+        <p class="shortcut-settings-hint">Click a shortcut, then press the new key combination. Changes apply only after Save.</p>
+        <div class="shortcut-settings-list" data-shortcut-list></div>
+        <div class="modal-actions shortcut-modal-actions">
+          <button data-shortcut-reset>Reset All to Defaults</button>
+          <span class="shortcut-actions-spacer"></span>
+          <button data-shortcut-choice="save">Save</button>
+          <button data-shortcut-choice="cancel">Cancel</button>
+        </div>
+      </div>`;
+    document.body.append(backdrop);
+
+    const list = backdrop.querySelector("[data-shortcut-list]");
+
+    const assignShortcuts = (action, chords, { restoringDefault = false } = {}) => {
+      const target = definitionByAction.get(action);
+      const assigned = [...new Set(chords)];
+      const displaced = [];
+      rowMessages.clear();
+
+      for (const definition of SHORTCUT_DEFINITIONS) {
+        if (definition.action === action) continue;
+        const previous = draft[definition.action] ?? [];
+        const removed = previous.filter((chord) => assigned.includes(chord));
+        if (!removed.length) continue;
+        draft[definition.action] = previous.filter((chord) => !assigned.includes(chord));
+        const unassigned = draft[definition.action].length === 0;
+        displaced.push({ definition, removed, unassigned });
+        rowMessages.set(
+          definition.action,
+          `${removed.join(" / ")} was reassigned to ${target.label}.${unassigned ? " This command is now unassigned." : ""}`
+        );
+      }
+
+      draft[action] = assigned;
+      if (displaced.length) {
+        const previousAssignments = displaced
+          .map(({ definition, unassigned }) => `${definition.label}${unassigned ? " (now unassigned)" : ""}`)
+          .join(", ");
+        rowMessages.set(action, `${assigned.join(" / ")} was previously assigned to ${previousAssignments}.`);
+      } else if (restoringDefault) {
+        rowMessages.set(action, "Restored to default. Save to apply.");
+      }
+    };
+
+    const renderRows = () => {
+      const groups = [...new Set(SHORTCUT_DEFINITIONS.map(({ group }) => group))];
+      list.innerHTML = groups.map((group) => `
+        <section class="shortcut-group">
+          <h3>${escapeHtml(group)}</h3>
+          ${SHORTCUT_DEFINITIONS.filter((definition) => definition.group === group).map((definition) => {
+            const recording = recordingAction === definition.action;
+            const display = shortcutDisplayForAction(definition.action, draft) || "Unassigned";
+            const message = rowMessages.get(definition.action) ?? "";
+            return `
+              <div class="shortcut-row">
+                <span class="shortcut-command-label">${escapeHtml(definition.label)}</span>
+                <button class="shortcut-capture${recording ? " recording" : ""}" data-shortcut-record="${escapeHtml(definition.action)}" aria-pressed="${recording ? "true" : "false"}">
+                  ${recording ? "Press shortcut..." : escapeHtml(display)}
+                </button>
+                <button class="shortcut-default" data-shortcut-default="${escapeHtml(definition.action)}" title="Restore default shortcut">Default</button>
+                ${message ? `<div class="shortcut-row-message" data-shortcut-message="${escapeHtml(definition.action)}" aria-live="polite">${escapeHtml(message)}</div>` : ""}
+              </div>`;
+          }).join("")}
+        </section>
+      `).join("");
+
+      for (const button of list.querySelectorAll("[data-shortcut-record]")) {
+        button.addEventListener("click", () => {
+          recordingAction = button.dataset.shortcutRecord;
+          rowMessages.clear();
+          rowMessages.set(recordingAction, "Press the new shortcut. Escape cancels recording.");
+          renderRows();
+          list.querySelector(`[data-shortcut-record='${recordingAction}']`)?.focus();
+        });
+      }
+      for (const button of list.querySelectorAll("[data-shortcut-default]")) {
+        button.addEventListener("click", () => {
+          const action = button.dataset.shortcutDefault;
+          assignShortcuts(action, defaults[action], { restoringDefault: true });
+          recordingAction = null;
+          renderRows();
+        });
+      }
+    };
+
+    const finish = (save = false) => {
+      if (closed) return;
+      if (save) {
+        const conflict = shortcutConflicts(draft)[0];
+        if (conflict) {
+          for (const action of conflict.actions) {
+            rowMessages.set(action, `${conflict.chord} is still assigned to ${conflict.labels.join(" and ")}.`);
+          }
+          renderRows();
+          return;
+        }
+        state.shortcuts = saveShortcutBindings(draft, storage);
+        showToast("Keyboard shortcuts saved.");
+      }
+      closed = true;
+      document.removeEventListener("keydown", onKeydown, true);
+      backdrop.remove();
+      els.host.focus();
+    };
+
+    const stopKeyEvent = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation?.();
+    };
+
+    const onKeydown = (event) => {
+      if (recordingAction) {
+        stopKeyEvent(event);
+        if (event.key === "Escape") {
+          rowMessages.delete(recordingAction);
+          recordingAction = null;
+          renderRows();
+          return;
+        }
+        const chord = shortcutChordFromEvent(event);
+        if (!chord) return;
+        const validation = validateShortcutChord(chord);
+        if (!validation.valid) {
+          rowMessages.clear();
+          rowMessages.set(recordingAction, validation.message);
+          renderRows();
+          list.querySelector(`[data-shortcut-record='${recordingAction}']`)?.focus();
+          return;
+        }
+        assignShortcuts(recordingAction, [validation.chord]);
+        recordingAction = null;
+        renderRows();
+        return;
+      }
+      if (event.key !== "Escape") return;
+      stopKeyEvent(event);
+      finish(false);
+    };
+
+    document.addEventListener("keydown", onKeydown, true);
+    backdrop.addEventListener("click", (event) => {
+      if (event.target === backdrop) return finish(false);
+      const choice = event.target.closest("[data-shortcut-choice]")?.dataset.shortcutChoice;
+      if (choice === "save") finish(true);
+      if (choice === "cancel") finish(false);
+      if (event.target.closest("[data-shortcut-reset]")) {
+        draft = cloneShortcutBindings(defaults);
+        recordingAction = null;
+        rowMessages.clear();
+        renderRows();
+      }
+    });
+
+    renderRows();
+  }
+
+  return { showShortcutSettings };
+}
diff --git a/src/ui/global-shortcut-policy.js b/src/ui/global-shortcut-policy.js
index 2d7c457..ad3f1ad 100644
--- a/src/ui/global-shortcut-policy.js
+++ b/src/ui/global-shortcut-policy.js
@@ -1,34 +1,18 @@
-const EDITOR_ALLOWED_CTRL_KEYS = new Set(["s", "w", "h", "l"]);
+import {
+  defaultShortcutBindings,
+  shortcutActionForEvent
+} from "./shortcut-policy.js";
+
+const DEFAULT_SHORTCUTS = defaultShortcutBindings();
 
 export function isEditorShortcutAllowed(key, ctrlKey) {
-  return Boolean(ctrlKey && EDITOR_ALLOWED_CTRL_KEYS.has(String(key).toLowerCase()));
+  return Boolean(globalShortcutAction({ key, ctrlKey }, { editingCell: true }));
 }
 
-export function globalShortcutAction(event, { editingCell = false } = {}) {
-  const key = String(event.key ?? "").toLowerCase();
-  const ctrlKey = Boolean(event.ctrlKey);
-  const shiftKey = Boolean(event.shiftKey);
-  const altKey = Boolean(event.altKey);
+export function gridScrollShortcutAction(event, { shortcuts = DEFAULT_SHORTCUTS } = {}) {
+  return shortcutActionForEvent(event, shortcuts, { context: "grid" });
+}
 
-  if (editingCell && !isEditorShortcutAllowed(key, ctrlKey)) return null;
-  if (ctrlKey && (key === "+" || key === "=")) return "zoom-in";
-  if (ctrlKey && key === "-") return "zoom-out";
-  if (ctrlKey && key === "0") return "zoom-reset";
-  if (ctrlKey && key === "o") return "open-file";
-  if (ctrlKey && key === "b") return "toggle-sidebar";
-  if (ctrlKey && key === "l") return "toggle-problems";
-  if (ctrlKey && key === "h") return "reset-row-heights";
-  if (ctrlKey && key === "s" && shiftKey) return "save-as";
-  if (ctrlKey && key === "s") return "save-file";
-  if (ctrlKey && key === "f") return "search";
-  if (ctrlKey && key === "z" && shiftKey) return "redo";
-  if (ctrlKey && key === "z") return "undo";
-  if (ctrlKey && key === "y") return "redo";
-  if (ctrlKey && key === "p") return "show-palette";
-  if (ctrlKey && key === "w") return "close-tab";
-  if (ctrlKey && key === "c") return "copy";
-  if (ctrlKey && key === "x") return "cut";
-  if (ctrlKey && key === "v") return "paste";
-  if (!ctrlKey && !altKey && key === "delete" && !editingCell) return "clear-selection";
-  return null;
+export function globalShortcutAction(event, { editingCell = false, shortcuts = DEFAULT_SHORTCUTS } = {}) {
+  return shortcutActionForEvent(event, shortcuts, { context: "global", editingCell });
 }
diff --git a/src/ui/grid-viewport-policy.js b/src/ui/grid-viewport-policy.js
index d7908a0..08b2851 100644
--- a/src/ui/grid-viewport-policy.js
+++ b/src/ui/grid-viewport-policy.js
@@ -103,6 +103,24 @@ export function clampedGridScrollOffsets({
   };
 }
 
+export function wheelScrollOffsets(
+  { deltaX = 0, deltaY = 0, deltaMode = 0, shiftKey = false } = {},
+  { scrollLeft = 0, scrollTop = 0, lineSize = 1, pageWidth = 1, pageHeight = 1 } = {}
+) {
+  const horizontalScale = deltaMode === 1 ? lineSize : deltaMode === 2 ? pageWidth : 1;
+  const verticalScale = deltaMode === 1 ? lineSize : deltaMode === 2 ? pageHeight : 1;
+  let left = (Number(deltaX) || 0) * horizontalScale;
+  let top = (Number(deltaY) || 0) * verticalScale;
+  if (shiftKey && left === 0) {
+    left = top;
+    top = 0;
+  }
+  return {
+    scrollLeft: scrollLeft + left,
+    scrollTop: scrollTop + top
+  };
+}
+
 export function applyGridScrollBounds({ host, doc, rowHeaderWidth, headerHeight, frozenColumnWidth, frozenRowHeight, scrollableColumnWidth, scrollableRowsHeight }) {
   const next = clampedGridScrollOffsets({
     scrollLeft: host.scrollLeft,
diff --git a/src/ui/shortcut-policy.js b/src/ui/shortcut-policy.js
new file mode 100644
index 0000000..429fe1d
--- /dev/null
+++ b/src/ui/shortcut-policy.js
@@ -0,0 +1,238 @@
+export const SHORTCUT_STORAGE_KEY = "txteditor.shortcuts.v1";
+
+export const SHORTCUT_DEFINITIONS = Object.freeze([
+  shortcut("open-file", "Open File", ["Ctrl+O"]),
+  shortcut("save-file", "Save", ["Ctrl+S"], { allowWhileEditing: true }),
+  shortcut("save-as", "Save As", ["Ctrl+Shift+S"], { allowWhileEditing: true }),
+  shortcut("search", "Find/Search", ["Ctrl+F"]),
+  shortcut("undo", "Undo", ["Ctrl+Z"]),
+  shortcut("redo", "Redo", ["Ctrl+Y", "Ctrl+Shift+Z"]),
+  shortcut("copy", "Copy", ["Ctrl+C"]),
+  shortcut("cut", "Cut", ["Ctrl+X"]),
+  shortcut("paste", "Paste", ["Ctrl+V"]),
+  shortcut("select-all", "Select All", ["Ctrl+A"]),
+  shortcut("clear-selection", "Clear Cell(s)", ["Delete"]),
+  shortcut("show-palette", "Command Palette", ["Ctrl+P", "Ctrl+Shift+P"]),
+  shortcut("close-tab", "Close Current Tab", ["Ctrl+W"], { allowWhileEditing: true }),
+  shortcut("toggle-sidebar", "Toggle Explorer", ["Ctrl+B"]),
+  shortcut("toggle-problems", "Toggle Problems", ["Ctrl+L"], { allowWhileEditing: true }),
+  shortcut("reset-row-heights", "Reset Row Heights", ["Ctrl+H"], { allowWhileEditing: true }),
+  shortcut("zoom-in", "Zoom In", ["Ctrl+Plus", "Ctrl+="]),
+  shortcut("zoom-out", "Zoom Out", ["Ctrl+Minus"]),
+  shortcut("zoom-reset", "Reset Zoom", ["Ctrl+0"]),
+  shortcut("scroll-page-up", "Scroll One Page Up", ["PageUp"], { context: "grid", group: "Grid scrolling" }),
+  shortcut("scroll-page-down", "Scroll One Page Down", ["PageDown"], { context: "grid", group: "Grid scrolling" }),
+  shortcut("scroll-top", "Scroll To Top", ["Home"], { context: "grid", group: "Grid scrolling" }),
+  shortcut("scroll-bottom", "Scroll To Bottom", ["End"], { context: "grid", group: "Grid scrolling" }),
+  shortcut("scroll-left", "Scroll To Left Edge", ["Shift+Home"], { context: "grid", group: "Grid scrolling" }),
+  shortcut("scroll-right", "Scroll To Right Edge", ["Shift+End"], { context: "grid", group: "Grid scrolling" })
+]);
+
+const DEFINITION_BY_ACTION = new Map(SHORTCUT_DEFINITIONS.map((definition) => [definition.action, definition]));
+const MODIFIER_KEYS = new Set(["Alt", "AltGraph", "Control", "Meta", "OS", "Shift"]);
+const FIXED_NAVIGATION_KEYS = new Set(["ArrowDown", "ArrowLeft", "ArrowRight", "ArrowUp", "Enter", "Escape", "F2", "Tab"]);
+const MODIFIER_ORDER = ["Ctrl", "Alt", "Shift", "Meta"];
+
+function shortcut(action, label, defaults, {
+  allowWhileEditing = false,
+  context = "global",
+  group = "Commands"
+} = {}) {
+  return Object.freeze({
+    action,
+    label,
+    defaults: Object.freeze([...defaults]),
+    allowWhileEditing,
+    context,
+    group
+  });
+}
+
+export function defaultShortcutBindings() {
+  return Object.fromEntries(SHORTCUT_DEFINITIONS.map(({ action, defaults }) => [action, [...defaults]]));
+}
+
+export function cloneShortcutBindings(bindings) {
+  return Object.fromEntries(SHORTCUT_DEFINITIONS.map(({ action, defaults }) => [
+    action,
+    [...(Array.isArray(bindings?.[action]) ? bindings[action] : defaults)]
+  ]));
+}
+
+export function normalizeShortcutBindings(value) {
+  const defaults = defaultShortcutBindings();
+  const source = value?.bindings && typeof value.bindings === "object" ? value.bindings : value;
+  if (!source || typeof source !== "object" || Array.isArray(source)) return defaults;
+
+  const normalized = {};
+  for (const definition of SHORTCUT_DEFINITIONS) {
+    const { action } = definition;
+    if (!Object.hasOwn(source, action)) {
+      normalized[action] = [...defaults[action]];
+      continue;
+    }
+    const raw = Array.isArray(source[action]) ? source[action] : [source[action]];
+    if (raw.length === 0) {
+      normalized[action] = [];
+      continue;
+    }
+    const chords = [...new Set(raw.map(normalizeShortcutChord).filter(Boolean))]
+      .filter((chord) => validateShortcutChord(chord).valid);
+    normalized[action] = chords.length ? chords : [...defaults[action]];
+  }
+
+  return shortcutConflicts(normalized).length ? defaults : normalized;
+}
+
+export function loadShortcutBindings(storage = localStorage) {
+  try {
+    const raw = storage.getItem(SHORTCUT_STORAGE_KEY);
+    return raw ? normalizeShortcutBindings(JSON.parse(raw)) : defaultShortcutBindings();
+  } catch {
+    return defaultShortcutBindings();
+  }
+}
+
+export function saveShortcutBindings(bindings, storage = localStorage) {
+  const normalized = normalizeShortcutBindings(bindings);
+  storage.setItem(SHORTCUT_STORAGE_KEY, JSON.stringify({ version: 1, bindings: normalized }));
+  return normalized;
+}
+
+export function shortcutChordFromEvent(event = {}) {
+  const key = normalizeEventKey(event.key);
+  if (!key || MODIFIER_KEYS.has(String(event.key ?? ""))) return "";
+  const modifiers = [];
+  if (event.ctrlKey) modifiers.push("Ctrl");
+  if (event.altKey) modifiers.push("Alt");
+  if (event.shiftKey && key !== "Plus") modifiers.push("Shift");
+  if (event.metaKey) modifiers.push("Meta");
+  return [...modifiers, key].join("+");
+}
+
+export function normalizeShortcutChord(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw) return "";
+  const parts = raw.split("+").map((part) => part.trim()).filter(Boolean);
+  if (!parts.length) return "";
+  const rawKey = parts.pop();
+  const key = normalizeEventKey(rawKey);
+  if (!key || MODIFIER_KEYS.has(rawKey)) return "";
+
+  const modifierSet = new Set();
+  for (const part of parts) {
+    const modifier = normalizeModifier(part);
+    if (!modifier) return "";
+    modifierSet.add(modifier);
+  }
+  if (key === "Plus") modifierSet.delete("Shift");
+  return [...MODIFIER_ORDER.filter((modifier) => modifierSet.has(modifier)), key].join("+");
+}
+
+export function validateShortcutChord(value) {
+  const chord = normalizeShortcutChord(value);
+  if (!chord) return { valid: false, message: "Press a non-modifier key." };
+  const { key, modifiers } = shortcutChordParts(chord);
+  if (FIXED_NAVIGATION_KEYS.has(key)) {
+    return { valid: false, message: `${key} is reserved for grid editing and navigation.` };
+  }
+  if (isPrintableShortcutKey(key) && !modifiers.some((modifier) => modifier === "Ctrl" || modifier === "Alt" || modifier === "Meta")) {
+    return { valid: false, message: "Use Ctrl, Alt, or Meta with letters, numbers, and symbols." };
+  }
+  return { valid: true, message: "", chord };
+}
+
+export function shortcutActionForEvent(event, bindings, {
+  context = "global",
+  editingCell = false
+} = {}) {
+  const chord = shortcutChordFromEvent(event);
+  if (!chord) return null;
+  for (const definition of SHORTCUT_DEFINITIONS) {
+    if (definition.context !== context) continue;
+    if (editingCell && !definition.allowWhileEditing) continue;
+    if (editingCell && !event.ctrlKey && !event.altKey && !event.metaKey) continue;
+    const assigned = Array.isArray(bindings?.[definition.action]) ? bindings[definition.action] : definition.defaults;
+    if (assigned.includes(chord)) return definition.action;
+  }
+  return null;
+}
+
+export function shortcutDisplayForAction(action, bindings) {
+  const definition = DEFINITION_BY_ACTION.get(action);
+  if (!definition) return "";
+  const assigned = Array.isArray(bindings?.[action]) ? bindings[action] : definition.defaults;
+  return assigned.join(" / ");
+}
+
+export function shortcutConflicts(bindings) {
+  const actionsByChord = new Map();
+  for (const definition of SHORTCUT_DEFINITIONS) {
+    const assigned = Array.isArray(bindings?.[definition.action]) ? bindings[definition.action] : definition.defaults;
+    for (const chord of new Set(assigned)) {
+      if (!actionsByChord.has(chord)) actionsByChord.set(chord, []);
+      actionsByChord.get(chord).push(definition.action);
+    }
+  }
+  return [...actionsByChord.entries()]
+    .filter(([, actions]) => actions.length > 1)
+    .map(([chord, actions]) => ({
+      chord,
+      actions,
+      labels: actions.map((action) => DEFINITION_BY_ACTION.get(action)?.label ?? action)
+    }));
+}
+
+export function shortcutDefinition(action) {
+  return DEFINITION_BY_ACTION.get(action) ?? null;
+}
+
+function normalizeModifier(value) {
+  const key = String(value ?? "").trim().toLowerCase();
+  if (key === "ctrl" || key === "control") return "Ctrl";
+  if (key === "alt" || key === "option") return "Alt";
+  if (key === "shift") return "Shift";
+  if (key === "meta" || key === "cmd" || key === "command" || key === "win" || key === "windows") return "Meta";
+  return "";
+}
+
+function normalizeEventKey(value) {
+  const raw = String(value ?? "");
+  const lower = raw.toLowerCase();
+  const aliases = {
+    " ": "Space",
+    "+": "Plus",
+    "-": "Minus",
+    add: "Plus",
+    alt: "Alt",
+    altgraph: "AltGraph",
+    control: "Control",
+    del: "Delete",
+    esc: "Escape",
+    meta: "Meta",
+    os: "OS",
+    pagedown: "PageDown",
+    "page down": "PageDown",
+    pageup: "PageUp",
+    "page up": "PageUp",
+    shift: "Shift",
+    subtract: "Minus"
+  };
+  if (Object.hasOwn(aliases, lower)) return aliases[lower];
+  if (/^[a-z]$/i.test(raw)) return raw.toUpperCase();
+  if (/^f([1-9]|1\d|2[0-4])$/i.test(raw)) return raw.toUpperCase();
+  if (/^arrow(up|down|left|right)$/i.test(raw)) return `Arrow${lower.slice(5, 6).toUpperCase()}${lower.slice(6)}`;
+  if (["backspace", "delete", "end", "enter", "escape", "home", "insert", "space", "tab"].includes(lower)) {
+    return `${lower[0].toUpperCase()}${lower.slice(1)}`;
+  }
+  return raw;
+}
+
+function shortcutChordParts(chord) {
+  const parts = chord.split("+");
+  return { key: parts.at(-1), modifiers: parts.slice(0, -1) };
+}
+
+function isPrintableShortcutKey(key) {
+  return key.length === 1 || key === "Space" || key === "Plus" || key === "Minus";
+}
diff --git a/tests/app-controller.test.js b/tests/app-controller.test.js
index 13a1b8a..5b2db86 100644
--- a/tests/app-controller.test.js
+++ b/tests/app-controller.test.js
@@ -12,6 +12,7 @@ import {
 import { LARGE_FILE_THRESHOLDS } from "../src/core/large-file-policy.js";
 import { fillSelectedCellsCommand } from "../src/core/operations.js";
 import { CanvasGrid } from "../src/ui/canvas-grid.js";
+import { createAppEventController } from "../src/ui/controllers/app-event-controller.js";
 import { createDocumentController } from "../src/ui/controllers/document-controller.js";
 import { createSearchController } from "../src/ui/controllers/search-controller.js";
 import {
@@ -38,6 +39,7 @@ import {
 import { syncDockChildren } from "../src/ui/dock-sync.js";
 import {
   globalShortcutAction,
+  gridScrollShortcutAction,
   isEditorShortcutAllowed
 } from "../src/ui/global-shortcut-policy.js";
 import {
@@ -573,7 +575,7 @@ test("opening another document saves the outgoing selection and scroll state", a
   let stateRef;
   const saves = [];
   selection.set(1, 0);
-  const { controller, state } = testDocumentController(active, gridState, {
+  const { controller, state, document, host } = testDocumentController(active, gridState, {
     saveSelectionState: () => {
       const doc = stateRef.docs[stateRef.active];
       saves.push(doc.name);
@@ -591,6 +593,7 @@ test("opening another document saves the outgoing selection and scroll state", a
   assert.deepEqual(active.selectionState.focus, { row: 1, column: 0 });
   assert.equal(active.scrollLeft, 12);
   assert.equal(active.scrollTop, 240);
+  assert.equal(document.activeElement, host);
 });
 
 test("activating an already-open document saves the outgoing selection and scroll state", async () => {
@@ -609,7 +612,7 @@ test("activating an already-open document saves the outgoing selection and scrol
   let stateRef;
   const saves = [];
   selection.set(1, 0);
-  const { controller, state } = testDocumentController([active, existing], gridState, {
+  const { controller, state, document, host } = testDocumentController([active, existing], gridState, {
     saveSelectionState: () => {
       const doc = stateRef.docs[stateRef.active];
       saves.push(doc.name);
@@ -628,6 +631,7 @@ test("activating an already-open document saves the outgoing selection and scrol
   assert.deepEqual(active.selectionState.focus, { row: 1, column: 0 });
   assert.equal(active.scrollLeft, 7);
   assert.equal(active.scrollTop, 360);
+  assert.equal(document.activeElement, host);
 });
 
 test("closing the active tab commits editor changes before checking dirty state", async () => {
@@ -1032,7 +1036,7 @@ test("Find Next includes the current header when the search scope changes", () =
   assert.equal(searchShouldIncludeStart("abc", SEARCH_SCOPE_COLUMN_TITLES, "abc", SEARCH_SCOPE_COLUMN_TITLES), false);
 });
 
-test("header search maps matches to the active row or column and preserves the other scroll axis", () => {
+test("search maps header matches to the active axis and centers only the searched axis", () => {
   assert.deepEqual(
     searchTargetForResult(SEARCH_SCOPE_COLUMN_TITLES, { row: 0, column: 7 }, { row: 300, column: 2 }),
     { row: 300, column: 7 }
@@ -1055,6 +1059,7 @@ test("Find scope options submit the current search on Enter", () => {
   const selection = new SelectionModel();
   selection.set(0, 1);
   const listeners = new Map();
+  const panelListeners = new Map();
   const rowScopeInput = {
     value: SEARCH_SCOPE_ROW_TITLES,
     addEventListener: (name, listener) => listeners.set(name, listener)
@@ -1074,7 +1079,7 @@ test("Find scope options submit the current search on Enter", () => {
       classList: { add: () => {}, remove: () => {} },
       querySelector: () => rowScopeInput,
       querySelectorAll: () => [rowScopeInput],
-      addEventListener: () => {}
+      addEventListener: (name, listener) => panelListeners.set(name, listener)
     },
     searchStatus: { textContent: "" }
   };
@@ -1082,7 +1087,8 @@ test("Find scope options submit the current search on Enter", () => {
     state,
     els,
     grid: {
-      scrollCellIntoView: (...args) => scrolls.push(args),
+      scrollCellToCenter: (...args) => scrolls.push(["center", ...args]),
+      scrollByWheel: (event) => scrolls.push(["wheel", event.deltaX, event.deltaY]),
       draw: () => {}
     },
     activeDoc: () => doc,
@@ -1098,8 +1104,19 @@ test("Find scope options submit the current search on Enter", () => {
 
   assert.equal(prevented, true);
   assert.deepEqual(selection.focus, { row: 2, column: 1 });
-  assert.deepEqual(scrolls, [[2, 1, { preserveScrollLeft: true }]]);
+  assert.deepEqual(scrolls, [["center", 2, 1, { preserveScrollLeft: true }]]);
   assert.equal(els.searchStatus.textContent, "Row R3 (title R3:C1)");
+
+  let wheelPrevented = false;
+  const wheelEvent = {
+    ctrlKey: false,
+    deltaX: 3,
+    deltaY: 40,
+    preventDefault: () => { wheelPrevented = true; }
+  };
+  panelListeners.get("wheel")(wheelEvent);
+  assert.equal(wheelPrevented, true);
+  assert.deepEqual(scrolls.at(-1), ["wheel", 3, 40]);
 });
 
 test("settings windows treat Escape as a close key only", () => {
@@ -1123,7 +1140,208 @@ test("Ctrl+B, Ctrl+L, and Ctrl+H use the shared panel and row-height reset paths
   assert.match(readme, /`Ctrl\+H`: reset all row heights to default/);
 });
 
+test("grid scroll shortcut policy maps only unmodified data-grid scroll keys", () => {
+  assert.equal(gridScrollShortcutAction({ key: "Home" }), "scroll-top");
+  assert.equal(gridScrollShortcutAction({ key: "End" }), "scroll-bottom");
+  assert.equal(gridScrollShortcutAction({ key: "Home", shiftKey: true }), "scroll-left");
+  assert.equal(gridScrollShortcutAction({ key: "End", shiftKey: true }), "scroll-right");
+  assert.equal(gridScrollShortcutAction({ key: "PageUp" }), "scroll-page-up");
+  assert.equal(gridScrollShortcutAction({ key: "PageDown" }), "scroll-page-down");
+  assert.equal(gridScrollShortcutAction({ key: "PageUp", shiftKey: true }), null);
+  assert.equal(gridScrollShortcutAction({ key: "Home", ctrlKey: true }), null);
+  assert.equal(gridScrollShortcutAction({ key: "End", altKey: true }), null);
+});
+
+test("data-grid scroll shortcuts require an open document and non-text focus", () => {
+  const previousDocument = globalThis.document;
+  const previousWindow = globalThis.window;
+  const previousElement = globalThis.Element;
+  const listeners = new Map();
+  globalThis.document = {
+    addEventListener: (type, listener) => listeners.set(type, listener)
+  };
+  globalThis.window = { addEventListener: () => {} };
+  class FakeElement {
+    constructor(matchSelector = "") {
+      this.matchSelector = matchSelector;
+    }
+    closest(selector) {
+      return this.matchSelector && selector.includes(this.matchSelector) ? this : null;
+    }
+  }
+  globalThis.Element = FakeElement;
+
+  try {
+    const calls = [];
+    const classList = (active = false) => ({
+      contains: (name) => active && name === "active",
+      add: () => {},
+      remove: () => {}
+    });
+    let editorActive = false;
+    const editorClassList = {
+      contains: (name) => editorActive && name === "active",
+      add: () => {},
+      remove: () => {}
+    };
+    const addEventListener = () => {};
+    const controller = createAppEventController({
+      state: { active: 0 },
+      els: {
+        closeDialog: { addEventListener },
+        tabs: { addEventListener },
+        fileInput: { addEventListener },
+        paletteInput: { addEventListener },
+        paletteResults: { querySelector: () => null },
+        palette: { classList: classList(false) },
+        contextMenu: { classList: classList(false) },
+        searchPanel: { classList: classList(false) },
+        host: { focus: () => calls.push("focus") },
+        editor: { classList: editorClassList }
+      },
+      grid: {
+        layout: () => {},
+        scrollToTop: () => calls.push("top"),
+        scrollToBottom: () => calls.push("bottom"),
+        scrollToLeft: () => calls.push("left"),
+        scrollToRight: () => calls.push("right"),
+        scrollPageUp: () => calls.push("page-up"),
+        scrollPageDown: () => calls.push("page-down")
+      },
+      commands: {},
+      documentController: { handleCloseDialogClick: () => {}, openBrowserFiles: async () => {} },
+      hasOpenDocument: () => true,
+      searchController: { wireEvents: () => {}, closeSearch: () => {}, showSearch: () => {} },
+      syncDockLayout: () => {},
+      wirePaneResizers: () => {},
+      positionContextMenu: () => {},
+      updateOverviewRuler: () => {},
+      renderPalette: () => {},
+      runCommand: () => {},
+      switchBottomTab: () => {},
+      showError: (error) => { throw error; },
+      hideContextMenu: () => {},
+      closeTab: () => {},
+      openFile: () => {},
+      toggleSidebar: () => {},
+      toggleProblemsPanel: () => {},
+      resetRowHeights: () => {},
+      saveAs: () => {},
+      saveFile: () => {},
+      redo: () => {},
+      undo: () => {},
+      showPalette: () => {},
+      copySelection: () => {},
+      cutSelection: () => {},
+      pasteSelection: () => {}
+    });
+    controller.wireEvents();
+
+    let prevented = 0;
+    listeners.get("keydown")({
+      key: "Home",
+      target: {},
+      preventDefault: () => { prevented += 1; }
+    });
+    listeners.get("keydown")({
+      key: "End",
+      shiftKey: true,
+      target: {},
+      preventDefault: () => { prevented += 1; }
+    });
+    listeners.get("keydown")({
+      key: "PageDown",
+      target: {},
+      preventDefault: () => { prevented += 1; }
+    });
+    assert.deepEqual(calls, ["top", "right", "page-down"]);
+    assert.equal(prevented, 3);
+
+    listeners.get("keydown")({
+      key: "PageUp",
+      target: new FakeElement("input"),
+      preventDefault: () => { prevented += 1; }
+    });
+    assert.deepEqual(calls, ["top", "right", "page-down"]);
+
+    listeners.get("keydown")({
+      key: "Home",
+      target: new FakeElement(".modal"),
+      preventDefault: () => { prevented += 1; }
+    });
+    assert.deepEqual(calls, ["top", "right", "page-down"]);
+
+    editorActive = true;
+    listeners.get("keydown")({
+      key: "End",
+      target: {},
+      preventDefault: () => { prevented += 1; }
+    });
+    assert.deepEqual(calls, ["top", "right", "page-down"]);
+    editorActive = false;
+
+    const closedController = createAppEventController({
+      state: { active: -1 },
+      els: {
+        closeDialog: { addEventListener },
+        tabs: { addEventListener },
+        fileInput: { addEventListener },
+        paletteInput: { addEventListener },
+        paletteResults: { querySelector: () => null },
+        palette: { classList: classList(false) },
+        contextMenu: { classList: classList(false) },
+        searchPanel: { classList: classList(false) },
+        host: { focus: () => {} },
+        editor: { classList: classList(false) }
+      },
+      grid: {
+        layout: () => {},
+        scrollToTop: () => calls.push("closed-top")
+      },
+      commands: {},
+      documentController: { handleCloseDialogClick: () => {}, openBrowserFiles: async () => {} },
+      hasOpenDocument: () => false,
+      searchController: { wireEvents: () => {}, closeSearch: () => {}, showSearch: () => {} },
+      syncDockLayout: () => {},
+      wirePaneResizers: () => {},
+      positionContextMenu: () => {},
+      updateOverviewRuler: () => {},
+      renderPalette: () => {},
+      runCommand: () => {},
+      switchBottomTab: () => {},
+      showError: (error) => { throw error; },
+      hideContextMenu: () => {},
+      closeTab: () => {},
+      openFile: () => {},
+      toggleSidebar: () => {},
+      toggleProblemsPanel: () => {},
+      resetRowHeights: () => {},
+      saveAs: () => {},
+      saveFile: () => {},
+      redo: () => {},
+      undo: () => {},
+      showPalette: () => {},
+      copySelection: () => {},
+      cutSelection: () => {},
+      pasteSelection: () => {}
+    });
+    closedController.wireEvents();
+    listeners.get("keydown")({
+      key: "Home",
+      target: {},
+      preventDefault: () => { prevented += 1; }
+    });
+    assert.equal(calls.includes("closed-top"), false);
+  } finally {
+    globalThis.document = previousDocument;
+    globalThis.window = previousWindow;
+    globalThis.Element = previousElement;
+  }
+});
+
 function testDocumentController(docOrDocs, gridOverrides = {}, options = {}) {
+  const hostDocument = { activeElement: null };
+  const host = { focus: () => { hostDocument.activeElement = host; } };
   const state = { docs: Array.isArray(docOrDocs) ? docOrDocs : [docOrDocs], active: 0, lint: { engine: options.lintEngine ?? "legacy" } };
   const grid = {
     commitEdit: () => {},
@@ -1134,6 +1352,7 @@ function testDocumentController(docOrDocs, gridOverrides = {}, options = {}) {
   const controller = createDocumentController({
     state,
     els: {
+      host,
       closeDialog: { classList: { add: () => {}, remove: () => {} } },
       closeDialogText: { textContent: "" },
       fileInput: { click: () => {} }
@@ -1162,7 +1381,7 @@ function testDocumentController(docOrDocs, gridOverrides = {}, options = {}) {
     updateGridDiagnostics: () => {},
     scrollProblemsToActiveFile: () => {}
   });
-  return { controller, state };
+  return { controller, state, document: hostDocument, host };
 }
 
 function deferred() {
diff --git a/tests/app-shell.test.js b/tests/app-shell.test.js
index 106ebb6..306a1f9 100644
--- a/tests/app-shell.test.js
+++ b/tests/app-shell.test.js
@@ -443,6 +443,7 @@ test("Explorer search preserves open document tab indexes", () => {
   ];
   const els = {
     shell: document.getElementById("app"),
+    host: document.getElementById("gridHost"),
     ...Object.fromEntries(ids.map((id) => [id, document.getElementById(id)]))
   };
   const controller = createShellController({
@@ -480,6 +481,7 @@ test("Explorer search preserves open document tab indexes", () => {
 
     assert.equal(state.active, 1);
     assert.equal(els.explorerFilter.value, "");
+    assert.equal(document.activeElement, els.host);
   } finally {
     if (originalDocument === undefined) delete globalThis.document;
     else globalThis.document = originalDocument;
diff --git a/tests/freeze-controls.test.js b/tests/freeze-controls.test.js
new file mode 100644
index 0000000..1cee53f
--- /dev/null
+++ b/tests/freeze-controls.test.js
@@ -0,0 +1,143 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+import { createInitialAppState } from "../src/ui/app-startup-state.js";
+import { createGridCommandController } from "../src/ui/controllers/grid-command-controller.js";
+import { createShellController } from "../src/ui/controllers/shell-controller.js";
+import { installFakeAppStartupDom } from "./helpers/fake-dom-app-startup.mjs";
+
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function pathKey(path) {
+  return String(path || "").replace(/\\/g, "/").toLowerCase();
+}
+
+test("startup ignores previously persisted freeze state", () => {
+  installFakeAppStartupDom();
+  localStorage.setItem("txteditor.freeze", JSON.stringify({ row: true, column: true }));
+
+  const { state } = createInitialAppState({ storage: localStorage });
+
+  assert.equal(state.freezeRow, false);
+  assert.equal(state.freezeColumn, false);
+});
+
+test("Freeze toolbar buttons are inactive and disabled until a document is open", () => {
+  const indexHtml = readFileSync(new URL("../index.html", import.meta.url), "utf8");
+  const { document } = installFakeAppStartupDom({ indexHtml });
+  const state = {
+    docs: [],
+    active: -1,
+    workspace: {
+      path: "E:/Game/Data",
+      files: [{ name: "armor.txt", path: "E:/Game/Data/armor.txt" }]
+    },
+    sidebarVisible: true,
+    problemsVisible: false,
+    bottomTab: "problems",
+    lint: { diagnostics: [], enabled: true },
+    freezeRow: true,
+    freezeColumn: true,
+    colorizeColumns: false,
+    theme: "dark",
+    selection: { set: () => {} }
+  };
+  const ids = [
+    "sidebar",
+    "problemsPanel",
+    "problemsList",
+    "logList",
+    "emptyState",
+    "lintSummary",
+    "tabs",
+    "fileList",
+    "explorerFilter",
+    "explorerSearchResults",
+    "gridHost"
+  ];
+  const els = {
+    shell: document.getElementById("app"),
+    ...Object.fromEntries(ids.map((id) => [id === "gridHost" ? "host" : id, document.getElementById(id)]))
+  };
+  const controller = createShellController({
+    state,
+    els,
+    grid: { setDocument: () => {} },
+    activeDoc: () => state.docs[state.active],
+    hasOpenDocument: () => state.docs.length > 0 && state.active >= 0,
+    applyFreezeToDoc: () => {},
+    closeTab: async () => {},
+    openDroppedNativePaths: async () => {},
+    updateGridDiagnostics: () => {},
+    renderProblemsPanelIfNeeded: () => {},
+    scrollProblemsToActiveFile: () => {},
+    docDiagnosticSeverity: () => "",
+    lintSummaryText: () => "",
+    problemBadgeForPath: () => "",
+    lintNotificationCount: () => 0,
+    renderLintControls: () => {},
+    syncDockLayout: () => {},
+    syncProblemsHeaderLayout: () => {},
+    scheduleHoverPrewarm: () => {},
+    recordUiPerf: () => {},
+    perfNow: () => 0,
+    showError: (error) => { throw error; },
+    lintPathKey: pathKey,
+    escapeHtml,
+    documentRef: document
+  });
+  const rowButton = document.querySelector("[data-command='toggle-freeze-row']");
+  const columnButton = document.querySelector("[data-command='toggle-freeze-column']");
+
+  controller.renderChrome();
+  assert.equal(rowButton.disabled, true);
+  assert.equal(columnButton.disabled, true);
+  assert.equal(rowButton.classList.contains("active"), false);
+  assert.equal(columnButton.classList.contains("active"), false);
+
+  state.docs = [{ name: "armor.txt", path: "E:/Game/Data/armor.txt", dirty: false }];
+  state.active = 0;
+  controller.renderChrome();
+  assert.equal(rowButton.disabled, false);
+  assert.equal(columnButton.disabled, false);
+  assert.equal(rowButton.classList.contains("active"), true);
+  assert.equal(columnButton.classList.contains("active"), true);
+});
+
+test("Freeze toggles update only the current session and active document", () => {
+  installFakeAppStartupDom();
+  const state = { freezeRow: false, freezeColumn: false };
+  const doc = { freezeFirstRow: false, freezeFirstColumn: false };
+  let layouts = 0;
+  let renders = 0;
+  const controller = createGridCommandController({
+    state,
+    grid: { layout: () => { layouts += 1; } },
+    activeDoc: () => doc,
+    hasOpenDocument: () => true,
+    execute: () => {},
+    saveSelectionState: () => {},
+    renderChrome: () => { renders += 1; },
+    showError: (error) => { throw error; },
+    applyFreezeToDoc: (target) => {
+      target.freezeFirstRow = state.freezeRow;
+      target.freezeFirstColumn = state.freezeColumn;
+    },
+    rowsForContextOperation: () => [],
+    columnsFromSelection: () => []
+  });
+
+  controller.toggleFreeze("row");
+
+  assert.equal(state.freezeRow, true);
+  assert.equal(doc.freezeFirstRow, true);
+  assert.equal(localStorage.getItem("txteditor.freeze"), null);
+  assert.equal(layouts, 1);
+  assert.equal(renders, 1);
+});
diff --git a/tests/grid-policy.test.js b/tests/grid-policy.test.js
index cca3317..7a7696e 100644
--- a/tests/grid-policy.test.js
+++ b/tests/grid-policy.test.js
@@ -406,6 +406,115 @@ test("centered scroll offsets clamp for short and bounded content", () => {
   }), {});
 });
 
+test("grid explicit scroll shortcuts clamp to table bounds", () => {
+  const grid = {
+    host: {
+      scrollLeft: 40,
+      scrollTop: 300,
+      clientWidth: 300,
+      clientHeight: 200
+    },
+    rowHeaderWidth: 40,
+    headerHeight: 24,
+    frozenColumnWidth: () => 10,
+    frozenRowHeight: () => 20,
+    scrollableColumnWidth: () => 900,
+    scrollableRowsHeight: () => 800,
+    scrollToOffsets: CanvasGrid.prototype.scrollToOffsets,
+    gridPageHeight: CanvasGrid.prototype.gridPageHeight,
+    scrollToTop: CanvasGrid.prototype.scrollToTop,
+    scrollToBottom: CanvasGrid.prototype.scrollToBottom,
+    scrollToLeft: CanvasGrid.prototype.scrollToLeft,
+    scrollToRight: CanvasGrid.prototype.scrollToRight,
+    scrollPageUp: CanvasGrid.prototype.scrollPageUp,
+    scrollPageDown: CanvasGrid.prototype.scrollPageDown
+  };
+
+  grid.scrollToTop();
+  assert.equal(grid.host.scrollTop, 0);
+  assert.equal(grid.host.scrollLeft, 40);
+
+  grid.scrollToBottom();
+  assert.equal(grid.host.scrollTop, 644);
+
+  grid.scrollToLeft();
+  assert.equal(grid.host.scrollLeft, 0);
+  assert.equal(grid.host.scrollTop, 644);
+
+  grid.scrollToRight();
+  assert.equal(grid.host.scrollLeft, 650);
+
+  grid.host.scrollTop = 300;
+  grid.scrollPageUp();
+  assert.equal(grid.host.scrollTop, 144);
+
+  grid.scrollPageDown();
+  assert.equal(grid.host.scrollTop, 300);
+
+  grid.scrollPageDown();
+  grid.scrollPageDown();
+  grid.scrollPageDown();
+  assert.equal(grid.host.scrollTop, 644);
+});
+
+test("grid wheel scrolling supports pixel, line, and shifted horizontal input", () => {
+  const grid = {
+    host: {
+      scrollLeft: 40,
+      scrollTop: 300,
+      clientWidth: 300,
+      clientHeight: 200
+    },
+    rowHeight: 26,
+    rowHeaderWidth: 40,
+    headerHeight: 24,
+    frozenColumnWidth: () => 10,
+    frozenRowHeight: () => 20,
+    scrollableColumnWidth: () => 900,
+    scrollableRowsHeight: () => 800,
+    scrollToOffsets: CanvasGrid.prototype.scrollToOffsets,
+    gridPageHeight: CanvasGrid.prototype.gridPageHeight,
+    scrollByWheel: CanvasGrid.prototype.scrollByWheel
+  };
+
+  grid.scrollByWheel({ deltaX: 5, deltaY: 20 });
+  assert.equal(grid.host.scrollLeft, 45);
+  assert.equal(grid.host.scrollTop, 320);
+
+  grid.scrollByWheel({ deltaY: 2, deltaMode: 1 });
+  assert.equal(grid.host.scrollTop, 372);
+
+  grid.scrollByWheel({ deltaY: 10, shiftKey: true });
+  assert.equal(grid.host.scrollLeft, 55);
+  assert.equal(grid.host.scrollTop, 372);
+});
+
+test("centered cell scrolling can preserve the unrelated search axis", () => {
+  const grid = {
+    host: { scrollLeft: 40, scrollTop: 300, clientWidth: 300, clientHeight: 200 },
+    doc: { freezeFirstRow: false, freezeFirstColumn: false },
+    rowHeaderWidth: 40,
+    headerHeight: 24,
+    frozenColumnWidth: () => 0,
+    frozenRowHeight: () => 0,
+    columnContentLeft: () => 600,
+    rowContentTop: () => 900,
+    scaledColumnWidth: () => 80,
+    scaledRowHeight: () => 26,
+    scrollableColumnWidth: () => 1200,
+    scrollableRowsHeight: () => 1600
+  };
+
+  CanvasGrid.prototype.scrollCellToCenter.call(grid, 20, 8, { preserveScrollTop: true });
+  assert.equal(grid.host.scrollLeft, 510);
+  assert.equal(grid.host.scrollTop, 300);
+
+  grid.host.scrollLeft = 40;
+  CanvasGrid.prototype.scrollCellToCenter.call(grid, 20, 8, { preserveScrollLeft: true });
+  assert.equal(grid.host.scrollLeft, 40);
+  assert.equal(grid.host.scrollTop, 825);
+});
+
 test("frozen pane edge uses a subtle raised effect instead of hard divider strokes", () => {
   const css = readFileSync(new URL("../src/styles.css", import.meta.url), "utf8");
   assert.deepEqual(frozenVerticalEdgeRects(80, 240), [
diff --git a/tests/platform-tauri-contract.test.js b/tests/platform-tauri-contract.test.js
index 0850b63..698dc75 100644
--- a/tests/platform-tauri-contract.test.js
+++ b/tests/platform-tauri-contract.test.js
@@ -539,7 +539,7 @@ test("Find UI is a centered modal and text inputs keep native shortcuts", () =>
   const css = readFileSync(new URL("../src/styles.css", import.meta.url), "utf8");
   assert.match(html, /id="searchPanel" class="modal-backdrop search-backdrop hidden"/);
   assert.match(html, /class="modal search-modal"/);
-  assert.match(html, /id="searchInput" class="modal-input"/);
+  assert.match(html, /id="searchInput" class="modal-input" type="search"[^>]*autocomplete="off"[^>]*spellcheck="false"/);
   assert.match(html, /data-search-close/);
   assert.doesNotMatch(html, /id="searchPanel" class="quick-panel/);
   class FakeElement {
diff --git a/tests/shortcut-policy.test.js b/tests/shortcut-policy.test.js
new file mode 100644
index 0000000..d1f7717
--- /dev/null
+++ b/tests/shortcut-policy.test.js
@@ -0,0 +1,108 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  SHORTCUT_STORAGE_KEY,
+  defaultShortcutBindings,
+  loadShortcutBindings,
+  normalizeShortcutChord,
+  saveShortcutBindings,
+  shortcutActionForEvent,
+  shortcutChordFromEvent,
+  shortcutConflicts,
+  shortcutDisplayForAction,
+  validateShortcutChord
+} from "../src/ui/shortcut-policy.js";
+import {
+  globalShortcutAction,
+  gridScrollShortcutAction
+} from "../src/ui/global-shortcut-policy.js";
+
+function makeStorage() {
+  const values = new Map();
+  return {
+    getItem: (key) => values.get(key) ?? null,
+    setItem: (key, value) => values.set(key, String(value))
+  };
+}
+
+test("shortcut defaults preserve command aliases and requested grid scrolling keys", () => {
+  const shortcuts = defaultShortcutBindings();
+
+  assert.equal(globalShortcutAction({ key: "s", ctrlKey: true }, { shortcuts }), "save-file");
+  assert.equal(globalShortcutAction({ key: "z", ctrlKey: true, shiftKey: true }, { shortcuts }), "redo");
+  assert.equal(globalShortcutAction({ key: "+", ctrlKey: true, shiftKey: true }, { shortcuts }), "zoom-in");
+  assert.equal(globalShortcutAction({ key: "a", ctrlKey: true }, { shortcuts }), "select-all");
+  assert.equal(gridScrollShortcutAction({ key: "PageUp" }, { shortcuts }), "scroll-page-up");
+  assert.equal(gridScrollShortcutAction({ key: "PageDown" }, { shortcuts }), "scroll-page-down");
+  assert.equal(gridScrollShortcutAction({ key: "Home" }, { shortcuts }), "scroll-top");
+  assert.equal(gridScrollShortcutAction({ key: "End" }, { shortcuts }), "scroll-bottom");
+  assert.equal(gridScrollShortcutAction({ key: "Home", shiftKey: true }, { shortcuts }), "scroll-left");
+  assert.equal(gridScrollShortcutAction({ key: "End", shiftKey: true }, { shortcuts }), "scroll-right");
+});
+
+test("remapped shortcuts replace defaults at runtime", () => {
+  const shortcuts = defaultShortcutBindings();
+  shortcuts["save-file"] = ["Ctrl+K"];
+  shortcuts["scroll-page-down"] = ["Ctrl+PageDown"];
+
+  assert.equal(globalShortcutAction({ key: "s", ctrlKey: true }, { shortcuts }), null);
+  assert.equal(globalShortcutAction({ key: "k", ctrlKey: true }, { shortcuts }), "save-file");
+  assert.equal(gridScrollShortcutAction({ key: "PageDown" }, { shortcuts }), null);
+  assert.equal(gridScrollShortcutAction({ key: "PageDown", ctrlKey: true }, { shortcuts }), "scroll-page-down");
+  assert.equal(shortcutActionForEvent({ key: "k", ctrlKey: true }, shortcuts), "save-file");
+});
+
+test("cell editing keeps unmodified text-navigation keys native after remapping", () => {
+  const shortcuts = defaultShortcutBindings();
+  shortcuts["save-file"] = ["Home", "Ctrl+K"];
+
+  assert.equal(globalShortcutAction({ key: "Home" }, { shortcuts, editingCell: false }), "save-file");
+  assert.equal(globalShortcutAction({ key: "Home" }, { shortcuts, editingCell: true }), null);
+  assert.equal(globalShortcutAction({ key: "k", ctrlKey: true }, { shortcuts, editingCell: true }), "save-file");
+});
+
+test("shortcut recording normalizes modifiers, aliases, and plus keys", () => {
+  assert.equal(shortcutChordFromEvent({ key: "s", ctrlKey: true }), "Ctrl+S");
+  assert.equal(shortcutChordFromEvent({ key: "S", ctrlKey: true, shiftKey: true }), "Ctrl+Shift+S");
+  assert.equal(shortcutChordFromEvent({ key: "+", ctrlKey: true, shiftKey: true }), "Ctrl+Plus");
+  assert.equal(shortcutChordFromEvent({ key: "Shift", shiftKey: true }), "");
+  assert.equal(normalizeShortcutChord("control+shift+s"), "Ctrl+Shift+S");
+  assert.equal(normalizeShortcutChord("Ctrl+Add"), "Ctrl+Plus");
+});
+
+test("shortcut validation keeps editing and navigation keys fixed", () => {
+  for (const chord of ["ArrowUp", "Ctrl+ArrowLeft", "Enter", "Shift+Tab", "Escape", "F2"]) {
+    assert.equal(validateShortcutChord(chord).valid, false, chord);
+  }
+  assert.equal(validateShortcutChord("S").valid, false);
+  assert.equal(validateShortcutChord("Shift+S").valid, false);
+  assert.equal(validateShortcutChord("Ctrl+S").valid, true);
+  assert.equal(validateShortcutChord("PageUp").valid, true);
+  assert.equal(validateShortcutChord("Shift+Home").valid, true);
+});
+
+test("shortcut conflicts are reported across command and grid contexts", () => {
+  const shortcuts = defaultShortcutBindings();
+  shortcuts["scroll-top"] = ["Ctrl+S"];
+  const conflicts = shortcutConflicts(shortcuts);
+
+  assert.equal(conflicts.length, 1);
+  assert.equal(conflicts[0].chord, "Ctrl+S");
+  assert.deepEqual(conflicts[0].actions, ["save-file", "scroll-top"]);
+});
+
+test("shortcut storage persists overrides, aliases, and unassigned commands", () => {
+  const storage = makeStorage();
+  const shortcuts = defaultShortcutBindings();
+  shortcuts["save-file"] = ["Ctrl+K"];
+  shortcuts.copy = [];
+
+  const saved = saveShortcutBindings(shortcuts, storage);
+  const loaded = loadShortcutBindings(storage);
+
+  assert.deepEqual(saved["save-file"], ["Ctrl+K"]);
+  assert.deepEqual(loaded["save-file"], ["Ctrl+K"]);
+  assert.deepEqual(loaded.copy, []);
+  assert.equal(shortcutDisplayForAction("save-file", loaded), "Ctrl+K");
+  assert.equal(JSON.parse(storage.getItem(SHORTCUT_STORAGE_KEY)).version, 1);
+});
diff --git a/tests/shortcut-settings.test.js b/tests/shortcut-settings.test.js
new file mode 100644
index 0000000..bf92e80
--- /dev/null
+++ b/tests/shortcut-settings.test.js
@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createShortcutSettingsController } from "../src/ui/controllers/shortcut-settings-controller.js";
+import {
+  SHORTCUT_STORAGE_KEY,
+  defaultShortcutBindings
+} from "../src/ui/shortcut-policy.js";
+import { installFakeAppStartupDom } from "./helpers/fake-dom-app-startup.mjs";
+
+function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function makeController() {
+  const { document } = installFakeAppStartupDom();
+  const host = document.createElement("section");
+  const state = { shortcuts: defaultShortcutBindings() };
+  const toasts = [];
+  const controller = createShortcutSettingsController({
+    state,
+    els: { host },
+    storage: localStorage,
+    showToast: (message) => toasts.push(message),
+    escapeHtml
+  });
+  return { controller, document, host, state, toasts };
+}
+
+function keyEvent(key, options = {}) {
+  return {
+    key,
+    ...options,
+    preventDefault() { this.defaultPrevented = true; },
+    stopPropagation() { this.propagationStopped = true; },
+    stopImmediatePropagation() { this.immediatePropagationStopped = true; }
+  };
+}
+
+test("shortcut settings renders all requested controls with Save and Cancel", () => {
+  const { controller, document } = makeController();
+  controller.showShortcutSettings();
+
+  assert.ok(document.body.querySelector(".shortcut-modal"));
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Ctrl+S");
+  assert.equal(document.body.querySelector("[data-shortcut-record='scroll-page-up']")?.textContent.trim(), "PageUp");
+  assert.equal(document.body.querySelector("[data-shortcut-record='scroll-left']")?.textContent.trim(), "Shift+Home");
+  assert.equal(document.body.querySelector("[data-shortcut-choice='save']")?.tagName, "BUTTON");
+  assert.equal(document.body.querySelector("[data-shortcut-choice='cancel']")?.tagName, "BUTTON");
+  assert.equal(document.body.querySelector("[data-shortcut-reset]")?.textContent.trim(), "Reset All to Defaults");
+  assert.equal(document.body.querySelector("[data-shortcut-default='save-file']")?.textContent.trim(), "Default");
+  assert.equal(document.body.querySelector("[data-shortcut-clear]"), null);
+  assert.equal(document.body.querySelector("[data-shortcut-error]"), null);
+});
+
+test("recorded shortcut applies only after Save", () => {
+  const { controller, document, state, toasts } = makeController();
+  controller.showShortcutSettings();
+
+  document.body.querySelector("[data-shortcut-record='save-file']").click();
+  const event = keyEvent("k", { ctrlKey: true });
+  document.listeners.get("keydown")[0](event);
+
+  assert.deepEqual(state.shortcuts["save-file"], ["Ctrl+S"]);
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Ctrl+K");
+  assert.equal(event.defaultPrevented, true);
+
+  document.body.querySelector("[data-shortcut-choice='save']").click();
+  assert.deepEqual(state.shortcuts["save-file"], ["Ctrl+K"]);
+  assert.ok(localStorage.getItem(SHORTCUT_STORAGE_KEY));
+  assert.deepEqual(toasts, ["Keyboard shortcuts saved."]);
+  assert.equal(document.body.querySelector(".shortcut-modal"), null);
+});
+
+test("Cancel and Escape discard shortcut drafts", () => {
+  const first = makeController();
+  first.controller.showShortcutSettings();
+  first.document.body.querySelector("[data-shortcut-record='save-file']").click();
+  first.document.listeners.get("keydown")[0](keyEvent("k", { ctrlKey: true }));
+  first.document.body.querySelector("[data-shortcut-choice='cancel']").click();
+  assert.deepEqual(first.state.shortcuts["save-file"], ["Ctrl+S"]);
+  assert.equal(first.document.activeElement, first.host);
+
+  const second = makeController();
+  second.controller.showShortcutSettings();
+  second.document.listeners.get("keydown")[0](keyEvent("Escape"));
+  assert.equal(second.document.body.querySelector(".shortcut-modal"), null);
+  assert.deepEqual(second.state.shortcuts["save-file"], ["Ctrl+S"]);
+});
+
+test("assigning an occupied shortcut transfers it and shows messages on both rows", () => {
+  const { controller, document, state } = makeController();
+  controller.showShortcutSettings();
+  document.body.querySelector("[data-shortcut-record='open-file']").click();
+  document.listeners.get("keydown")[0](keyEvent("s", { ctrlKey: true }));
+
+  const save = document.body.querySelector("[data-shortcut-choice='save']");
+  assert.notEqual(save.disabled, true);
+  assert.equal(document.body.querySelector("[data-shortcut-record='open-file']")?.textContent.trim(), "Ctrl+S");
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Unassigned");
+  assert.match(document.body.querySelector("[data-shortcut-message='open-file']").textContent, /previously assigned to Save/);
+  assert.match(document.body.querySelector("[data-shortcut-message='save-file']").textContent, /reassigned to Open File/);
+  assert.match(document.body.querySelector("[data-shortcut-message='save-file']").textContent, /now unassigned/);
+  assert.deepEqual(state.shortcuts["open-file"], ["Ctrl+O"]);
+  assert.deepEqual(state.shortcuts["save-file"], ["Ctrl+S"]);
+
+  save.click();
+  assert.deepEqual(state.shortcuts["open-file"], ["Ctrl+S"]);
+  assert.deepEqual(state.shortcuts["save-file"], []);
+  assert.equal(document.body.querySelector(".shortcut-modal"), null);
+});
+
+test("Default restores one shortcut without applying it before Save", () => {
+  const { controller, document, state } = makeController();
+  state.shortcuts["save-file"] = ["Ctrl+K"];
+  controller.showShortcutSettings();
+
+  document.body.querySelector("[data-shortcut-default='save-file']").click();
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Ctrl+S");
+  assert.deepEqual(state.shortcuts["save-file"], ["Ctrl+K"]);
+
+  document.body.querySelector("[data-shortcut-choice='save']").click();
+  assert.deepEqual(state.shortcuts["save-file"], ["Ctrl+S"]);
+});
+
+test("recording guidance and validation errors render below the active shortcut row", () => {
+  const { controller, document } = makeController();
+  controller.showShortcutSettings();
+
+  document.body.querySelector("[data-shortcut-record='save-file']").click();
+  assert.match(document.body.querySelector("[data-shortcut-message='save-file']").textContent, /Press the new shortcut/);
+
+  document.listeners.get("keydown")[0](keyEvent("Enter"));
+  assert.match(document.body.querySelector("[data-shortcut-message='save-file']").textContent, /reserved for grid editing/);
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Press shortcut...");
+});
+
+test("Default also transfers an occupied default binding from another command", () => {
+  const { controller, document, state } = makeController();
+  state.shortcuts["open-file"] = ["Ctrl+S"];
+  state.shortcuts["save-file"] = [];
+  controller.showShortcutSettings();
+
+  document.body.querySelector("[data-shortcut-default='save-file']").click();
+
+  assert.equal(document.body.querySelector("[data-shortcut-record='save-file']")?.textContent.trim(), "Ctrl+S");
+  assert.equal(document.body.querySelector("[data-shortcut-record='open-file']")?.textContent.trim(), "Unassigned");
+  assert.match(document.body.querySelector("[data-shortcut-message='open-file']").textContent, /reassigned to Save/);
+});