Babel and export fixes from the manual review !161

merged merged by cmc on 2026-10-08 04:05 UTC · krz/orgstar:babel-export-fixes into main

14 files changed, +445 −62

Layout: unified · split

Sources/OrgCore/Compute/Babel.swift +49 −11

         guard let m = line.firstMatch(of: #/(?i)^[ \t]*#\+CALL:[ \t]*([^\s(\[]+)(?:\[([^\]]*)\])?\((.*?)\)[ \t]*(.*?)[ \t]*\n?$/#) else { return nil }
         let name = String(m.1)
         guard let block = model.srcBlocks.first(where: { $0.name == name }) else { throw Failure.message("Reference '\(name)' not found in this buffer") }
-        var extra: [[(String, String)]] = []
+        var extra = [lobDefaults]
         if let inside = m.2 { extra.append(Params.parse(String(inside))) }
         extra.append(splitArguments(String(m.3)).map { (":var", $0) })
         if !m.4.isEmpty { extra.append(Params.parse(String(m.4))) }
         guard let object = found, let m = object.text.firstMatch(of: /^call_([^()\[\]\s]+)(?:\[([^\]]*)\])?\((.*?)\)(?:\[([^\]]*)\])?$/) else { return nil }
         let name = String(m.1)
         guard let block = model.srcBlocks.first(where: { $0.name == name }) else { throw Failure.message("Reference '\(name)' not found in this buffer") }
-        var extra: [[(String, String)]] = []
+        var extra = [lobDefaults]
         if let inside = m.2 { extra.append(Params.parse(String(inside))) }
         extra.append(splitArguments(String(m.3)).map { (":var", $0) })
         if let end = m.4 { extra.append(Params.parse(String(end))) }
         return (block, try Params(block: block, model: model, text: text, extra: extra), object.range)
     }
