Buffers !54

merged merged by cmc on 2026-10-05 21:22 UTC · krz/orgstar:buffers into main

19 files changed, +640 −131

Layout: unified · split

Sources/OrgApp/AgendaModel.swift +7 −7

Sources/OrgApp/CaptureModel.swift +1 −1

	@@ -70,7 +70,7 @@ extension DocumentSession {
70	/// otherwise in the file, created if missing, through the save path.	70	/// otherwise in the file, created if missing, through the save path.
71	public func capture(_ text: String, template: CaptureTemplate, root: String?) -> String? {	71	public func capture(_ text: String, template: CaptureTemplate, root: String?) -> String? {
72	let path = Self.resolve(template.target.file, root: root)	72	let path = Self.resolve(template.target.file, root: root)
73	if path != self.path, !FileManager.default.fileExists(atPath: path) {	73	if !isOpen(path), !FileManager.default.fileExists(atPath: path) {
74	do {	74	do {
75	try FileManager.default.createDirectory(at: URL(fileURLWithPath: path).deletingLastPathComponent(), withIntermediateDirectories: true)	75	try FileManager.default.createDirectory(at: URL(fileURLWithPath: path).deletingLastPathComponent(), withIntermediateDirectories: true)
76	try Data().write(to: URL(fileURLWithPath: path))	76	try Data().write(to: URL(fileURLWithPath: path))

Sources/OrgApp/ClockModel.swift +1 −1

	@@ -79,7 +79,7 @@ public final class ClockModel {
79	/// Where the running clock's line is, for `org-clock-goto`.	79	/// Where the running clock's line is, for `org-clock-goto`.
80	public func location(_ session: DocumentSession) -> (path: String, offset: Int)? {	80	public func location(_ session: DocumentSession) -> (path: String, offset: Int)? {
81	guard let clock = running else { return nil }	81	guard let clock = running else { return nil }
82	let open = session.path == clock.path ? session.document?.text : nil	82	let open = session.openDocuments.first { $0.path == clock.path }?.document.text
83	guard let text = open ?? (try? String(contentsOfFile: clock.path, encoding: .utf8)) else { return nil }	83	guard let text = open ?? (try? String(contentsOfFile: clock.path, encoding: .utf8)) else { return nil }
84	let buffer = text as NSString	84	let buffer = text as NSString
85	let range = buffer.range(of: "CLOCK: [\(clock.start)]")	85	let range = buffer.range(of: "CLOCK: [\(clock.start)]")

Sources/OrgApp/DocumentSession.swift +189 −59

     case explicit
 }
-/// The file open in a window: its buffer, outline, saving, and requests for the editor to
+/// The files open in a window, as Emacs's buffers: each keeps its text, caret, undo and
-/// show a location. The view layer attaches the editor as the buffer and follows
+/// unsaved edits while another is shown. The current buffer's outline, saving and requests
-/// `revealRequest`.
+/// for the editor to show a location are what most views use. The view layer attaches an
+/// editor to each buffer and follows `path` and `revealRequest`.
 @MainActor
 @Observable
 public final class DocumentSession {
+    /// The current buffer's file.
     public private(set) var path: String?
-    /// A copy of the buffer's state as of its last change. Not observed: it changes on every
+    /// A copy of the current buffer's state as of its last change. Not observed: it changes
-    /// keystroke; views follow `path`, `isDirty` and `outline`.
+    /// on every keystroke; views follow `path`, `isDirty` and `outline`.
     @ObservationIgnored public private(set) var document: DocumentState?
     public private(set) var outline: [OutlineEntry] = []
     /// Bumped when the buffer settles after edits, and when a file opens: views that read
     public private(set) var conflict: String?
     /// Bumped to ask the editor to reveal an offset.
     public private(set) var revealRequest: (offset: Int, id: Int)?
+    /// Open files, in the order buffers were opened (each after the one current then).
+    public private(set) var openPaths: [String] = []
+    /// Open files with unsaved edits.
+    public private(set) var dirtyPaths: Set<String> = []
     public var lastError: String?
     public var saveMode: SaveMode = .automatic
     public var autosaveDelay: Duration = .seconds(1)
     /// TODO keywords and priorities for files without their own settings.
     public var defaults: OrgSettings = .default
+    /// One open file.
+    @MainActor
+    final class Entry {
+        let path: String
+        var buffer: DocumentBuffer
+        var conflict: String?
+        var autosave: Task<Void, Never>?
+        init(path: String, buffer: DocumentBuffer) {
+            self.path = path
+            self.buffer = buffer
+        }
+    }
     private let fileSystem: FileSystem
     private let recovery: RecoveryStore
-    @ObservationIgnored private var buffer: DocumentBuffer?
+    @ObservationIgnored private var entries: [Entry] = []
-    @ObservationIgnored var autosave: Task<Void, Never>?
+    @ObservationIgnored private var current: Entry?
+    /// Paths, most recently shown first.
+    @ObservationIgnored private var history: [String] = []
     @ObservationIgnored private var outlineUpdate: Task<Void, Never>?
     private var requestID = 0
         self.recovery = recovery
     }
+    private var buffer: DocumentBuffer? { current?.buffer }
+    /// The current buffer's pending autosave, for tests to wait on.
+    var autosave: Task<Void, Never>? { current?.autosave }
     private var url: URL? { path.map { URL(fileURLWithPath: $0) } }
     /// Whether the open file is an org file (`.org`, `.org_archive`), not plain text.
     public var isOrg: Bool { path.map(Self.isOrgPath) ?? false }
     public var caret: Int { buffer?.selection.first?.lowerBound ?? 0 }
     private var name: String { path.map { ($0 as NSString).lastPathComponent } ?? "" }
+    private func entry(_ path: String) -> Entry? { entries.first { $0.path == path } }
+    public func isOpen(_ path: String) -> Bool { entry(path) != nil }
+    /// The caret of an open file.
+    public func caret(of path: String) -> Int? { entry(path)?.buffer.selection.first?.lowerBound }
+    /// The text of every open file, for views that read files (the agenda, search).
+    public var openDocuments: [(path: String, document: DocumentState)] {
+        entries.map { ($0.path, $0.buffer.document) }
+    }
+    /// The text of every open file by path, for the agenda.
+    public var openTexts: [String: String] {
+        Dictionary(entries.map { ($0.path, $0.buffer.document.text) }, uniquingKeysWith: { a, _ in a })
+    }
+    /// Open buffers, most recently shown first.
+    public var recentPaths: [String] { history.filter(isOpen) }
+    /// Shows the buffer of `path`, opening the file if it isn't open.
     public func open(_ path: String) {
+        if let existing = entry(path) {
+            activate(existing)
+            return
+        }
         do {
             guard let bytes = try fileSystem.read(URL(fileURLWithPath: path)) else {
                 lastError = "\((path as NSString).lastPathComponent) no longer exists."
                 return
             }
-            autosave?.cancel()
+            let entry = Entry(path: path, buffer: StateBuffer(DocumentState(bytes: bytes, defaults: defaults)))
-            self.path = path
+            let index = current.flatMap { c in entries.firstIndex { $0 === c } }.map { $0 + 1 } ?? entries.count
-            buffer = StateBuffer(DocumentState(bytes: bytes, defaults: defaults))
+            entries.insert(entry, at: index)
-            conflict = nil
+            activate(entry)
-            revealRequest = nil
-            refresh()
         } catch {
             lastError = "Can't open \(path): \(error.localizedDescription)"
         }
     }
-    /// Closes the open file without saving, as when it was deleted.
+    private func activate(_ entry: Entry) {
-    public func close() {
+        current = entry
-        autosave?.cancel()
+        path = entry.path
-        outlineUpdate?.cancel()
+        conflict = entry.conflict
-        path = nil
-        buffer = nil
-        document = nil
-        outline = []
-        isDirty = false
-        conflict = nil
         revealRequest = nil
+        history.removeAll { $0 == entry.path }
+        history.insert(entry.path, at: 0)
+        refresh()
     }
-    /// Makes `buffer`, built from `document`, the live state of the open file.
+    /// The buffer before or after the current one, wrapping.
+    public func cycle(_ step: Int) {
+        guard let current, let index = entries.firstIndex(where: { $0 === current }), entries.count > 1 else { return }
+        activate(entries[((index + step) % entries.count + entries.count) % entries.count])
+    }
+    /// The buffer shown before the current one.
+    public func showPrevious() {
+        guard let previous = recentPaths.dropFirst().first else { return }
+        open(previous)
+    }
+    /// Closes the buffer of `path` without saving it; the most recent other buffer shows.
+    public func kill(_ path: String) {
+        guard let entry = entry(path) else { return }
+        entry.autosave?.cancel()
+        entries.removeAll { $0 === entry }
+        history.removeAll { $0 == path }
+        if entry === current {
+            current = nil
+            if let next = recentPaths.first.flatMap(self.entry) ?? entries.last {
+                activate(next)
+            } else {
+                outlineUpdate?.cancel()
+                self.path = nil
+                document = nil
+                outline = []
+                isDirty = false
+                conflict = nil
+                revealRequest = nil
+                refreshLists()
+            }
+        } else {
+            refreshLists()
+        }
+    }
+    /// Closes the current buffer without saving, as when its file was deleted.
+    public func close() {
+        if let path { kill(path) }
+    }
+    /// Makes `buffer`, built from `document`, the live state of the current file.
     public func attach(_ buffer: DocumentBuffer) {
-        self.buffer = buffer
+        current?.buffer = buffer
         refresh()
     }
             self.outline = self.isOrg ? Presentation.outline(document.tree) : []
             self.editVersion += 1
         }
-        scheduleAutosave()
+        if let current { scheduleAutosave(current) }
     }
     private func refresh(outline updateOutline: Bool = true) {
+        refreshLists()
         guard let buffer else { return }
         let state = buffer.document
         document = state
         if isDirty != state.isDirty { isDirty = state.isDirty }
         if isReadOnly == state.isEditable { isReadOnly = !state.isEditable }
+        if conflict != current?.conflict { conflict = current?.conflict }
         if updateOutline {
             outline = isOrg ? Presentation.outline(state.tree) : []
             editVersion += 1
         }
     }
+    private func refreshLists() {
+        let paths = entries.map(\.path)
+        if paths != openPaths { openPaths = paths }
+        let dirty = Set(entries.filter { $0.buffer.document.isDirty }.map(\.path))
+        if dirty != dirtyPaths { dirtyPaths = dirty }
+    }
     // MARK: - Saving
     private var saver: Saver { Saver(fileSystem: fileSystem, recovery: recovery) }
-    private func scheduleAutosave() {
+    private func scheduleAutosave(_ entry: Entry) {
-        autosave?.cancel()
+        entry.autosave?.cancel()
-        guard saveMode == .automatic, isDirty, conflict == nil else { return }
+        guard saveMode == .automatic, entry.buffer.document.isDirty, entry.conflict == nil else { return }
-        autosave = Task { [weak self, autosaveDelay] in
+        entry.autosave = Task { [weak self, weak entry, autosaveDelay] in
             try? await Task.sleep(for: autosaveDelay)
-            guard !Task.isCancelled else { return }
+            guard !Task.isCancelled, let self, let entry else { return }
-            self?.save()
+            self.save(entry)
         }
     }
-    /// Saves now. True when nothing is left unsaved.
+    /// Saves the current buffer now. True when nothing is left unsaved.
     @discardableResult
     public func save() -> Bool {
-        autosave?.cancel()
+        guard let current else { return true }
-        guard let buffer, let url, isDirty else { return !isDirty }
+        return save(current)
-        guard conflict == nil else { return false }
+    }
+    /// Saves the buffer of `path`. True when nothing is left unsaved.
+    @discardableResult
+    public func save(_ path: String) -> Bool {
+        guard let entry = entry(path) else { return true }
+        return save(entry)
+    }
+    /// Saves every open buffer. True when nothing is left unsaved.
+    @discardableResult
+    public func saveAll() -> Bool {
+        entries.map { save($0) }.allSatisfy { $0 }
+    }
+    @discardableResult
+    private func save(_ entry: Entry) -> Bool {
+        entry.autosave?.cancel()
+        let name = (entry.path as NSString).lastPathComponent
+        guard entry.buffer.document.isDirty else { return true }
+        guard entry.conflict == nil else { return false }
         do {
-            let outcome = try buffer.update { try saver.save(&$0, to: url) }
+            let outcome = try entry.buffer.update { try saver.save(&$0, to: URL(fileURLWithPath: entry.path)) }
             switch outcome {
             case .saved, .mergedAndSaved:
                 break
             case .conflict:
-                conflict = "\(name) changed on disk, and the changes conflict with yours."
+                entry.conflict = "\(name) changed on disk, and the changes conflict with yours."
             case .overwroteExternalChange(let change), .changedAfterWrite(let change):
                 if case .conflict = change {
-                    conflict = "\(name) changed on disk while saving, and the changes conflict with yours."
+                    entry.conflict = "\(name) changed on disk while saving, and the changes conflict with yours."
                 }
             }
         } catch {
             lastError = "Can't save \(name): \(error.localizedDescription)"
         }
-        refresh()
+        if entry === current { refresh() } else { refreshLists() }
-        return !isDirty
+        return !entry.buffer.document.isDirty
     }
     /// Resolves a conflict by writing the buffer over the disk version, which goes to recovery.
         guard let buffer, let url else { return }
         do {
             try buffer.update { try saver.overwrite(&$0, to: url) }
-            conflict = nil
+            current?.conflict = nil
         } catch {
             lastError = "Can't save \(name): \(error.localizedDescription)"
         }
             guard let bytes = try fileSystem.read(url) else { return }
             if isDirty { try recovery.keep(try buffer.document.encodedText(), for: url, label: "local") }
             buffer.update { $0 = DocumentState(bytes: bytes, defaults: $0.defaults) }
-            conflict = nil
+            current?.conflict = nil
         } catch {
             lastError = "Can't read \(name): \(error.localizedDescription)"
         }
             guard expect.start + (expect.line as NSString).length <= ns.length else { return false }
             return ns.substring(with: NSRange(location: expect.start, length: (expect.line as NSString).length)) == expect.line
         }
-        if path == self.path, let buffer {
+        if let entry = entry(path) {
+            let buffer = entry.buffer
             guard matches(buffer.document.text) else { return stale }
             do {
                 let options = self.options
                 let step = try buffer.update { try $0.run(command, selection: [offset..<offset], now: now, answers: answers, options: options) }
-                if case .commit = step { bufferChanged() }
+                if case .commit = step {
+                    if entry === current { bufferChanged() } else { scheduleAutosave(entry); refreshLists() }
+                }
                 return step
             } catch {
                 return .failed("\(error)")
     /// Recalculates a table in Emacs from a snapshot of the buffer, then replaces the table
     /// with Emacs's text if it hasn't changed meanwhile. Returns a message for the echo area.
     public func recalculateInEmacs(table: Range<Int>, point: Int, form: String) async -> String {
-        guard let buffer, let path else { return "No file is open." }
+        guard let entry = current else { return "No file is open." }
-        let snapshot = buffer.document.text as NSString
+        let path = entry.path
+        let snapshot = entry.buffer.document.text as NSString
         guard table.upperBound <= snapshot.length else { return "The table moved; try again." }
         let old = snapshot.substring(with: NSRange(table))
         let directory = URL(fileURLWithPath: path).deletingLastPathComponent()
         do {
             let new = try await EmacsRunner.recalculateTable(text: snapshot as String, directory: directory, table: table, point: point, form: form)
-            guard let current = self.buffer, self.path == path else { return "The file was closed before Emacs finished." }
+            guard entries.contains(where: { $0 === entry }) else { return "The file was closed before Emacs finished." }
+            let current = entry.buffer
             let text = current.document.text as NSString
             guard table.upperBound <= text.length, text.substring(with: NSRange(table)) == old else {
                 return "The table changed while Emacs recalculated it; nothing was changed."
             guard new != old else { return "Recalculated in Emacs" }
             let result = EditResult(baseRevision: current.document.revision, edits: [TextEdit(range: table, replacement: new)])
             if case .failed(let message) = current.perform(PrecomputedEdit(result), now: Date(), answers: [:]) { return message }
-            bufferChanged()
+            changed(entry)
             return "Recalculated in Emacs"
         } catch {
             return "\(error)"
     /// Runs a src block and writes its result under it, unless the block changed while it
     /// ran. Returns a message for the echo area.
     public func runBabel(_ job: BabelJob) async -> String {
-        guard let path, buffer != nil else { return "No file is open." }
+        guard let entry = current else { return "No file is open." }
-        let directory = URL(fileURLWithPath: path).deletingLastPathComponent()
+        let directory = URL(fileURLWithPath: entry.path).deletingLastPathComponent()
         do {
             let output = try await BabelRunner.run(job, fileDirectory: directory)
-            guard let current = self.buffer, self.path == path else { return "The file was closed before the block finished." }
+            guard entries.contains(where: { $0 === entry }) else { return "The file was closed before the block finished." }
+            let current = entry.buffer
             let document = current.document
             switch Babel.finish(job, output: output, text: document.text, settings: document.tree.settings) {
             case .failure(.message(let message)):
                 guard !edits.isEmpty else { return job.finish.params.contains("silent") ? output.stdout : "Code block evaluation complete." }
                 let result = EditResult(baseRevision: document.revision, edits: edits)
                 if case .failed(let message) = current.perform(PrecomputedEdit(result), now: Date(), answers: [:]) { return message }
-                bufferChanged()
+                changed(entry)
                 return "Code block evaluation complete."
             }
         } catch {
         }
     }
+    /// A buffer changed outside typing: the current one updates its views, another saves.
+    private func changed(_ entry: Entry) {
+        if entry === current { bufferChanged() } else { scheduleAutosave(entry); refreshLists() }
+    }
     // MARK: - Locations
     /// Opens the file of `location` if needed and asks the editor to show the heading. Offsets
         revealRequest = (offset, requestID)
     }
-    /// Called when the workspace sees the open file change on disk.
+    /// Called when the workspace sees a file change on disk: an open buffer of it takes the
+    /// change in.
     public func fileChanged(_ path: String) {
-        guard path == self.path, let buffer, let bytes = try? fileSystem.read(URL(fileURLWithPath: path)) else { return }
+        guard let entry = entry(path), let bytes = try? fileSystem.read(URL(fileURLWithPath: path)) else { return }
+        let buffer = entry.buffer
         guard bytes != buffer.document.mergeBase else { return }
+        let name = (path as NSString).lastPathComponent
         switch buffer.update({ $0.diskChanged(to: bytes) }) {
         case .conflict:
-            autosave?.cancel()
+            entry.autosave?.cancel()
-            conflict = "\(name) changed on disk, and the changes conflict with yours."
+            entry.conflict = "\(name) changed on disk, and the changes conflict with yours."
         case .merged, .reloaded:
-            conflict = nil
+            entry.conflict = nil
         case .unchanged:
             break
         }
-        refresh()
+        if entry === current { refresh() } else { refreshLists() }
     }
 }

Sources/OrgApp/UserConfig.swift +2

         Setting(section: "orgstar", key: "option-as-meta", defaultsKey: "optionAsMeta",
                 kind: .integerChoice([("left", 1), ("right", 2), ("both", 3), ("none", 0)]), fallback: .string("left"),
                 comment: "left, right, both or none", legacy: "general.option-as-meta"),
+        Setting(section: "orgstar", key: "tab-bar", defaultsKey: "showTabBar", kind: .bool, fallback: .bool(false),
+                comment: "a tab for each open buffer above the editor (View ▸ Show Tab Bar)", legacy: ""),
         Setting(section: "orgstar", key: "show-markup", defaultsKey: "showMarkup", kind: .bool, fallback: .bool(false),
                 comment: "show link brackets and emphasis markers (View ▸ Show Markup)", legacy: "editor.show-markup"),
         Setting(section: "orgstar", key: "show-hidden-files", defaultsKey: "showHiddenFiles", kind: .bool, fallback: .bool(true),

Sources/OrgApp/WorkspaceModel.swift +9

	@@ -266,6 +266,15 @@ public final class WorkspaceModel {
266	/// Index rows for an open file's unsaved text, keyed by path, for queries to use in place	266	/// Index rows for an open file's unsaved text, keyed by path, for queries to use in place
267	/// of its rows on disk. Empty when the file has no unsaved edits. Cached until the text	267	/// of its rows on disk. Empty when the file has no unsaved edits. Cached until the text
268	/// changes.	268	/// changes.
		269	/// Index records for open buffers with unsaved edits, so search sees what they hold.
		270	public func overlay(_ documents: [(path: String, document: DocumentState)]) -> [String: FileRecord] {
		271	var result: [String: FileRecord] = [:]
		272	for (path, document) in documents where document.isDirty {
		273	result.merge(overlay(path: path, document: document)) { a, _ in a }
		274	}
		275	return result
		276	}
		277
269	public func overlay(path: String?, document: DocumentState?) -> [String: FileRecord] {	278	public func overlay(path: String?, document: DocumentState?) -> [String: FileRecord] {
270	guard let path, let document, document.isDirty, let bytes = try? document.encodedText(),	279	guard let path, let document, document.isDirty, let bytes = try? document.encodedText(),
271	let entry = files.first(where: { $0.path == path }) else { return [:] }	280	let entry = files.first(where: { $0.path == path }) else { return [:] }

Sources/OrgCore/Keymap/Presets.swift +89

	@@ -94,6 +94,71 @@ public enum KeymapPreset: String, Sendable, CaseIterable {
94	keys = "SPC f s"	94	keys = "SPC f s"
95	command = "app.save"	95	command = "app.save"
96	mode = "normal"	96	mode = "normal"
		97	# Buffers
		98	[[bind]]
		99	keys = "SPC b b"
		100	command = "app.buffer.switch"
		101	mode = "normal"
		102	[[bind]]
		103	keys = "SPC b B"
		104	command = "app.buffer.switch"
		105	mode = "normal"
		106	[[bind]]
		107	keys = "SPC ,"
		108	command = "app.buffer.switch"
		109	mode = "normal"
		110	[[bind]]
		111	keys = "SPC `"
		112	command = "app.buffer.last"
		113	mode = "normal"
		114	[[bind]]
		115	keys = "SPC b k"
		116	command = "app.buffer.kill"
		117	mode = "normal"
		118	[[bind]]
		119	keys = "SPC b d"
		120	command = "app.buffer.kill"
		121	mode = "normal"
		122	[[bind]]
		123	keys = "SPC b K"
		124	command = "app.buffer.kill-all"
		125	mode = "normal"
		126	[[bind]]
		127	keys = "SPC b O"
		128	command = "app.buffer.kill-others"
		129	mode = "normal"
		130	[[bind]]
		131	keys = "SPC b n"
		132	command = "app.buffer.next"
		133	mode = "normal"
		134	[[bind]]
		135	keys = "SPC b p"
		136	command = "app.buffer.previous"
		137	mode = "normal"
		138	[[bind]]
		139	keys = "SPC b ]"
		140	command = "app.buffer.next"
		141	mode = "normal"
		142	[[bind]]
		143	keys = "SPC b ["
		144	command = "app.buffer.previous"
		145	mode = "normal"
		146	[[bind]]
		147	keys = "] b"
		148	command = "app.buffer.next"
		149	mode = "normal"
		150	[[bind]]
		151	keys = "[ b"
		152	command = "app.buffer.previous"
		153	mode = "normal"
		154	[[bind]]
		155	keys = "SPC b s"
		156	command = "app.save"
		157	mode = "normal"
		158	[[bind]]
		159	keys = "SPC b S"
		160	command = "app.save-all"
		161	mode = "normal"
97	[[bind]]	162	[[bind]]
98	keys = "SPC s s"	163	keys = "SPC s s"
99	command = "edit.find"	164	command = "edit.find"
	@@ -490,6 +555,24 @@ public enum KeymapPreset: String, Sendable, CaseIterable {
490	keys = "C-x C-s"	555	keys = "C-x C-s"
491	command = "app.save"	556	command = "app.save"
492	[[bind]]	557	[[bind]]
		558	keys = "C-x b"
		559	command = "app.buffer.switch"
		560	[[bind]]
		561	keys = "C-x C-b"
		562	command = "app.buffer.switch"
		563	[[bind]]
		564	keys = "C-x k"
		565	command = "app.buffer.kill"
		566	[[bind]]
		567	keys = "C-x <right>"
		568	command = "app.buffer.next"
		569	[[bind]]
		570	keys = "C-x <left>"
		571	command = "app.buffer.previous"
		572	[[bind]]
		573	keys = "C-x s"
		574	command = "app.save-all"
		575	[[bind]]
493	keys = "C-x C-f"	576	keys = "C-x C-f"
494	command = "app.quick-open"	577	command = "app.quick-open"
495	[[bind]]	578	[[bind]]
	@@ -745,6 +828,12 @@ public enum KeymapPreset: String, Sendable, CaseIterable {
745	/// Standard Mac text keys stay as they are; org commands use Control-Command chords, which	828	/// Standard Mac text keys stay as they are; org commands use Control-Command chords, which
746	/// macOS text editing leaves free.	829	/// macOS text editing leaves free.
747	static let macBindings = """	830	static let macBindings = """
		831	[[bind]]
		832	keys = "C-TAB"
		833	command = "app.buffer.next"
		834	[[bind]]
		835	keys = "C-S-TAB"
		836	command = "app.buffer.previous"
748	[[bind]]	837	[[bind]]
749	keys = "C-s-t"	838	keys = "C-s-t"
750	command = "org.todo.cycle"	839	command = "org.todo.cycle"

Sources/OrgEditorAppKit/EditorCommands.swift +9

	@@ -40,6 +40,15 @@ public enum EditorCommands {
40		40
41	EditorCommand(id: "app.save", title: "Save", action: .app),	41	EditorCommand(id: "app.save", title: "Save", action: .app),
42	EditorCommand(id: "app.quit", title: "Quit Orgstar", action: .app),	42	EditorCommand(id: "app.quit", title: "Quit Orgstar", action: .app),
		43	EditorCommand(id: "app.save-all", title: "Save All Buffers", action: .app),
		44	EditorCommand(id: "app.buffer.switch", title: "Switch to Buffer…", action: .app),
		45	EditorCommand(id: "app.buffer.kill", title: "Close Buffer", action: .app),
		46	EditorCommand(id: "app.buffer.kill-others", title: "Close Other Buffers", action: .app),
		47	EditorCommand(id: "app.buffer.kill-all", title: "Close All Buffers", action: .app),
		48	EditorCommand(id: "app.buffer.next", title: "Next Buffer", action: .app),
		49	EditorCommand(id: "app.buffer.previous", title: "Previous Buffer", action: .app),
		50	EditorCommand(id: "app.buffer.last", title: "Last Buffer", action: .app),
		51	EditorCommand(id: "app.toggle-tab-bar", title: "Show or Hide Tab Bar", action: .app),
43	EditorCommand(id: "app.toggle-outline", title: "Show or Hide Outline", action: .app),	52	EditorCommand(id: "app.toggle-outline", title: "Show or Hide Outline", action: .app),
44	EditorCommand(id: "app.toggle-markup", title: "Show or Hide Markup", action: .app),	53	EditorCommand(id: "app.toggle-markup", title: "Show or Hide Markup", action: .app),
45	EditorCommand(id: "app.edit-config", title: "Edit Config File", action: .app),	54	EditorCommand(id: "app.edit-config", title: "Edit Config File", action: .app),

Sources/OrgEditorAppKit/Keys.swift +3

     /// Returns true when the key was handled.
     var keyHandler: ((NSEvent) -> Bool)?
     var onMouseDown: (() -> Void)?
+    /// Each editor keeps its own undo history, not the window's.
+    private let ownUndoManager = UndoManager()
+    override var undoManager: UndoManager? { ownUndoManager }
     var lineNumberFont = NSFont.monospacedDigitSystemFont(ofSize: 11, weight: .regular)
     var lineNumberColor = NSColor.tertiaryLabelColor
     var currentLineNumberColor = NSColor.labelColor

Sources/OrgEditorAppKit/Theme.swift +4 −2

     /// A color that follows the appearance, or nil when the theme has none for `key`.
     func color(_ key: String) -> NSColor? {
-        let light = spec.light[key] ?? spec.dark[key]
+        // Editor colors are set for both appearances by the default theme; a key the theme
-        let dark = spec.dark[key] ?? spec.light[key]
+        // has for one only takes the default for the other.
+        let light = spec.light[key] ?? ThemeSpec.default.light[key] ?? spec.dark[key]
+        let dark = spec.dark[key] ?? ThemeSpec.default.dark[key] ?? spec.light[key]
         guard let light, let dark else { return nil }
         return Self.dynamic(light, dark)
     }

Sources/Orgstar/AgendaView.swift +1 −1

	@@ -162,7 +162,7 @@ struct AgendaView: View {
162	agenda.span = span	162	agenda.span = span
163	agenda.startOffset = startOffset	163	agenda.startOffset = startOffset
164	agenda.includeSubfolders = includeSubfolders	164	agenda.includeSubfolders = includeSubfolders
165	let open = session.path.flatMap { path in session.document.map { (path, $0.text) } }	165	let open = session.openTexts
166	await agenda.refresh(open: open)	166	await agenda.refresh(open: open)
167	}	167	}
168	.task {	168	.task {

Sources/Orgstar/BoardView.swift +1 −1

	@@ -78,7 +78,7 @@ struct BoardView: View {
78	.navigationTitle(kanban ? "Kanban" : "Entries")	78	.navigationTitle(kanban ? "Kanban" : "Entries")
79	.task(id: RefreshKey(match: match, subfolders: includeSubfolders, files: workspace.files.count, changed: workspace.changedFile?.version, edits: session.editVersion, path: session.path, tick: tick)) {	79	.task(id: RefreshKey(match: match, subfolders: includeSubfolders, files: workspace.files.count, changed: workspace.changedFile?.version, edits: session.editVersion, path: session.path, tick: tick)) {
80	agenda.includeSubfolders = includeSubfolders	80	agenda.includeSubfolders = includeSubfolders
81	let open = session.path.flatMap { path in session.document.map { (path, $0.text) } }	81	let open = session.openTexts
82	let result = await agenda.board(open: open, match: match)	82	let result = await agenda.board(open: open, match: match)
83	entries = result.entries	83	entries = result.entries
84	keywords = result.keywords	84	keywords = result.keywords

Sources/Orgstar/ContentView.swift +108 −15

	@@ -67,6 +67,9 @@ struct ContentView: View {
67	/// The outline for a file that isn't org, off until asked for.	67	/// The outline for a file that isn't org, off until asked for.
68	@State private var plainOutlineShown = false	68	@State private var plainOutlineShown = false
69	@State private var showingImport = false	69	@State private var showingImport = false
		70	@AppStorage("showTabBar") private var showTabBar = false
		71	/// Carets of restored buffers, shown when each first shows.
		72	@State private var pendingCarets: [String: Int] = [:]
70	@State private var query = ""	73	@State private var query = ""
71	@FocusState private var searchFocused: Bool	74	@FocusState private var searchFocused: Bool
72	@Environment(\.openWindow) private var openWindow	75	@Environment(\.openWindow) private var openWindow
	@@ -87,13 +90,16 @@ struct ContentView: View {
87	if let previewPath {	90	if let previewPath {
88	FilePreview(path: previewPath)	91	FilePreview(path: previewPath)
89	} else if session.path != nil {	92	} else if session.path != nil {
90	EditorView(session: session, commands: commands, keymap: keymap, modal: preset.isModal, optionAsMeta: OptionAsMeta(rawValue: optionAsMeta), options: options, showMarkup: showMarkup, showLineNumbers: showLineNumbers, theme: theme, onAppCommand: perform, onExternal: runExternal)	93	VStack(spacing: 0) {
91	.safeAreaInset(edge: .bottom, spacing: 0) {	94	if showTabBar { BufferTabs(session: session) }
92	VStack(spacing: 0) {	95	EditorView(session: session, commands: commands, keymap: keymap, modal: preset.isModal, optionAsMeta: OptionAsMeta(rawValue: optionAsMeta), options: options, showMarkup: showMarkup, showLineNumbers: showLineNumbers, theme: theme, onAppCommand: perform, onExternal: runExternal)
93	ModeLine(session: session, commands: commands, clock: clock, perform: perform)	96	}
94	EchoArea(commands: commands)	97	.safeAreaInset(edge: .bottom, spacing: 0) {
95	}	98	VStack(spacing: 0) {
		99	ModeLine(session: session, commands: commands, clock: clock, perform: perform)
		100	EchoArea(commands: commands)
96	}	101	}
		102	}
97	} else {	103	} else {
98	ContentUnavailableView(	104	ContentUnavailableView(
99	workspace.roots.isEmpty ? "Add a folder of org files" : "Choose a file",	105	workspace.roots.isEmpty ? "Add a folder of org files" : "Choose a file",
	@@ -146,8 +152,7 @@ struct ContentView: View {
146	if query.isEmpty {	152	if query.isEmpty {
147	OutlineColumn(session: session)	153	OutlineColumn(session: session)
148	} else {	154	} else {
149	SearchResults(results: workspace.search(query, overlay: workspace.overlay(path: session.path, document: session.document))) { location in	155	SearchResults(results: workspace.search(query, overlay: workspace.overlay(session.openDocuments))) { location in
150	guard location.path == session.path \|\| UnsavedChanges.resolve(session) else { return }
151	selectedFile = location.path	156	selectedFile = location.path
152	session.show(location)	157	session.show(location)
153	}	158	}
	@@ -177,12 +182,15 @@ struct ContentView: View {
177	}	182	}
178	previewPath = nil	183	previewPath = nil
179	guard path != session.path else { return }	184	guard path != session.path else { return }
180	if UnsavedChanges.resolve(session) {	185	session.open(path)
181	session.open(path)
182	} else {
183	selectedFile = old
184	}
185	}	186	}
		187	.onChange(of: session.path) {
		188	// Buffers switched by keys show in the sidebar too; a restored caret shows once.
		189	if let path = session.path, selectedFile != path { selectedFile = path }
		190	if let path = session.path, let caret = pendingCarets.removeValue(forKey: path) { session.reveal(caret) }
		191	BufferRestore.save(session)
		192	}
		193	.onChange(of: session.openPaths) { BufferRestore.save(session) }
186	.onChange(of: saveMode, initial: true) { _, mode in session.saveMode = mode }	194	.onChange(of: saveMode, initial: true) { _, mode in session.saveMode = mode }
187	.onChange(of: options, initial: true) { _, options in session.options = options }	195	.onChange(of: options, initial: true) { _, options in session.options = options }
188	.onChange(of: preset, initial: true) { loadKeymap() }	196	.onChange(of: preset, initial: true) { loadKeymap() }
	@@ -233,7 +241,6 @@ struct ContentView: View {
233	.onChange(of: commands.jumpRequest?.id) {	241	.onChange(of: commands.jumpRequest?.id) {
234	guard let request = commands.jumpRequest else { return }	242	guard let request = commands.jumpRequest else { return }
235	if request.path != session.path {	243	if request.path != session.path {
236	guard UnsavedChanges.resolve(session) else { return }
237	session.open(request.path)	244	session.open(request.path)
238	selectedFile = request.path	245	selectedFile = request.path
239	}	246	}
	@@ -279,6 +286,8 @@ struct ContentView: View {
279	}	286	}
280	.task {	287	.task {
281	DevelopmentHooks.scheduleSnapshot()	288	DevelopmentHooks.scheduleSnapshot()
		289	pendingCarets = BufferRestore.restore(session)
		290	if let path = session.path, let caret = pendingCarets.removeValue(forKey: path) { session.reveal(caret) }
282	if let path = DevelopmentHooks.fileToOpen { selectedFile = path }	291	if let path = DevelopmentHooks.fileToOpen { selectedFile = path }
283	if let root = DevelopmentHooks.rootToAdd { try? await workspace.addRoot(URL(fileURLWithPath: root)) }	292	if let root = DevelopmentHooks.rootToAdd { try? await workspace.addRoot(URL(fileURLWithPath: root)) }
284	if let command = DevelopmentHooks.commandToRun { perform(command) }	293	if let command = DevelopmentHooks.commandToRun { perform(command) }
	@@ -389,7 +398,7 @@ struct ContentView: View {
389	let agenda = reminderAgenda ?? AgendaModel(workspace: workspace)	398	let agenda = reminderAgenda ?? AgendaModel(workspace: workspace)
390	reminderAgenda = agenda	399	reminderAgenda = agenda
391	agenda.includeSubfolders = agendaSubfolders	400	agenda.includeSubfolders = agendaSubfolders
392	let open = session.path.flatMap { path in session.document.map { (path, $0.text) } }	401	let open = session.openTexts
393	let reminders = await agenda.reminders(open: open, lead: reminderLead)	402	let reminders = await agenda.reminders(open: open, lead: reminderLead)
394	guard !Task.isCancelled else { return }	403	guard !Task.isCancelled else { return }
395	await scheduler.reconcile(reminders)	404	await scheduler.reconcile(reminders)
	@@ -406,6 +415,22 @@ struct ContentView: View {
406	}	415	}
407	}	416	}
408		417
		418	/// `SPC b b`: open buffers, most recent first, by name (with the folder when names repeat).
		419	private func switchBuffer() {
		420	let paths = session.recentPaths.dropFirst() + session.recentPaths.prefix(1)
		421	let names = paths.map { ($0 as NSString).lastPathComponent }
		422	let labels = paths.map { path in
		423	let name = (path as NSString).lastPathComponent
		424	guard names.filter({ $0 == name }).count > 1 else { return name }
		425	return name + " — " + ((path as NSString).deletingLastPathComponent as NSString).lastPathComponent
		426	}
		427	guard !labels.isEmpty else { return commands.show("No buffers are open") }
		428	commands.ask(Prompt(key: "buffer", message: "Switch to buffer:", choices: labels)) { answer in
		429	guard let answer, let index = labels.firstIndex(of: answer) else { return }
		430	session.open(Array(paths)[index])
		431	}
		432	}
		433
409	/// Runs a command from a key, the palette or the Org menu.	434	/// Runs a command from a key, the palette or the Org menu.
410	private func perform(_ id: String) {	435	private func perform(_ id: String) {
411	let orgOnly = ["app.refile", "app.archive", "app.clock.in"].contains(id) \|\| id.hasPrefix("app.export.")	436	let orgOnly = ["app.refile", "app.archive", "app.clock.in"].contains(id) \|\| id.hasPrefix("app.export.")
	@@ -417,6 +442,25 @@ struct ContentView: View {
417	case "app.save":	442	case "app.save":
418	if !session.save(), session.conflict != nil { commands.showingConflict = true }	443	if !session.save(), session.conflict != nil { commands.showingConflict = true }
419	case "app.quit": NSApp.terminate(nil)	444	case "app.quit": NSApp.terminate(nil)
		445	case "app.save-all":
		446	if !session.saveAll(), session.conflict != nil { commands.showingConflict = true }
		447	case "app.buffer.switch": switchBuffer()
		448	case "app.buffer.next": session.cycle(1)
		449	case "app.buffer.previous": session.cycle(-1)
		450	case "app.buffer.last": session.showPrevious()
		451	case "app.buffer.kill":
		452	guard let path = session.path else {
		453	NSApp.keyWindow?.performClose(nil)
		454	return
		455	}
		456	if UnsavedChanges.resolve(session) { session.kill(path) }
		457	case "app.buffer.kill-others":
		458	let others = session.openPaths.filter { $0 != session.path }
		459	if UnsavedChanges.resolve(session, paths: others) { others.forEach(session.kill) }
		460	case "app.buffer.kill-all":
		461	let all = session.openPaths
		462	if UnsavedChanges.resolve(session, paths: all) { all.forEach(session.kill) }
		463	case "app.toggle-tab-bar": showTabBar.toggle()
420	case "app.toggle-outline": toggleOutline()	464	case "app.toggle-outline": toggleOutline()
421	case "app.toggle-markup": showMarkup.toggle()	465	case "app.toggle-markup": showMarkup.toggle()
422	case "app.toggle-line-numbers": showLineNumbers.toggle()	466	case "app.toggle-line-numbers": showLineNumbers.toggle()
	@@ -680,3 +724,52 @@ struct PaneDivider: View {
680	.accessibilityHidden(true)	724	.accessibilityHidden(true)
681	}	725	}
682	}	726	}
		727
		728	/// A tab for each open buffer: click to show it, × to close it, a dot for unsaved edits.
		729	struct BufferTabs: View {
		730	let session: DocumentSession
		731	@Environment(\.orgTheme) private var theme
		732
		733	var body: some View {
		734	ScrollView(.horizontal, showsIndicators: false) {
		735	HStack(spacing: 0) {
		736	ForEach(session.openPaths, id: \.self) { path in
		737	tab(path)
		738	}
		739	}
		740	}
		741	.frame(height: 28)
		742	.background { if let bg = theme.color("modeline-background") { bg } else { Rectangle().fill(.bar) } }
		743	.overlay(alignment: .bottom) { Divider() }
		744	}
		745
		746	private func tab(_ path: String) -> some View {
		747	let current = path == session.path
		748	return HStack(spacing: 6) {
		749	Text((path as NSString).lastPathComponent)
		750	.lineLimit(1)
		751	.foregroundStyle(current ? .primary : .secondary)
		752	Button {
		753	if path == session.path {
		754	if UnsavedChanges.resolve(session) { session.kill(path) }
		755	} else if UnsavedChanges.resolve(session, paths: [path]) {
		756	session.kill(path)
		757	}
		758	} label: {
		759	Image(systemName: session.dirtyPaths.contains(path) ? "circle.fill" : "xmark")
		760	.font(.system(size: session.dirtyPaths.contains(path) ? 6 : 9, weight: .semibold))
		761	.frame(width: 12, height: 12)
		762	}
		763	.buttonStyle(.borderless)
		764	.help("Close")
		765	}
		766	.font(.callout)
		767	.padding(.horizontal, 12)
		768	.frame(maxHeight: .infinity)
		769	.background(current ? theme.color("background") ?? Color(nsColor: .textBackgroundColor) : .clear)
		770	.overlay(alignment: .trailing) { Divider() }
		771	.contentShape(Rectangle())
		772	.onTapGesture { session.open(path) }
		773	.help(path)
		774	}
		775	}

Sources/Orgstar/EditorView.swift +42 −25

 import OrgHighlight
 import SwiftUI
-/// The TextKit 2 editor for the session's file. A new file gets a new editor, which becomes the
+/// The TextKit 2 editors for the session's buffers: one per open file, kept while another
-/// session's buffer; reveal requests go to the existing one.
+/// shows so its caret, folds and undo stay. An editor becomes its buffer's live state; reveal
+/// requests go to the one showing.
 struct EditorView: NSViewRepresentable {
     /// One highlighter for every editor: it caches compiled grammars and results.
     static let highlighter = TreeSitterHighlighter()
         var editor: OrgEditor?
         var path: String?
         var revealID = 0
+        /// Editors of open buffers, with their scroll views.
+        var editors: [String: (editor: OrgEditor, scroll: NSScrollView)] = [:]
     }
     func makeCoordinator() -> Coordinator { Coordinator() }
     func updateNSView(_ container: NSView, context: Context) {
         let coordinator = context.coordinator
+        // Buffers that were killed take their editors with them.
+        for path in coordinator.editors.keys where !session.openPaths.contains(path) {
+            coordinator.editors[path]?.scroll.removeFromSuperview()
+            coordinator.editors[path] = nil
+        }
         if coordinator.path != session.path {
             coordinator.path = session.path
             container.subviews.forEach { $0.removeFromSuperview() }
             coordinator.editor = nil
-            if let document = session.document {
+            if let path = session.path, let shown = coordinator.editors[path] ?? makeEditor(container) {
-                let mode: OrgEditor.Mode = session.isOrg ? .org : .plain(language: session.path.flatMap(FileTypes.language))
+                coordinator.editors[path] = shown
-                let editor = OrgEditor(document: document, frame: container.bounds, editable: document.isEditable, highlighter: Self.highlighter, mode: mode)
+                shown.scroll.frame = container.bounds
-                editor.onChange = { [weak session] in session?.bufferChanged() }
+                container.addSubview(shown.scroll)
-                editor.onMessage = { [weak commands] in commands?.show($0) }
+                container.window?.makeFirstResponder(shown.editor.textView)
-                editor.onKeysPending = { [weak commands] keys, next in
+                coordinator.editor = shown.editor
-                    commands?.pendingKeys = keys
+                commands.editor = shown.editor
-                    commands?.keyHints = next.map { KeyHint(key: $0.key, title: $0.title) }
+                session.attach(shown.editor)
-                }
+            } else {
-                editor.onModeChange = { [weak commands] in commands?.editorState = $0 }
+                commands.editor = nil
-                editor.onSelectionChange = { [weak commands] in commands?.selection = $0 }
-                editor.onAppCommand = onAppCommand
-                editor.onExternal = onExternal
-                editor.onPrompt = { [weak commands] prompt, reply in commands?.ask(prompt, reply: reply) }
-                commands.editor = editor
-                let scroll = editor.makeScrollView()
-                scroll.frame = container.bounds
-                scroll.autoresizingMask = [.width, .height]
-                container.addSubview(scroll)
-                container.window?.makeFirstResponder(editor.textView)
-                coordinator.editor = editor
-                session.attach(editor)
             }
         }
         if let editor = coordinator.editor {
             editor.showLineNumbers = showLineNumbers
             editor.themeSpec = theme
         }
-        container.window?.isDocumentEdited = session.isDirty
+        container.window?.isDocumentEdited = !session.dirtyPaths.isEmpty
         if let request = session.revealRequest, request.id != coordinator.revealID {
             coordinator.revealID = request.id
             coordinator.editor?.reveal(request.offset)
         }
     }
+    /// An editor for the current buffer, which becomes the buffer's live state.
+    private func makeEditor(_ container: NSView) -> (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)
+        editor.onChange = { [weak session] in session?.bufferChanged() }
+        editor.onMessage = { [weak commands] in commands?.show($0) }
+        editor.onKeysPending = { [weak commands] keys, next in
+            commands?.pendingKeys = keys
+            commands?.keyHints = next.map { KeyHint(key: $0.key, title: $0.title) }
+        }
+        editor.onModeChange = { [weak commands] in commands?.editorState = $0 }
+        editor.onSelectionChange = { [weak commands] in commands?.selection = $0 }
+        editor.onAppCommand = onAppCommand
+        editor.onExternal = onExternal
+        editor.onPrompt = { [weak commands] prompt, reply in commands?.ask(prompt, reply: reply) }
+        let scroll = editor.makeScrollView()
+        scroll.autoresizingMask = [.width, .height]
+        return (editor, scroll)
+    }
 }

Sources/Orgstar/OrgstarApp.swift +74 −1

	@@ -115,7 +115,8 @@ final class AppDelegate: NSObject, NSApplicationDelegate, UNUserNotificationCent
115		115
116	func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {	116	func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
117	guard let session else { return .terminateNow }	117	guard let session else { return .terminateNow }
118	return UnsavedChanges.resolve(session) ? .terminateNow : .terminateCancel	118	BufferRestore.save(session)
		119	return UnsavedChanges.resolve(session, paths: session.openPaths) ? .terminateNow : .terminateCancel
119	}	120	}
120	}	121	}
121		122
	@@ -139,6 +140,54 @@ enum UnsavedChanges {
139	default: return false	140	default: return false
140	}	141	}
141	}	142	}
		143
		144	/// Whether the buffers of `paths` can be closed: saved in automatic mode, or as the user
		145	/// chooses for all of them in explicit mode.
		146	static func resolve(_ session: DocumentSession, paths: [String]) -> Bool {
		147	let dirty = paths.filter(session.dirtyPaths.contains)
		148	guard !dirty.isEmpty else { return true }
		149	if session.saveMode == .automatic { return dirty.map(session.save).allSatisfy { $0 } }
		150	if dirty == [session.path] { return resolve(session) }
		151	let alert = NSAlert()
		152	alert.messageText = "Save changes to \(dirty.count) files?"
		153	alert.informativeText = dirty.map { ($0 as NSString).lastPathComponent }.joined(separator: ", ")
		154	alert.addButton(withTitle: "Save All")
		155	alert.addButton(withTitle: "Don't Save")
		156	alert.addButton(withTitle: "Cancel")
		157	switch alert.runModal() {
		158	case .alertFirstButtonReturn: return dirty.map(session.save).allSatisfy { $0 }
		159	case .alertSecondButtonReturn: return true
		160	default: return false
		161	}
		162	}
		163	}
		164
		165	/// The open buffers, their order and carets, kept for the next launch.
		166	@MainActor
		167	enum BufferRestore {
		168	private static let key = "openBuffers"
		169
		170	struct State: Codable {
		171	var paths: [String]
		172	var current: String?
		173	var carets: [String: Int]
		174	}
		175
		176	static func save(_ session: DocumentSession, defaults: UserDefaults = .standard) {
		177	var carets: [String: Int] = [:]
		178	for path in session.openPaths { carets[path] = session.caret(of: path) }
		179	let state = State(paths: session.openPaths, current: session.path, carets: carets)
		180	if let data = try? JSONEncoder().encode(state) { defaults.set(data, forKey: key) }
		181	}
		182
		183	/// Opens the buffers that were open, in order, and returns the carets to show them at.
		184	static func restore(_ session: DocumentSession, defaults: UserDefaults = .standard) -> [String: Int] {
		185	guard let data = defaults.data(forKey: key), let state = try? JSONDecoder().decode(State.self, from: data) else { return [:] }
		186	let existing = state.paths.filter { FileManager.default.fileExists(atPath: $0) }
		187	for path in existing { session.open(path) }
		188	if let current = state.current, existing.contains(current) { session.open(current) }
		189	return state.carets
		190	}
142	}	191	}
143		192
144	@main	193	@main
	@@ -216,11 +265,26 @@ struct OrgstarApp: App {
216	.disabled(session.path == nil)	265	.disabled(session.path == nil)
217	}	266	}
218	CommandGroup(replacing: .saveItem) {	267	CommandGroup(replacing: .saveItem) {
		268	Button("Close Buffer") {
		269	// ⌘W closes the buffer in the main window, and other windows themselves.
		270	if let key = NSApp.keyWindow, key.identifier?.rawValue.contains("main") != true {
		271	key.performClose(nil)
		272	} else {
		273	commands.run("app.buffer.kill")
		274	}
		275	}
		276	.keyboardShortcut("w")
		277	Button("Close Window") { NSApp.keyWindow?.performClose(nil) }
		278	.keyboardShortcut("w", modifiers: [.command, .shift])
		279	Divider()
219	Button("Save") {	280	Button("Save") {
220	if !session.save(), session.conflict != nil { commands.showingConflict = true }	281	if !session.save(), session.conflict != nil { commands.showingConflict = true }
221	}	282	}
222	.keyboardShortcut("s")	283	.keyboardShortcut("s")
223	.disabled(session.path == nil \|\| session.isReadOnly)	284	.disabled(session.path == nil \|\| session.isReadOnly)
		285	Button("Save All") { commands.run("app.save-all") }
		286	.keyboardShortcut("s", modifiers: [.command, .option])
		287	.disabled(session.dirtyPaths.isEmpty)
224	}	288	}
225	CommandGroup(after: .sidebar) {	289	CommandGroup(after: .sidebar) {
226	Button("Show or Hide Outline") { commands.run("app.toggle-outline") }	290	Button("Show or Hide Outline") { commands.run("app.toggle-outline") }
	@@ -237,6 +301,13 @@ struct OrgstarApp: App {
237	}	301	}
238	CommandGroup(before: .windowList) {	302	CommandGroup(before: .windowList) {
239	AgendaMenuItem()	303	AgendaMenuItem()
		304	Divider()
		305	Button("Switch to Buffer…") { commands.run("app.buffer.switch") }
		306	Button("Next Buffer") { commands.run("app.buffer.next") }
		307	.keyboardShortcut("]", modifiers: [.command, .shift])
		308	Button("Previous Buffer") { commands.run("app.buffer.previous") }
		309	.keyboardShortcut("[", modifiers: [.command, .shift])
		310	Divider()
240	}	311	}
241	CommandGroup(after: .newItem) {	312	CommandGroup(after: .newItem) {
242	Button("Capture…") { commands.run("app.capture") }	313	Button("Capture…") { commands.run("app.capture") }
	@@ -279,6 +350,7 @@ struct OrgMenuItems: View {
279		350
280	/// View ▸ Show Markup (link brackets and targets, emphasis markers) and Show Line Numbers.	351	/// View ▸ Show Markup (link brackets and targets, emphasis markers) and Show Line Numbers.
281	struct MarkupToggle: View {	352	struct MarkupToggle: View {
		353	@AppStorage("showTabBar") private var showTabBar = false
282	@AppStorage("showMarkup") private var showMarkup = false	354	@AppStorage("showMarkup") private var showMarkup = false
283	@AppStorage("showLineNumbers") private var showLineNumbers = true	355	@AppStorage("showLineNumbers") private var showLineNumbers = true
284		356
	@@ -287,6 +359,7 @@ struct MarkupToggle: View {
287	.keyboardShortcut("m", modifiers: [.command, .shift])	359	.keyboardShortcut("m", modifiers: [.command, .shift])
288	Toggle("Show Line Numbers", isOn: $showLineNumbers)	360	Toggle("Show Line Numbers", isOn: $showLineNumbers)
289	.keyboardShortcut("l", modifiers: [.command, .shift])	361	.keyboardShortcut("l", modifiers: [.command, .shift])
		362	Toggle("Show Tab Bar", isOn: $showTabBar)
290	}	363	}
291	}	364	}
292		365

Sources/Orgstar/SidebarFiles.swift +21 −13

         pending = operation
     }
-    /// Whether `path` is the open file or a folder holding it.
+    /// The open buffers of `path`, a file or a folder holding them.
-    func holdsOpenFile(_ path: String) -> Bool {
+    func openFiles(under path: String) -> [String] {
-        guard let open = session.path else { return false }
+        session.openPaths.filter { $0 == path || $0.hasPrefix(path + "/") }
-        return open == path || open.hasPrefix(path + "/")
     }
+    /// Whether `path` is an open file or a folder holding one.
+    func holdsOpenFile(_ path: String) -> Bool { !openFiles(under: path).isEmpty }
     func finish() {
         guard let operation = pending else { return }
         pending = nil
                 case .create(let folder):
                     selection = try await workspace.createFile(named: name, in: folder)
                 case .rename(let path):
-                    let affected = holdsOpenFile(path)
+                    let affected = openFiles(under: path)
-                    // The open file is saved first, so the rename carries its edits.
+                    // Open files are saved first, so the rename carries their edits, and open
-                    if affected, !UnsavedChanges.resolve(session) { return }
+                    // again under their new paths.
+                    if !UnsavedChanges.resolve(session, paths: affected) { return }
+                    let shown = session.path
                     let renamed = try await workspace.rename(path, to: name)
-                    if affected, let open = session.path {
+                    for open in affected {
-                        let moved = renamed + open.dropFirst(path.count)
+                        session.kill(open)
+                        session.open(renamed + open.dropFirst(path.count))
+                    }
+                    if let shown, affected.contains(shown) {
+                        let moved = renamed + shown.dropFirst(path.count)
                         session.open(moved)
                         selection = moved
+                    } else if let shown {
+                        session.open(shown)
                     }
                 case .trash(let path):
-                    if holdsOpenFile(path) {
+                    for open in openFiles(under: path) { session.kill(open) }
-                        session.close()
+                    if session.path == nil { selection = nil }
-                        selection = nil
-                    }
                     try await workspace.trash(path)
                 }
             } catch {

Sources/Orgstar/ThemeColors.swift +16 −2

 extension ThemeSpec {
     /// A color that follows the appearance, or nil when the theme leaves `key` to the system.
+    /// A key set for one appearance only leaves the other to the system.
     func color(_ key: String) -> Color? {
-        guard let light = self.light[key] ?? self.dark[key], let dark = self.dark[key] ?? self.light[key] else { return nil }
+        guard light[key] != nil || dark[key] != nil else { return nil }
+        let (light, dark) = (light[key], dark[key])
+        let fallback = Self.systemColor(key)
         return Color(nsColor: NSColor(name: nil) { appearance in
-            let c = appearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua ? dark : light
+            let isDark = appearance.bestMatch(from: [.aqua, .darkAqua]) == .darkAqua
+            guard let c = isDark ? dark : light else { return fallback }
             return NSColor(srgbRed: c.red, green: c.green, blue: c.blue, alpha: c.alpha)
         })
     }
+    /// What the system shows for a key the theme leaves unset in one appearance.
+    static func systemColor(_ key: String) -> NSColor {
+        switch key {
+        case "sidebar-background", "modeline-background": .windowBackgroundColor
+        case "agenda-background", "background": .textBackgroundColor
+        case "sidebar-header", "modeline-foreground", "agenda-time", "agenda-category", "agenda-scheduled", "tags": .secondaryLabelColor
+        default: .labelColor
+        }
+    }
     /// A TODO keyword's color: its own from `[theme.todo]`, else the theme's TODO or DONE.
     func keywordColor(_ keyword: String, done: Bool) -> Color {
         if let c = todo[keyword] { return Color(.sRGB, red: c.red, green: c.green, blue: c.blue, opacity: c.alpha) }

Tests/OrgAppTests/AppTests.swift +60 −3

	@@ -561,14 +561,71 @@ struct ClockModelTests {
561	#expect(clock.running?.heading == "Task")	561	#expect(clock.running?.heading == "Task")
562	#expect(ClockModel(file: stateFile).running == clock.running)	562	#expect(ClockModel(file: stateFile).running == clock.running)
563		563
564	// Out from another file: the clocked file is closed now (saved first, as leaving a	564	// Out from another file: the clocked file's buffer is still open behind it and takes
565	// file does in the app).	565	// the change.
566	#expect(session.save())
567	session.open(other.path)	566	session.open(other.path)
568	let message = clock.clockOut(session, now: start.addingTimeInterval(95 * 60))	567	let message = clock.clockOut(session, now: start.addingTimeInterval(95 * 60))
569	#expect(message == "Clock stopped after 1:35")	568	#expect(message == "Clock stopped after 1:35")
570	#expect(clock.running == nil)	569	#expect(clock.running == nil)
		570	#expect(session.dirtyPaths == [work.path])
		571	#expect(session.saveAll())
571	let text = try String(contentsOf: work, encoding: .utf8)	572	let text = try String(contentsOf: work, encoding: .utf8)
572	#expect(text.hasPrefix("* Task\n:LOGBOOK:\nCLOCK: [") && text.contains("=> 1:35\n:END:\nBody\n"), "\(text)")	573	#expect(text.hasPrefix("* Task\n:LOGBOOK:\nCLOCK: [") && text.contains("=> 1:35\n:END:\nBody\n"), "\(text)")
573	}	574	}
574	}	575	}
		576
		577	@MainActor
		578	struct BufferTests {
		579	@Test func buffersKeepEditsWhileOthersShow() throws {
		580	let notes = try Folder()
		581	let a = try notes.write("a.org", "* A\n")
		582	let b = try notes.write("b.org", "* B\n")
		583	let c = try notes.write("c.org", "* C\n")
		584	let session = DocumentSession(recovery: FileRecoveryStore(directory: notes.url.appendingPathComponent(".r")))
		585	session.saveMode = .explicit
		586	session.open(a.path)
		587	_ = session.perform(SetTodo(keyword: "TODO"), path: a.path, at: 0, expect: nil)
		588	session.open(b.path)
		589	#expect(session.path == b.path)
		590	#expect(session.openPaths == [a.path, b.path])
		591	#expect(session.dirtyPaths == [a.path])
		592	// A background buffer takes commands for its file, not the disk.
		593	_ = session.perform(SetTodo(keyword: "DONE"), path: a.path, at: 0, expect: nil)
		594	#expect(try String(contentsOf: a, encoding: .utf8) == "* A\n")
		595	#expect(session.openDocuments.first { $0.path == a.path }?.document.text.hasPrefix("* DONE A") == true)
		596
		597	session.open(a.path)
		598	#expect(session.document?.text.hasPrefix("* DONE A") == true)
		599	session.open(c.path)
		600	// Opened after the current buffer.
		601	#expect(session.openPaths == [a.path, c.path, b.path])
		602	session.cycle(1)
		603	#expect(session.path == b.path)
		604	session.cycle(1)
		605	#expect(session.path == a.path)
		606	session.showPrevious()
		607	#expect(session.path == b.path)
		608	#expect(session.recentPaths == [b.path, a.path, c.path])
		609
		610	session.kill(b.path)
		611	#expect(session.path == a.path)
		612	#expect(session.openPaths == [a.path, c.path])
		613	#expect(session.saveAll())
		614	#expect(try String(contentsOf: a, encoding: .utf8).hasPrefix("* DONE A"))
		615	session.kill(a.path)
		616	session.kill(c.path)
		617	#expect(session.path == nil && session.document == nil && session.openPaths.isEmpty)
		618	}
		619
		620	@Test func backgroundBuffersFollowTheDisk() throws {
		621	let notes = try Folder()
		622	let a = try notes.write("a.org", "* A\n")
		623	let b = try notes.write("b.org", "* B\n")
		624	let session = DocumentSession(recovery: FileRecoveryStore(directory: notes.url.appendingPathComponent(".r")))
		625	session.open(a.path)
		626	session.open(b.path)
		627	try notes.write("a.org", "* A changed\n")
		628	session.fileChanged(a.path)
		629	#expect(session.openDocuments.first { $0.path == a.path }?.document.text == "* A changed\n")
		630	}
		631	}

Tests/OrgCoreTests/KeymapTests.swift +3

         let labels = doom.keyLabels(for: "org.todo.cycle", modes: ["normal", "insert"])
         #expect(labels == ["C-c C-t", "SPC m t"])
         #expect(doom.keyLabels(for: "app.quit", modes: ["normal", "insert"]) == ["SPC q q"])
+        #expect(doom.keyLabels(for: "app.buffer.kill", modes: ["normal"], limit: 3) == ["SPC b d", "SPC b k"])
+        #expect(doom.keyLabels(for: "app.buffer.next", modes: ["normal"]) == ["] b", "SPC b ]"])
+        #expect(emacs.keyLabels(for: "app.buffer.switch") == ["C-x b", "C-x C-b"])
     }
     @Test func dispatchesPrefixes() {

	@@ -41,8 +41,8 @@ public final class AgendaModel {
41	.sorted()	41	.sorted()
42	}	42	}
43		43
44	/// Recomputes the days. `open` is the open file's path and text.	44	/// Recomputes the days. `open` is the open buffers' text by path.
45	public func refresh(open: (path: String, text: String)?, now: Date = Date(), calendar: Calendar = .current) async {	45	public func refresh(open: [String: String], now: Date = Date(), calendar: Calendar = .current) async {
46	generation += 1	46	generation += 1
47	let id = generation	47	let id = generation
48	isComputing = true	48	isComputing = true
	@@ -78,25 +78,25 @@ public final class AgendaModel {
78	}	78	}
79		79
80	/// Reminders for the timed entries of the next `days` days.	80	/// Reminders for the timed entries of the next `days` days.
81	public func reminders(open: (path: String, text: String)?, now: Date = Date(), calendar: Calendar = .current, days: Int = 7, lead: Int = 12) async -> [Reminder] {	81	public func reminders(open: [String: String], now: Date = Date(), calendar: Calendar = .current, days: Int = 7, lead: Int = 12) async -> [Reminder] {
82	let all = await sources(open: open)	82	let all = await sources(open: open)
83	return await Task.detached { Reminders.upcoming(all, now: now, calendar: calendar, days: days, lead: lead) }.value	83	return await Task.detached { Reminders.upcoming(all, now: now, calendar: calendar, days: days, lead: lead) }.value
84	}	84	}
85		85
86	/// Entries for the table and kanban views, and the keywords their files use.	86	/// Entries for the table and kanban views, and the keywords their files use.
87	public func board(open: (path: String, text: String)?, match: String) async -> (entries: [BoardEntry], keywords: [String]) {	87	public func board(open: [String: String], match: String) async -> (entries: [BoardEntry], keywords: [String]) {
88	let all = await sources(open: open)	88	let all = await sources(open: open)
89	return await Task.detached { (Board.entries(all, match: match), Board.keywords(all)) }.value	89	return await Task.detached { (Board.entries(all, match: match), Board.keywords(all)) }.value
90	}	90	}
91		91
92	/// The agenda files' sources: the open file's from its text, the others from the cache	92	/// The agenda files' sources: the open file's from its text, the others from the cache
93	/// while their modification date and size are unchanged.	93	/// while their modification date and size are unchanged.
94	private func sources(open: (path: String, text: String)?) async -> [AgendaSource] {	94	private func sources(open: [String: String]) async -> [AgendaSource] {
95	let defaults = workspace.settings.org	95	let defaults = workspace.settings.org
96	var reads: [(path: String, cached: AgendaSource?, mtime: Date, size: Int, text: String?)] = []	96	var reads: [(path: String, cached: AgendaSource?, mtime: Date, size: Int, text: String?)] = []
97	for path in files {	97	for path in files {
98	if let open, open.path == path {	98	if let text = open[path] {
99	reads.append((path, nil, .distantPast, -1, open.text))	99	reads.append((path, nil, .distantPast, -1, text))
100	continue	100	continue
101	}	101	}
102	let attributes = try? FileManager.default.attributesOfItem(atPath: path)	102	let attributes = try? FileManager.default.attributesOfItem(atPath: path)