Commit `a831086741`

a831086741e83ef42f7b688ea43b68e6528c2e94

parent: a6139aad41

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-05 21:22 UTC

Buffers

Files stay open as buffers, as in Emacs: each keeps its editor (text,
caret, folds, its own undo) and unsaved edits while another shows, and
saves on its own in automatic mode. The agenda, board, capture, clock,
refile targets and search read and edit open buffers by path, and
buffers follow their files on disk. Switching files no longer saves or
asks; closing a buffer, closing others or all, and quitting do.

Commands: switch (SPC b b, SPC ,, C-x b), next/previous (SPC b n/p,
] b/[ b, C-x <right>/<left>, ⌃Tab, ⇧⌘]/[), last (SPC `), close (SPC b k,
SPC b d, C-x k, ⌘W), close others (SPC b O), close all (SPC b K), save
all (SPC b S, C-x s, ⌥⌘S). An optional tab bar (tab-bar, View ▸ Show
Tab Bar) is off by default. Open buffers, their order and carets come
back at launch. A theme color set for one appearance leaves the other
to the system.

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)

Commit a831086741

Commit `a831086741`