Keymap and Vim fixes from the manual review !162

merged merged by cmc on 2026-10-08 04:12 UTC · krz/orgstar:keys-vim-fixes into main

17 files changed, +696 −67

Layout: unified · split

Sources/OrgApp/KeymapLoader.swift +4 −3

     public static var userFile: URL { UserConfig.file("keymap.toml") }
     /// The preset with the user's file on top, and the problems found in the file. A missing
-    /// file adds nothing; a file that isn't valid TOML adds nothing and is reported.
+    /// file adds nothing; a file that isn't valid TOML adds nothing and is reported. With
-    public static func load(_ preset: KeymapPreset, userFile: URL = userFile) -> (keymap: Keymap, problems: [String]) {
+    /// `commands`, bindings of other command ids are reported and skipped.
+    public static func load(_ preset: KeymapPreset, userFile: URL = userFile, commands: Set<String>? = nil) -> (keymap: Keymap, problems: [String]) {
         guard let text = try? String(contentsOf: userFile, encoding: .utf8) else { return (preset.keymap, []) }
         var problems: [String] = []
         do {
-            let user = try Keymap(toml: text, problems: &problems)
+            let user = try Keymap(toml: text, problems: &problems, commands: commands)
             return (.layered([preset.keymap, user]), problems)
         } catch {
             return (preset.keymap, ["\(error)"])

Sources/OrgCore/Commands/Fill.swift +51

	@@ -467,6 +467,28 @@ extension EmacsBuffer {
467	}	467	}
468	}	468	}
469		469
		470	/// `fill-region` over whole lines: each paragraph's part of `from..<to` filled as a
		471	/// paragraph. Other elements stay.
		472	func fillRegion(_ from: Int, _ to: Int) {
		473	var spans: [Range<Int>] = []
		474	var line = lineStart(from)
		475	while line < to, line < length {
		476	var next = lineEnd(line) + 1
		477	let blank = substring(line, lineEnd(line)).allSatisfy { $0 == " " \|\| $0 == "\t" }
		478	if !blank, let element = element(at: lineEnd(line)) {
		479	if element.kind == .paragraph {
		480	let span = max(paragraphContentsBegin(element), from)..<min(contentsEnd(element), to)
		481	if !span.isEmpty { spans.append(span) }
		482	}
		483	next = max(next, lineStart(min(length, max(element.range.lowerBound, contentsEnd(element)))))
		484	if next <= line { next = lineEnd(line) + 1 }
		485	}
		486	line = next
		487	}
		488	// Back to front, so the spans before stay where they are.
		489	for span in spans.reversed() { fillRegionAsParagraph(span.lowerBound, span.upperBound) }
		490	}
		491
470	/// Where a paragraph's text starts: past affiliated keywords, and for a paragraph that	492	/// Where a paragraph's text starts: past affiliated keywords, and for a paragraph that
471	/// opens an item, past the bullet.	493	/// opens an item, past the bullet.
472	func paragraphContentsBegin(_ node: Element) -> Int {	494	func paragraphContentsBegin(_ node: Element) -> Int {
	@@ -482,3 +504,32 @@ public struct FillParagraph: OrgCommand {
482	public func applies(in context: EditContext) -> Bool { true }	504	public func applies(in context: EditContext) -> Bool { true }
483	public func run(in context: EditContext) -> CommandStep { commitBuffer(context) { $0.fillParagraph() } }	505	public func run(in context: EditContext) -> CommandStep { commitBuffer(context) { $0.fillParagraph() } }
484	}	506	}
		507
		508	/// evil's `gq` and `gw` operators: the paragraphs in `range`'s lines filled, as `fill-region`.
		509	/// With `keep` (`gw`) the caret stays there; without (`gq`) it goes to the first non-blank
		510	/// of the range's last line.
		511	public struct FillRegion: OrgCommand {
		512	public let range: Range<Int>
		513	public let keep: Int?
		514
		515	public init(range: Range<Int>, keep: Int?) {
		516	self.range = range
		517	self.keep = keep
		518	}
		519
		520	public var id: String { "org.fill-region" }
		521	public var title: String { "Fill Region" }
		522	public func applies(in context: EditContext) -> Bool { true }
		523	public func run(in context: EditContext) -> CommandStep {
		524	commitBuffer(context) { buffer in
		525	let target = buffer.marker(keep ?? max(range.lowerBound, range.upperBound - 1))
		526	defer { buffer.release(target) }
		527	buffer.fillRegion(range.lowerBound, range.upperBound)
		528	buffer.point = target.position
		529	if keep == nil {
		530	buffer.beginningOfLine()
		531	buffer.skipForward(EmacsBuffer.blanks)
		532	}
		533	}
		534	}
		535	}

Sources/OrgCore/Keymap/Keymap.swift +22 −7

     }
     public var unbinds: Bool { command == "none" }
+    /// Modal states a binding's `mode` can name.
+    public static let modes: Set<String> = ["normal", "insert", "visual"]
 }
 /// Bindings in priority order: later bindings win over earlier ones for the same keys.
     }
     /// Reads `[[bind]]` tables. Entries that can't be used are skipped and reported in
-    /// `problems`; a file that isn't valid TOML throws.
+    /// `problems`; a file that isn't valid TOML throws. With `commands`, a command id outside
-    public init(toml: String, problems: inout [String]) throws {
+    /// it (other than `none`) is such an entry.
+    public init(toml: String, problems: inout [String], commands: Set<String>? = nil) throws {
         bindings = []
         for table in try TOML.parse(toml) where !(table.name.isEmpty && table.values.isEmpty) {
             guard table.name == "bind", table.isArrayElement else {
                 problems.append("line \(table.line): missing command")
                 continue
             }
+            if let commands, command != "none", !commands.contains(command) {
+                problems.append("line \(table.line): unknown command \(command)")
+                continue
+            }
             let when = table.values["when"]?.string
             if let when, !KeyContext.names.contains(when) {
                 problems.append("line \(table.line): unknown context \(when)")
                 continue
             }
-            bindings.append(KeyBinding(keys: keys, command: command, when: when, mode: table.values["mode"]?.string))
+            let mode = table.values["mode"]?.string
+            if let mode, !KeyBinding.modes.contains(mode) {
+                problems.append("line \(table.line): unknown mode \(mode)")
+                continue
+            }
+            bindings.append(KeyBinding(keys: keys, command: command, when: when, mode: mode))
         }
     }
     }
     /// What can follow `prefix`: each next key with the command it runs, or nil when it
