@happy-nut/monacori 0.1.22 → 0.1.25

package/dist/viewer.client.js

@@ -1100,6 +1100,11 @@ function handleTreeKey(event) {
   if (event.key === 'ArrowUp') { event.preventDefault(); focusTree(treeFocusIndex - 1); return true; }
   if (event.key === 'PageDown') { event.preventDefault(); focusTree(treeFocusIndex + treePageSize()); return true; }
   if (event.key === 'PageUp') { event.preventDefault(); focusTree(treeFocusIndex - treePageSize()); return true; }
+  if (event.key === 'Enter' && event.altKey) {
+    event.preventDefault();
+    if (row && typeof openTreeRowMenu === 'function') openTreeRowMenu(row); // copy path / Finder / terminal
+    return true;
+  }
   if (event.key === 'Enter') {
     event.preventDefault();
     if (row && row.classList.contains('file-link')) { row.click(); clearTreeFocus(); }
@@ -1137,6 +1142,9 @@ function handleTreeKey(event) {
 function isFloatingModalOpen() {
   var sm = document.getElementById('settings-modal');
   if (sm && !sm.classList.contains('hidden')) return true;
+  var hv = document.getElementById('history-view');
+  if (hv && !hv.classList.contains('hidden')) return true; // history overlay owns the keys (Esc/filter/click)
+  if (document.getElementById('goto-line')) return true; // go-to-line prompt owns the keys until Enter/Esc
   // The merged/memo panels are now docked (inline), not overlays — but while one OWNS focus we still stand
   // down the global nav shortcuts so typing / ▲▼ inside it isn't hijacked. Focus elsewhere -> shortcuts run.
   return isDockFocused();
@@ -1170,11 +1178,27 @@ document.addEventListener('keydown', (event) => {
     openMemoView();
     return;
   }
+  // Cmd/Ctrl+9 toggles the git history view (above the focus guard so a 2nd press closes it from inside).
+  if (!settingsUp && (event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.code === 'Digit9' || event.key === '9') && typeof toggleHistory === 'function') {
+    event.preventDefault();
+    toggleHistory();
+    return;
+  }
 
   // Settings overlay (or a focused merged/memo dock) captures keys: stand down the rest of the global
   // shortcuts (Cmd+1, F7, Cmd+[/], Cmd+B, …). Each has its own Esc + editing handlers.
   if (isFloatingModalOpen()) return;
 
+  // Cmd/Ctrl+A in the diff/source view selects ONLY that view's content (the browser default reached into
+  // the sidebar + terminal). In an editable field, let the default select-within-field stand.
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'a' || event.key === 'A')) {
+    var aae = document.activeElement;
+    if (!(aae && (aae.tagName === 'INPUT' || aae.tagName === 'TEXTAREA' || aae.tagName === 'SELECT')) && selectAllInView()) {
+      event.preventDefault();
+      return;
+    }
+  }
+
   if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === '1') {
     event.preventDefault();
     // Coming from the diff: open the file you were viewing as source so Cmd+1 lands ON it (not a stale/blank
@@ -1190,6 +1214,24 @@ document.addEventListener('keydown', (event) => {
     focusOpenFileInTree();
     return;
   }
+  // Cmd/Ctrl+L = go to line (numeric prompt); Cmd/Ctrl+K = copy the caret's file:line. Skip when an
+  // editable field owns focus (a comment composer textarea) so we don't hijack the user's typing.
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'l' || event.key === 'L')) {
+    var lkae = document.activeElement;
+    if (!(lkae && (lkae.tagName === 'INPUT' || lkae.tagName === 'TEXTAREA' || lkae.tagName === 'SELECT'))) {
+      event.preventDefault();
+      openGotoLine();
+      return;
+    }
+  }
+  if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && (event.key === 'k' || event.key === 'K')) {
+    var kkae = document.activeElement;
+    if (!(kkae && (kkae.tagName === 'INPUT' || kkae.tagName === 'TEXTAREA' || kkae.tagName === 'SELECT'))) {
+      event.preventDefault();
+      copyCaretLocation();
+      return;
+    }
+  }
   if ((event.metaKey || event.ctrlKey) && !event.shiftKey && !event.altKey && event.key === '0') {
     event.preventDefault();
     setTab('changes');
@@ -1483,6 +1525,7 @@ document.querySelector('.activity-rail')?.addEventListener('click', (event) => {
   else if (view === 'files') { setTab('files'); }
   else if (view === 'q' || view === 'c') { toggleMergedRail(view); }
   else if (view === 'memo') { openMemoView(); } // openMemoView already toggles
+  else if (view === 'history') { toggleHistory(); }
   syncRail();
 });
 
@@ -2834,6 +2877,10 @@ refreshComments();
     // Exception: keep focus for clipboard/selection combos (Cmd+C/V/X/A) so the terminal's own copy &
     // paste keep working — blurring on Cmd+V drops the textarea focus the paste event needs.
     term.attachCustomKeyEventHandler(function (e) {
+      // F7 / Shift+F7 are diff prev/next-change nav. Don't let the terminal eat them (it would send an
+      // escape sequence to the shell); return false so xterm ignores the key and it bubbles to the document
+      // handler. We DON'T blur — the diff caret is a JS cursor, so nav runs while the terminal keeps focus.
+      if (e.type === 'keydown' && e.key === 'F7' && !e.metaKey && !e.ctrlKey && !e.altKey) return false;
       if (e.type === 'keydown' && e.metaKey) {
         var k = (e.key || '').toLowerCase();
         // The bare modifier press (Cmd goes down BEFORE the letter on macOS) must not blur — blurring
@@ -2846,6 +2893,10 @@ refreshComments();
         // copy misses xterm's own selection, so Cmd+C silently did nothing. No selection -> fall through.
         if (e.code === 'KeyC' && term.hasSelection && term.hasSelection()) { copyToClipboard(term.getSelection()); return false; }
         if (e.code === 'KeyC' || e.code === 'KeyV' || e.code === 'KeyX' || e.code === 'KeyA') return true;
+        // Cmd/Ctrl+W is the close-pane menu accelerator. onCloseTab closes the FOCUSED pane only if the
+        // terminal still has focus — blurring here first made hasFocus() false, so the focused split pane
+        // never closed. Release the key WITHOUT blurring so focus stays and onCloseTab can close it.
+        if (e.code === 'KeyW') return false;
         try { term.blur(); } catch (x) {}
         return false;
       }
@@ -3266,6 +3317,8 @@ function syncRail() {
   setOn('q', !!(merged && merged.dataset.kind === 'q'));
   setOn('c', !!(merged && merged.dataset.kind === 'c'));
   setOn('memo', !!document.getElementById('mc-memo-panel'));
+  var hv = document.getElementById('history-view');
+  setOn('history', !!(hv && !hv.classList.contains('hidden')));
 }
 // Rail click for the merged views toggles: a 2nd click on the open kind closes it (memo already toggles).
 function toggleMergedRail(kind) {
@@ -3348,15 +3401,21 @@ function restoreUiState() {
       }
       return true;
     }
-    if (state.sourcePath && sourceByPath.has(state.sourcePath)) {
-      openSourceFile(state.sourcePath);
+    // Source view. Open the saved file — or fall back to the first restored tab when that file is gone
+    // (filtered out above) or wasn't recorded. Otherwise we'd render the tab bar but leave the body on its
+    // "select a file" placeholder, which looks broken (a tab is clearly open). No openable tab → drop the
+    // stale tabs and let the init fallback pick a sensible default.
+    var openPath = (state.sourcePath && sourceByPath.has(state.sourcePath)) ? state.sourcePath : (sourceTabs[0] || '');
+    if (openPath) {
+      openSourceFile(openPath);
       // Restore the exact source caret/scroll (openSourceFile alone resets it to the top).
-      if (state.viewerCursor && state.viewerCursor.path === state.sourcePath) {
+      if (state.viewerCursor && state.viewerCursor.path === openPath) {
         var vc = state.viewerCursor;
-        setTimeout(function () { try { setSourceCursor(state.sourcePath, vc.lineIndex, vc.column, true, -1); } catch (e) {} }, 60);
+        setTimeout(function () { try { setSourceCursor(openPath, vc.lineIndex, vc.column, true, -1); } catch (e) {} }, 60);
       }
       return true;
     }
+    sourceTabs = [];
   } catch {
     sessionStorage.removeItem(uiStateKey);
   }
@@ -3377,6 +3436,45 @@ function flushPendingDiffUpdate() {
   pendingDiffUpdate = null;
   try { applyDiffUpdate(u); } catch (e) {}
 }
+// Flicker-saver for the live-watch refresh. The default path replaces the WHOLE diff DOM
+// (container.innerHTML = …), which re-renders the file you're looking at even when only an OFF-SCREEN file
+// changed. When the file set AND order are identical, reconcile per-file instead: keep every unchanged
+// wrapper's DOM node untouched (no flicker — including the visible one) and swap only the changed wrappers,
+// which are off-screen so the swap is invisible. Returns false (caller does the full innerHTML swap) for the
+// risky cases — files added/removed/reordered — so that proven path still handles index-shift correctly.
+function reconcileDiffWrappers(container, newDiffHtml, oldSigByPath, newSigByPath) {
+  var oldW = Array.prototype.slice.call(container.querySelectorAll('.d2h-file-wrapper'));
+  if (!oldW.length) return false;
+  var tmp = document.createElement('div');
+  tmp.innerHTML = newDiffHtml;
+  var newW = Array.prototype.slice.call(tmp.querySelectorAll('.d2h-file-wrapper'));
+  if (newW.length !== oldW.length) return false; // add/remove → full swap (global hunk indices shift)
+  for (var i = 0; i < oldW.length; i++) {
+    if (diffWrapperPathKey(oldW[i]) !== diffWrapperPathKey(newW[i])) return false; // reordered → full swap
+  }
+  for (var j = 0; j < oldW.length; j++) {
+    var ow = oldW[j], nw = newW[j], p = diffWrapperPathKey(ow);
+    if ((oldSigByPath.get(p) || '') !== (newSigByPath.get(p) || '')) {
+      // Changed file (off-screen): drop in the fresh shell and clear its cached body so it refetches the
+      // new content when it next scrolls into view. Replacing an off-screen node is invisible.
+      var nidx = (nw.id || '').replace('file-', '');
+      delete bodyCache[nidx];
+      delete bodyPromise[nidx];
+      ow.parentNode.replaceChild(nw, ow);
+    } else {
+      // Unchanged file: keep its DOM node (no flicker). An earlier file's changed hunk count can shift the
+      // global numbering, so sync the index attrs and renumber a materialized body's hunk ids (id/class
+      // changes only — invisible, no flicker).
+      var baseChanged = ow.getAttribute('data-first-hunk') !== nw.getAttribute('data-first-hunk');
+      ow.id = nw.id;
+      if (nw.hasAttribute('data-first-hunk')) ow.setAttribute('data-first-hunk', nw.getAttribute('data-first-hunk'));
+      if (nw.hasAttribute('data-hunk-count')) ow.setAttribute('data-hunk-count', nw.getAttribute('data-hunk-count'));
+      var body = ow.querySelector('.d2h-files-diff');
+      if (baseChanged && body && !body.hasAttribute('data-lazy')) markWrapperHunks(ow);
+    }
+  }
+  return true;
+}
 function applyDiffUpdate(u) {
   if (!u || !u.signature || u.signature === currentSignature) return false; // unchanged — nothing to do
   if (composerState) { pendingDiffUpdate = u; return false; } // composing a comment — hold the refresh until close/save
@@ -3396,11 +3494,19 @@ function applyDiffUpdate(u) {
   // open file's signature BEFORE fileSignatureByPath is rebuilt below.
   var prevOpenSig = openPath ? (fileSignatureByPath.get(openPath) || '') : '';
 
-  // Snapshot already-materialized file bodies (keyed by path + current signature) BEFORE the swap, so an
-  // UNCHANGED file can be re-filled synchronously afterwards. Without this, the swap turns every wrapper into
-  // an empty lazy shell that blanks until its body re-loads over IPC — the visible "flicker" on a watch tick.
+  // Fast-path: when the file set + order are unchanged, reconcile per-file so an off-screen change never
+  // flickers the file you're viewing. Falls back to the full swap (below) for add/remove/reorder or eager.
+  var newSigByPath = new Map((u.fileStates || []).map(function (f) { return [f.path, f.signature]; }));
+  var fastPath = false;
+  if (REVIEW_LAZY && container && u.diffContainer) {
+    fastPath = reconcileDiffWrappers(container, u.diffContainer, fileSignatureByPath, newSigByPath);
+  }
+
+  // Full-swap path only: snapshot already-materialized bodies (keyed by path + signature) BEFORE the swap so
+  // UNCHANGED files re-fill synchronously afterwards — otherwise the swap blanks every wrapper into an empty
+  // lazy shell until its body reloads over IPC (the "flicker"). The fast-path keeps those nodes, so skip it.
   var prevBodies = {};
-  if (REVIEW_LAZY && container) {
+  if (!fastPath && REVIEW_LAZY && container) {
     container.querySelectorAll('.d2h-file-wrapper').forEach(function (w) {
       var b = w.querySelector('.d2h-files-diff');
       if (!b || b.hasAttribute('data-lazy')) return; // only bodies that are actually materialized
@@ -3409,8 +3515,9 @@ function applyDiffUpdate(u) {
     });
   }
 
-  // 1) Replace the visible regions straight from the payload (no full-HTML parse).
-  if (container) container.innerHTML = u.diffContainer || '';
+  // 1) Replace the visible regions straight from the payload (no full-HTML parse) — unless the fast-path
+  // already reconciled the diff DOM in place.
+  if (container && !fastPath) container.innerHTML = u.diffContainer || '';
   var changesPanel = document.getElementById('changes-panel');
   if (changesPanel) changesPanel.innerHTML = u.changesPanel || '';
   // Files tree: keep the inert island (lazy, not yet opened) in sync, and refresh the live panel when it's
@@ -3472,7 +3579,7 @@ function applyDiffUpdate(u) {
   // flicker). Runs BEFORE setupLazyDiff so the IntersectionObserver sees them already materialized and never
   // re-fetches them. The fresh wrapper carries the correct data-first-hunk + file index, so materializeBody
   // numbers hunks exactly as a normal lazy load would. Changed/new files stay shells and lazy-load as usual.
-  if (REVIEW_LAZY && container) {
+  if (!fastPath && REVIEW_LAZY && container) {
     container.querySelectorAll('.d2h-file-wrapper').forEach(function (w) {
       var p = diffWrapperPathKey(w);
       var prev = p ? prevBodies[p] : null;
@@ -3859,6 +3966,26 @@ function isSourceViewerVisible() {
   return Boolean(viewer && !viewer.classList.contains('hidden'));
 }
 
+// Cmd/Ctrl+A scoped to the current view: select the source body, or the active diff file's content —
+// NOT the whole page (the browser default reached into the sidebar/terminal). Returns false if there's
+// no view target so the caller can fall back to the default.
+function selectAllInView() {
+  var target = null;
+  if (isSourceViewerVisible()) target = document.getElementById('source-body');
+  else if (typeof isDiffViewVisible === 'function' && isDiffViewVisible()) {
+    target = document.querySelector('#diff2html-container .d2h-file-wrapper:not(.df-inactive)') || document.getElementById('diff2html-container');
+  }
+  if (!target) return false;
+  try {
+    var sel = window.getSelection();
+    var range = document.createRange();
+    range.selectNodeContents(target);
+    sel.removeAllRanges();
+    sel.addRange(range);
+  } catch (e) { return false; }
+  return true;
+}
+
 function openDiffFileAtCaret() {
   if (diffCursor && isDiffViewVisible()) {
     const dwrap = diffWrapperByPath(diffCursor.path);
@@ -5175,3 +5302,328 @@ function formatBytes(bytes) {
   if (kib < 1024) return kib.toFixed(1) + ' KiB';
   return (kib / 1024).toFixed(1) + ' MiB';
 }
+// ===== Git history view (Cmd+9): commit list with graph lanes + per-commit diff. =====
+// Data comes from the main process (window.monacoriGit.log / .commitDiff); the lane layout is computed
+// here from each commit's parents. Read-only — the per-commit diff is static diff2html HTML.
+
+var HISTORY_LANE_W = 14, HISTORY_DOT_R = 3.5, HISTORY_ROW_H = 24;
+var HISTORY_COLORS = ['#6c9fd4', '#7faf6b', '#d4a857', '#c77dd4', '#d36c6c', '#5bb6b6', '#b0884f', '#8d8df0'];
+var historyCommits = [];
+var historyGraph = [];
+var historyMaxLane = 0;
+var historyActiveSha = '';
+var historyLoading = false;
+
+// Lane layout. Walks commits newest-first, tracking open edges (lanes) by the hash each expects next.
+// Returns per-row { hash, myLane, color, topEdges, bottomEdges } using LANE INDICES + COLOR INDICES (px-free,
+// so it's unit-testable). First parent inherits the commit's color so a branch keeps one hue down its line.
+function computeHistoryGraph(commits) {
+  var lanes = [];           // lane index -> hash the lane is waiting to reach (open edge from above)
+  var colorOf = {};         // hash -> color index
+  var next = 0;
+  function colorFor(h) { if (colorOf[h] == null) colorOf[h] = next++; return colorOf[h]; }
+  function freeLane() { for (var i = 0; i < lanes.length; i++) if (lanes[i] == null) return i; lanes.push(null); return lanes.length - 1; }
+  var rows = [];
+  var maxLane = 0;
+  for (var ci = 0; ci < commits.length; ci++) {
+    var c = commits[ci];
+    var incoming = lanes.slice();
+    var myLane = lanes.indexOf(c.hash);
+    if (myLane === -1) myLane = freeLane();
+    var myColor = colorFor(c.hash);
+    lanes[myLane] = c.hash;
+    for (var i = 0; i < lanes.length; i++) if (i !== myLane && lanes[i] === c.hash) lanes[i] = null; // merge other edges in
+    var parents = c.parents || [];
+    var parentLanes = {};
+    if (parents.length === 0) {
+      lanes[myLane] = null; // root commit — the lane ends here
+    } else {
+      lanes[myLane] = parents[0];
+      if (colorOf[parents[0]] == null) colorOf[parents[0]] = myColor; // first parent keeps the hue
+      parentLanes[myLane] = true;
+      for (var p = 1; p < parents.length; p++) {
+        var ex = lanes.indexOf(parents[p]);
+        var l = ex !== -1 ? ex : freeLane();
+        lanes[l] = parents[p];
+        colorFor(parents[p]);
+        parentLanes[l] = true;
+      }
+    }
+    var outgoing = lanes.slice();
+    var topEdges = [];
+    for (var a = 0; a < incoming.length; a++) {
+      if (incoming[a] == null) continue;
+      topEdges.push({ from: a, to: incoming[a] === c.hash ? myLane : a, color: colorOf[incoming[a]] });
+    }
+    var bottomEdges = [];
+    for (var b = 0; b < outgoing.length; b++) {
+      if (outgoing[b] == null) continue;
+      bottomEdges.push({ from: parentLanes[b] ? myLane : b, to: b, color: colorOf[outgoing[b]] });
+    }
+    for (var m = 0; m < Math.max(incoming.length, outgoing.length); m++) {
+      if (incoming[m] != null || outgoing[m] != null) maxLane = Math.max(maxLane, m);
+    }
+    maxLane = Math.max(maxLane, myLane);
+    rows.push({ hash: c.hash, myLane: myLane, color: myColor, topEdges: topEdges, bottomEdges: bottomEdges });
+  }
+  rows.maxLane = maxLane;
+  return rows;
+}
+if (typeof window !== 'undefined') window.computeHistoryGraph = computeHistoryGraph; // exposed for tests
+
+function historyLaneX(l) { return 9 + l * HISTORY_LANE_W; }
+function historyColor(i) { return HISTORY_COLORS[i % HISTORY_COLORS.length]; }
+function historyRowSvg(row) {
+  var w = historyLaneX(historyMaxLane) + 9, h = HISTORY_ROW_H, mid = h / 2;
+  var s = '<svg class="hgraph" width="' + w + '" height="' + h + '" viewBox="0 0 ' + w + ' ' + h + '" aria-hidden="true">';
+  var edge = function (e, y1, y2) {
+    var x1 = historyLaneX(e.from), x2 = historyLaneX(e.to);
+    var c1 = (y1 + y2) / 2;
+    return '<path d="M' + x1 + ' ' + y1 + ' C ' + x1 + ' ' + c1 + ', ' + x2 + ' ' + c1 + ', ' + x2 + ' ' + y2 + '" stroke="' + historyColor(e.color) + '" fill="none" stroke-width="1.6"/>';
+  };
+  row.topEdges.forEach(function (e) { s += edge(e, 0, mid); });
+  row.bottomEdges.forEach(function (e) { s += edge(e, mid, h); });
+  s += '<circle cx="' + historyLaneX(row.myLane) + '" cy="' + mid + '" r="' + HISTORY_DOT_R + '" fill="' + historyColor(row.color) + '"/></svg>';
+  return s;
+}
+
+// "HEAD -> main, origin/main, tag: v1" -> small badges (HEAD/branch/tag styled distinctly).
+function historyRefBadges(refs) {
+  if (!refs || !refs.trim()) return '';
+  return refs.split(',').map(function (r) {
+    r = r.trim();
+    if (!r) return '';
+    var cls = 'href-branch', label = r;
+    if (r.indexOf('tag:') === 0) { cls = 'href-tag'; label = r.replace('tag:', '').trim(); }
+    else if (r.indexOf('HEAD') === 0) { cls = 'href-head'; }
+    else if (r.indexOf('origin/') === 0 || r.indexOf('/') !== -1) { cls = 'href-remote'; }
+    return '<span class="href ' + cls + '">' + escapeHtml(label) + '</span>';
+  }).join('');
+}
+
+function historyShortDate(iso) {
+  if (!iso) return '';
+  // 2026-06-20T21:03:11+09:00 -> "2026-06-20 21:03"
+  var m = String(iso).match(/^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})/);
+  return m ? m[1] + ' ' + m[2] : String(iso).slice(0, 16);
+}
+
+function renderHistoryList() {
+  var list = document.getElementById('history-list');
+  if (!list) return;
+  if (!historyCommits.length) {
+    list.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t(historyLoading ? 'history.loading' : 'history.empty')) + '</div>';
+    return;
+  }
+  list.style.setProperty('--hgraph-w', (historyLaneX(historyMaxLane) + 9) + 'px');
+  list.innerHTML = historyCommits.map(function (c, i) {
+    return '<button type="button" class="hrow' + (c.hash === historyActiveSha ? ' active' : '') + '" data-sha="' + escapeHtml(c.hash) + '">'
+      + '<span class="hgraph-cell">' + historyRowSvg(historyGraph[i]) + '</span>'
+      + '<span class="hmsg">' + historyRefBadges(c.refs) + escapeHtml(c.subject) + '</span>'
+      + '<span class="hauthor">' + escapeHtml(c.author) + '</span>'
+      + '<span class="hdate">' + escapeHtml(historyShortDate(c.date)) + '</span>'
+      + '</button>';
+  }).join('');
+}
+
+// Text filter (subject / author). The graph only reads right on the full contiguous history, so filtering
+// hides the graph column (IntelliJ does the same) and just shows matching rows.
+function applyHistoryFilter() {
+  var input = document.getElementById('history-search');
+  var list = document.getElementById('history-list');
+  if (!list) return;
+  var q = (input && input.value || '').trim().toLowerCase();
+  list.classList.toggle('filtering', q.length > 0);
+  var rows = list.querySelectorAll('.hrow');
+  for (var i = 0; i < rows.length; i++) {
+    var c = historyCommits[i];
+    var hit = !q || (c.subject + '\n' + c.author + '\n' + c.hash).toLowerCase().indexOf(q) !== -1;
+    rows[i].classList.toggle('hidden', !hit);
+  }
+}
+
+function openHistoryCommit(sha) {
+  if (!sha || !window.monacoriGit) return;
+  historyActiveSha = sha;
+  var list = document.getElementById('history-list');
+  if (list) list.querySelectorAll('.hrow').forEach(function (r) { r.classList.toggle('active', r.dataset.sha === sha); });
+  var detail = document.getElementById('history-detail');
+  if (detail) detail.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t('history.loading')) + '</div>';
+  Promise.resolve(window.monacoriGit.commitDiff(sha)).then(function (d) {
+    if (!d || historyActiveSha !== sha) return; // selection moved on while loading
+    renderHistoryDetail(d);
+  }, function () {});
+}
+
+function renderHistoryDetail(d) {
+  var detail = document.getElementById('history-detail');
+  if (!detail) return;
+  var head = '<div class="history-detail-head">'
+    + '<div class="hd-msg">' + escapeHtml(d.message || '').replace(/\n/g, '<br>') + '</div>'
+    + '<div class="hd-meta"><span class="hd-hash">' + escapeHtml((d.hash || '').slice(0, 10)) + '</span>'
+    + '<span class="hd-author">' + escapeHtml(d.author) + (d.email ? ' &lt;' + escapeHtml(d.email) + '&gt;' : '') + '</span>'
+    + '<span class="hd-date">' + escapeHtml(historyShortDate(d.date)) + '</span>'
+    + historyRefBadges(d.refs) + '</div></div>';
+  var body = (d.diffHtml && d.diffHtml.trim())
+    ? '<div class="history-diff diff2html-container">' + d.diffHtml + '</div>'
+    : '<div class="quick-open-empty">' + escapeHtml(t(d.isMerge ? 'history.merge' : 'history.noDiff')) + '</div>';
+  detail.innerHTML = head + body;
+}
+
+function isHistoryOpen() {
+  var v = document.getElementById('history-view');
+  return !!(v && !v.classList.contains('hidden'));
+}
+function closeHistory() {
+  var v = document.getElementById('history-view');
+  if (v) v.classList.add('hidden');
+  if (typeof syncRail === 'function') syncRail();
+}
+function openHistory() {
+  var v = document.getElementById('history-view');
+  if (!v) return;
+  if (!window.monacoriGit) return; // browser/serve mode: no git bridge
+  v.classList.remove('hidden');
+  if (typeof syncRail === 'function') syncRail();
+  var search = document.getElementById('history-search');
+  if (search) { search.value = ''; }
+  applyHistoryFilter();
+  historyLoading = true;
+  renderHistoryList();
+  Promise.resolve(window.monacoriGit.log({ limit: 300 })).then(function (commits) {
+    historyLoading = false;
+    historyCommits = Array.isArray(commits) ? commits : [];
+    historyGraph = computeHistoryGraph(historyCommits);
+    historyMaxLane = historyGraph.maxLane || 0;
+    renderHistoryList();
+    var detail = document.getElementById('history-detail');
+    if (detail) detail.innerHTML = '<div class="quick-open-empty">' + escapeHtml(t('history.selectCommit')) + '</div>';
+    if (historyCommits[0]) openHistoryCommit(historyCommits[0].hash); // preview the newest commit
+    if (search) setTimeout(function () { try { search.focus(); } catch (e) {} }, 0);
+  }, function () { historyLoading = false; renderHistoryList(); });
+}
+function toggleHistory() { if (isHistoryOpen()) closeHistory(); else openHistory(); }
+if (typeof window !== 'undefined') window.__monacoriHistory = { open: openHistory, close: closeHistory, toggle: toggleHistory, isOpen: isHistoryOpen };
+
+(function wireHistory() {
+  var list = document.getElementById('history-list');
+  if (list) list.addEventListener('click', function (e) {
+    var row = e.target.closest && e.target.closest('.hrow[data-sha]');
+    if (row) openHistoryCommit(row.dataset.sha);
+  });
+  var search = document.getElementById('history-search');
+  if (search) search.addEventListener('input', applyHistoryFilter);
+  var closeBtn = document.getElementById('history-close');
+  if (closeBtn) closeBtn.addEventListener('click', closeHistory);
+  var view = document.getElementById('history-view');
+  if (view) view.addEventListener('keydown', function (e) {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); closeHistory(); }
+  });
+})();
+// ===== Go-to-line (Cmd/Ctrl+L), copy caret location (Cmd/Ctrl+K), and the sidebar row action menu. =====
+
+// Programmatic clipboard write. Electron's bridge is reliable on file://; navigator.clipboard is the fallback.
+function copyTextToClipboard(text) {
+  try { if (window.monacoriClipboard && typeof window.monacoriClipboard.write === 'function') { window.monacoriClipboard.write(text); return true; } } catch (e) {}
+  try { if (navigator.clipboard && navigator.clipboard.writeText) { navigator.clipboard.writeText(text); return true; } } catch (e) {}
+  return false;
+}
+
+// "path:line" for the current caret — source view (the painted file) or the diff caret. '' if neither.
+function caretLocation() {
+  if (typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) {
+    var sv = document.getElementById('source-viewer');
+    var p = (sv && sv.dataset.openPath) || '';
+    if (p && typeof viewerCursor !== 'undefined' && viewerCursor && viewerCursor.path === p) return p + ':' + (viewerCursor.lineIndex + 1);
+    if (p) return p;
+  }
+  if (typeof isDiffViewVisible === 'function' && isDiffViewVisible() && typeof diffCursor !== 'undefined' && diffCursor) {
+    var wrap = diffWrapperByPath(diffCursor.path);
+    var row = wrap ? diffRowAt(wrap, diffCursor.side, diffCursor.rowIndex) : null;
+    var ln = row ? diffLineNumber(row) : null;
+    return diffCursor.path + (ln ? ':' + ln : '');
+  }
+  return '';
+}
+
+// Cmd/Ctrl+K — copy the caret's file:line to the clipboard.
+function copyCaretLocation() {
+  var loc = caretLocation();
+  if (!loc) return;
+  if (copyTextToClipboard(loc) && typeof showToast === 'function') showToast(t('goto.copied') + ' ' + loc);
+}
+
+// Diff view: place the caret on the row whose (new, then old) line number matches n, in the active file.
+function gotoDiffLine(n) {
+  var path = (typeof diffCursor !== 'undefined' && diffCursor && diffCursor.path) || '';
+  if (!path && typeof diffActiveWrapper === 'function') {
+    var w = diffActiveWrapper();
+    var nm = w && w.querySelector('.d2h-file-name');
+    if (nm && nm.textContent) path = nm.textContent.trim();
+  }
+  var wrap = path && diffWrapperByPath(path);
+  if (!wrap) return;
+  var sides = [(diffCursor && diffCursor.side) || 'new', 'new', 'old'];
+  for (var s = 0; s < sides.length; s++) {
+    var rows = diffRowsOf(diffSideTable(wrap, sides[s]));
+    for (var i = 0; i < rows.length; i++) {
+      if (diffLineNumber(rows[i]) === n) { setDiffCursor(path, sides[s], i, 0, true); return; }
+    }
+  }
+}
+
+function gotoLineJump(n) {
+  if (!(n >= 1)) return;
+  if (typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) {
+    var sv = document.getElementById('source-viewer');
+    var p = (sv && sv.dataset.openPath) || '';
+    var f = p && sourceByPath.get(p);
+    if (f && f.embedded && typeof f.content === 'string') {
+      var max = f.content.split(/\r?\n/).length;
+      setSourceCursor(p, Math.max(0, Math.min(max - 1, n - 1)), 0, true, -1);
+      return;
+    }
+  }
+  if (typeof isDiffViewVisible === 'function' && isDiffViewVisible()) gotoDiffLine(n);
+}
+
+// Cmd/Ctrl+L — a small numeric prompt; Enter jumps, Esc closes.
+function openGotoLine() {
+  if (!((typeof isSourceViewerVisible === 'function' && isSourceViewerVisible()) || (typeof isDiffViewVisible === 'function' && isDiffViewVisible()))) return;
+  var prior = document.getElementById('goto-line');
+  if (prior) prior.remove();
+  var box = document.createElement('div');
+  box.id = 'goto-line';
+  box.className = 'goto-line';
+  var input = document.createElement('input');
+  input.type = 'text';
+  input.inputMode = 'numeric';
+  input.className = 'goto-line-input';
+  input.placeholder = t('goto.placeholder');
+  box.appendChild(input);
+  document.body.appendChild(box);
+  function close() { box.remove(); document.removeEventListener('keydown', onKey, true); }
+  function onKey(e) {
+    if (e.key === 'Escape') { e.preventDefault(); e.stopPropagation(); close(); }
+    else if (e.key === 'Enter') { e.preventDefault(); e.stopPropagation(); var n = parseInt(input.value, 10); close(); if (n >= 1) gotoLineJump(n); }
+  }
+  // Capture phase so Enter/Esc are handled here before the global keymap (which is on bubble).
+  document.addEventListener('keydown', onKey, true);
+  setTimeout(function () { try { input.focus(); } catch (e) {} }, 0);
+}
+
+// Sidebar Opt+Enter: actions for a focused file row (copy path / reveal in Finder / open terminal here).
+function openTreeRowMenu(row) {
+  if (!row) return;
+  var path = row.dataset.sourceFile || row.dataset.file || '';
+  if (!path) return;
+  var r = row.getBoundingClientRect();
+  var items = [
+    { label: t('menu.copyPath'), onSelect: function () { if (copyTextToClipboard(path) && typeof showToast === 'function') showToast(t('goto.copied') + ' ' + path); } },
+  ];
+  if (window.monacoriApp && typeof window.monacoriApp.revealInFinder === 'function') {
+    items.push({ label: t('menu.revealFinder'), onSelect: function () { try { window.monacoriApp.revealInFinder(path); } catch (e) {} } });
+    items.push({ label: t('menu.openTerminal'), onSelect: function () { try { window.monacoriApp.openTerminalAt(path); } catch (e) {} } });
+  }
+  showCustomDropdown(Math.round(r.left + 14), Math.round(r.bottom + 2), items, Math.round(r.top));
+}