+    /// `org-babel-default-lob-header-args`, over the called block's own header arguments.
+    static let lobDefaults = [(":exports", "results")]
+    /// `:exports` from the language's `org-babel-default-header-args:LANG` in Org 9.8.7.
+    static let languageExports = ["dot": "results", "plantuml": "results", "ditaa": "results", "gnuplot": "results",
+                                  "latex": "results", "lilypond": "results"]
+    /// What export shows of the src block, `#+CALL:` line, inline call or inline src block
+    /// starting at `offset` (`org-babel-exp-process-buffer`): `code`, `results`, `both` or
+    /// `none`, from the header arguments as evaluation resolves them. Calls never show code.
+    /// Nil when nothing there runs.
+    public static func exports(at offset: Int, tree: OrgTree, model: DocumentModel, text: NSString) -> String? {
+        func value(_ params: Params?, language: String?) -> String {
+            (params?.single[":exports"] ?? language.flatMap { languageExports[$0] } ?? "code").lowercased()
+        }
+        if let block = model.srcBlocks.first(where: { $0.range.lowerBound == offset }) {
+            return value(try? Params(block: block, model: model, text: text), language: block.language)
+        }
+        let line = text.substring(with: text.lineRange(for: NSRange(location: min(offset, text.length), length: 0)))
+        let call: Params?
+        if line.range(of: "(?i)^[ \\t]*#\\+CALL:", options: .regularExpression) != nil {
+            call = (try? callAt(offset, model: model, text: text))?.params
+        } else if tree.root.descendants().contains(where: { $0.kind == .inlineBabelCall && $0.range.lowerBound == offset }) {
+            call = (try? inlineCallAt(offset, tree: tree, model: model, text: text))?.params
+        } else if let inline = try? inlineAt(offset, tree: tree, model: model, text: text), inline.block.range.lowerBound == offset {
+            return value(inline.params, language: inline.block.language)
+        } else {
+            return nil
+        }
+        // `org-babel-exp-code` for a call is `org-babel-exp-call-line-template`, empty.
+        switch call?.single[":exports"]?.lowercased() ?? "results" {
+        case "both", "results": return "results"
+        default: return "none"
+        }
+    }
     /// Call arguments split on commas outside quotes and parentheses.
     static func splitArguments(_ s: String) -> [String] {
         var parts: [String] = []
         guard let object = found, let m = object.text.firstMatch(of: /^src_([^\s\[{]+)(?:\[([^\]]*)\])?\{(.*)\}$/) else { return nil }
         let heading = model.headings.lastIndex { $0.headingRange.lowerBound <= object.range.lowerBound }
         let block = SrcBlockInfo(range: object.range, heading: heading, name: nil, language: String(m.1), switches: [], body: String(m.3), headerArguments: [:])
-        var extra: [[(String, String)]] = [[(":exports", "results"), (":hlines", "yes")]]
+        let extra = m.2.map { [Params.parse(String($0))] } ?? []
-        if let headers = m.2 { extra.append(Params.parse(String(headers))) }
+        return (block, try Params(block: block, model: model, text: text, defaults: [(":exports", "results"), (":hlines", "yes")], extra: extra, inline: true))
-        return (block, try Params(block: block, model: model, text: text, extra: extra, inline: true))
     }
     /// What `:var` references resolve to while planning.
         let needsFile = options.file == nil && params.lisp.contains { params.evaluated[$0] == nil }
         guard let language = block.language else { return .failure(.message("This block has no language")) }
         let eval = params.single[":eval"]?.lowercased()
-        if eval == "never" || eval == "no" || eval == "never-export" || eval == "no-export" {
+        if eval == "never" || eval == "no" {
             return .failure(.message("Evaluation of this \(language) code block\(block.name.map { " (\($0)) " } ?? " ")is disabled."))
         }
         if params.single[":cmdline"] != nil, !["dot", "plantuml", "mermaid"].contains(language), !shells.contains(language) {
             let shebang = params.single[":shebang"].flatMap { $0.contains(where: { !$0.isWhitespace }) ? $0 : nil }
             if session == nil, stdin != nil || cmdline != nil || shebang != nil {
                 // `org-babel-sh-evaluate`: an executable script, run by the shell with the
-                // command line after it and `:stdin` as its input; the value is its last line.
+                // command line after it and `:stdin` as its input; the result is its standard
+                // output, or its exit status for `:results value`.
                 var script = (shebang ?? "#!/usr/bin/env \(executable)") + "\n"
                 if params.single[":padline"] != "no" { script += "\n" }
                 script += (lines + [body]).joined(separator: "\n") + (valueIsExitStatus ? "\necho $?" : "")
             ["output", "value"],
         ]
-        init(block: SrcBlockInfo, model: DocumentModel, text: NSString, extra: [[(String, String)]] = [], inline: Bool = false) throws {
+        /// `defaults` go under the properties, as `org-babel-default-inline-header-args` do.
-            var layers: [[(String, String)]] = []
+        init(block: SrcBlockInfo, model: DocumentModel, text: NSString, defaults: [(String, String)] = [], extra: [[(String, String)]] = [],
+             inline: Bool = false) throws {
+            var layers: [[(String, String)]] = [defaults]
             let language = block.language ?? ""
             // `org-babel-params-from-properties`: the inherited `header-args`, then the inherited
             // `header-args:LANG`, each the nearest value with `+` additions after it.
     public var title: String { "Run Source Block" }
     public func applies(in context: EditContext) -> Bool { KeyContext.holds("src", in: context) || Self.atCallOrInline(context) }
-    /// On a `#+CALL:` line or an inline `src_` block.
+    /// On a `#+CALL:` line, an inline `call_` or an inline `src_` block.
     static func atCallOrInline(_ context: EditContext) -> Bool {
         let ns = context.text as NSString
         let line = ns.substring(with: ns.lineRange(for: NSRange(location: min(context.caret, ns.length), length: 0)))
         if line.range(of: "(?i)^[ \\t]*#\\+CALL:", options: .regularExpression) != nil { return true }
         var node = context.tree.root
         while let child = node.child(containing: context.caret) {
-            if child.kind == .inlineSourceBlock { return true }
+            if child.kind == .inlineSourceBlock || child.kind == .inlineBabelCall { return true }
             node = child
         }
         return false

Sources/OrgCore/Compute/Tangle.swift +7 −2

         public var blocks: Int
     }
-    /// `org-babel-tangle-lang-exts`.
+    /// `org-babel-tangle-lang-exts`, with what Org 9.8.7's ob-LANG files add to it.
-    static let extensions = ["emacs-lisp": "el", "elisp": "el", "bibtex": "bib"]
+    static let extensions = [
+        "emacs-lisp": "el", "elisp": "el", "bibtex": "bib",
+        "C++": "cpp", "D": "d", "awk": "awk", "clojure": "clj", "clojurescript": "cljs", "csharp": "cs", "fortran": "F90",
+        "groovy": "groovy", "haskell": "hs", "java": "java", "julia": "jl", "latex": "tex", "LilyPond": "ly", "lisp": "lisp",
+        "lua": "lua", "maxima": "max", "ocaml": "ml", "perl": "pl", "processing": "pde", "python": "py", "ruby": "rb", "sed": "sed",
+    ]
     /// `org-babel-shell-names`, and `shell` itself.
     static let shells: Set<String> = ["sh", "bash", "zsh", "fish", "csh", "ash", "dash", "ksh", "mksh", "posh", "shell"]

Sources/OrgCore/Export/ExportOptions.swift +33 −2

	@@ -194,6 +194,28 @@ public enum ExportPreprocess {
194	}	194	}
195	}	195	}
196	var counters: [String: Int] = [:]	196	var counters: [String: Int] = [:]
		197	var model: DocumentModel?
		198	/// `org-entry-get` with `selective` inheritance at the heading holding `location`, or
		199	/// at the entry `search` finds (`*Title`, `#custom-id` or a title).
		200	func property(_ name: String, _ search: String?, at location: Int) -> String {
		201	if model == nil { model = DocumentModel(tree: OrgParser.parse(text)) }
		202	let headings = model!.headings
		203	let index: Int?
		204	if let search, !search.isEmpty {
		205	if search.hasPrefix("#") {
		206	let id = String(search.dropFirst())
		207	index = headings.firstIndex { $0.properties.contains { $0.key.uppercased() == "CUSTOM_ID" && $0.value == id } }
		208	} else {
		209	let title = search.hasPrefix("*") ? String(search.dropFirst()) : search
		210	index = headings.firstIndex { Links.displayFormat($0.title).trimmingCharacters(in: .whitespaces) == title \|\| $0.title == title }
		211	}
		212	} else {
		213	index = headings.lastIndex { $0.headingRange.lowerBound <= location }
		214	}
		215	guard let index else { return "" }
		216	if name.uppercased() == "ITEM" { return headings[index].title }
		217	return model!.property(name, of: index)?.value ?? ""
		218	}
197	let regex = try! NSRegularExpression(pattern: "\\{\\{\\{([-A-Za-z0-9_]+)(?:\$(.*?)\$)?\\}\\}\\}")	219	let regex = try! NSRegularExpression(pattern: "\\{\\{\\{([-A-Za-z0-9_]+)(?:\$(.*?)\$)?\\}\\}\\}")
198	var out = ""	220	var out = ""
199	var at = 0	221	var at = 0
	@@ -208,8 +230,16 @@ public enum ExportPreprocess {
208	continue	230	continue
209	}	231	}
210	let name = ns.substring(with: m.range(at: 1)).lowercased()	232	let name = ns.substring(with: m.range(at: 1)).lowercased()
		233	// Inline results stay for the exporter, which shows them as `:exports` says.
		234	if name == "results", definitions[name] == nil {
		235	out += ns.substring(with: m.range)
		236	continue
		237	}
211	let args = m.range(at: 2).location == NSNotFound ? [] : arguments(ns.substring(with: m.range(at: 2)))	238	let args = m.range(at: 2).location == NSNotFound ? [] : arguments(ns.substring(with: m.range(at: 2)))
212	out += expand(name, args, definitions: definitions, keywords: keywords, counters: &counters, path: path, now: now)	239	let location = m.range.location
		240	out += expand(name, args, definitions: definitions, keywords: keywords, counters: &counters, path: path, now: now) {
		241	property($0, $1, at: location)
		242	}
213	}	243	}
214	out += ns.substring(from: at)	244	out += ns.substring(from: at)
215	return out	245	return out
	@@ -240,7 +270,7 @@ public enum ExportPreprocess {
240	}	270	}
241		271
242	static func expand(_ name: String, _ args: [String], definitions: [String: String], keywords: [String: String],	272	static func expand(_ name: String, _ args: [String], definitions: [String: String], keywords: [String: String],
243	counters: inout [String: Int], path: String?, now: Date) -> String {	273	counters: inout [String: Int], path: String?, now: Date, property: (String, String?) -> String) -> String {
244	if let template = definitions[name] {	274	if let template = definitions[name] {
245	guard !template.hasPrefix("(eval") else { return "" }	275	guard !template.hasPrefix("(eval") else { return "" }
246	var result = template	276	var result = template
	@@ -251,6 +281,7 @@ public enum ExportPreprocess {
251	case "title", "author", "date", "email": return keywords[name.uppercased()] ?? ""	281	case "title", "author", "date", "email": return keywords[name.uppercased()] ?? ""
252	case "keyword": return args.first.flatMap { keywords[$0.uppercased()] } ?? ""	282	case "keyword": return args.first.flatMap { keywords[$0.uppercased()] } ?? ""
253	case "input-file": return path.map { ($0 as NSString).lastPathComponent } ?? ""	283	case "input-file": return path.map { ($0 as NSString).lastPathComponent } ?? ""
		284	case "property": return args.first.map { property($0, args.count > 1 ? args[1] : nil) } ?? ""
254	case "n":	285	case "n":
255	let counter = args.first ?? ""	286	let counter = args.first ?? ""
256	let action = args.count > 1 ? args[1] : ""	287	let action = args.count > 1 ? args[1] : ""

Sources/OrgCore/Export/HTMLExport.swift +76 −23

     }
 }
+/// The tree being exported, for what its src blocks, calls and inline blocks export.
+final class ExportSource {
+    let tree: OrgTree
+    let text: NSString
+    private lazy var model = DocumentModel(tree: tree)
+    /// Whether the last inline src block or call lets the `{{{results(…)}}}` after it show;
+    /// nil when nothing asks.
+    var inlineResults: Bool?
+    init(tree: OrgTree, text: String) {
+        self.tree = tree
+        self.text = text as NSString
+    }
+    func exports(at offset: Int) -> String? {
+        Babel.exports(at: offset, tree: tree, model: model, text: text)
+    }
+    /// `{{{results(…)}}}`, Org's `$1` macro, as the inline block or call before it allows:
+    /// nil for other macros, the text to show (or nil) for this one.
+    func resultsMacro(_ node: SyntaxNode) -> String?? {
+        guard let m = node.text.firstMatch(of: /(?i)^\{\{\{results\((.*)\)\}\}\}$/) else { return .none }
+        defer { inlineResults = nil }
+        return inlineResults ?? true ? ExportPreprocess.arguments(String(m.1)).first : .some(nil)
+    }
+}
 final class HTMLRenderer {
     let settings: OrgSettings
     let options: ExportOptions
         collectDefinitions(tree.root)
         selected = Self.selection(tree, tags: options.selectTags)
         var out = ""
-        for child in tree.root.children { out += element(child) }
+        rendering(tree, text) {
+            for child in tree.root.children { out += element(child) }
+        }
         out += footnoteSection()
         return out
     }
+    private var source: ExportSource?
+    /// `body` with `tree` as the source of `:exports`.
+    private func rendering<T>(_ tree: OrgTree, _ text: String, _ body: () -> T) -> T {
+        let saved = source
+        source = ExportSource(tree: tree, text: text)
+        defer { source = saved }
+        return body()
+    }
     private func collectDefinitions(_ node: SyntaxNode) {
         for child in node.children {
             if child.kind == .footnoteDefinition {
     func blocks(_ text: String) -> String {
         let tree = OrgParser.parse(text, defaults: settings)
         var out = ""
-        for child in tree.root.children { out += element(child) }
+        rendering(tree, text) {
+            for child in tree.root.children { out += element(child) }
+        }
         return out
     }
     func inlineString(_ text: String) -> String {
         let tree = OrgParser.parse(text, defaults: settings)
         guard let paragraph = tree.root.descendants().first(where: { $0.kind == .paragraph }) else { return Self.escape(text) }
-        return inline(paragraph).trimmingCharacters(in: .whitespacesAndNewlines)
+        return rendering(tree, text) { inline(paragraph).trimmingCharacters(in: .whitespacesAndNewlines) }
     }
     /// A citation's or a bibliography entry's pieces: text escaped, prefixes and suffixes as
     // MARK: - Elements
     private var affiliated: [String: String] = [:]
-    /// `:exports` of the last src block: its results are exported only for `results` and
+    /// `:exports` of the last src block or call: its results are exported only for `results`
-    /// `both`; nothing runs.
+    /// and `both`; nothing runs.
     private var lastExports = "code"
     func element(_ node: SyntaxNode) -> String {
             defer { lastExports = "code" }
             if lastExports != "results", lastExports != "both" { return "" }
         }
-        if node.kind == .block, let exports = Self.srcExports(node) {
+        if node.kind == .block || node.kind == .keyword, let exports = source?.exports(at: node.range.lowerBound) {
             lastExports = exports
             if exports == "results" || exports == "none" { return "" }
         }
         switch node.kind {
         case .section:
             guard let heading = node.firstChild(.heading) else { fallthrough }
-            let tags = heading.tokens.first { $0.kind == .tags }?.text.split(separator: ":").map(String.init) ?? []
+            switch Self.sectionExport(heading, options: options, selected: selected) {
-            let title = heading.firstChild(.title)?.text.trimmingCharacters(in: .whitespaces) ?? ""
+            case .nothing: return ""
-            // `org-export--skip-p`: excluded tags, COMMENT, unselected trees.
+            case .heading: return self.heading(heading)
-            if tags.contains(where: options.excludeTags.contains) || title == "COMMENT" || title.hasPrefix("COMMENT ") { return "" }
+            case .all: break
-            if let selected, !selected.contains(heading.range.lowerBound) { return "" }
+            }
-            // Archived trees export their heading only.
-            if tags.contains("ARCHIVE") { return self.heading(heading) }
             var out = ""
             for child in node.children { out += element(child) }
             return out
         }
     }
-    /// The `:exports` value of a src block, or nil for other blocks.
-    static func srcExports(_ node: SyntaxNode) -> String? {
-        guard DocumentModel.isSrcBlock(node) else { return nil }
-        let first = node.text.components(separatedBy: "\n").first ?? ""
-        if let m = first.firstMatch(of: /:exports[ \t]+(\S+)/) { return m.1.lowercased() }
-        return "code"
-    }
     private func slug(_ text: String) -> String {
         var slug = ""
         var dash = false
     /// `org-export--selected-trees`: headings with a select tag, everything below them and
     /// their ancestors; nil when no heading has one.
+    enum SectionExport {
+        case all, heading, nothing
+    }
+    /// `org-export--skip-p` for the section under `heading`: excluded tags, COMMENT and
+    /// unselected trees export nothing, archived trees their heading only.
+    static func sectionExport(_ heading: SyntaxNode, options: ExportOptions, selected: Set<Int>?) -> SectionExport {
+        let tags = heading.tokens.first { $0.kind == .tags }?.text.split(separator: ":").map(String.init) ?? []
+        let title = heading.firstChild(.title)?.text.trimmingCharacters(in: .whitespaces) ?? ""
+        if tags.contains(where: options.excludeTags.contains) || title == "COMMENT" || title.hasPrefix("COMMENT ") { return .nothing }
+        if let selected, !selected.contains(heading.range.lowerBound) { return .nothing }
+        return tags.contains("ARCHIVE") ? .heading : .all
+    }
     static func selection(_ tree: OrgTree, tags: [String]) -> Set<Int>? {
         let model = DocumentModel(tree: tree)
         let picked = model.headings.indices.filter { model.headings[$0].localTags.contains(where: tags.contains) }
             let inner = braced ? String(body.dropFirst().dropLast()) : String(body)
             return text.hasPrefix("_") ? "<sub>\(Self.escape(inner))</sub>" : "<sup>\(Self.escape(inner))</sup>"
         case .lineBreak: return "<br>\n"
-        case .target, .macro: return ""
+        case .macro:
+            guard case .some(let value) = source?.resultsMacro(node) else { return "" }
+            return value.map(inlineString) ?? ""
+        case .target: return ""
         case .inlineSourceBlock:
+            let exports = source?.exports(at: node.range.lowerBound) ?? "results"
+            source?.inlineResults = exports == "results" || exports == "both"
+            guard exports == "code" || exports == "both" else { return "" }
             if let m = node.text.firstMatch(of: /\{(.*)\}$/) { return "<code>\(Self.escape(String(m.1)))</code>" }
             return Self.escape(node.text)
         case .latexFragment:
             if inTitle { return "" }
             guard let pieces = citations?.next(node.text) else { return Self.escape(node.text) }
             return render(pieces)
-        case .inlineBabelCall: return Self.escape(node.text)
+        case .inlineBabelCall:
+            source?.inlineResults = (source?.exports(at: node.range.lowerBound) ?? "results") == "results"
+            return ""
         default: return inline(node)
         }
     }

Sources/OrgCore/Export/MarkdownExport.swift +62 −18

 /// Markdown export, GitHub-flavored: ATX headings, fenced code, pipe tables, task lists and
 /// `[^n]` footnotes. The title, when there is one, becomes the top heading.
 public enum MarkdownExport {
-    /// `path` is the file's, for `#+bibliography:`.
+    /// As the HTML page: `#+INCLUDE`, macros, `#+OPTIONS` and the select and exclude tags.
-    public static func document(_ text: String, settings: OrgSettings = .default, path: String? = nil) -> String {
+    /// `path` is the file's, for `#+INCLUDE`, `{{{input-file}}}` and `#+bibliography:`.
-        let renderer = MarkdownRenderer(settings: settings)
+    public static func document(_ text: String, settings: OrgSettings = .default, path: String? = nil, now: Date = Date()) -> String {
+        let directory = path.map { URL(fileURLWithPath: $0).deletingLastPathComponent() }
+        let text = ExportPreprocess.macros(ExportPreprocess.includes(text, directory: directory), path: path, now: now, setup: settings.setupKeywords)
+        let options = ExportOptions.parse(settings.setupKeywords + text)
+        let renderer = MarkdownRenderer(settings: settings, options: options)
         var out = ""
         renderer.inTitle = true
-        if let title = HTMLExport.metadata(text, settings: settings).title { out = "# " + renderer.inlineString(title) + "\n\n" }
+        if options.title, let title = HTMLExport.metadata(text, settings: settings).title { out = "# " + renderer.inlineString(title) + "\n\n" }
         renderer.inTitle = false
-        renderer.citations = CiteProcessor(text: text, directory: path.map { URL(fileURLWithPath: $0).deletingLastPathComponent() })
+        renderer.citations = CiteProcessor(text: text, directory: directory)
         out += renderer.document(renderer.citations == nil ? text : renderer.citations!.inliningNotes(CiteProcessor.removingNocite(text)))
         return out.trimmingCharacters(in: .newlines) + "\n"
     }
 final class MarkdownRenderer {
     let settings: OrgSettings
+    let options: ExportOptions
+    /// With select tags in the document: the sections to export, by heading start.
+    private var selected: Set<Int>?
     private var definitions: [String: String] = [:]
     private var numbers: [String: Int] = [:]
     private var notes: [(Int, String)] = []
     /// Rendering the title, where Org exports citations as nothing.
     var inTitle = false
-    init(settings: OrgSettings) {
+    init(settings: OrgSettings, options: ExportOptions) {
         self.settings = settings
+        self.options = options
     }
     func document(_ text: String) -> String {
                 definitions[String(m.1)] = String(node.text[m.range.upperBound...]).trimmingCharacters(in: .whitespacesAndNewlines)
             }
         }
-        var out = blocks(tree.root)
+        selected = HTMLRenderer.selection(tree, tags: options.selectTags)
+        var out = rendering(tree, text) { blocks(tree.root) }
         if !notes.isEmpty {
             out += notes.map { "[^\($0.0)]: " + $0.1 }.joined(separator: "\n") + "\n"
         }
     func inlineString(_ text: String) -> String {
         let tree = OrgParser.parse(text, defaults: settings)
         guard let paragraph = tree.root.descendants().first(where: { $0.kind == .paragraph }) else { return text }
-        return inline(paragraph).trimmingCharacters(in: .whitespacesAndNewlines)
+        return rendering(tree, text) { inline(paragraph).trimmingCharacters(in: .whitespacesAndNewlines) }
+    }
+    private var source: ExportSource?
+    /// `body` with `tree` as the source of `:exports`.
+    private func rendering<T>(_ tree: OrgTree, _ text: String, _ body: () -> T) -> T {
+        let saved = source
+        source = ExportSource(tree: tree, text: text)
+        defer { source = saved }
+        return body()
     }
     private var lastExports = "code"
                 defer { lastExports = "code" }
                 if lastExports != "results", lastExports != "both" { return "" }
             }
-            if child.kind == .block, let exports = HTMLRenderer.srcExports(child) {
+            if child.kind == .block || child.kind == .keyword, let exports = source?.exports(at: child.range.lowerBound) {
                 lastExports = exports
                 if exports == "results" || exports == "none" { return "" }
             }
     }
     private func blocks(text: String) -> String {
-        blocks(OrgParser.parse(text, defaults: settings).root)
+        let tree = OrgParser.parse(text, defaults: settings)
+        return rendering(tree, text) { blocks(tree.root) }
     }
     private func element(_ node: SyntaxNode, indent: String) -> String {
         switch node.kind {
         case .zerothSection, .section:
+            if node.kind == .section, let heading = node.firstChild(.heading) {
+                switch HTMLRenderer.sectionExport(heading, options: options, selected: selected) {
+                case .nothing: return ""
+                case .heading: return element(heading, indent: indent)
+                case .all: break
+                }
+            }
             return blocks(node, indent: indent).trimmingCharacters(in: .newlines)
         case .heading:
             let level = node.tokens.first { $0.kind == .stars }?.text.count ?? 1
             var parts: [String] = []
-            if let todo = node.tokens.first(where: { $0.kind == .todoKeyword })?.text { parts.append(todo) }
+            if options.todo, let todo = node.tokens.first(where: { $0.kind == .todoKeyword })?.text { parts.append(todo) }
-            if let priority = node.tokens.first(where: { $0.kind == .priority })?.text { parts.append(priority) }
+            if options.priority, let priority = node.tokens.first(where: { $0.kind == .priority })?.text { parts.append(priority) }
             if let title = node.firstChild(.title) { parts.append(inline(title).trimmingCharacters(in: .whitespaces)) }
-            if let tags = node.tokens.first(where: { $0.kind == .tags })?.text {
+            if options.tags, let tags = node.tokens.first(where: { $0.kind == .tags })?.text {
                 parts.append(tags.split(separator: ":").map { "`\($0)`" }.joined(separator: " "))
             }
             return String(repeating: "#", count: min(level + 1, 6)) + " " + parts.filter { !$0.isEmpty }.joined(separator: " ")
             return String(node.text.dropFirst(3).dropLast(3))
         case .superscript, .subscript:
             let body = node.text.dropFirst()
-            let inner = body.hasPrefix("{") && body.hasSuffix("}") ? String(body.dropFirst().dropLast()) : String(body)
+            let braced = body.hasPrefix("{") && body.hasSuffix("}")
+            if options.scripts == .off || (options.scripts == .braces && !braced) { return node.text }
+            let inner = braced ? String(body.dropFirst().dropLast()) : String(body)
             return node.text.hasPrefix("_") ? "<sub>\(inner)</sub>" : "<sup>\(inner)</sup>"
         case .lineBreak: return "  \n"
-        case .target, .macro: return ""
+        case .macro:
+            guard case .some(let value) = source?.resultsMacro(node) else { return "" }
+            return value.map(inlineString) ?? ""
+        case .target: return ""
+        case .inlineSourceBlock:
+            let exports = source?.exports(at: node.range.lowerBound) ?? "results"
+            source?.inlineResults = exports == "results" || exports == "both"
+            guard exports == "code" || exports == "both" else { return "" }
+            if let m = node.text.firstMatch(of: /\{(.*)\}$/) { return code(String(m.1)) }
+            return node.text
         // ox-md uses ox-html's translator: only HTML snippets.
         case .exportSnippet:
             guard node.tokens.first?.text == "@@html:" else { return "" }
             if inTitle { return "" }
             guard let pieces = citations?.next(node.text) else { return node.text }
             return render(pieces)
-        case .inlineBabelCall: return node.text
+        case .inlineBabelCall:
+            source?.inlineResults = (source?.exports(at: node.range.lowerBound) ?? "results") == "results"
+            return ""
         default: return inline(node)
         }
     }
             return "<\(target)>"
         }
         var href = path
-        if path.hasPrefix("file:") { href = String(path.dropFirst(5)) }
+        if path.hasPrefix("file:") {
+            // ox-md drops the search option and, as `org-md-link-org-files-as-md`, writes .org as .md.
+            href = String(path.dropFirst(5))
+            if let search = href.range(of: "::") { href = String(href[..<search.lowerBound]) }
+        }
         if path.hasPrefix("id:") { href = "#" + path.dropFirst(3) }
-        if !path.contains(":"), href.lowercased().hasSuffix(".org") { href = String(href.dropLast(4)) + ".md" }
+        if !path.contains(":") || path.hasPrefix("file:"), href.lowercased().hasSuffix(".org") { href = String(href.dropLast(4)) + ".md" }
         if let description = node.firstChild(.linkDescription) { return "[\(inline(description))](\(href))" }
         let ext = href.split(separator: ".").last.map { $0.lowercased() } ?? ""
         if HTMLRenderer.imageExtensions.contains(ext) { return "![](\(href))" }

Sources/OrgCore/Keymap/Presets.swift −3

         keys = "C-c C-x A"
         command = "org.archive.to-sibling"
         [[bind]]
-        keys = "C-c C-e"
-        command = "app.export-dialog"
-        [[bind]]
         keys = "C-c C-x C-v"
         command = "org.toggle-inline-images"
         [[bind]]

Sources/OrgCore/Semantic/HeadingInfo.swift +4 −1

         let trimmed = line.trimmingCharacters(in: .whitespacesAndNewlines)
         guard trimmed.hasPrefix(":") else { return nil }
         let rest = trimmed.dropFirst()
-        guard let colon = rest.firstIndex(of: ":") else { return nil }
+        // `org-property-re`: the key ends at the first colon followed by a blank or the end,
+        // so `:header-args:sh:` is one key.
+        guard let colon = rest.indices.first(where: { rest[$0] == ":" && (rest.index(after: $0) == rest.endIndex || rest[rest.index(after: $0)].isWhitespace) })
+        else { return nil }
         var key = rest[..<colon]
         guard !key.isEmpty else { return nil }
         let additive = key.hasSuffix("+")

Sources/OrgPresentation/Presentation.swift +1 −1

	@@ -51,7 +51,7 @@ public enum SyntaxCategory: String, Hashable, Sendable, CaseIterable {
51	}	51	}
52	}	52	}
53		53
54	/// Highlights source code; the platform supplies one (tree-sitter on macOS and iOS).	54	/// Highlights source code; the platform supplies one (tree-sitter on macOS; iOS supplies none).
55	public protocol CodeHighlighter: Sendable {	55	public protocol CodeHighlighter: Sendable {
56	/// Categories for ranges of `code`, in UTF-16 offsets; later runs win over earlier ones.	56	/// Categories for ranges of `code`, in UTF-16 offsets; later runs win over earlier ones.
57	/// Empty for languages it doesn't know.	57	/// Empty for languages it doesn't know.

Sources/Orgstar/ExportSheet.swift +1 −1

	@@ -1,7 +1,7 @@
1	import AppKit	1	import AppKit
2	import SwiftUI	2	import SwiftUI
3		3
4	/// C-c C-e: the format, where the file goes, and whether to open it after.	4	/// Export… (`app.export-dialog`): the format, where the file goes, and whether to open it after.
5	struct ExportSheet: View {	5	struct ExportSheet: View {
6	let source: URL	6	let source: URL
7	let export: (_ format: String, _ destination: URL, _ open: Bool) -> Void	7	let export: (_ format: String, _ destination: URL, _ open: Bool) -> Void

Tests/OrgCoreTests/BabelTests.swift +26

	@@ -143,6 +143,7 @@ struct BabelTests {
143	"#+begin_src emacs-lisp :var x=4\n(* x x)\n#+end_src\n",	143	"#+begin_src emacs-lisp :var x=4\n(* x x)\n#+end_src\n",
144	"#+PROPERTY: header-args :results output\n#+begin_src sh\nprintf 'a b\\nc d\\n'\n#+end_src\n",	144	"#+PROPERTY: header-args :results output\n#+begin_src sh\nprintf 'a b\\nc d\\n'\n#+end_src\n",
145	"* Heading\n:PROPERTIES:\n:header-args:sh: :results verbatim\n:END:\n#+begin_src sh\necho 1 2\n#+end_src\n",	145	"* Heading\n:PROPERTIES:\n:header-args:sh: :results verbatim\n:END:\n#+begin_src sh\necho 1 2\n#+end_src\n",
		146	"* Heading\n:PROPERTIES:\n:header-args:sh: :results verbatim\n:END:\n#+begin_src python\nreturn [[1, 2]]\n#+end_src\n",
146	"#+HEADER: :results output\n#+begin_src sh\nprintf 'x y\\nz w\\n'\n#+end_src\n",	147	"#+HEADER: :results output\n#+begin_src sh\nprintf 'x y\\nz w\\n'\n#+end_src\n",
147	// `:cmdline`, `:stdin` and `:shebang`.	148	// `:cmdline`, `:stdin` and `:shebang`.
148	"#+begin_src sh :cmdline one \"two words\" :results output\nfor a in \"$@\"; do echo \"[$a]\"; done\n#+end_src\n",	149	"#+begin_src sh :cmdline one \"two words\" :results output\nfor a in \"$@\"; do echo \"[$a]\"; done\n#+end_src\n",
	@@ -328,6 +329,17 @@ struct BabelTests {
328	#expect(got == message)	329	#expect(got == message)
329	}	330	}
330	}	331	}
		332
		333	@Test func noExportStillRunsInteractively() {
		334	for eval in ["never-export", "no-export"] {
		335	let text = "#+begin_src sh :eval \(eval)\necho 1\n#+end_src\n"
		336	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [2..<2])
		337	guard case .success = Babel.plan(context) else {
		338	Issue.record("refused :eval \(eval)")
		339	continue
		340	}
		341	}
		342	}
331	}	343	}
332		344
333	struct BabelCallTests {	345	struct BabelCallTests {
	@@ -378,6 +390,20 @@ struct BabelCallTests {
378	}	390	}
379	}	391	}
380		392
		393	extension BabelCallTests {
		394	@Test func ctrlCCtrlCRunsInlineCalls() {
		395	let text = Self.named + "Inline call_double(n=6) here.\n"
		396	let caret = (text as NSString).range(of: "call_").location + 2
		397	let context = EditContext(revision: 0, text: text, tree: OrgParser.parse(text), selection: [caret..<caret])
		398	#expect(ExecuteSrcBlock().applies(in: context))
		399	guard case .external(.babel(let job)) = CtrlCCtrlC().run(in: context) else {
		400	Issue.record("inline call not run")
		401	return
		402	}
		403	#expect((job.script ?? job.input).contains("echo $((n*2))"))
		404	}
		405	}
		406
381	struct BabelFileTests {	407	struct BabelFileTests {
382	static let cases = [	408	static let cases = [
383	"#+begin_src sh :results file :file out.txt\necho hello\necho there\n#+end_src\n",	409	"#+begin_src sh :results file :file out.txt\necho hello\necho there\n#+end_src\n",

Tests/OrgCoreTests/ExportOptionsTests.swift +28

	@@ -44,6 +44,34 @@ struct ExportOptionsTests {
44	#expect(!selected.contains("<p>a</p>") && selected.contains("<p>b</p>") && selected.contains("<p>c</p>"))	44	#expect(!selected.contains("<p>a</p>") && selected.contains("<p>b</p>") && selected.contains("<p>c</p>"))
45	}	45	}
46		46
		47	@Test(.enabled(if: oracle))
		48	func expandsPropertyMacroLikeOrg() throws {
		49	let text = """
		50	#+PROPERTY: color filecolor
		51	Top: [{{{property(color)}}}]
		52	* One
		53	:PROPERTIES:
		54	:color: red
		55	:Size: big
		56	:CUSTOM_ID: one
		57	:END:
		58	In one: [{{{property(color)}}}] [{{{property(SIZE)}}}] [{{{property(missing)}}}] [{{{property(ITEM)}}}]
		59	** Child
		60	Child: [{{{property(color)}}}]
		61	* Two
		62	Two: [{{{property(color,*One)}}}] [{{{property(color,#one)}}}] [{{{property(Size, One)}}}]
		63	""" + "\n"
		64	let emacs = try EmacsOracle.evaluate(text, """
		65	(progn
		66	(require 'ox)
		67	(org-macro-initialize-templates)
		68	(org-macro-replace-all org-macro-templates)
		69	(list (buffer-substring-no-properties (point-min) (point-max))))
		70	""")
		71	let ours = ExportPreprocess.macros(text, path: nil)
		72	#expect(ours.contains("[red] [big] [] [One]") && ours == emacs.first, "ours:\n\(ours)\nemacs:\n\(emacs.first ?? "")")
		73	}
		74
47	@Test(.enabled(if: oracle))	75	@Test(.enabled(if: oracle))
48	func expandsIncludesAndMacrosLikeOrg() throws {	76	func expandsIncludesAndMacrosLikeOrg() throws {
49	let folder = FileManager.default.temporaryDirectory.appendingPathComponent("orgstar-include-\(UUID().uuidString)")	77	let folder = FileManager.default.temporaryDirectory.appendingPathComponent("orgstar-include-\(UUID().uuidString)")

Tests/OrgCoreTests/ExportTests.swift +123

	@@ -168,6 +168,48 @@ struct MarkdownExportTests {
168	let ours = MarkdownExport.document(org)	168	let ours = MarkdownExport.document(org)
169	#expect(ours == expected)	169	#expect(ours == expected)
170	}	170	}
		171
		172	/// Words that ox-md keeps or drops for `#+OPTIONS`, the tags, COMMENT, `#+INCLUDE` and
		173	/// macros, and where links to Org files point.
		174	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		175	func documentLevelLikeOrgMd() throws {
		176	let folder = FileManager.default.temporaryDirectory.appendingPathComponent("orgstar-md-\(UUID().uuidString)")
		177	try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
		178	defer { try? FileManager.default.removeItem(at: folder) }
		179	try "* Included\nwordincluded\n".write(to: folder.appendingPathComponent("part.org"), atomically: true, encoding: .utf8)
		180	let text = """
		181	#+TITLE: wordtitle
		182	#+OPTIONS: todo:nil tags:nil ^:nil toc:nil num:nil
		183	#+EXCLUDE_TAGS: private
		184	#+MACRO: greet wordmacro $1
		185	{{{greet(wordarg)}}} a_wordsub
		186	* TODO wordtodo :wordtag:
		187	* Kept :noexport:
		188	wordnoexport
		189	* Private :private:
		190	wordprivate
		191	* COMMENT Hidden
		192	wordcomment
		193	* Links
		194	[[file:x.org]] [[file:x.org][X]] [[./y.org]] [[file:sub/z.ORG::*Head][Z]]
		195	#+INCLUDE: "part.org"
		196	""" + "\n"
		197	let path = folder.appendingPathComponent("main.org").path
		198	try text.write(toFile: path, atomically: true, encoding: .utf8)
		199	let emacs = try EmacsOracle.evaluate(text, """
		200	(with-current-buffer (find-file-noselect \(Babel.lispString(path)))
		201	(require 'ox-md)
		202	(list (org-export-as 'md)))
		203	""")[0]
		204	let ours = MarkdownExport.document(text, path: path)
		205	// ox-md writes no title; this export makes it the top heading.
		206	for word in text.matches(of: /\bword[a-z]+\b\|\bTODO\b/).map({ String($0.0) }) where word != "wordtitle" {
		207	#expect(ours.contains(word) == emacs.contains(word), "\(word)\nours:\n\(ours)\nemacs:\n\(emacs)")
		208	}
		209	#expect(ours.contains("<sub>") == emacs.contains("<sub>"))
		210	let targets = { (s: String) in Set(s.matches(of: /[\w.\/]+\.(?:md\|org\|ORG)\b/).map { String($0.0) }) }
		211	#expect(targets(ours) == targets(emacs), "ours:\n\(ours)\nemacs:\n\(emacs)")
		212	}
171	}	213	}
172		214
173	struct ExportCorpusTests {	215	struct ExportCorpusTests {
	@@ -220,4 +262,85 @@ struct ExportResultsTests {
220	#expect(html.contains("echo b") && html.contains(">b</pre>"))	262	#expect(html.contains("echo b") && html.contains(">b</pre>"))
221	#expect(!html.contains("echo c") && html.contains(">c</pre>"))	263	#expect(!html.contains("echo c") && html.contains(">c</pre>"))
222	}	264	}
		265
		266	static let exports = """
		267	#+PROPERTY: header-args :exports both
		268	* Heading
		269	:PROPERTIES:
		270	:header-args:sh: :exports results
		271	:END:
		272	#+begin_src sh
		273	echo codeprop
		274	#+end_src
		275
		276	#+RESULTS:
		277	: resprop
		278
		279	#+HEADER: :exports code
		280	#+begin_src sh
		281	echo codeheader
		282	#+end_src
		283
		284	#+RESULTS:
		285	: resheader
		286
		287	#+begin_src python
		288	codefile
		289	#+end_src
		290
		291	#+RESULTS:
		292	: resfile
		293
		294	#+NAME: named
		295	#+begin_src sh :exports none
		296	echo codenamed
		297	#+end_src
		298
		299	#+CALL: named()
		300
		301	#+RESULTS:
		302	: rescall
		303
		304	#+CALL: named() :exports code
		305
		306	#+RESULTS:
		307	: rescallcode
		308
		309	#+begin_src dot :file graph.png
		310	digraph { codedot }
		311	#+end_src
		312
		313	#+RESULTS:
		314	: resdot
		315
		316	Inline src_sh{echo codeinline} {{{results(=resinline=)}}} one.
		317
		318	Inline src_sh[:exports code]{echo codeinlinecode} {{{results(=resinlinecode=)}}} two.
		319
		320	Inline src_sh[:exports both]{echo codeinlineboth} {{{results(=resinlineboth=)}}} three.
		321
		322	Inline call_named() {{{results(=resinlinecall=)}}} four.
		323	""" + "\n"
		324
		325	/// Which code and results the HTML and Markdown exports keep, against ox-html with nothing
		326	/// evaluated.
		327	@Test(.enabled(if: ProcessInfo.processInfo.environment["ORGSTAR_SKIP_ORACLE"] == nil))
		328	func exportsLikeOrg() throws {
		329	let emacs = try EmacsOracle.evaluate(Self.exports, """
		330	(progn
		331	(require 'ox-html) (require 'ob-shell) (require 'ob-python) (require 'ob-dot)
		332	(dolist (v '(org-babel-default-header-args org-babel-default-inline-header-args org-babel-default-lob-header-args))
		333	(set v (cons '(:eval . "never-export") (symbol-value v))))
		334	(list (org-export-as 'html nil nil t)))
		335	""")[0]
		336	let words = Self.exports.matches(of: /\b(?:code\|res)[a-z]+\b/).map { String($0.0) }
		337	let expected = Set(words.filter { emacs.contains($0) })
		338	#expect(expected.count > 4 && expected.count < words.count)
		339	let html = HTMLExport.page(Self.exports, fallbackTitle: "t")
		340	let markdown = MarkdownExport.document(Self.exports)
		341	for word in words {
		342	#expect(html.contains(word) == expected.contains(word), "HTML \(word)")
		343	#expect(markdown.contains(word) == expected.contains(word), "Markdown \(word)")
		344	}
		345	}
223	}	346	}

Tests/OrgCoreTests/KeymapTests.swift +11

	@@ -126,6 +126,17 @@ struct KeymapTests {
126	#expect(KeymapPreset.mac.keymap.keys(for: "org.deadline") == [KeyChord("e", [.control, .command])])	126	#expect(KeymapPreset.mac.keymap.keys(for: "org.deadline") == [KeyChord("e", [.control, .command])])
127	}	127	}
128		128
		129	/// A binding whose keys start a longer live binding never runs: the dispatcher waits for more.
		130	@Test func presetsBindNoPrefixes() {
		131	for preset in KeymapPreset.allCases {
		132	let keymap = preset.keymap
		133	for binding in keymap.bindings where !binding.unbinds && keymap.isLive(binding) {
		134	#expect(!keymap.isPrefix(binding.keys, mode: binding.mode),
		135	"\(preset): \(KeySequence.format(binding.keys)) (\(binding.command)) is also a prefix")
		136	}
		137	}
		138	}
		139
129	@Test func shadowedBindingsShowNoKeys() throws {	140	@Test func shadowedBindingsShowNoKeys() throws {
130	var problems: [String] = []	141	var problems: [String] = []
131	let map = Keymap.layered([KeymapPreset.emacs.keymap, try Keymap(toml: "[[bind]]\nkeys = \"C-c C-t\"\ncommand = \"app.save\"\n", problems: &problems)])	142	let map = Keymap.layered([KeymapPreset.emacs.keymap, try Keymap(toml: "[[bind]]\nkeys = \"C-c C-t\"\ncommand = \"app.save\"\n", problems: &problems)])

Tests/OrgCoreTests/TangleTests.swift +24

	@@ -291,6 +291,30 @@ struct TangleTests {
291	#expect(Self.describe(ours, root: "/oracle") == theirs.text, "ours:\n\(Self.describe(ours, root: "/oracle"))\nemacs:\n\(theirs.text)\n\(theirs.error)")	291	#expect(Self.describe(ours, root: "/oracle") == theirs.text, "ours:\n\(Self.describe(ours, root: "/oracle"))\nemacs:\n\(theirs.text)\n\(theirs.error)")
292	}	292	}
293		293
		294	/// The file names only: Emacs also wraps C, D, Java, Fortran and Clojure bodies with org-babel-expand-body:LANG.
		295	@Test func extensionsLikeOrg() throws {
		296	let languages = ["python", "ruby", "perl", "C", "C++", "D", "awk", "sed", "lua", "haskell", "java", "latex", "LilyPond",
		297	"fortran", "clojure", "ocaml", "julia", "sh", "text"]
		298	let text = languages.map { "#+begin_src \($0) :tangle yes\n\($0)\n#+end_src\n" }.joined()
		299	let features = ["ob-python", "ob-ruby", "ob-perl", "ob-C", "ob-awk", "ob-sed", "ob-lua", "ob-haskell", "ob-java", "ob-latex",
		300	"ob-lilypond", "ob-fortran", "ob-clojure", "ob-ocaml", "ob-julia", "ob-shell"]
		301	let form = """
		302	(let* ((dir (file-truename (make-temp-file "orgstar-tangle" t)))
		303	(src (expand-file-name "notes.org" dir))
		304	(text (buffer-string)) out)
		305	\(features.map { "(require '\($0))" }.joined(separator: " ")) (setq org-babel-clojure-backend 'babashka)
		306	(with-temp-file src (insert text))
		307	(with-current-buffer (find-file-noselect src)
		308	(let ((files (org-babel-tangle)))
		309	(setq out (mapconcat (lambda (f) (concat (file-relative-name f dir) "\\n")) (sort (copy-sequence files) #'string<) ""))))
		310	(erase-buffer) (insert out))
		311	"""
		312	let theirs = try EmacsOracle.run([EmacsOracle.Case(text: text, point: 1, form: form)])[0]
		313	let ours = try Tangle.run(text: text, path: "/oracle/notes.org").get()
		314	let names = ours.files.map { ($0.path as NSString).lastPathComponent + "\n" }.sorted().joined()
		315	#expect(names == theirs.text, "ours:\n\(names)\nemacs:\n\(theirs.text)\n\(theirs.error)")
		316	}
		317
294	@Test func refusesWhatItCantDo() {	318	@Test func refusesWhatItCantDo() {
295	for (language, header) in [("haskell", ":comments link"), ("sh", ":tangle (concat user-emacs-directory \"a.sh\")"), ("sh", ":tangle-mode go+q")] {	319	for (language, header) in [("haskell", ":comments link"), ("sh", ":tangle (concat user-emacs-directory \"a.sh\")"), ("sh", ":tangle-mode go+q")] {
296	let text = "#+begin_src \(language) :tangle yes \(header)\necho\n#+end_src\n"	320	let text = "#+begin_src \(language) :tangle yes \(header)\necho\n#+end_src\n"