feat(markdown): share one renderer for chat and preview

Chat transcript and file Markdown preview used separate
pipelines, so math, code chrome, fonts, and allowlisted
HTML only worked in one place. Route both through
MarkdownView: preprocess TeX/HTML into safe markdown,
render with Qt NoHTML, paint formulas via a cached
layout engine, and cap wide/large previews so the UI
stays readable and responsive.

Author: nullmastermind

src/AcpTurnFolding.cpp

@@ -70,8 +70,8 @@ QVector<Turn> compute(const QVector<AcpTimelineEntry> &timeline,
     starts.append(n);
     const int turnCount = starts.size() - 1;
 
-    // The newest turn stays open for review; only older ones can fold, unless
-    // the caller wants it too (to give it an expanded "Worked for Xs" row).
+    // The newest turn may still be running; only older ones can fold, unless
+    // the caller says it has ended.
     const int lastTurn = includeNewest ? turnCount : turnCount - 1;
     for (int t = 0; t < lastTurn; ++t) {
         Turn turn;
@@ -98,25 +98,40 @@ QVector<Turn> compute(const QVector<AcpTimelineEntry> &timeline,
                 continue;
             const AcpTimelineEntry &e = timeline.at(i);
             if (e.kind == AcpTimelineEntry::Kind::ToolCall) {
-                if (toolCalls.contains(e.toolCallId))
+                if (toolCalls.contains(e.toolCallId)) {
                     turn.folded.append(i);
+                    ++turn.toolCalls;
+                }
             } else if (e.messageIndex >= 0 && e.messageIndex < messages.size()
                        && messageHasVisibleContent(messages.at(e.messageIndex))) {
                 turn.folded.append(i);
             }
         }
-        if (turn.folded.isEmpty())
-            continue;
-
         if (turn.anchor >= 0 && turn.survivor >= 0) {
             const qint64 a = messages.at(timeline.at(turn.anchor).messageIndex).timestamp;
             const qint64 b = messages.at(timeline.at(turn.survivor).messageIndex).timestamp;
             if (a > 0 && b >= a)
                 turn.workedMs = b - a;
         }
+        // A turn with nothing to fold still gets its "Worked for Xs" label
+        // (report-only reply), as long as there is a duration to show.
+        if (turn.folded.isEmpty() && turn.workedMs < 0)
+            continue;
         out.append(turn);
     }
     return out;
 }
 
+int newestTurnBegin(const QVector<AcpTimelineEntry> &timeline,
+                    const QVector<AcpMessage> &messages)
+{
+    if (timeline.isEmpty())
+        return -1;
+    for (int i = timeline.size() - 1; i > 0; --i) {
+        if (isUserAnchor(timeline.at(i), messages))
+            return i;
+    }
+    return 0;
+}
+
 } // namespace AcpTurnFolding

src/AcpTurnFolding.h

@@ -36,10 +36,10 @@
 //   - the survivor is the LAST assistant message with visible content — the
 //     report the user reads; it stays visible beside the fold row
 //   - every other entry that would render (tool calls, thoughts, earlier
-//     assistant messages) is folded
-// The LAST turn is never folded: the user reviews it. Once it ends the view
-// shows its "Worked for Xs" row expanded; it folds when a newer prompt starts
-// a new turn.
+//     assistant messages) is folded; a turn may fold nothing (report only)
+// While the newest turn runs it is not folded (the view shows a live ticking
+// "Worked for Xs" row above it); once it ends it folds exactly like every
+// older turn.
 //
 // Complexity: O(n) time over the timeline, one pass.
 namespace AcpTurnFolding {
@@ -51,18 +51,25 @@ struct Turn
     int anchor = -1;          // timeline index of the user/goal message; -1 for a prefix turn
     int survivor = -1;        // timeline index of the final report; -1 when there is none
     QVector<int> folded;      // timeline indices hidden while collapsed, in order
+    int toolCalls = 0;        // tool-call entries among `folded`
     qint64 workedMs = -1;     // anchor -> survivor wall time; -1 when unknown
 };
 
 bool messageHasVisibleContent(const AcpMessage &msg);
 
 // Every foldable turn except the newest turn (included when includeNewest is
-// set; the view then shows its row expanded). Turns with nothing to fold are omitted.
+// set, i.e. the newest turn has ended). A turn with nothing to fold is kept only
+// when its duration is known (the row is then a plain, non-expandable label).
 QVector<Turn> compute(const QVector<AcpTimelineEntry> &timeline,
                       const QVector<AcpMessage> &messages,
                       const QHash<QString, AcpProtocol::AcpToolCall> &toolCalls,
                       bool includeNewest = false);
 