-    /// leads to a longer sequence. Sorted by key.
+    /// leads to a longer sequence. Sorted by key. The command is the first candidate that
-    public func continuations(of prefix: [KeyChord], mode: String? = nil) -> [(key: KeyChord, command: String?)] {
+    /// `runs` accepts, as dispatch picks it, or the first candidate when none does.
+    public func continuations(of prefix: [KeyChord], mode: String? = nil, runs: (KeyBinding) -> Bool = { _ in true }) -> [(key: KeyChord, command: String?)] {
         var seen: [KeyChord: String?] = [:]
         for binding in bindings where binding.mode == mode && binding.keys.count > prefix.count && Array(binding.keys.prefix(prefix.count)) == prefix {
             let next = binding.keys[prefix.count]
             guard seen[next] == nil else { continue }
             if isPrefix(sequence, mode: mode) {
                 seen[next] = .some(nil)
-            } else if let command = candidates(for: sequence, mode: mode).first?.command {
+            } else {
-                seen[next] = .some(command)
+                let found = candidates(for: sequence, mode: mode)
+                if let command = (found.first(where: runs) ?? found.first)?.command { seen[next] = .some(command) }
             }
         }
         return seen.map { (key: $0.key, command: $0.value) }.sorted { $0.key.description < $1.key.description }

Sources/OrgCore/Keymap/Presets.swift +4 −12

                 || (first.modifiers.contains(.meta) && ["<left>", "<right>", "<up>", "<down>", "RET"].contains(first.key))
                 || (first.modifiers.contains(.shift) && ["<left>", "<right>", "<up>", "<down>"].contains(first.key))
                 || (first.modifiers == [.control] && first.key == "RET")
-                || keys == "M-x"
+                || keys == "M-x" || keys == "M-q"
             guard orgKey else { continue }
             for mode in ["normal", "insert", "visual"] { bind(keys, binding.command, when: binding.when, mode: mode) }
             // evil-org: M-h/j/k/l and M-H/J/K/L in normal, visual and insert.
         mode = "normal"
         [[bind]]
         keys = "z a"
-        command = "org.cycle"
+        command = "org.fold.toggle"
         mode = "normal"
         [[bind]]
         keys = "z c"
-        command = "org.cycle"
+        command = "org.fold.close"
         mode = "normal"
         [[bind]]
         keys = "z o"
-        command = "org.cycle"
+        command = "org.fold.open"
         mode = "normal"
         [[bind]]
         keys = "z A"
         command = "org.heading.up"
         mode = "normal"
         [[bind]]
-        keys = "g j"
-        command = "org.heading.forward-same-level"
-        mode = "normal"
-        [[bind]]
-        keys = "g k"
-        command = "org.heading.backward-same-level"
-        mode = "normal"
-        [[bind]]
         keys = "] h"
         command = "org.heading.forward-same-level"
         mode = "normal"

Sources/OrgCore/Keymap/Vim.swift +73 −14

         case setClipboard(String)
         /// Ask for a search pattern (`/`, `?`) or an ex command (`:`).
         case prompt(String)
+        /// `gq` and `gw`: fill these lines' paragraphs (`FillRegion`); the caret stays at
+        /// `keep`, or without it goes to the last line's first non-blank.
+        case fill(Range<Int>, keep: Int?)
+        /// An ex command to run, as if typed after `:` (`ZZ` is `:wq`, `ZQ` is `:q!`).
+        case ex(String)
         case message(String)
         /// `m`: a mark at this offset, for the editor to keep through edits.
         case setMark(Character, Int)
         public var halfPage: Int
         /// Marks where the editor keeps them now; `'` and `` ` `` are the last jump's start.
         public var marks: [Character: Int]
+        /// The text the window shows, for H, M and L; nil when unknown.
+        public var visible: Range<Int>?
+        /// An Org buffer, where evil-org's keys apply.
+        public var org: Bool
-        public init(text: String, caret: Int, clipboard: String? = nil, halfPage: Int = 15, marks: [Character: Int] = [:]) {
+        public init(text: String, caret: Int, clipboard: String? = nil, halfPage: Int = 15, marks: [Character: Int] = [:], visible: Range<Int>? = nil, org: Bool = false) {
+            self.org = org
             self.text = text
             self.caret = caret
             self.clipboard = clipboard
             self.halfPage = halfPage
             self.marks = marks
+            self.visible = visible
         }
     }
     public internal(set) var mode: Mode = .normal
     /// Keys of the command being typed.
     public private(set) var pending: [KeyChord] = []
-    var registers: [Character: (text: String, linewise: Bool)] = [:]
+    /// Named registers. Evil's are global: an editor with several engines shares them.
+    public var registers: [Character: (text: String, linewise: Bool)] = [:]
     /// What the clipboard held when this engine last wrote it, and whether that was whole lines.
-    var clipboardRecord: (text: String, linewise: Bool)?
+    public var clipboardRecord: (text: String, linewise: Bool)?
     var anchor = 0
     var goalColumn: Int?
     var lastFind: (kind: Character, char: String)?
-    var lastSnipe: (forward: Bool, chars: String)?
+    var lastSnipe: (forward: Bool, chars: String, count: Int)?
+    /// `;` and `,` repeat a snipe when one came after the last f, F, t or T.
+    var lastWasSnipe = false
     var lastSearch: (pattern: String, forward: Bool)?
     /// The keys and inserted text of the last change, for `.`.
     var lastChange: (keys: [KeyChord], inserted: String?)?
     var blockInsert: (lines: [Int], column: Int, pad: Bool)?
     /// The editor's marks for this key.
     var contextMarks: [Character: Int] = [:]
+    /// The context's half page and visible text for this key.
+    var contextHalfPage = 15
+    var contextVisible: Range<Int>?
+    var contextOrg = false
     /// Keys are going into a macro register.
     public internal(set) var recording = false
     var lastMacro: Character?
             let keys = pending
             caretForApply = context.caret
             contextMarks = context.marks
+            contextHalfPage = context.halfPage
+            contextVisible = context.visible
+            contextOrg = context.org
             var buffer = Buffer(context)
             switch parse(keys, &buffer, context) {
             case .incomplete:
             op = o
         } else if first.key == "g", first.modifiers.isEmpty {
             guard let second = rest.dropFirst().first else { return .incomplete }
-            if ["~", "u", "U", "c"].contains(second.key), second.modifiers.isEmpty {
+            if ["~", "u", "U", "c", "q", "w"].contains(second.key), second.modifiers.isEmpty {
                 op = "g" + second.key
                 afterOp = rest.dropFirst(2)
             }
             case ("Z", []):
                 guard rest.count >= 2 else { return .incomplete }
                 switch rest[rest.startIndex + 1].key {
-                case "Z": return .done([.command("app.save")])
+                case "Z": return .done([.ex("wq")])
-                case "Q": return .done([.message("ZQ isn't available; use the window's close button")])
+                case "Q": return .done([.ex("q!")])
                 default: return .invalid
                 }
             default:
             }
         }
-        if mode == .normal, rest.count == 2, first == KeyChord("g"), rest.last == KeyChord("j") || rest.last == KeyChord("k") {
+        if mode == .normal, !contextOrg, rest.count == 2, first == KeyChord("g"), rest.last == KeyChord("j") || rest.last == KeyChord("k") {
             return .done([.visualLines(rest.last == KeyChord("j") ? n : -n)])
         }
             return .moved(min(limit, c + n), .exclusive)
         case ("j", []), ("k", []), ("<down>", []), ("<up>", []), ("d", [.control]), ("u", [.control]), ("+", []), ("-", []), ("RET", []):
             let down = ["j", "<down>", "+", "RET"].contains(key.key) || key == KeyChord("d", .control)
-            let lines = key.modifiers.contains(.control) ? (n == 1 ? 15 : n) : n
+            let lines = key.modifiers.contains(.control) ? (n == 1 ? contextHalfPage : n) : n
             let goal = goalColumn ?? column(c)
             var line = buffer.lineStart(c)
             var moved = 0
                 var p = c
                 for _ in 0..<n { p = buffer.wordEndBackward(p, bigWord: keys[1].key == "E") }
                 return .moved(p, .inclusive)
+            case "j" where contextOrg, "k" where contextOrg:
+                // evil-org: org-forward-element and org-backward-element, which take no count.
+                guard let p = Self.orgObject(keys[1].key, inner: false, buffer, c)?.range.lowerBound, p != c else { return .invalid }
+                goalColumn = nil
+                return .moved(p, .exclusive)
             case "j":
                 return motion([KeyChord("j")], &buffer, &caret, count: n, operatorPending: operatorPending)
             case "k":
             let char = keys[1].key == "SPC" ? " " : keys[1].key
             guard char.count == 1 else { return .invalid }
             lastFind = (Character(key.key), char)
+            lastWasSnipe = false
             guard let p = find(Character(key.key), char, buffer, c, count: n) else { return .invalid }
             return .moved(p, key.key == "f" || key.key == "t" ? .inclusive : .exclusive)
+        case (";", []) where lastWasSnipe, (",", []) where lastWasSnipe:
+            // evil-snipe-repeat, with Doom's `evil-snipe-repeat-scope` visible.
+            guard let last = lastSnipe else { return .invalid }
+            let forward = key.key == ";" ? last.forward : !last.forward
+            let scope = contextVisible.map { min($0.lowerBound, buffer.length)..<min($0.upperBound, buffer.length) }
+            guard let p = snipe(forward: forward, last.chars, buffer, c, count: n * last.count, scope: scope) else { return .invalid }
+            return .moved(p, .exclusive)
         case (";", []), (",", []):
             guard let last = lastFind else { return .invalid }
             var kind = last.kind
             // evil-snipe with `evil-snipe-scope` line.
             guard keys.count >= 3 else { return .incomplete }
             let chars = keys[1].key + keys[2].key
-            lastSnipe = (key.key == "s", chars)
+            lastSnipe = (key.key == "s", chars, n)
+            lastWasSnipe = true
             guard let p = snipe(forward: key.key == "s", chars, buffer, c, count: n) else { return .invalid }
             return .moved(p, .exclusive)
         case ("%", []):
             lastSearch = (pattern, key.key == "*")
             guard let p = buffer.search(pattern, from: buffer.wordStart(c), forward: key.key == "*", count: n) else { return .invalid }
             return .moved(p, .exclusive)
+        case ("H", []), ("M", []), ("L", []):
+            // The visible lines: H the count-th from the top, L from the bottom, M the middle.
+            guard let visible = contextVisible else { return .invalid }
+            goalColumn = nil
+            let lower = min(visible.lowerBound, buffer.length)
+            let last = buffer.lineStart(max(lower, min(visible.upperBound, buffer.length) - 1))
+            var lines: [Int] = []
+            var line = buffer.lineStart(lower)
+            while true {
+                lines.append(line)
+                guard line < last, buffer.lineEnd(line) < buffer.length else { break }
+                line = buffer.lineEnd(line) + 1
+            }
+            let index = key.key == "H" ? min(n, lines.count) - 1 : key.key == "L" ? max(0, lines.count - n) : (lines.count - 1) / 2
+            return .moved(buffer.firstNonBlank(lines[index]), .linewise)
         default:
             return .invalid
         }
         return p
     }
-    func snipe(forward: Bool, _ chars: String, _ buffer: Buffer, _ c: Int, count n: Int) -> Int? {
+    /// Searches the caret's line, or `scope` when given.
-        let line = buffer.substring(buffer.lineStart(c)..<buffer.lineEnd(c)) as NSString
+    func snipe(forward: Bool, _ chars: String, _ buffer: Buffer, _ c: Int, count n: Int, scope: Range<Int>? = nil) -> Int? {
-        let start = buffer.lineStart(c)
+        let range = scope ?? buffer.lineStart(c)..<buffer.lineEnd(c)
+        let line = buffer.substring(range) as NSString
+        let start = range.lowerBound
+        guard range.lowerBound <= c, c <= range.upperBound else { return nil }
         let smart = chars == chars.lowercased()
         var p = c - start
         for _ in 0..<n {
         case "gc":
             lastChange = (wasVisual ? [] : keys, nil)
             return [.edit(Self.toggleComments(buffer, range), caret: buffer.lineStart(range.lowerBound))]
+        case "gq", "gw":
+            // Whole lines, as evil's fill operators take them.
+            lastChange = (wasVisual ? [] : keys, nil)
+            let end = buffer.lineEnd(max(range.lowerBound, range.upperBound - 1))
+            let lines = buffer.lineStart(range.lowerBound)..<min(buffer.length, end + 1)
+            return [.fill(lines, keep: op == "gw" ? caretForApply : nil)]
         default:
             let transformed: String
             switch op {
                     caret += inserted.utf16.count
                 }
             }
-            let produced = copy.feed(key, Context(text: text, caret: caret, clipboard: context.clipboard, halfPage: context.halfPage))
+            let produced = copy.feed(key, Context(text: text, caret: caret, clipboard: context.clipboard, halfPage: context.halfPage, visible: context.visible, org: context.org))
             for action in produced {
                 switch action {
                 case .edit(let edits, let to):

Sources/OrgCore/Keymap/VimExtras.swift +56 −5

	@@ -253,14 +253,23 @@ extension Vim {
253	var node: SyntaxNode?	253	var node: SyntaxNode?
254	}	254	}
255		255
256	static func orgObject(_ key: String, inner: Bool, _ buffer: Buffer, _ c: Int) -> (range: Range<Int>, linewise: Bool)? {	256	/// `j` and `k` are evil-org's `gj` and `gk` (`org-forward-element`, `org-backward-element`):
		257	/// an empty range where they go, nil where they can't.
		258	static func orgObject(_ key: String, inner: Bool, _ buffer: Buffer, _ position: Int) -> (range: Range<Int>, linewise: Bool)? {
257	let tree = OrgParser.parse(buffer.ns as String)	259	let tree = OrgParser.parse(buffer.ns as String)
		260	/// The point the element functions look at, and the nodes containing it.
		261	var c = position
258	var chain: [SyntaxNode] = []	262	var chain: [SyntaxNode] = []
259	var node = tree.root	263	func look(at p: Int) {
260	while let child = node.child(containing: c) {	264	c = p
261	chain.append(child)	265	chain = []
262	node = child	266	var node = tree.root
		267	while let child = node.child(containing: c) {
		268	chain.append(child)
		269	node = child
		270	}
263	}	271	}
		272	look(at: position)
264	/// The end of the line ending at or after `p`, without trailing blank lines.	273	/// The end of the line ending at or after `p`, without trailing blank lines.
265	func trimmed(_ lower: Int, _ upper: Int) -> Int {	274	func trimmed(_ lower: Int, _ upper: Int) -> Int {
266	var end = upper	275	var end = upper
	@@ -353,7 +362,49 @@ extension Vim {
353	if let contents = e.contents { return contents }	362	if let contents = e.contents { return contents }
354	return e.begin..<max(e.begin, trimmed(e.begin, e.end) - (buffer.char(trimmed(e.begin, e.end) - 1) == 10 ? 1 : 0))	363	return e.begin..<max(e.begin, trimmed(e.begin, e.end) - (buffer.char(trimmed(e.begin, e.end) - 1) == 10 ? 1 : 0))
355	}	364	}
		365	/// The stars of the heading on the line holding `p`, or nil.
		366	func headingLevel(_ p: Int) -> Int? {
		367	let line = buffer.substring(buffer.lineStart(p)..<buffer.lineEnd(p))
		368	guard let stars = line.range(of: "^\\*+(?=[ \\t]\|$)", options: .regularExpression) else { return nil }
		369	return line.distance(from: stars.lowerBound, to: stars.upperBound)
		370	}
		371	func at(_ p: Int) -> (range: Range<Int>, linewise: Bool) { (p..<p, false) }
356	switch key {	372	switch key {
		373	case "j":
		374	guard position < buffer.length else { return nil }
		375	if headingLevel(position) != nil {
		376	// To the end of the subtree, when a heading is there.
		377	guard let section = chain.last(where: { $0.kind == .section }) else { return nil }
		378	let end = section.range.upperBound
		379	return end < buffer.length && headingLevel(end) != nil ? at(end) : nil
		380	}
		381	guard let e = atPoint() else { return nil }
		382	if let up = parent(e), up.contents?.upperBound == e.end { return at(up.end) }
		383	return at(e.end)
		384	case "k":
		385	guard position > 0 else { return nil }
		386	if let level = headingLevel(position) {
		387	// The previous heading at this level, or else the parent.
		388	var line = buffer.lineStart(position)
		389	while line > 0 {
		390	line = buffer.lineStart(line - 1)
		391	if let other = headingLevel(line), other <= level { return at(line) }
		392	}
		393	return nil
		394	}
		395	guard let e = atPoint() else { return nil }
		396	if position != e.begin { return at(e.begin) }
		397	var p = e.begin
		398	while p > 0, let ch = buffer.char(p - 1), Buffer.isSpace(ch) { p -= 1 }
		399	guard p > 0 else { return at(0) }
		400	look(at: p)
		401	guard var prev = atPoint() else { return at(e.begin) }
		402	var target = prev.begin
		403	while let up = parent(prev), up.end <= e.begin {
		404	target = up.begin
		405	prev = up
		406	}
		407	return at(target)
357	case "R":	408	case "R":
358	guard let headline = chain.last(where: { $0.kind == .section }).map(element) else { return nil }	409	guard let headline = chain.last(where: { $0.kind == .section }).map(element) else { return nil }
359	return (inner ? (headline.contents ?? headline.begin..<headline.begin) : headline.begin..<headline.end, true)	410	return (inner ? (headline.contents ?? headline.begin..<headline.begin) : headline.begin..<headline.end, true)

Sources/OrgEditorAppKit/EditorCommands.swift +3

     public static let all: [EditorCommand] = Commands.everything.map { EditorCommand(id: $0.id, title: $0.title, action: .text($0)) } + [
         EditorCommand(id: "org.cycle", title: "Cycle Visibility", action: .view),
         EditorCommand(id: "org.cycle-global", title: "Cycle Global Visibility", action: .view),
+        EditorCommand(id: "org.fold.toggle", title: "Toggle Fold", action: .view),
+        EditorCommand(id: "org.fold.open", title: "Open Fold", action: .view),
+        EditorCommand(id: "org.fold.close", title: "Close Fold", action: .view),
         EditorCommand(id: "org.narrow.subtree", title: "Narrow to Subtree", action: .view),
         EditorCommand(id: "org.narrow.block", title: "Narrow to Block", action: .view),
         EditorCommand(id: "org.widen", title: "Widen", action: .view),

Sources/OrgEditorAppKit/Modal.swift +73 −11

 import OrgCore
 import OrgDocument
+/// An editor a file mark is in, gone when its buffer closes.
+struct WeakEditor {
+    weak var editor: OrgEditor?
+}
 /// Modal editing: keys go to the keymap for the current evil state first (leader keys,
 /// evil-org's org keys), then to `Vim`.
 extension OrgEditor {
         }
         switch dispatcher.feed(chord) {
         case .pending(let keys):
-            let next = keymap.continuations(of: keys, mode: dispatcher.mode).map { item in
+            let context = editContext()
+            let next = keymap.continuations(of: keys, mode: dispatcher.mode) { modalRuns($0, in: context) }.map { item in
                 (key: item.key.description, title: item.command.map { EditorCommands.command($0)?.title ?? $0 } ?? "+prefix")
             }
             onKeysPending?(KeySequence.format(keys), next)
         case .complete(let keys, let candidates):
             if keys.count > 1 { onKeysPending?(nil, []) }
             let context = editContext()
-            if let binding = candidates.first(where: { binding in
+            if let binding = candidates.first(where: { modalRuns($0, in: context) }) {
-                (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && commandApplies(binding.command, in: context)
-            }) {
                 run(binding.command)
                 updateCursor()
                 return true
             return feedVim(keys)
         case .undefined(let keys):
             onKeysPending?(nil, [])
+            // The leader and Emacs prefixes (C-c, C-x) mean nothing to evil: the sequence is
+            // undefined, as in Doom. Other prefixes (g, z, [, ]) are evil's too.
+            if let first = keys.first, first == KeyChord("SPC") || !first.modifiers.isDisjoint(with: [.control, .meta]) {
+                onMessage?("\(KeySequence.format(keys)) is undefined")
+                return true
+            }
             return feedVim(keys)
         case .unbound:
             return feedVim([chord])
             let wasInsert = vim.mode == .insert
             let visual = vim.mode == .visual || vim.mode == .visualLine
             let caret = visual ? (visualCaret ?? textView.selectedRange().location) : textView.selectedRange().location
+            if jumpToFileMark(key) { continue }
             let clipboard = NSPasteboard.general.string(forType: .string)
             var marks = vimMarks
+            for (name, mark) in Self.fileMarks where mark.owner.editor === self { marks[name] = mark.offset }
             if jumpIndex > 0, jumpIndex <= jumpList.count { marks["'"] = jumpList[jumpIndex - 1] }
-            let actions = vim.feed(key, Vim.Context(text: document.text, caret: caret, clipboard: clipboard, halfPage: halfPage, marks: marks))
+            vim.registers = Self.vimRegisters
+            vim.clipboardRecord = Self.vimClipboardRecord
+            let actions = vim.feed(key, Vim.Context(text: document.text, caret: caret, clipboard: clipboard, halfPage: halfPage, marks: marks, visible: visibleText, org: isOrg))
+            Self.vimRegisters = vim.registers
+            Self.vimClipboardRecord = vim.clipboardRecord
             apply(actions)
             if !wasInsert, vim.mode == .insert {
                 insertSnapshot = (document.text, textView.selectedRange().location)
         return true
     }
+    /// `'A` or `` `A `` for a file mark in another editor: that editor's buffer shows at the
+    /// mark. True when the key went there.
+    private func jumpToFileMark(_ key: KeyChord) -> Bool {
+        guard vim.mode == .normal, vim.pending.count == 1, let quote = vim.pending.first, quote == KeyChord("'") || quote == KeyChord("`"),
+              key.modifiers.isEmpty, key.key.count == 1, let name = key.key.first, name.isUppercase,
+              let mark = Self.fileMarks[name], let owner = mark.owner.editor, owner !== self else { return false }
+        vim.reset()
+        let ns = owner.document.text as NSString
+        var target = min(mark.offset, ns.length)
+        if quote == KeyChord("'") {
+            // The line's first non-blank.
+            target = ns.lineRange(for: NSRange(location: target, length: 0)).location
+            while target < ns.length, ns.character(at: target) == 32 || ns.character(at: target) == 9 { target += 1 }
+        }
+        onJumpToEditor?(owner, target)
+        return true
+    }
     /// Moves marks and jump positions through an edit.
     func mapVimPositions(through edit: TextEdit) {
-        guard !vimMarks.isEmpty || !jumpList.isEmpty else { return }
+        let owned = Self.fileMarks.filter { $0.value.owner.editor === self }
+        guard !vimMarks.isEmpty || !jumpList.isEmpty || !owned.isEmpty else { return }
         let names = Array(vimMarks.keys)
-        let mapped = ViewState(selection: names.map { vimMarks[$0]!..<vimMarks[$0]! } + jumpList.map { $0..<$0 }).mapped(through: [edit]).selection
+        let fileNames = Array(owned.keys)
+        let positions = names.map { vimMarks[$0]! } + fileNames.map { owned[$0]!.offset } + jumpList
+        let mapped = ViewState(selection: positions.map { $0..<$0 }).mapped(through: [edit]).selection
         for (i, name) in names.enumerated() { vimMarks[name] = mapped[i].lowerBound }
-        jumpList = mapped.dropFirst(names.count).map { $0.lowerBound }
+        for (i, name) in fileNames.enumerated() { Self.fileMarks[name]?.offset = mapped[names.count + i].lowerBound }
+        jumpList = mapped.dropFirst(names.count + fileNames.count).map { $0.lowerBound }
     }
     func insertTyped(_ key: KeyChord) {
         return max(1, Int(scroll.contentView.bounds.height / lineHeight / 2))
     }
+    /// The text the window shows, from the line at its top to the line at its bottom.
+    var visibleText: Range<Int>? {
+        guard let layout = textView.textLayoutManager, let content = layout.textContentManager, let scroll = textView.enclosingScrollView else { return nil }
+        let bounds = scroll.contentView.bounds
+        let origin = textView.textContainerOrigin
+        let start = content.documentRange.location
+        guard let top = layout.textLayoutFragment(for: CGPoint(x: 0, y: max(0, bounds.minY - origin.y))) else { return nil }
+        let lower = content.offset(from: start, to: top.rangeInElement.location)
+        let bottom = layout.textLayoutFragment(for: CGPoint(x: 0, y: max(0, bounds.maxY - origin.y - 1)))
+        let upper = bottom.map { content.offset(from: start, to: $0.rangeInElement.endLocation) } ?? utf16Length
+        return lower..<max(lower, upper)
+    }
     private func editContext() -> EditContext {
         let selected = textView.selectedRange()
         return EditContext(revision: document.revision, text: document.text, tree: document.tree, selection: [selected.location..<NSMaxRange(selected)], options: options)
     }
+    private func modalRuns(_ binding: KeyBinding, in context: EditContext) -> Bool {
+        (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && commandApplies(binding.command, in: context)
+    }
     private func commandApplies(_ id: String, in context: EditContext) -> Bool {
         if !isOrg, id.hasPrefix("org.") { return false }
         return switch EditorCommands.command(id)?.action {
                 NSPasteboard.general.setString(text, forType: .string)
             case .prompt(let kind):
                 prompt(kind)
+            case .ex(let command):
+                ex(command)
+            case .fill(let range, let keep):
+                visualCaret = nil
+                textView.setSelectedRange(NSRange(location: textView.selectedRange().location, length: 0))
+                _ = perform(FillRegion(range: range, keep: keep))
+                clampCaret()
             case .message(let text):
                 onMessage?(text)
             case .setMark(let name, let offset):
-                vimMarks[name] = offset
+                if name.isUppercase { Self.fileMarks[name] = (WeakEditor(editor: self), offset) } else { vimMarks[name] = offset }
             case .jumped(let from):
                 // A new jump drops the ones C-o went back past.
                 jumpList = Array(jumpList.prefix(jumpIndex))
                     onMessage?("Defining keyboard macro…")
                 } else if let register = recordingRegister {
                     // Without the `q` that ended it.
-                    macros[register] = Array(recordedKeys.dropLast())
+                    Self.macros[register] = Array(recordedKeys.dropLast())
                     recordingRegister = nil
                     onMessage?("Keyboard macro defined")
                 }
             case .playMacro(let name, let count):
-                guard let keys = macros[name], !keys.isEmpty else {
+                guard let keys = Self.macros[name], !keys.isEmpty else {
                     onMessage?("No macro in register \(name)")
                     continue
                 }

Sources/OrgEditorAppKit/OrgEditor.swift +36 −6

     var insertSnapshot: (text: String, caret: Int)?
     /// The evil cursor in visual states, where the selection's start isn't it.
     var visualCaret: Int?
-    /// Vim marks, mapped through edits.
+    /// Vim's lowercase marks, mapped through edits.
     var vimMarks: [Character: Int] = [:]
+    /// Uppercase marks, with the editor each is in: global, as evil's file marks are.
+    static var fileMarks: [Character: (owner: WeakEditor, offset: Int)] = [:]
+    /// Registers and keyboard macros, shared by every editor as evil's are global.
+    static var vimRegisters: [Character: (text: String, linewise: Bool)] = [:]
+    static var vimClipboardRecord: (text: String, linewise: Bool)?
+    static var macros: [Character: [KeyChord]] = [:]
+    /// Shows `editor`'s buffer with the caret at the offset, for a jump to a file mark set
+    /// there.
+    public var onJumpToEditor: ((OrgEditor, Int) -> Void)?
     /// Jump positions, oldest first, mapped through edits; `jumpIndex` is where C-o and C-i are.
     var jumpList: [Int] = []
     var jumpIndex = 0
     /// The register keys go into while `q` records, and its keys so far.
     var recordingRegister: Character?
     var recordedKeys: [KeyChord] = []
-    var macros: [Character: [KeyChord]] = [:]
     var replayingMacro = 0
     /// A region is active: movement extends the selection, as after C-SPC in Emacs.
     private(set) var markActive = false
         if modal { return handleModal(chord) }
         switch dispatcher.feed(chord) {
         case .pending(let keys):
-            let next = keymap.continuations(of: keys).map { item in
+            let context = context()
+            let next = keymap.continuations(of: keys) { runs($0, in: context) }.map { item in
                 (key: item.key.description, title: item.command.map { EditorCommands.command($0)?.title ?? $0 } ?? "+prefix")
             }
             onKeysPending?(KeySequence.format(keys), next)
         case .complete(let keys, let candidates):
             if keys.count > 1 { onKeysPending?(nil, []) }
             let context = context()
-            let runnable = candidates.first { binding in
+            let runnable = candidates.first { runs($0, in: context) }
-                (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && applies(binding.command, in: context)
-            }
             if let binding = runnable ?? (keys.count > 1 ? candidates.first : nil) {
                 run(binding.command)
                 return true
         return true
     }
+    /// Whether a key's `binding` runs in `context`: its context holds and its command applies.
+    private func runs(_ binding: KeyBinding, in context: EditContext) -> Bool {
+        (binding.when.map { KeyContext.holds($0, in: context) } ?? true) && applies(binding.command, in: context)
+    }
     private func applies(_ id: String, in context: EditContext) -> Bool {
         if !isOrg, id.hasPrefix("org.") { return false }
         return switch EditorCommands.command(id)?.action {
             switch id {
             case "org.cycle": cycleAtCaret()
             case "org.cycle-global": cycleGlobal()
+            case "org.fold.toggle", "org.fold.open", "org.fold.close": fold(id)
             case "org.narrow.subtree", "org.narrow.block", "org.narrow.toggle", "org.widen": narrow(id)
             case "org.toggle-inline-images": toggleImages()
             case "editor.toggle-spell-check": toggleSpellCheck()
         return true
     }
+    /// Doom's `za`, `zo` (on a heading line) and `zc` (anywhere in a subtree).
+    func fold(_ id: String) {
+        leaveSparseTree()
+        let caret = textView.selectedRange().location
+        let tree = document.tree
+        let next: FoldState?
+        if id == "org.fold.close" {
+            next = Presentation.outline(tree).last { $0.start <= caret && (caret < $0.end || $0.end == utf16Length) }
+                .map { Presentation.hideSubtree($0.start, foldState) }
+        } else {
+            next = Presentation.heading(containing: caret, in: tree).map {
+                id == "org.fold.open" ? Presentation.openFold($0, in: tree, foldState) : Presentation.toggleFold($0, in: tree, foldState)
+            }
+        }
+        if let next, next != foldState { setFolds(next) }
+    }
     /// Shift-TAB: overview, contents, show all.
     public func cycleGlobal() {
         leaveSparseTree()

Sources/OrgPresentation/Folding.swift +36

	@@ -87,6 +87,42 @@ extension Presentation {
87	return next	87	return next
88	}	88	}
89		89
		90	/// Doom's `za` (`+org/toggle-fold`) on a heading: folded, it opens one level (its body and
		91	/// child headings, folded); otherwise it folds.
		92	public static func toggleFold(_ heading: Int, in tree: OrgTree, _ state: FoldState) -> FoldState {
		93	isFolded(heading, state) ? showChildren(heading, in: tree, state) : hideSubtree(heading, state)
		94	}
		95
		96	/// Doom's `zo` (`+org/open-fold`): a folded heading opens one level; an open one stays.
		97	public static func openFold(_ heading: Int, in tree: OrgTree, _ state: FoldState) -> FoldState {
		98	isFolded(heading, state) ? showChildren(heading, in: tree, state) : state
		99	}
		100
		101	/// `zc` (`outline-hide-subtree`): the heading's subtree folded.
		102	public static func hideSubtree(_ heading: Int, _ state: FoldState) -> FoldState {
		103	var next = state
		104	next.folds.insert(heading)
		105	return next
		106	}
		107
		108	/// Whether the heading's body is hidden.
		109	private static func isFolded(_ heading: Int, _ state: FoldState) -> Bool {
		110	state.folds.contains(heading) \|\| state.bodyFolds.contains(heading)
		111	}
		112
		113	/// org's children view of a heading: its body and child headings show, their subtrees folded.
		114	private static func showChildren(_ heading: Int, in tree: OrgTree, _ state: FoldState) -> FoldState {
		115	let outline = outline(tree)
		116	guard let index = outline.firstIndex(where: { $0.start == heading }) else { return state }
		117	let entry = outline[index]
		118	let subtree = outline.filter { $0.start >= entry.start && $0.start < entry.end }.map(\.start)
		119	var next = state
		120	next.folds.subtract(subtree)
		121	next.bodyFolds.subtract(subtree)
		122	next.folds.formUnion(outline.enumerated().filter { $0.element.parent == index }.map(\.element.start))
		123	return next
		124	}
		125
90	/// TAB at `offset` (`org-cycle`): on the first or last line of a drawer or block, folds or	126	/// TAB at `offset` (`org-cycle`): on the first or last line of a drawer or block, folds or
91	/// unfolds it; on a heading, cycles it. Nil elsewhere.	127	/// unfolds it; on a heading, cycles it. Nil elsewhere.
92	public static func cycle(at offset: Int, in tree: OrgTree, _ state: FoldState) -> FoldState? {	128	public static func cycle(at offset: Int, in tree: OrgTree, _ state: FoldState) -> FoldState? {

Sources/Orgstar/ContentView.swift +1 −1

	@@ -498,7 +498,7 @@ struct ContentView: View {
498	}	498	}
499		499
500	private func loadKeymap() {	500	private func loadKeymap() {
501	let loaded = KeymapLoader.load(preset)	501	let loaded = KeymapLoader.load(preset, commands: Set(EditorCommands.all.map(\.id)))
502	keymap = loaded.keymap	502	keymap = loaded.keymap
503	commands.keymap = loaded.keymap	503	commands.keymap = loaded.keymap
504	commands.modal = preset.isModal	504	commands.modal = preset.isModal

Sources/Orgstar/EditorView.swift +7 −2

             coordinator.path = session.path
             container.subviews.forEach { $0.removeFromSuperview() }
             coordinator.editor = nil
-            if let path = session.path, let shown = coordinator.editors[path] ?? makeEditor(container) {
+            if let path = session.path, let shown = coordinator.editors[path] ?? makeEditor(container, coordinator) {
                 coordinator.editors[path] = shown
                 shown.scroll.frame = container.bounds
                 container.addSubview(shown.scroll)
     }
     /// An editor for the current buffer, which becomes the buffer's live state.
-    private func makeEditor(_ container: NSView) -> (editor: OrgEditor, scroll: NSScrollView)? {
+    private func makeEditor(_ container: NSView, _ coordinator: Coordinator) -> (editor: OrgEditor, scroll: NSScrollView)? {
         guard let document = session.document else { return nil }
         let mode: OrgEditor.Mode = session.isOrg ? .org : .plain(language: session.path.flatMap(FileTypes.language))
         let editor = OrgEditor(document: document, frame: container.bounds, editable: document.isEditable, highlighter: Self.highlighter, mode: mode, options: options)
             }
             session?.open(target)
         }
+        editor.onJumpToEditor = { [weak session, weak coordinator] other, offset in
+            guard let session, let path = coordinator?.editors.first(where: { $0.value.editor === other })?.key else { return }
+            session.open(path)
+            session.reveal(offset)
+        }
         editor.onExternal = onExternal
         editor.knownTags = knownTags
         editor.onPrompt = { [weak commands] prompt, reply in commands?.ask(prompt, reply: reply) }

Tests/OrgCoreTests/KeymapTests.swift +40

	@@ -71,6 +71,33 @@ struct KeymapTests {
71	#expect(problems.count == 3)	71	#expect(problems.count == 3)
72	}	72	}
73		73
		74	@Test func reportsUnknownModesAndCommands() throws {
		75	var problems: [String] = []
		76	let keymap = try Keymap(toml: """
		77	[[bind]]
		78	keys = "g x"
		79	command = "org.todo.cycle"
		80	mode = "visual-line"
		81	[[bind]]
		82	keys = "g y"
		83	command = "org.todo.cycel"
		84	mode = "normal"
		85	[[bind]]
		86	keys = "g z"
		87	command = "none"
		88	mode = "visual"
		89	[[bind]]
		90	keys = "C-c x"
		91	command = "org.todo.cycle"
		92	""", problems: &problems, commands: ["org.todo.cycle"])
		93	#expect(problems == ["line 1: unknown mode visual-line", "line 5: unknown command org.todo.cycel"])
		94	#expect(keymap.bindings.map(\.command) == ["none", "org.todo.cycle"])
		95	// Without a command list, ids aren't checked.
		96	problems = []
		97	_ = try Keymap(toml: "[[bind]]\nkeys = \"x\"\ncommand = \"anything\"\nmode = \"insert\"\n", problems: &problems)
		98	#expect(problems.isEmpty)
		99	}
		100
74	@Test func laterLayersWinAndCanUnbind() throws {	101	@Test func laterLayersWinAndCanUnbind() throws {
75	let preset = KeymapPreset.emacs.keymap	102	let preset = KeymapPreset.emacs.keymap
76	let (user, _) = try map("""	103	let (user, _) = try map("""
	@@ -167,6 +194,19 @@ struct KeymapTests {
167	#expect(keymap.continuations(of: []).contains { $0.key == KeyChord("c", .control) && $0.command == nil })	194	#expect(keymap.continuations(of: []).contains { $0.key == KeyChord("c", .control) && $0.command == nil })
168	}	195	}
169		196
		197	@Test func continuationsFollowContext() {
		198	let keymap = KeymapPreset.emacs.keymap
		199	let text = "* a\n#+begin_src sh\necho\n#+end_src\n"
		200	func hint(at caret: Int) -> String?? {
		201	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret])
		202	return keymap.continuations(of: [KeyChord("c", .control)]) { binding in
		203	binding.when.map { KeyContext.holds($0, in: context) } ?? true
		204	}.first { $0.key == KeyChord("c", .control) }?.command
		205	}
		206	#expect(hint(at: 1) == "org.ctrl-c-ctrl-c")
		207	#expect(hint(at: 20) == "org.babel.execute")
		208	}
		209
170	@Test func contexts() {	210	@Test func contexts() {
171	let text = "* a\n\| x \|\n- item\n"	211	let text = "* a\n\| x \|\n- item\n"
172	let tree = OrgParser.parse(text)	212	let tree = OrgParser.parse(text)

Tests/OrgCoreTests/VimExtrasTests.swift +72 −2

	@@ -38,6 +38,35 @@ struct VimExtrasTests {
38	#expect(run("abcdef\n", 1, "v l l ESC 0 g v d").text == "aef\n")	38	#expect(run("abcdef\n", 1, "v l l ESC 0 g v d").text == "aef\n")
39	}	39	}
40		40
		41	@Test func fillOperators() {
		42	let text = "short\nlines\njoin here\n\nnext para\n"
		43	#expect(run(text, 0, "g q a p").text == "short lines join here\n\nnext para\n")
		44	#expect(run(text, 8, "g w a p") == ("short lines join here\n\nnext para\n", 8))
		45	#expect(run("a\nb\nc\n", 2, "g q q").text == "a\nb\nc\n")
		46	#expect(run("a\nb\nc\n", 0, "V j g q") == ("a b\nc\n", 0))
		47	let doom = KeymapPreset.doom.keymap
		48	#expect(Set(["normal", "insert", "visual"]).allSatisfy { doom.candidates(for: [KeyChord("q", .meta)], mode: $0).first?.command == "org.fill-paragraph" })
		49	}
		50
		51	@Test func elementMotionsStop() {
		52	let text = "intro\n\n* H\npara one\n* Next\nend\n"
		53	func moved(_ caret: Int, _ keys: String, org: Bool = true) -> Int {
		54	var driver = VimDriver(text, caret: caret)
		55	driver.org = org
		56	driver.type(KeySequence.parse(keys)!)
		57	return driver.caret
		58	}
		59	#expect(moved(0, "g k") == 0)
		60	#expect(moved(7, "g k") == 7)
		61	#expect(moved(20, "g j") == 20)
		62	// A count doesn't repeat them: org-forward-element takes no argument.
		63	#expect(moved(0, "2 g j") == 7)
		64	// Outside Org, gj and gk are screen lines, which the editor moves.
		65	var vim = Vim()
		66	_ = vim.feed(KeyChord("g"), Vim.Context(text: text, caret: 0))
		67	#expect(vim.feed(KeyChord("j"), Vim.Context(text: text, caret: 0)) == [.visualLines(1)])
		68	}
		69
41	@Test func blockVisual() {	70	@Test func blockVisual() {
42	#expect(run("abc\ndef\nghi\n", 0, "C-v j l d").text == "c\nf\nghi\n")	71	#expect(run("abc\ndef\nghi\n", 0, "C-v j l d").text == "c\nf\nghi\n")
43	#expect(run("abc\ndef\nghi\n", 0, "C-v j l y j j P").text == "abc\ndef\nabghi\n" \|\| true)	72	#expect(run("abc\ndef\nghi\n", 0, "C-v j l y j j P").text == "abc\ndef\nabghi\n" \|\| true)
	@@ -117,7 +146,47 @@ struct VimExtrasTests {
117	("a =code= b\n", 3, "d i e"),	146	("a =code= b\n", 3, "d i e"),
118	("a =code= b\n", 3, "d a e"),	147	("a =code= b\n", 3, "d a e"),
119	("a [[https://x.org]] b\n", 5, "d i e"),	148	("a [[https://x.org]] b\n", 5, "d i e"),
		149	] + elementCases + fillCases
		150	}()
		151
		152	/// gq and gw: evil-fill-and-move and evil-fill.
		153	static let fillCases: [(String, Int, String)] = {
		154	let long = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
		155	return [
		156	(long + "\n", 0, "g q q"),
		157	(long + "\n", 10, "g w w"),
		158	("short\nlines\njoin here\n\nnext para\n", 0, "g q a p"),
		159	("short\nlines\njoin here\n\nnext para\n", 2, "g w a p"),
		160	("one\ntwo\n\nthree\nfour\n", 0, "g q G"),
		161	("- item " + long + "\n- b\n", 0, "g q q"),
		162	("* H\n" + long + "\n", 4, "g q q"),
		163	("* H\n" + long + "\n", 0, "g q j"),
		164	("a\nb\nc\n", 2, "g q q"),
		165	("a\nb\nc\nd\n", 2, "g q j"),
		166	("a\nb\nc\n", 0, "V j g q"),
		167	("a\nb\n\nc\nd\n", 0, "g q j j ."),
		168	]
		169	}()
		170
		171	/// evil-org's gj and gk: org-forward-element and org-backward-element.
		172	static let elementCases: [(String, Int, String)] = {
		173	let text = "intro\n\n* H\npara one\nstill\n\n- a\n- b\n\nafter\n Sub\nsub body\n Two\n* Next\nend\n"
		174	let at = { (s: String) in (text as NSString).range(of: s).location }
		175	var cases: [(String, Int, String)] = []
		176	// Org signals an error, and evil stays, for g k at 0 and on the first heading, and g j on
		177	// the last one: see `elementMotionsStop`.
		178	for start in [0, 3, at("* H"), at("para"), at("still") + 2, at("- a"), at("- b"), at("after"), at(" Sub"), at("sub body"), at(" Two"), at("* Next"), at("end")] {
		179	if start != at("* Next") { cases.append((text, start, "g j")) }
		180	if start != 0, start != at("* H") { cases.append((text, start, "g k")) }
		181	}
		182	cases += [
		183	(text, at("para"), "g j g j g j"),
		184	(text, at("end"), "g k g k"),
		185	(text, at("para"), "3 g j"),
		186	(text, at("para"), "d g j"),
		187	(text, at("* H"), "d g j"),
120	]	188	]
		189	return cases
121	}()	190	}()
122		191
123	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))	192	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
	@@ -134,7 +203,7 @@ struct VimExtrasTests {
134	(require 'evil-surround)	203	(require 'evil-surround)
135	(setq kill-ring nil)	204	(setq kill-ring nil)
136	(switch-to-buffer (current-buffer))	205	(switch-to-buffer (current-buffer))
137	\(org ? "(org-mode) (require 'evil-org) (evil-org-set-key-theme '(textobjects)) (evil-org-mode 1)" : "")	206	\(org ? "(org-mode) (require 'evil-org) (evil-org-set-key-theme '(textobjects navigation)) (evil-org-mode 1)" : "")
138	(evil-local-mode 1)	207	(evil-local-mode 1)
139	(evil-surround-mode 1)	208	(evil-surround-mode 1)
140	(evil-normal-state)	209	(evil-normal-state)
	@@ -148,9 +217,10 @@ struct VimExtrasTests {
148	""")	217	""")
149	}	218	}
150	let results = try EmacsOracle.run(forms)	219	let results = try EmacsOracle.run(forms)
151	for ((c, _), result) in zip(all, results) {	220	for ((c, org), result) in zip(all, results) {
152	let (text, point, keys) = c	221	let (text, point, keys) = c
153	var driver = VimDriver(text, caret: point)	222	var driver = VimDriver(text, caret: point)
		223	driver.org = org
154	driver.type(KeySequence.parse(keys)!)	224	driver.type(KeySequence.parse(keys)!)
155	guard let marker = result.text.range(of: "\n@@STATE ") else {	225	guard let marker = result.text.range(of: "\n@@STATE ") else {
156	Issue.record("\(keys): \(result.error)")	226	Issue.record("\(keys): \(result.error)")

Tests/OrgCoreTests/VimTests.swift +76 −1

	@@ -10,6 +10,9 @@ struct VimDriver {
10	var caret: Int	10	var caret: Int
11	var clipboard: String?	11	var clipboard: String?
12	var commands: [String] = []	12	var commands: [String] = []
		13	var halfPage = 15
		14	var visible: Range<Int>?
		15	var org = false
13		16
14	init(_ text: String, caret: Int) {	17	init(_ text: String, caret: Int) {
15	self.text = text	18	self.text = text
	@@ -36,7 +39,7 @@ struct VimDriver {
36	}	39	}
37	continue	40	continue
38	}	41	}
39	let actions = vim.feed(key, Vim.Context(text: text, caret: caret, clipboard: clipboard))	42	let actions = vim.feed(key, Vim.Context(text: text, caret: caret, clipboard: clipboard, halfPage: halfPage, visible: visible, org: org))
40	for action in actions {	43	for action in actions {
41	switch action {	44	switch action {
42	case .edit(let edits, let to):	45	case .edit(let edits, let to):
	@@ -45,6 +48,10 @@ struct VimDriver {
45	case .move(let to): caret = to	48	case .move(let to): caret = to
46	case .setClipboard(let s): clipboard = s	49	case .setClipboard(let s): clipboard = s
47	case .command(let id): commands.append(id)	50	case .command(let id): commands.append(id)
		51	case .fill(let range, let keep):
		52	let result = runCommand(FillRegion(range: range, keep: keep), text, caret: caret)
		53	text = result.text
		54	caret = result.caret
48	default: break	55	default: break
49	}	56	}
50	}	57	}
	@@ -131,6 +138,11 @@ struct VimTests {
131	("long line here\nab\nlonger line\n", 10, "j j x"),	138	("long line here\nab\nlonger line\n", 10, "j j x"),
132	("one two three\n", 0, "s t h x"),	139	("one two three\n", 0, "s t h x"),
133	("one two three\n", 12, "S t w x"),	140	("one two three\n", 12, "S t w x"),
		141	("ab ab ab ab\n", 0, "s a b ; ; x"),
		142	("ab ab ab ab\n", 0, "s a b ; ; , x"),
		143	("ab ab ab ab\n", 10, "S a b ; x"),
		144	("ab ab ab ab ab ab\n", 0, "2 s a b ; x"),
		145	("one tw tw tw\n", 0, "f w s t w ; x"),
134	("one two three\n", 0, "\" a y w w \" a P"),	146	("one two three\n", 0, "\" a y w w \" a P"),
135	("one two three\n", 0, "\" _ d w"),	147	("one two three\n", 0, "\" _ d w"),
136	(" one\n", 2, "o x ESC"),	148	(" one\n", 2, "o x ESC"),
	@@ -183,6 +195,69 @@ struct VimTests {
183	("one two three\n", 0, "v 2 e c X ESC"),	195	("one two three\n", 0, "v 2 e c X ESC"),
184	]	196	]
185		197
		198	/// Thirty lines of seven characters: line `i` starts at `7 * i`.
		199	static let lines = (0..<30).map { String(format: "line%02d\n", $0) }.joined()
		200
		201	func driven(_ caret: Int, _ keys: String, halfPage: Int? = nil, visible: Range<Int>? = nil) -> Int {
		202	var driver = VimDriver(Self.lines, caret: caret)
		203	if let halfPage { driver.halfPage = halfPage }
		204	driver.visible = visible
		205	driver.type(Self.keys(keys))
		206	return driver.caret
		207	}
		208
		209	@Test func zzAndZqRunExCommands() {
		210	var vim = Vim()
		211	let context = Vim.Context(text: "a\n", caret: 0)
		212	#expect(vim.feed(KeyChord("Z"), context) == [])
		213	#expect(vim.feed(KeyChord("Z"), context) == [.ex("wq")])
		214	_ = vim.feed(KeyChord("Z"), context)
		215	#expect(vim.feed(KeyChord("Q"), context) == [.ex("q!")])
		216	}
		217
		218	@Test func snipeRepeatsOverTheVisibleText() {
		219	let text = "ab x\ncd ab\nab\n"
		220	func caret(_ keys: String, visible: Range<Int>?) -> Int {
		221	var driver = VimDriver(text, caret: 0)
		222	driver.visible = visible
		223	driver.type(Self.keys(keys))
		224	return driver.caret
		225	}
		226	// The snipe itself keeps to the line; repeats search what the window shows.
		227	#expect(caret("s a b ;", visible: nil) == 0)
		228	#expect(caret("s a b ;", visible: 0..<14) == 8)
		229	#expect(caret("s a b ; ;", visible: 0..<14) == 11)
		230	#expect(caret("s a b ; ; ,", visible: 0..<14) == 8)
		231	// After f, ; repeats the f.
		232	#expect(caret("s a b f x ;", visible: 0..<14) == 3)
		233	}
		234
		235	@Test func halfPageScrollsFollowTheWindow() {
		236	#expect(driven(0, "C-d", halfPage: 5) == 35)
		237	#expect(driven(70, "C-u", halfPage: 5) == 35)
		238	#expect(driven(0, "C-d") == 105)
		239	#expect(driven(0, "3 C-d", halfPage: 5) == 21)
		240	}
		241
		242	@Test func windowLines() {
		243	let shown = 70..<140
		244	#expect(driven(0, "H", visible: shown) == 70)
		245	#expect(driven(0, "3 H", visible: shown) == 84)
		246	#expect(driven(0, "2 0 H", visible: shown) == 133)
		247	#expect(driven(0, "L", visible: shown) == 133)
		248	#expect(driven(0, "2 L", visible: shown) == 126)
		249	#expect(driven(0, "M", visible: shown) == 98)
		250	#expect(driven(3, "H") == 3)
		251	// Linewise with an operator, and a jump.
		252	var driver = VimDriver(Self.lines, caret: 70)
		253	driver.visible = shown
		254	driver.type(Self.keys("d L"))
		255	#expect(driver.text == Self.lines.replacingOccurrences(of: (10..<20).map { String(format: "line%02d\n", $0) }.joined(), with: ""))
		256	var vim = Vim()
		257	let actions = vim.feed(KeyChord("L"), Vim.Context(text: Self.lines, caret: 70, visible: shown))
		258	#expect(actions == [.jumped(from: 70), .move(caret: 133)])
		259	}
		260
186	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))	261	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
187	func matchesEvil() throws {	262	func matchesEvil() throws {
188	let evil = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".config/emacs/.local/straight/repos")	263	let evil = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".config/emacs/.local/straight/repos")

Tests/OrgEditorAppKitTests/ModalTests.swift +138

	@@ -1,5 +1,6 @@
1	import AppKit	1	import AppKit
2	import OrgCore	2	import OrgCore
		3	import OrgPresentation
3	import Testing	4	import Testing
4	@testable import OrgEditorAppKit	5	@testable import OrgEditorAppKit
5		6
	@@ -72,6 +73,131 @@ struct ModalTests {
72	#expect(h.editor.vim.mode == .normal)	73	#expect(h.editor.vim.mode == .normal)
73	}	74	}
74		75
		76	@Test func registersAndMacrosAreShared() {
		77	let a = doom("alpha beta\n")
		78	let b = doom("one\ntwo\n")
		79	a.caret(at: 0)
		80	type(a, "\" r y w")
		81	b.caret(at: 0)
		82	type(b, "\" r P")
		83	#expect(b.editor.document.text == "alpha one\ntwo\n")
		84	type(a, "q m A ! ESC q")
		85	type(b, "j @ m")
		86	#expect(b.editor.document.text == "alpha one\ntwo!\n")
		87	}
		88
		89	@Test func uppercaseMarksAreGlobal() {
		90	let a = doom("first\n second\n")
		91	let b = doom("other\ntext\n")
		92	var jumps: [(OrgEditor, Int)] = []
		93	b.editor.onJumpToEditor = { jumps.append(($0, $1)) }
		94	a.caret(at: 10)
		95	type(a, "m Q m q")
		96	b.caret(at: 0)
		97	type(b, "' Q")
		98	#expect(jumps.count == 1 && jumps.first?.0 === a.editor && jumps.first?.1 == 8)
		99	type(b, "` Q")
		100	#expect(jumps.last?.1 == 10)
		101	// Lowercase marks stay in their buffer.
		102	type(b, "j ' q")
		103	#expect(b.textView.selectedRange().location == 6)
		104	// In its own buffer the mark is an ordinary jump, and follows edits.
		105	type(a, "g g O")
		106	a.textView.insertText("new", replacementRange: a.textView.selectedRange())
		107	type(a, "ESC ` Q")
		108	#expect(a.textView.selectedRange().location == 14)
		109	}
		110
		111	@Test func foldKeysToggleOpenAndClose() {
		112	let h = doom("* A\nbody\n** B\nb body\n* C\n")
		113	h.caret(at: 0)
		114	type(h, "z c")
		115	#expect(h.editor.foldState.folds == [0])
		116	type(h, "z o")
		117	#expect(h.editor.foldState.folds == [9])
		118	type(h, "z o")
		119	#expect(h.editor.foldState.folds == [9])
		120	type(h, "z a")
		121	#expect(h.editor.foldState.folds.contains(0))
		122	type(h, "z a")
		123	#expect(h.editor.foldState.folds == [9])
		124	// za and zo act on a heading line; zc closes the subtree around the caret.
		125	h.editor.setFolds(FoldState())
		126	h.caret(at: 5)
		127	type(h, "z a")
		128	type(h, "z o")
		129	#expect(h.editor.foldState.folds.isEmpty)
		130	h.caret(at: 15)
		131	type(h, "z c")
		132	#expect(h.editor.foldState.folds == [9])
		133	}
		134
		135	@Test func fillOperatorsInTheEditor() {
		136	let h = doom("short\nlines\n\nnext\n")
		137	h.caret(at: 7)
		138	type(h, "g w a p")
		139	#expect(h.editor.document.text == "short lines\n\nnext\n")
		140	#expect(h.textView.selectedRange().location == 7)
		141	type(h, "u")
		142	#expect(h.editor.document.text == "short\nlines\n\nnext\n")
		143	}
		144
		145	@Test func zzSavesAndClosesAsWq() {
		146	let h = doom("text\n")
		147	var app: [String] = []
		148	h.editor.onAppCommand = { app.append($0) }
		149	h.caret(at: 0)
		150	type(h, "Z Q")
		151	#expect(app.isEmpty)
		152	type(h, "Z Z")
		153	#expect(app == ["app.save"])
		154	}
		155
		156	@Test func windowLinesInTheEditor() {
		157	let h = doom("one\ntwo\nthree\nfour\nfive\n")
		158	h.caret(at: 0)
		159	type(h, "L")
		160	#expect(h.textView.selectedRange().location == 19)
		161	type(h, "M")
		162	#expect(h.textView.selectedRange().location == 8)
		163	type(h, "H")
		164	#expect(h.textView.selectedRange().location == 0)
		165	}
		166
		167	@Test func undefinedLeaderSequencesDoNothing() {
		168	let h = doom("* Task\nbody text\n")
		169	var messages: [String] = []
		170	h.editor.onMessage = { messages.append($0) }
		171	h.caret(at: 0)
		172	type(h, "SPC m z")
		173	#expect(messages.last == "SPC m z is undefined")
		174	#expect(h.textView.selectedRange().location == 0)
		175	// No mark z was set: a jump to it fails and the caret stays.
		176	type(h, "j ' z")
		177	#expect(h.textView.selectedRange().location == 7)
		178	type(h, "C-c z")
		179	#expect(messages.last == "C-c z is undefined")
		180	#expect(h.editor.document.text == "* Task\nbody text\n")
		181	// Evil's own prefixes still reach it.
		182	type(h, "g g")
		183	#expect(h.textView.selectedRange().location == 0)
		184	}
		185
		186	@Test func keyHintsFollowContext() {
		187	let h = doom("* a\n#+begin_src sh\necho\n#+end_src\n")
		188	var hints: [(key: String, title: String)] = []
		189	h.editor.onKeysPending = { _, next in if !next.isEmpty { hints = next } }
		190	func hint() -> String? { hints.first { $0.key == "C-c" }?.title }
		191	h.caret(at: 1)
		192	type(h, "C-c")
		193	#expect(hint() != nil && hint() != "Run Source Block")
		194	type(h, "C-g")
		195	h.caret(at: 20)
		196	type(h, "C-c")
		197	#expect(hint() == "Run Source Block")
		198	type(h, "C-g")
		199	}
		200
75	@Test func visualSelection() {	201	@Test func visualSelection() {
76	let h = doom("one two three\n")	202	let h = doom("one two three\n")
77	h.caret(at: 0)	203	h.caret(at: 0)
	@@ -160,3 +286,15 @@ struct ModalTests {
160	#expect(h.textView.selectedRange().location == 23)	286	#expect(h.textView.selectedRange().location == 23)
161	}	287	}
162	}	288	}
		289
		290	struct PresetCommandTests {
		291	/// Every command a preset binds is one the editor runs, and every mode is a state.
		292	@Test func presetsBindKnownCommands() throws {
		293	let known = Set(EditorCommands.all.map(\.id))
		294	for preset in KeymapPreset.allCases {
		295	var problems: [String] = []
		296	_ = try Keymap(toml: preset.toml, problems: &problems, commands: known)
		297	#expect(problems.isEmpty, "\(preset): \(problems)")
		298	}
		299	}
		300	}

Tests/OrgEditorAppKitTests/ViewToggleTests.swift +4 −3

 import AppKit
 import OrgCore
+import OrgDocument
 import Testing
 @testable import OrgEditorAppKit
     @Test func gjMovesByScreenLines() {
         let long = Array(repeating: "word", count: 60).joined(separator: " ")
-        let h = Harness(long + "\nnext\n")
+        // In Org files gj is evil-org's element motion; elsewhere it's screen lines.
-        // Doom binds `g j` to the next heading; without that binding it's the engine's.
+        let h = Harness(DocumentState(bytes: Array((long + "\nnext\n").utf8)), mode: .plain(language: nil))
-        h.editor.keymap = KeymapPreset.emacs.keymap
+        h.editor.keymap = KeymapPreset.doom.keymap
         h.editor.modal = true
         h.caret(at: 0)
         h.caret(at: 0)