@lattices/cli 0.4.10 → 0.4.12

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arach Tchoupani
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,14 +1,14 @@
 <picture>
-  <img alt="lattices" src="site/public/og.png" />
+  <img alt="lattices" src="apps/site/public/og.png" />
 </picture>
 
 # lattices
 
-The agentic window manager for macOS.
+The agentic workspace manager for macOS.
 
-Tile windows with hotkeys, manage persistent tmux sessions, index screen
-text with OCR, and give AI agents a 35-method desktop API — all from a
-native menu bar app and CLI.
+Lattices turns your Mac workspace into a coherent API, so agents can see and
+control windows, tmux sessions, screen text, and layouts. It also gives you
+an assistant to control that workspace in plain language.
 
 **[lattices.dev](https://lattices.dev)** · [Docs](https://lattices.dev/docs/overview) · [Download](https://github.com/arach/lattices/releases/latest)
 
@@ -42,25 +42,25 @@ The CLI and app work independently — use either or both.
 git clone https://github.com/arach/lattices.git
 cd lattices
 
-# Build the menu bar app (requires Swift 5.9+ / Xcode 15+)
-cd app && swift build -c release && cd ..
+# Build the menu bar app (requires Swift 6.2 / Xcode 26+)
+cd apps/mac && swift build -c release && cd ../..
 
 # Install CLI dependencies
 npm install
 
 # Launch
-node bin/lattices-app.js build   # bundle the .app
-node bin/lattices-app.js         # launch it
+bun bin/lattices-app.ts build    # bundle the .app
+bun bin/lattices-app.ts          # launch it
 ```
 
 To build a signed, notarized DMG for distribution:
 
 ```sh
 # Requires a Developer ID certificate and notarytool keychain profile
-./scripts/build-dmg.sh
+./tools/release/build-dmg.sh
 
 # Update v<package.json version> and upload the DMG to GitHub Releases
-./scripts/ship.sh
+./tools/release/ship.sh
 ```
 
 ## Quick start
@@ -215,13 +215,13 @@ lattices help               Show help
 
 ## Requirements
 
-- macOS 13.0+
+- macOS 26.0+
 - Node.js 18+
 
 ### Optional
 
 - tmux for persistent terminal sessions (`brew install tmux`)
-- Swift 5.9+ to build the menu bar app from source
+- Swift 6.2 / Xcode 26+ to build the menu bar app from source
 
 ## Docs
 

package/{app → apps/mac}/Lattices.app/Contents/Info.plist

@@ -26,9 +26,17 @@
         </dict>
     </array>
     <key>CFBundleVersion</key>
-    <string>0.4.10</string>
+    <string>0.4.12</string>
     <key>CFBundleShortVersionString</key>
-    <string>0.4.10</string>
+    <string>0.4.12</string>
+    <key>LatticesBuildChannel</key>
+    <string>dev</string>
+    <key>LatticesBuildTrack</key>
+    <string>latest</string>
+    <key>LatticesBuildRevision</key>
+    <string>b84f24f</string>
+    <key>LatticesBuildTimestamp</key>
+    <string>2026-05-04T16:17:39Z</string>
     <key>LSMinimumSystemVersion</key>
     <string>13.0</string>
     <key>LSUIElement</key>

package/{app → apps/mac}/Package.swift

@@ -5,7 +5,7 @@ let package = Package(
     name: "Lattices",
     platforms: [.macOS(.v13)],
     dependencies: [
-        .package(path: "../swift")
+        .package(path: "../../swift")
     ],
     targets: [
         .executableTarget(
@@ -16,6 +16,7 @@ let package = Package(
             path: "Sources",
             resources: [
                 .copy("../Resources/tap.wav"),
+                .copy("../Resources/Pets"),
             ]
         ),
         .testTarget(

package/apps/mac/Resources/Pets/assistant-spark/pet.json

@@ -0,0 +1,62 @@
+{
+  "id": "assistant-spark",
+  "displayName": "Assistant Spark",
+  "description": "A small luminous assistant companion for Codex sessions.",
+  "spritesheetPath": "spritesheet.webp",
+  "states": {
+    "idle": {
+      "row": 0,
+      "frames": 6,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "run_right": {
+      "row": 1,
+      "frames": 8,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "run_left": {
+      "row": 2,
+      "frames": 8,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "waving": {
+      "row": 3,
+      "frames": 4,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "jumping": {
+      "row": 4,
+      "frames": 5,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "failed": {
+      "row": 5,
+      "frames": 8,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "waiting": {
+      "row": 6,
+      "frames": 6,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "running": {
+      "row": 7,
+      "frames": 6,
+      "frameWidth": 192,
+      "frameHeight": 208
+    },
+    "review": {
+      "row": 8,
+      "frames": 6,
+      "frameWidth": 192,
+      "frameHeight": 208
+    }
+  }
+}

package/apps/mac/Resources/Pets/scout-ranger/pet.json

@@ -0,0 +1,6 @@
+{
+  "id": "scout-ranger",
+  "displayName": "Scout Ranger",
+  "description": "A tiny chunky robot field-general companion for Scout and Codex sessions.",
+  "spritesheetPath": "spritesheet.webp"
+}

package/apps/mac/Sources/AppShell/AppActivationCoordinator.swift

@@ -0,0 +1,27 @@
+import AppKit
+
+final class AppActivationCoordinator {
+    static let shared = AppActivationCoordinator()
+
+    private var surfaceVisibilityProviders: [(id: String, isVisible: () -> Bool)] = []
+
+    private init() {}
+
+    func registerSurface(id: String, isVisible: @escaping () -> Bool) {
+        guard !surfaceVisibilityProviders.contains(where: { $0.id == id }) else { return }
+        surfaceVisibilityProviders.append((id: id, isVisible: isVisible))
+    }
+
+    func refresh() {
+        let hasVisibleWindow = surfaceVisibilityProviders.contains { provider in
+            provider.isVisible()
+        }
+        let desired: NSApplication.ActivationPolicy = hasVisibleWindow ? .regular : .accessory
+        if NSApp.activationPolicy() != desired {
+            NSApp.setActivationPolicy(desired)
+            if desired == .regular {
+                NSApp.activate(ignoringOtherApps: true)
+            }
+        }
+    }
+}

package/apps/mac/Sources/AppShell/AppDelegate.swift

@@ -0,0 +1,189 @@
+import AppKit
+import Carbon
+
+extension Notification.Name {
+    static let latticesPopoverWillShow = Notification.Name("latticesPopoverWillShow")
+    static let latticesShowGeneralSettings = Notification.Name("latticesShowGeneralSettings")
+    static let latticesShowAssistantSettings = Notification.Name("latticesShowAssistantSettings")
+}
+
+class AppDelegate: NSObject, NSApplicationDelegate {
+    private var notificationObservers: [NSObjectProtocol] = []
+
+    static func updateActivationPolicy() {
+        AppActivationCoordinator.shared.refresh()
+    }
+
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        NSApp.setActivationPolicy(.accessory)
+        NSApp.appearance = NSAppearance(named: .darkAqua)
+        registerDeepLinkHandler()
+        installSystemInputBoundaryObservers()
+
+        MenuBarController.shared.start()
+        registerVisibleSurfaces()
+        HotkeyBootstrap.registerHotkeys()
+
+        DispatchQueue.main.async { HUDController.shared.warmUp() }
+        DispatchQueue.main.async { MenuBarController.shared.warmUpPopover() }
+        DispatchQueue.main.async { ScreenOverlayCanvasController.shared.warmUp() }
+
+        WindowDragSnapController.shared.start()
+        MouseGestureController.shared.start()
+        KeyboardRemapController.shared.start()
+        SecureEventInputMonitor.shared.start()
+
+        if !OnboardingWindowController.shared.showIfNeeded() {
+            PermissionChecker.shared.check()
+        }
+
+        AppServicesBootstrap.start()
+
+        Task {
+            await AppUpdater.shared.checkIfNeeded()
+        }
+
+        // --diagnostics flag: auto-open diagnostics panel on launch
+        if CommandLine.arguments.contains("--diagnostics") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                DiagnosticWindow.shared.show()
+            }
+        }
+
+        // --screen-map flag: auto-open layout on launch
+        if CommandLine.arguments.contains("--screen-map") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                ScreenMapWindowController.shared.showPage(.screenMap)
+            }
+        }
+
+        // Explicit preview entry point for development/demo flows. This still
+        // requires a launch argument; the assistant never opens automatically.
+        if CommandLine.arguments.contains("--permissions-assistant") {
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                PermissionsAssistantWindowController.shared.show()
+            }
+        }
+    }
+
+    func applicationWillTerminate(_ notification: Notification) {
+        removeSystemInputBoundaryObservers()
+        SecureEventInputMonitor.shared.stop()
+        KeyboardRemapController.shared.stop()
+        AppServicesBootstrap.stop()
+    }
+
+    func applicationDidBecomeActive(_ notification: Notification) {
+        resetInputCapture(reason: "app became active")
+    }
+
+    func applicationWillResignActive(_ notification: Notification) {
+        resetInputCapture(reason: "app resigned active")
+    }
+
+    private func registerVisibleSurfaces() {
+        let coordinator = AppActivationCoordinator.shared
+        coordinator.registerSurface(id: "menuBarPopover") { MenuBarController.shared.isPopoverShown }
+        coordinator.registerSurface(id: "commandMode") { CommandModeWindow.shared.isVisible }
+        coordinator.registerSurface(id: "commandPalette") { CommandPaletteWindow.shared.isVisible }
+        coordinator.registerSurface(id: "mainWindow") { MainWindow.shared.isVisible }
+        coordinator.registerSurface(id: "screenMap") { ScreenMapWindowController.shared.isVisible }
+        coordinator.registerSurface(id: "omniSearch") { OmniSearchWindow.shared.isVisible }
+    }
+
+    private func installSystemInputBoundaryObservers() {
+        let center = NSWorkspace.shared.notificationCenter
+        notificationObservers.append(center.addObserver(
+            forName: NSWorkspace.willSleepNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.resetInputCapture(reason: "system will sleep")
+        })
+        notificationObservers.append(center.addObserver(
+            forName: NSWorkspace.didWakeNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.resetInputCapture(reason: "system did wake")
+        })
+        notificationObservers.append(center.addObserver(
+            forName: NSWorkspace.screensDidWakeNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.resetInputCapture(reason: "screens did wake")
+        })
+        notificationObservers.append(center.addObserver(
+            forName: NSWorkspace.screensDidSleepNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.resetInputCapture(reason: "screens did sleep")
+        })
+    }
+
+    private func removeSystemInputBoundaryObservers() {
+        let center = NSWorkspace.shared.notificationCenter
+        for observer in notificationObservers {
+            center.removeObserver(observer)
+        }
+        notificationObservers.removeAll()
+    }
+
+    private func resetInputCapture(reason: String) {
+        InputCaptureResetCenter.reset(reason: reason)
+    }
+
+    // MARK: - Deep Links
+
+    private func registerDeepLinkHandler() {
+        NSAppleEventManager.shared().setEventHandler(
+            self,
+            andSelector: #selector(handleGetURLEvent(_:withReplyEvent:)),
+            forEventClass: AEEventClass(kInternetEventClass),
+            andEventID: AEEventID(kAEGetURL)
+        )
+    }
+
+    @objc private func handleGetURLEvent(
+        _ event: NSAppleEventDescriptor,
+        withReplyEvent replyEvent: NSAppleEventDescriptor
+    ) {
+        guard
+            let value = event.paramDescriptor(forKeyword: keyDirectObject)?.stringValue,
+            let url = URL(string: value)
+        else {
+            return
+        }
+        handleDeepLink(url)
+    }
+
+    private func handleDeepLink(_ url: URL) {
+        guard url.scheme?.localizedCaseInsensitiveCompare("lattices") == .orderedSame else {
+            return
+        }
+
+        let host = url.host?.lowercased()
+        let action = url.pathComponents
+            .first { $0 != "/" }?
+            .lowercased()
+
+        guard host == "companion" else {
+            SettingsWindowController.shared.show()
+            return
+        }
+
+        switch action {
+        case "enable", "start":
+            Preferences.shared.companionBridgeEnabled = true
+            SettingsWindowController.shared.showCompanion()
+        case "disable", "stop":
+            Preferences.shared.companionBridgeEnabled = false
+            SettingsWindowController.shared.showCompanion()
+        default:
+            SettingsWindowController.shared.showCompanion()
+        }
+    }
+
+}

package/apps/mac/Sources/AppShell/AppServicesBootstrap.swift

@@ -0,0 +1,25 @@
+enum AppServicesBootstrap {
+    static func start() {
+        let diagnosticLog = DiagnosticLog.shared
+        let timedBoot = diagnosticLog.startTimed("Daemon services boot")
+        OcrStore.shared.open()
+        DesktopModel.shared.start()
+        OcrModel.shared.start()
+        TmuxModel.shared.start()
+        ProcessModel.shared.start()
+        LatticesApi.setup()
+        DaemonServer.shared.start()
+        if Preferences.shared.companionBridgeEnabled {
+            LatticesCompanionBridgeServer.shared.start()
+        } else {
+            diagnosticLog.info("CompanionBridge: disabled by preference")
+        }
+        AgentPool.shared.start()
+        diagnosticLog.finish(timedBoot)
+    }
+
+    static func stop() {
+        LatticesCompanionBridgeServer.shared.stop()
+        DaemonServer.shared.stop()
+    }
+}

package/{app → apps/mac}/Sources/AppShell/AppShellView.swift

@@ -14,9 +14,9 @@ enum AppPage: String, CaseIterable {
     var label: String {
         switch self {
         case .home:             return "Home"
-        case .screenMap:        return "Screen Map"
+        case .screenMap:        return "Layout"
         case .desktopInventory: return "Desktop Inventory"
-        case .pi:               return "Pi"
+        case .pi:               return "Assistant"
         case .settings:         return "Settings"
         case .companionSettings:return "Settings"
         case .docs:             return "Docs"
@@ -28,7 +28,7 @@ enum AppPage: String, CaseIterable {
         case .home:             return "house"
         case .screenMap:        return "rectangle.3.group"
         case .desktopInventory: return "macwindow.on.rectangle"
-        case .pi:               return "terminal"
+        case .pi:               return "bubble.left.and.bubble.right"
         case .settings:         return "gearshape"
         case .companionSettings:return "ipad.and.iphone"
         case .docs:             return "book"
@@ -63,6 +63,21 @@ struct AppShellView: View {
         }
         .onChange(of: windowController.activePage) { page in
             syncPageState(page)
+            clearRelevantDismissals(for: page)
+        }
+    }
+
+    /// Entering a feature page clears its capability snooze — the user is
+    /// telling us they want this to work, so the banner can resurface.
+    private func clearRelevantDismissals(for page: AppPage) {
+        let prefs = Preferences.shared
+        switch page {
+        case .screenMap:
+            prefs.clearDismissal(Capability.windowControl.rawValue)
+        case .desktopInventory:
+            prefs.clearDismissal(Capability.screenSearch.rawValue)
+        default:
+            break
         }
     }
 

package/{app → apps/mac}/Sources/AppShell/AppUpdater.swift

@@ -31,6 +31,7 @@ final class AppUpdater: ObservableObject {
     private init() {}
 
     var currentVersion: String { LatticesRuntime.appVersion }
+    var currentDisplayVersion: String { LatticesRuntime.appDisplayVersion }
 
     var canUpdate: Bool {
         LatticesRuntime.bunPath != nil && LatticesRuntime.appHelperScriptPath != nil
@@ -124,7 +125,7 @@ final class AppUpdater: ObservableObject {
                 } else {
                     presentAlert(
                         title: "Lattices Is Up to Date",
-                        message: "You’re running \(currentVersion), which is the latest published release."
+                        message: "You’re running \(currentDisplayVersion), which is the latest available build for this install."
                     )
                 }
             }
@@ -140,7 +141,7 @@ final class AppUpdater: ObservableObject {
         if let update = availableUpdate {
             alert.messageText = "Update Lattices?"
             alert.informativeText = """
-            Current version: \(currentVersion)
+            Current version: \(currentDisplayVersion)
             New version: \(update.version)
 
             Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.
@@ -148,7 +149,7 @@ final class AppUpdater: ObservableObject {
         } else {
             alert.messageText = "Check and update Lattices?"
             alert.informativeText = """
-            Current version: \(currentVersion)
+            Current version: \(currentDisplayVersion)
             New version: latest published release
 
             Lattices will download the signed release, quit briefly, replace the app, and relaunch when the update is ready.

package/apps/mac/Sources/AppShell/HotkeyBootstrap.swift

@@ -0,0 +1,87 @@
+import AppKit
+
+enum HotkeyBootstrap {
+    static func registerHotkeys() {
+        let scanner = ProjectScanner.shared
+        CommandPaletteWindow.shared.configure(scanner: scanner)
+
+        let store = HotkeyStore.shared
+        store.register(action: .palette) { CommandPaletteWindow.shared.toggle() }
+        store.register(action: .unifiedWindow) { ScreenMapWindowController.shared.toggle() }
+        store.register(action: .bezel) { WorkspaceInspectorPresenter.show() }
+        store.register(action: .cheatSheet) { SettingsWindowController.shared.show() }
+        store.register(action: .desktopInventory) {
+            DiagnosticLog.shared.info("Hotkey: desktopInventory triggered")
+            ScreenMapWindowController.shared.showPage(.desktopInventory)
+        }
+        store.register(action: .voiceCommand) {
+            DiagnosticLog.shared.info("Hotkey: voiceCommand triggered")
+            VoiceCommandWindow.shared.toggle()
+        }
+        store.register(action: .handsOff) {
+            DiagnosticLog.shared.info("Hotkey: handsOff triggered")
+            HandsOffSession.shared.toggle()
+            if HandsOffSession.shared.state != .idle {
+                HUDController.shared.showVoiceBar()
+            } else {
+                HUDController.shared.hideVoiceBar()
+            }
+        }
+        store.register(action: .hud) { HUDController.shared.toggle() }
+        store.register(action: .mouseFinder) { MouseFinder.shared.find() }
+        store.register(action: .overlayActors) { ScreenOverlayCanvasController.shared.toggleAgentActorsVisibility() }
+        store.register(action: .omniSearch) { OmniSearchWindow.shared.toggle() }
+
+        registerLayerHotkeys(store: store)
+        registerTilingHotkeys(store: store)
+    }
+
+    private static func registerLayerHotkeys(store: HotkeyStore) {
+        store.register(action: .layerNext) { SessionLayerStore.shared.cycleNext() }
+        store.register(action: .layerPrev) { SessionLayerStore.shared.cyclePrev() }
+        store.register(action: .layerTag) { SessionLayerStore.shared.tagFrontmostWindow() }
+
+        let workspace = WorkspaceManager.shared
+        let configLayerCount = (workspace.config?.layers ?? []).count
+        let maxLayers = max(configLayerCount, 9)
+        for (index, action) in HotkeyAction.layerActions.prefix(maxLayers).enumerated() {
+            store.register(action: action) {
+                let session = SessionLayerStore.shared
+                if !session.layers.isEmpty && index < session.layers.count {
+                    session.switchTo(index: index)
+                } else {
+                    workspace.focusLayer(index: index)
+                }
+                EventBus.shared.post(.layerSwitched(index: index))
+            }
+        }
+    }
+
+    private static func registerTilingHotkeys(store: HotkeyStore) {
+        let tileMap: [(HotkeyAction, TilePosition)] = [
+            (.tileLeft, .left), (.tileRight, .right),
+            (.tileMaximize, .maximize), (.tileCenter, .center),
+            (.tileTopLeft, .topLeft), (.tileTopRight, .topRight),
+            (.tileBottomLeft, .bottomLeft), (.tileBottomRight, .bottomRight),
+            (.tileTop, .top), (.tileBottom, .bottom),
+            (.tileLeftThird, .leftThird), (.tileCenterThird, .centerThird),
+            (.tileRightThird, .rightThird),
+        ]
+        for (action, position) in tileMap {
+            store.register(action: action) {
+                WindowTiler.tileFrontmostViaAX(to: position)
+            }
+        }
+        store.register(action: .tileDistribute) {
+            WindowTiler.distributeVisible(reactivateLattices: false)
+        }
+        store.register(action: .tileTypeGrid) {
+            WindowTiler.distributeVisibleByFrontmostType(reactivateLattices: false)
+        }
+        store.register(action: .tileOrganize) {
+            let appName = DesktopModel.shared.frontmostWindow()?.app
+                ?? NSWorkspace.shared.frontmostApplication?.localizedName
+            CommandModeWindow.shared.show(launchMode: .organize(appName: appName))
+        }
+    }
+}

package/{app → apps/mac}/Sources/AppShell/LatticesRuntime.swift

@@ -55,7 +55,50 @@ enum LatticesRuntime {
             ?? "unknown"
     }
 
+    static var appDisplayVersion: String {
+        let base = appVersion == "unknown" ? "unknown" : "v\(appVersion)"
+        guard isDevBuild else { return base }
+
+        let track = buildTrack ?? "latest"
+        return "\(base)-dev.\(track)"
+    }
+
+    static var buildChannel: String {
+        let raw = Bundle.main.infoDictionary?["LatticesBuildChannel"] as? String
+        return raw?.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() ?? "release"
+    }
+
+    static var buildTrack: String? {
+        normalizedInfoValue("LatticesBuildTrack")
+    }
+
+    static var buildRevision: String? {
+        normalizedInfoValue("LatticesBuildRevision")
+    }
+
+    static var buildTimestamp: String? {
+        normalizedInfoValue("LatticesBuildTimestamp")
+    }
+
+    static var isDevBuild: Bool {
+        buildChannel == "dev"
+    }
+
+    static var buildStatusLabel: String {
+        isDevBuild ? "Latest local dev build" : "Signed release build"
+    }
+
+    static var buildChannelLabel: String {
+        isDevBuild ? "DEV" : "RELEASE"
+    }
+
     private static func hasAppHelper(in root: String) -> Bool {
         FileManager.default.fileExists(atPath: root + "/bin/lattices-app.ts")
     }
+
+    private static func normalizedInfoValue(_ key: String) -> String? {
+        guard let raw = Bundle.main.infoDictionary?[key] as? String else { return nil }
+        let value = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+        return value.isEmpty || value == "unknown" ? nil : value
+    }
 }