+// First timeline index of the newest turn (last user/goal prompt, else 0);
+// -1 for an empty timeline.
+int newestTurnBegin(const QVector<AcpTimelineEntry> &timeline,
+                    const QVector<AcpMessage> &messages);
+
 } // namespace AcpTurnFolding
 
 #endif // ACP_TURN_FOLDING_H

src/CMakeLists.txt

@@ -14,6 +14,10 @@ qt_add_executable(NotepadAI
 	AcpSessionModel.h
 	AcpTranscriptTruncation.h
 	AcpTurnFolding.h
+	markdown/MarkdownPreprocessor.h
+	markdown/MathLayout.h
+	markdown/MathParser.h
+	markdown/MathRenderCache.h
 	ActionUtils.h
 	ApplicationSettings.h
 	CronExpression.h
@@ -69,8 +73,8 @@ qt_add_executable(NotepadAI
 	CsvSortFilter.h
 	CsvFilterStrip.h
 	IFaceTable.h
+	MarkdownPreviewSupport.h
 	MarkdownPreviewWidget.h
-	MarkdownRenderer.h
 	PandocExporter.h
 	PreviewContentWidget.h
 	PreviewTabManager.h
@@ -130,6 +134,10 @@ qt_add_executable(NotepadAI
 	AcpSessionModel.cpp
 	AcpTranscriptTruncation.cpp
 	AcpTurnFolding.cpp
+	markdown/MarkdownPreprocessor.cpp
+	markdown/MathLayout.cpp
+	markdown/MathParser.cpp
+	markdown/MathRenderCache.cpp
 	LocalAcpProcessChannel.cpp
 	SshAcpProcessChannel.cpp
 	CronExpression.cpp
@@ -178,7 +186,6 @@ qt_add_executable(NotepadAI
 	CsvFilterStrip.cpp
 	IFaceTable.cpp
 	MarkdownPreviewWidget.cpp
-	MarkdownRenderer.cpp
 	PandocExporter.cpp
 	PreviewTabManager.cpp
 	IFaceTableMixer.cpp
@@ -451,7 +458,10 @@ qt_add_executable(NotepadAI
     widgets/AcpImageAttachmentList.cpp
 	widgets/AcpImageAttachmentList.h
 	widgets/AcpMessageWidget.cpp
+	widgets/MarkdownView.cpp
 	widgets/AcpMessageWidget.h
+	widgets/ChatFont.h
+	widgets/MarkdownView.h
 	widgets/AcpPermissionPrompt.cpp
 	widgets/AcpPermissionPrompt.h
 	widgets/AcpPlanWidget.cpp

src/MarkdownPreviewSupport.h

@@ -0,0 +1,54 @@
+/*
+ * This file is part of Notepad Next.
+ * Copyright 2026 NotepadAI contributors
+ *
+ * Notepad Next is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Notepad Next is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Notepad Next.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef MARKDOWN_PREVIEW_SUPPORT_H
+#define MARKDOWN_PREVIEW_SUPPORT_H
+
+#include <QString>
+
+// The two pure pieces of MarkdownPreviewWidget, kept free of the application so
+// they can be unit-tested.
+namespace MarkdownPreviewSupport {
+
+// Cap a document before it reaches the synchronous renderer. Over the cap the text
+// is cut at the last line boundary (unless that would discard more than half the
+// budget, then at the cap itself) and a truncation notice is appended.
+inline QString clampSource(const QString &text, int maxChars)
+{
+    if (text.size() <= maxChars)
+        return text;
+    int cut = int(text.lastIndexOf(QLatin1Char('\n'), maxChars));
+    if (cut < maxChars / 2)
+        cut = maxChars;
+    return text.left(cut)
+           + QStringLiteral("\n\n---\n\n*[Preview truncated — file too large]*\n");
+}
+
+// Where in the rendered document a source line lands, as a 0..1 fraction of the
+// scroll range: (line - 1) / (totalLines - 1), clamped. 0 for degenerate input.
+inline double scrollFraction(int line, int totalLines)
+{
+    if (totalLines <= 1)
+        return 0.0;
+    const double f = double(line - 1) / double(totalLines - 1);
+    return f < 0.0 ? 0.0 : (f > 1.0 ? 1.0 : f);
+}
+
+} // namespace MarkdownPreviewSupport
+
+#endif // MARKDOWN_PREVIEW_SUPPORT_H