Perf/typing hotpath main

Demo/MarkdownEngineDemo/ContentView.swift

@@ -107,12 +107,34 @@ private var sampleMarkdown: String {
     [
         markdownHeader,
         inlineFormattingSection,
+        tableSection,
         latexSection,
         codeSection,
         markdownFooter,
     ].joined(separator: "\n\n")
 }
 
+/// Table layout demo: the first table's cells WRAP to the available width
+/// (CSS auto-layout style); the second has so many columns that even the
+/// longest-word minimums don't fit — it stays wide and scrolls horizontally.
+private let tableSection = """
+## Tables
+
+Cells wrap to the available width:
+
+| Rechtsform | Gründungskosten | Laufende Kosten/Jahr |
+|---|---|---|
+| Einzelunternehmen (Kleingewerbe) | 20–60€ (Gewerbeanmeldung) | ~0€ (nur Steuerberater optional, 300–800€) |
+| GbR (mit zwei Gesellschaftern) | 20–60€ x Anzahl Gesellschafter (jeder meldet einzeln an) | Gesellschaftervertrag empfohlen (Anwalt: 500–1.500€ einmalig) |
+| UG (haftungsbeschränkt) | Notar + Handelsregister: ~300–500€ (Musterprotokoll) bis 1.000€+ | IHK-Beitrag (~150–400€), Steuerberater fast Pflicht |
+
+Too many columns → horizontal scroll instead of crushed cells:
+
+| Rechtsformvergleich | Gründungskostenaufstellung | Haftungsbeschränkung | Steuerberaterkosten | Handelsregistereintrag | Stammkapitalanforderung |
+|---|---|---|---|---|---|
+| Einzelunternehmen | Gewerbeanmeldung | unbeschränkt | optional | nein | keines |
+"""
+
 private let markdownHeader = """
 # MarkdownEngine
 

Sources/MarkdownEngine/Diagnostics/PerfTrace.swift

@@ -0,0 +1,135 @@
+//
+//  PerfTrace.swift
+//  MarkdownEngine
+//
+//  Created by Luca Chen on 07.07.26.
+//
+//  TEMP diagnostics (typing performance). Prints one compact line per keystroke
+//  with a per-phase breakdown plus the current document length, so we can see
+//  which costs grow with file size instead of staying constant. The whole point:
+//  type in a short file, then a long one, and compare `total` for the same edit.
+//
+//  Toggle: set the env var MD_PERF=0 in the run scheme to silence.
+//  Debug-only — the whole thing compiles out in Release.
+//  Remove before shipping (this file + the `PerfTrace.` call sites).
+//
+
+import Foundation
+
+enum PerfTrace {
+#if DEBUG
+    static var enabled = ProcessInfo.processInfo.environment["MD_PERF"] != "0"
+    /// Opt-in for the sampled full-rebuild verifier asserts (wiki splice,
+    /// backtick census, parse buffer). They run 3× O(doc) work synchronously
+    /// on every 64th keystroke — periodic spikes that pollute the PERF
+    /// numbers — so they stay off unless explicitly requested.
+    static let verifyEnabled = ProcessInfo.processInfo.environment["MD_PERF_VERIFY"] == "1"
+#else
+    static let enabled = false
+    static let verifyEnabled = false
+#endif
+
+    // All call sites run on the main thread (the coordinator + text view are
+    // main-actor), so plain static state is safe under the package's Swift 5 mode.
+    private static var active = false
+    private static var frameStart: UInt64 = 0
+    private static var docLength = 0
+    private static var phases: [(String, Double)] = []
+    private static var notes: [String] = []
+    /// Summed costs for code that runs MANY times per frame or from inside
+    /// AppKit callbacks (caret reveal, spell-checker callbacks) — printed as
+    /// `+label=…(×n)` after the sequential phases.
+    private static var accumulated: [(String, Double, Int)] = []
+
+    private static func nowMs() -> Double {
+        Double(DispatchTime.now().uptimeNanoseconds) / 1_000_000
+    }
+
+    /// Open a per-keystroke frame. Every `measure`/`note` until `end()` attaches to it.
+    /// A frame already opened this keystroke is CONTINUED, not reset:
+    /// shouldChangeTextIn opens the frame (so the pre-edit parse and the
+    /// smart-input interceptors are counted — they used to run before the
+    /// frame and were invisible), the mid-edit selection change and
+    /// textDidChange attach to it. A frame left open by an edit that never
+    /// reached textDidChange is considered stale after 1s and reset.
+    static func begin(docLength len: Int) {
+        guard enabled else { return }
+        let now = DispatchTime.now().uptimeNanoseconds
+        docLength = len
+        if active, Double(now - frameStart) / 1_000_000 < 1_000 { return }
+        active = true
+        phases.removeAll(keepingCapacity: true)
+        notes.removeAll(keepingCapacity: true)
+        accumulated.removeAll(keepingCapacity: true)
+        frameStart = now
+    }
+
+    /// Like `measure`, but SUMS repeated calls under one label instead of
+    /// appending a phase per call — for work triggered from inside AppKit
+    /// (caret reveal, spell-checker callbacks) that can fire several times
+    /// per keystroke and would otherwise stay invisible in the frame.
+    @discardableResult
+    static func accumulate<T>(_ label: String, _ body: () -> T) -> T {
+        guard enabled, active else { return body() }
+        let t0 = nowMs()
+        let result = body()
+        let dt = nowMs() - t0
+        if let i = accumulated.firstIndex(where: { $0.0 == label }) {
+            accumulated[i].1 += dt
+            accumulated[i].2 += 1
+        } else {
+            accumulated.append((label, dt, 1))
+        }
+        return result
+    }
+
+    /// Time one sequential top-level phase of the current frame.
+    @discardableResult
+    static func measure<T>(_ label: String, _ body: () -> T) -> T {
+        guard enabled, active else { return body() }
+        let t0 = nowMs()
+        let result = body()
+        phases.append((label, nowMs() - t0))
+        return result
+    }
+
+    /// Attach a free-form detail line (e.g. how many tables were re-rendered).
+    /// The closure only runs when tracing is active, so it costs nothing when off.
+    static func note(_ make: () -> String) {
+        guard enabled, active else { return }
+        notes.append(make())
+    }
+
+    /// Record a named timestamp (offset from frame start) inline in the
+    /// breakdown, printed as `@label=12.34`. The gaps BETWEEN checkpoints and
+    /// the measured spans locate work the spans don't cover (AppKit edit
+    /// application, layout, notification dispatch between our callbacks).
+    static func checkpoint(_ label: String) {
+        guard enabled, active else { return }
+        phases.append(("@" + label, Double(DispatchTime.now().uptimeNanoseconds - frameStart) / 1_000_000))
+    }
+
+    /// Close the frame and print total + per-phase breakdown + notes.
+    /// `other` = total − Σ(phases + accumulated): time inside the frame that
+    /// no span covers (AppKit edit processing, layout, unmeasured code).
+    static func end() {
+        guard enabled, active else { return }
+        active = false
+        let total = Double(DispatchTime.now().uptimeNanoseconds - frameStart) / 1_000_000
+        var breakdown = phases.map { String(format: "%@=%.2f", $0.0, $0.1) }.joined(separator: " ")
+        if !accumulated.isEmpty {
+            breakdown += " " + accumulated.map { String(format: "+%@=%.2f(×%d)", $0.0, $0.1, $0.2) }.joined(separator: " ")
+        }
+        let covered = phases.filter { !$0.0.hasPrefix("@") }.reduce(0) { $0 + $1.1 }
+            + accumulated.reduce(0) { $0 + $1.1 }
+        print(String(format: "⌨️ PERF doc=%dch total=%.2fms | %@ other=%.2f", docLength, total, breakdown, total - covered))
+        for note in notes { print("    └─ \(note)") }
+    }
+
+    /// Standalone timing print for a cost that runs *outside* the keystroke frame
+    /// (e.g. the async wide-table overlay reconcile fired after the edit settles).
+    static func stamp(_ label: String, _ ms: Double, _ detail: @autoclosure () -> String = "") {
+        guard enabled else { return }
+        print(String(format: "⏱️ PERF %@ %.2fms %@", label, ms, detail()))
+    }
+}

Sources/MarkdownEngine/Input/MarkdownInputHandler.swift

@@ -11,15 +11,26 @@ import AppKit
 
 enum MarkdownInputHandler {
 
-    static func handleListInsertion(textView: NSTextView, affectedCharRange: NSRange, replacementString: String?) -> Bool {
-        return MarkdownLists.handleInsertion(textView: textView, affectedCharRange: affectedCharRange, replacementString: replacementString)
+    /// `codeTokens` (codeBlock + inlineCode, from the keystroke's existing
+    /// parse) answers "is the caret in code?" without the O(doc) document
+    /// scan the handler otherwise runs on every space/Enter/Tab.
+    static func handleListInsertion(textView: NSTextView, affectedCharRange: NSRange, replacementString: String?, codeTokens: [MarkdownToken]? = nil) -> Bool {
+        let isInsideCodeBlock = codeTokens.map {
+            MarkdownDetection.isInsideCodeBlock(location: affectedCharRange.location, codeTokens: $0)
+        }
+        return MarkdownLists.handleInsertion(textView: textView, affectedCharRange: affectedCharRange,
+                                             replacementString: replacementString, isInsideCodeBlock: isInsideCodeBlock)
     }
 
     // MARK: - Block LaTeX Auto-Wrap
 
     private static func insertTextProgrammatically(_ textView: NSTextView, text: String, at range: NSRange, cursorAfter: Int) {
         if let coord = textView.delegate as? NativeTextViewWrapper.Coordinator {
             coord.isProgrammaticEdit = true
+            // Replaces a suppressed keystroke that never applied — reset its
+            // pending count so this edit registers as the cycle's single
+            // tracked edit and textDidChange keeps the trusted fast paths.
+            coord.pendingEditCount = 0
         }
         textView.insertText(text, replacementRange: range)
         if let coord = textView.delegate as? NativeTextViewWrapper.Coordinator {

Sources/MarkdownEngine/Input/MarkdownListHandler.swift

@@ -17,7 +17,15 @@ struct MarkdownLists {
         let len = min(range.length, max(0, maxLen))
         let safeRange = NSRange(location: loc, length: len)
 
-        if let coord = textView.delegate as? NativeTextViewWrapper.Coordinator { coord.isProgrammaticEdit = true }
+        if let coord = textView.delegate as? NativeTextViewWrapper.Coordinator {
+            coord.isProgrammaticEdit = true
+            // This edit REPLACES a suppressed keystroke that never applied.
+            // Dropping its pending count lets the shouldChangeText below
+            // re-register as the cycle's single tracked edit, so textDidChange
+            // keeps the trusted fast paths (the descriptor is refreshed for
+            // every proposed edit and describes THIS transition exactly).
+            coord.pendingEditCount = 0
+        }
         defer {
             if let coord = textView.delegate as? NativeTextViewWrapper.Coordinator { coord.isProgrammaticEdit = false }
         }
@@ -87,10 +95,14 @@ struct MarkdownLists {
 
     // MARK: - Input Handling
 
-    static func handleInsertion(textView: NSTextView, affectedCharRange: NSRange, replacementString: String?) -> Bool {
+    /// `isInsideCodeBlock` is the caller's pre-parsed answer for
+    /// `affectedCharRange.location` (the coordinator derives it from the
+    /// keystroke's existing parse). `nil` — direct callers without a parse —
+    /// falls back to deriving it here, which walks the whole document.
+    static func handleInsertion(textView: NSTextView, affectedCharRange: NSRange, replacementString: String?, isInsideCodeBlock: Bool? = nil) -> Bool {
         guard let replacementString = replacementString else { return true }
 
-        // Fast path: skip the expensive isInsideCodeBlock scan for ordinary typing.
+        // Fast path: plain characters never trigger list/pair/arrow handling.
         if replacementString.count == 1,
            let ch = replacementString.first,
            ch != ">" && ch != "[" && ch != "(" && ch != "{" &&
@@ -109,9 +121,11 @@ struct MarkdownLists {
             return false
         }
 
-        let isInCodeBlock = textView.string.contains("`")
-            ? MarkdownDetection.isInsideCodeBlock(location: affectedCharRange.location, in: textView.string)
-            : false
+        let isInCodeBlock = isInsideCodeBlock ?? (
+            textView.string.contains("`")
+                ? MarkdownDetection.isInsideCodeBlock(location: affectedCharRange.location, in: textView.string)
+                : false
+        )
 
         if replacementString == ">" && affectedCharRange.length == 0 && !isInCodeBlock {
             let insertionLocation = affectedCharRange.location
@@ -204,12 +218,24 @@ struct MarkdownLists {
             // Horizontal rules render via the styler; source stays literal `---` so files round-trip.
 
             if currentLine.range(of: "^```\\w*$", options: .regularExpression) != nil {
-                let textBeforeLine = nsText.substring(to: currentLineRange.location)
-                let openingCount = textBeforeLine.components(separatedBy: "```").count - 1
+                // Non-overlapping ``` count before the line (what
+                // components(separatedBy:).count-1 computed, without
+                // materializing an O(doc) substring array).
+                var openingCount = 0
+                var searchLocation = 0
+                while searchLocation < currentLineRange.location {
+                    let found = nsText.range(of: "```", options: [],
+                                             range: NSRange(location: searchLocation,
+                                                            length: currentLineRange.location - searchLocation))
+                    if found.location == NSNotFound { break }
+                    openingCount += 1
+                    searchLocation = NSMaxRange(found)
+                }
                 let afterLineStart = currentLineRange.location + currentLineRange.length
                 let hasClosingAfter: Bool = {
                     guard afterLineStart < nsText.length else { return false }
-                    return nsText.substring(from: afterLineStart).contains("```")
+                    let after = NSRange(location: afterLineStart, length: nsText.length - afterLineStart)
+                    return nsText.range(of: "```", options: [], range: after).location != NSNotFound
                 }()
                 let lineEnd = currentLineRange.location + max(0, currentLineRange.length - 1)
                 let cursorAtLineEnd = affectedCharRange.location >= lineEnd