crazy-macs/tag-launcher.git

			@@ -6,7 +6,12 @@

			@main
			struct TagLauncherApp: App {
			private static let singletonLockFile = TagLauncherProcessSingleton.acquireOrHandOffAndExit()
			@NSApplicationDelegateAdaptor(AppDelegate.self) var appDelegate

			init() {
			_ = Self.singletonLockFile
			}

			var body: some Scene {
			Settings {
			@@ -16,55 +21,204 @@
			.commands {
			CommandGroup(replacing: .systemServices) { }
			CommandGroup(replacing: .appVisibility) { }
			CommandGroup(replacing: .help) { }
			}
			}
			}

			// MARK: - App Delegate (menubar + overlay window + hotkey)

			final class OverlayPanel: NSPanel {
			override var canBecomeKey: Bool { true }
			override var canBecomeMain: Bool { true }
			}

			final class AppDelegate: NSObject, NSApplicationDelegate {
			final class AppDelegate: NSObject, NSApplicationDelegate, NSMenuDelegate {
			private static let showDockIconKey = "showDockIcon"
			private static let statusItemAutosaveName = AppIdentity.statusItemAutosaveName
			private static let statusItemButtonIdentifier = NSUserInterfaceItemIdentifier("TagLauncherStatusItemButton")
			private static let statusItemAccessibilityLabel = AppIdentity.displayName
			private static let showAppListMenuItemIdentifier = NSUserInterfaceItemIdentifier("TagLauncherShowAppListMenuItem")
			private static let showAppListShortcutGlyphs = "⌥⇧␣"
			private static let helpMenuItemIdentifier = NSUserInterfaceItemIdentifier("TagLauncherHelpMenu")
			private static let downloadHelpMenuItemIdentifier = NSUserInterfaceItemIdentifier("TagLauncherDownloadHelpMenuItem")
			private static let externalActivationNotification = Notification.Name("TagLauncherExternalActivationRequested")
			private static let externalActivationObject = AppIdentity.bundleIdentifier
			private static let launcherOverlayLevel = NSWindow.Level(rawValue: NSWindow.Level.mainMenu.rawValue - 1)
			private static let overlayDefaultLevel = launcherOverlayLevel
			private static let overlayTextInputLevel = launcherOverlayLevel

			private var statusItem: NSStatusItem?
			private var overlayWindow: NSWindow?
			private var overlayKeyMonitor: Any?
			private var quickSearchLocalMouseMonitor: Any?
			private var quickSearchExternalMouseMonitor: Any?
			private var settingsWindow: NSWindow? // Track Settings window to keep it above overlay
			private var hotkeyRef: EventHotKeyRef?
			private var mainHotkeyRef: EventHotKeyRef?
			private var quickSearchHotkeyRef: EventHotKeyRef?
			private var hotkeyEventHandlerInstalled = false
			private var isQuickSearchOpen = false
			private var isModalInteractionActive = false
			private var isInEditMode = false // Suppress auto-dismiss during editing
			private var isEditingAppNote = false
			private var isConfiguringApplicationMenu = false
			private var lastShowDockIcon: Bool?
			private var statusMenuScreenForNextOverlay: NSScreen?
			private var suppressReopenUntil = Date.distantPast

			private lazy var overlayController = OverlayWindowController(
			dependencies: OverlayWindowController.Dependencies(
			shouldStageAsAccessory: { [weak self] in
			self?.shouldStageOverlayAsAccessory ?? false
			},
			isSettingsVisible: { [weak self] in
			self?.isSettingsVisible ?? false
			},
			settingsWindow: { [weak self] in
			self?.settingsWindow
			},
			canHideOverlay: { [weak self] in
			self?.isInEditMode == false
			},
			currentOverlayLevel: { [weak self] in
			self?.currentOverlayLevel ?? Self.overlayDefaultLevel
			},
			overlayLevel: { [weak self] initialQuickSearchSource in
			self?.overlayLevel(initialQuickSearchSource: initialQuickSearchSource) ?? Self.overlayDefaultLevel
			},
			makeContentView: { [weak self] initialQuickSearchSource in
			DismissibleHostingView(
			rootView: ContentView(
			hideOverlay: { [weak self] in
			self?.hideOverlay(force: true)
			},
			initialQuickSearchSource: initialQuickSearchSource
			),
			onBackdropTap: { [weak self] in
			self?.hideOverlay()
			}
			)
			},
			installOverlayKeyMonitor: { [weak self] in
			self?.installOverlayKeyMonitor()
			},
			removeOverlayKeyMonitor: { [weak self] in
			self?.removeOverlayKeyMonitor()
			},
			removeQuickSearchMouseMonitor: { [weak self] in
			self?.removeQuickSearchExternalMouseMonitor()
			},
			detachSettingsWindow: { [weak self] window in
			self?.detachSettingsWindow(window)
			},
			prepareSettingsWindow: { [weak self] window in
			self?.prepareSettingsWindow(window)
			},
			refreshChromeState: { [weak self] activate, avoidSpaceSwitch in
			self?.refreshLauncherChromeState(activate: activate, avoidSpaceSwitch: avoidSpaceSwitch)
			},
			onWillHide: {
			TagDatabase.flushPendingCategorySchemeBackupBatch()
			},
			onDidHide: {
			NotificationCenter.default.post(name: .tagLauncherOverlayDidHide, object: nil)
			},
			onDidShow: {
			NotificationCenter.default.post(name: .tagLauncherOverlayDidShow, object: nil)
			}
			)
			)

			private var overlayWindow: NSWindow? {
			overlayController.window
			}

			private var overlayGeneration: Int {
			overlayController.generation
			}

			private var overlayAvoidsSpaceSwitch: Bool {
			get { overlayController.avoidsSpaceSwitch }
			set { overlayController.avoidsSpaceSwitch = newValue }
			}

			private var isOverlayVisible: Bool {
			overlayWindow?.isVisible == true
			}

			private var isSettingsVisible: Bool {
			settingsWindow?.isVisible == true
			}

			private var requiresForegroundOwnership: Bool {
			isOverlayVisible \|\| isSettingsVisible
			}

			private var shouldStageOverlayAsAccessory: Bool {
			!isSettingsVisible && !UserDefaults.standard.bool(forKey: Self.showDockIconKey)
			}

			private var currentOverlayLevel: NSWindow.Level {
			if isEditingAppNote \|\| isQuickSearchOpen {
			return Self.overlayTextInputLevel
			}
			return Self.overlayDefaultLevel
			}

			private func overlayLevel(initialQuickSearchSource: String? = nil) -> NSWindow.Level {
			if initialQuickSearchSource != nil {
			return Self.overlayTextInputLevel
			}
			return currentOverlayLevel
			}

			static func refreshChromeSettings() {
			(NSApp.delegate as? AppDelegate)?.syncChromeSettings(force: true)
			}

			static func openPreferencesWindow() {
			(NSApp.delegate as? AppDelegate)?.openPreferences()
			}

			func applicationDidFinishLaunching(_ notification: Notification) {
			AppDefaults.register()
			L10n.setup()
			migrateDefaultGroupName()
			TagDatabase.seedDefaultTags()
			syncChromeSettings(force: true)
			registerHotkey()
			observeHotkeyStatusChanges()
			registerConfiguredHotkeys()
			observeOtherWindows()
			observeSettingsClose()
			observeEditMode()
			observeAppNoteEditing()
			observeQuickSearch()
			observePreferencesRequests()
			observeExternalActivationRequests()
			observeApplicationMenuChanges()
			observeChromeSettings()
			observeLanguageChanges()
			setupLaunchAtLogin()
			configureApplicationMenuWhenAvailable()
			suppressReopenUntil = Date().addingTimeInterval(1.0)
			configureApplicationMenuWhenAvailable(retries: 200)
			}

			func applicationDidBecomeActive(_ notification: Notification) {
			configureApplicationMenuWhenAvailable(retries: 12)
			}

			/// Dock icon click → show overlay (same as menubar "Show TagLauncher")
			func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
			showOverlay()
			guard Date() >= suppressReopenUntil else { return false }
			showOrFocusOverlay()
			return false // Suppress default "unhide all windows" behavior
			}

			func applicationWillTerminate(_ notification: Notification) {
			hideOverlay(force: true, discardWindow: true)
			unregisterHotkey(for: .main)
			unregisterHotkey(for: .quickSearch)
			TagDatabase.flushPendingCategorySchemeBackupBatch()
			removeOverlayKeyMonitor()
			removeQuickSearchExternalMouseMonitor()
			DistributedNotificationCenter.default().removeObserver(
			self,
			name: Self.externalActivationNotification,
			object: Self.externalActivationObject
			)
			}

			/// Ensure defaultGroupName is always the language-neutral key "Other".
			@@ -100,12 +254,114 @@
			let dockChanged = lastShowDockIcon != showDock

			if force \|\| dockChanged {
			NSApp.setActivationPolicy(showDock ? .regular : .accessory)
			lastShowDockIcon = showDock
			refreshLauncherChromeState()
			}

			if force {
			setupMenuBar()
			}
			}

			private func beginLauncherForegroundOwnership(activate: Bool = true, keyWindow: NSWindow? = nil) {
			if NSApp.activationPolicy() != .regular {
			NSApp.setActivationPolicy(.regular)
			}
			if activate {
			claimLauncherForeground(keyWindow: keyWindow)
			}
			}

			private func claimLauncherForeground(
			keyWindow: NSWindow? = nil,
			retries: Int = 0,
			overlayGeneration expectedOverlayGeneration: Int? = nil
			) {
			if NSApp.activationPolicy() != .regular {
			NSApp.setActivationPolicy(.regular)
			}

			if isOverlayVisible && !NSApp.presentationOptions.contains(.hideDock) {
			NSApp.presentationOptions = [.hideDock]
			}

			NSApp.unhide(nil)
			NSApp.activate(ignoringOtherApps: true)

			if let keyWindow, keyWindow.isVisible {
			keyWindow.makeKeyAndOrderFront(nil)
			keyWindow.makeMain()
			keyWindow.orderFrontRegardless()
			}
			configureApplicationMenuWhenAvailable(retries: 4)

			let overlayShouldYieldToSettings = keyWindow == overlayWindow && isSettingsVisible
			let keyWindowStillNeedsFocus = !overlayShouldYieldToSettings
			&& keyWindow?.isVisible == true
			&& keyWindow?.isKeyWindow == false
			let shouldRetry = !NSApp.isActive
			\|\| !NSApp.presentationOptions.contains(.hideDock)
			\|\| keyWindowStillNeedsFocus
			guard retries > 0, isOverlayVisible else { return }
			guard shouldRetry else { return }

			let retryWindow = keyWindow
			DispatchQueue.main.asyncAfter(deadline: .now() + 0.08) { [weak self] in
			guard let self, self.isOverlayVisible else { return }
			if let expectedOverlayGeneration,
			expectedOverlayGeneration != self.overlayGeneration {
			return
			}
			self.refreshLauncherChromeState()
			self.claimLauncherForeground(
			keyWindow: retryWindow,
			retries: retries - 1,
			overlayGeneration: expectedOverlayGeneration
			)
			}
			}

			private func refreshLauncherChromeState(activate: Bool = false, avoidSpaceSwitch: Bool = false) {
			let showDock = UserDefaults.standard.bool(forKey: Self.showDockIconKey)
			lastShowDockIcon = showDock

			let shouldStayAccessoryForCurrentFullscreenSpace = isOverlayVisible
			&& (avoidSpaceSwitch \|\| overlayAvoidsSpaceSwitch)
			let desiredPolicy: NSApplication.ActivationPolicy = shouldStayAccessoryForCurrentFullscreenSpace
			? .accessory
			: (requiresForegroundOwnership
			? .regular
			: (showDock ? .regular : .accessory))
			if NSApp.activationPolicy() != desiredPolicy {
			NSApp.setActivationPolicy(desiredPolicy)
			}

			let desiredPresentation: NSApplication.PresentationOptions = isOverlayVisible ? [.hideDock] : []
			if NSApp.presentationOptions != desiredPresentation {
			NSApp.presentationOptions = desiredPresentation
			}

			if activate && requiresForegroundOwnership && !shouldStayAccessoryForCurrentFullscreenSpace {
			let keyWindow = isSettingsVisible ? settingsWindow : (isOverlayVisible ? overlayWindow : nil)
			claimLauncherForeground(
			keyWindow: keyWindow,
			retries: isOverlayVisible && !isSettingsVisible ? 5 : 0,
			overlayGeneration: isOverlayVisible ? overlayGeneration : nil
			)
			}
			}

			private func handleApplicationDidResignActive() {
			guard !isOverlayVisible else {
			return
			}

			if isQuickSearchOpen {
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			}

			if !requiresForegroundOwnership {
			refreshLauncherChromeState()
			}
			}

			@@ -122,7 +378,7 @@

			// MARK: - Launch at Login (LaunchAgent, zero permissions)

			private static let launchAgentLabel = "com.apptag.launcher"
			private static let launchAgentLabel = AppIdentity.launchAgentLabel
			static var supportsLaunchAtLogin: Bool {
			ProcessInfo.processInfo.environment["APP_SANDBOX_CONTAINER_ID"] == nil
			}
			@@ -136,7 +392,7 @@
			guard supportsLaunchAtLogin else { return }
			let plist: [String: Any] = [
			"Label": Self.launchAgentLabel,
			"ProgramArguments": ["open", Bundle.main.bundlePath, "--hide"],
			"ProgramArguments": Self.expectedLaunchAgentProgramArguments(),
			"RunAtLoad": true,
			]
			let dir = Self.launchAgentURL.deletingLastPathComponent()
			@@ -144,10 +400,16 @@
			(plist as NSDictionary).write(to: Self.launchAgentURL, atomically: true)

			let uid = getuid()
			let bootoutTask = Process()
			bootoutTask.launchPath = "/bin/launchctl"
			bootoutTask.arguments = ["bootout", "gui/\(uid)/\(Self.launchAgentLabel)"]
			try? bootoutTask.run()
			bootoutTask.waitUntilExit()

			let task = Process()
			task.launchPath = "/bin/launchctl"
			task.arguments = ["bootstrap", "gui/\(uid)", Self.launchAgentURL.path]
			task.launch()
			try? task.run()
			}

			static func disableLaunchAtLogin() {
			@@ -156,8 +418,23 @@
			let task = Process()
			task.launchPath = "/bin/launchctl"
			task.arguments = ["bootout", "gui/\(uid)/\(Self.launchAgentLabel)"]
			task.launch()
			try? task.run()
			try? FileManager.default.removeItem(at: Self.launchAgentURL)
			}

			private static func launchAgentProgramArguments() -> [String]? {
			guard let plist = NSDictionary(contentsOf: Self.launchAgentURL) as? [String: Any] else {
			return nil
			}
			return plist["ProgramArguments"] as? [String]
			}

			private static func expectedLaunchAgentProgramArguments() -> [String] {
			let executablePath = Bundle.main.executablePath
			?? Bundle.main.bundleURL
			.appendingPathComponent("Contents/MacOS/\(AppIdentity.displayName)")
			.path
			return [executablePath, "--hide"]
			}

			/// On first launch, enable login item by default via LaunchAgent.
			@@ -170,8 +447,14 @@
			return
			}
			let key = "launchAtLogin"
			if UserDefaults.standard.object(forKey: key) == nil {
			UserDefaults.standard.set(true, forKey: key)
			guard UserDefaults.standard.bool(forKey: key) else {
			Self.disableLaunchAtLogin()
			return
			}

			let expectedArguments = Self.expectedLaunchAgentProgramArguments()
			if !AppDefaults.hasStoredValue(for: key)
			\|\| Self.launchAgentProgramArguments() != expectedArguments {
			Self.enableLaunchAtLogin()
			}
			}
			@@ -179,24 +462,32 @@
			// MARK: - Menu Bar

			private func setupMenuBar() {
			removeMenuBarItem()
			statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
			if statusItem == nil {
			statusItem = NSStatusBar.system.statusItem(withLength: NSStatusItem.squareLength)
			} else {
			statusItem?.length = NSStatusItem.squareLength
			}
			guard let statusItem else { return }
			statusItem.autosaveName = Self.statusItemAutosaveName
			statusItem.isVisible = true

			if let button = statusItem.button {
			button.identifier = Self.statusItemButtonIdentifier
			button.setAccessibilityIdentifier(Self.statusItemAutosaveName)
			button.setAccessibilityLabel(Self.statusItemAccessibilityLabel)
			button.image = makeMenuBarIcon()
			button.imageScaling = .scaleProportionallyDown
			button.imagePosition = .imageOnly
			button.toolTip = "TagLauncher — Tag-based app launcher"
			button.action = #selector(toggleOverlay)
			button.action = #selector(toggleOverlay(_:))
			button.target = self
			}

			let menu = NSMenu()
			menu.delegate = self
			let showItem = NSMenuItem(
			title: showAppListMenuTitle,
			action: #selector(toggleOverlay),
			action: #selector(toggleOverlayFromStatusMenu(_:)),
			keyEquivalent: ""
			)
			showItem.target = self
			@@ -217,9 +508,10 @@
			menu.addItem(.separator())
			let prefsItem = NSMenuItem(
			title: tr("menu.preferences"),
			action: #selector(openPreferences),
			action: #selector(openPreferences(_:)),
			keyEquivalent: ","
			)
			prefsItem.target = self
			prefsItem.keyEquivalentModifierMask = .command
			menu.addItem(prefsItem)
			menu.addItem(.separator())
			@@ -248,24 +540,73 @@
			statusItem.menu = menu
			}

			func menuWillOpen(_ menu: NSMenu) {
			statusMenuScreenForNextOverlay = overlayController.screenContainingCurrentPointer()
			?? statusItem?.button?.window?.screen
			?? NSScreen.main
			?? NSScreen.screens.first
			}

			func menuDidClose(_ menu: NSMenu) {
			DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
			self?.statusMenuScreenForNextOverlay = nil
			}
			}

			private func makeMenuBarIcon() -> NSImage {
			let image = NSImage(size: NSSize(width: 18, height: 18))
			let menuBarIconSize = NSSize(width: 19, height: 19)
			if let url = Bundle.main.url(forResource: "TagLauncherMenuBarIcon", withExtension: "svg"),
			let image = NSImage(contentsOf: url) {
			image.size = menuBarIconSize
			image.isTemplate = true
			image.accessibilityDescription = "TagLauncher"
			return image
			}

			let image = NSImage(size: menuBarIconSize)
			image.lockFocus()
			defer { image.unlockFocus() }

			NSColor.black.setFill()
			NSGraphicsContext.current?.shouldAntialias = true
			NSColor.black.withAlphaComponent(0.88).setStroke()
			NSColor.black.withAlphaComponent(0.88).setFill()

			let tagBody = NSBezierPath()
			tagBody.move(to: NSPoint(x: 5.0, y: 2.2))
			tagBody.line(to: NSPoint(x: 15.6, y: 5.0))
			tagBody.line(to: NSPoint(x: 12.8, y: 15.8))
			tagBody.line(to: NSPoint(x: 2.2, y: 13.0))
			tagBody.close()
			tagBody.fill()
			let scale = image.size.width / 220.0
			func rectFromSVG(x: CGFloat, y: CGFloat, width: CGFloat, height: CGFloat) -> NSRect {
			NSRect(
			x: x * scale,
			y: (220.0 - y - height) * scale,
			width: width * scale,
			height: height * scale
			)
			}

			NSGraphicsContext.current?.compositingOperation = .clear
			NSBezierPath(ovalIn: NSRect(x: 10.9, y: 11.2, width: 3.2, height: 3.2)).fill()
			NSGraphicsContext.current?.compositingOperation = .sourceOver
			let outline = NSBezierPath(
			roundedRect: rectFromSVG(x: 15, y: 15, width: 190, height: 190),
			xRadius: 44 * scale,
			yRadius: 44 * scale
			)
			outline.lineWidth = 11 * scale
			outline.stroke()

			for rect in [
			rectFromSVG(x: 49, y: 134, width: 27, height: 27),
			rectFromSVG(x: 92, y: 134, width: 27, height: 27),
			rectFromSVG(x: 49, y: 91, width: 27, height: 27),
			rectFromSVG(x: 92, y: 91, width: 27, height: 27),
			rectFromSVG(x: 49, y: 48, width: 27, height: 27),
			rectFromSVG(x: 92, y: 48, width: 27, height: 27)
			] {
			NSBezierPath(roundedRect: rect, xRadius: 8 * scale, yRadius: 8 * scale).fill()
			}

			for rect in [
			rectFromSVG(x: 132, y: 133, width: 47, height: 28),
			rectFromSVG(x: 132, y: 90.5, width: 47, height: 28),
			rectFromSVG(x: 132, y: 48, width: 47, height: 28)
			] {
			NSBezierPath(roundedRect: rect, xRadius: 12 * scale, yRadius: 12 * scale).fill()
			}

			image.isTemplate = true
			image.accessibilityDescription = "TagLauncher"
			@@ -273,7 +614,10 @@
			}

			private var showAppListMenuTitle: String {
			"\(tr("menu.showAppList")) \(Self.showAppListShortcutGlyphs)"
			if LauncherHotkeyRegistrationStore.state(for: .main) == .failed {
			return tr("menu.showShortcutUnavailable")
			}
			return "\(tr("menu.showAppList")) \(LauncherHotkey.main.displayString)"
			}

			private func observeApplicationMenuChanges() {
			@@ -308,6 +652,7 @@
			}

			self.configureApplicationMenu()
			self.configureHelpMenu()
			if retries > 0 && self.applicationMenuNeedsCleanup() {
			self.configureApplicationMenuWhenAvailable(retries: retries - 1)
			}
			@@ -322,6 +667,7 @@
			defer { isConfiguringApplicationMenu = false }

			removeUnusedDefaultItems(from: appMenu)
			configurePreferencesMenuItem(in: appMenu)
			upsertShowAppListItem(in: appMenu)
			normalizeSeparators(in: appMenu)
			}
			@@ -371,16 +717,37 @@

			private func configureShowAppListItem(_ item: NSMenuItem) {
			item.title = showAppListMenuTitle
			item.action = #selector(toggleOverlay)
			item.action = #selector(toggleOverlayFromStatusMenu(_:))
			item.target = self
			item.keyEquivalent = ""
			item.keyEquivalentModifierMask = []
			item.isEnabled = true
			}

			private func configurePreferencesMenuItem(in menu: NSMenu) {
			let item: NSMenuItem
			if let existingItem = menu.items.first(where: { isSettingsMenuItem($0) }) {
			item = existingItem
			} else {
			item = NSMenuItem()
			if let firstSeparatorIndex = menu.items.firstIndex(where: { $0.isSeparatorItem }) {
			menu.insertItem(item, at: firstSeparatorIndex)
			} else {
			menu.addItem(item)
			}
			}

			item.title = tr("menu.preferences")
			item.action = #selector(openPreferences(_:))
			item.target = self
			item.keyEquivalent = ","
			item.keyEquivalentModifierMask = .command
			item.isEnabled = true
			}

			private func isSettingsMenuItem(_ item: NSMenuItem) -> Bool {
			item.action == Selector(("showSettingsWindow:"))
			\|\| item.action == #selector(openPreferences)
			\|\| item.action == #selector(openPreferences(_:))
			\|\| item.title == tr("menu.preferences")
			}

			@@ -404,6 +771,42 @@
			}
			}

			private func configureHelpMenu() {
			guard let mainMenu = NSApp.mainMenu else { return }
			NSApp.helpMenu = nil

			for item in mainMenu.items.reversed() {
			let isHelpMenu = item.identifier == Self.helpMenuItemIdentifier
			\|\| item.title.localizedCaseInsensitiveContains("help")
			\|\| item.title == tr("menu.help")
			\|\| item.submenu?.title.localizedCaseInsensitiveContains("help") == true
			\|\| item.submenu?.title == tr("menu.help")
			if isHelpMenu {
			mainMenu.removeItem(item)
			}
			}

			let menuItem = NSMenuItem(title: tr("menu.help"), action: nil, keyEquivalent: "")
			let helpMenu = NSMenu(title: tr("menu.help"))
			menuItem.identifier = Self.helpMenuItemIdentifier
			menuItem.submenu = helpMenu

			let downloadItem = NSMenuItem()
			downloadItem.identifier = Self.downloadHelpMenuItemIdentifier
			downloadItem.title = tr("help.downloadPDF")
			downloadItem.action = #selector(openLocalizedHelp(_:))
			downloadItem.target = self
			downloadItem.keyEquivalent = ""
			downloadItem.keyEquivalentModifierMask = []
			downloadItem.isEnabled = true
			helpMenu.addItem(downloadItem)
			mainMenu.addItem(menuItem)
			}

			@objc private func openLocalizedHelp(_ sender: Any? = nil) {
			NSWorkspace.shared.open(HelpDocument.currentURL)
			}

			private func removeMenuBarItem() {
			guard let statusItem else { return }
			NSStatusBar.system.removeStatusItem(statusItem)
			@@ -412,41 +815,97 @@

			// MARK: - Overlay Window

			@objc private func toggleOverlay() {
			if overlayWindow?.isVisible == true {
			hideOverlay()
			} else {
			showOverlay()
			@objc func toggleOverlay(_ sender: Any) {
			performToggleOverlay(preferredScreen: nil)
			}

			@objc func toggleOverlayFromStatusMenu(_ sender: Any) {
			let preferredScreen = statusMenuScreenForNextOverlay
			statusMenuScreenForNextOverlay = nil
			DispatchQueue.main.async { [weak self] in
			self?.performToggleOverlay(preferredScreen: preferredScreen)
			}
			}

			private func showOverlay() {
			// Use the screen under the mouse cursor — works in fullscreen spaces
			let mousePoint = NSEvent.mouseLocation
			guard let screen = NSScreen.screens.first(where: {
			NSMouseInRect(mousePoint, $0.frame, false)
			}) ?? NSScreen.main ?? NSScreen.screens.first else { return }
			private func performToggleOverlay(preferredScreen: NSScreen?) {
			overlayController.toggle(preferredScreen: preferredScreen)
			}

			overlayWindow?.orderOut(nil)
			overlayWindow = makeOverlayWindow(on: screen)
			overlayWindow?.setFrame(screen.frame, display: true)
			overlayWindow?.level = NSWindow.Level(rawValue: Int(CGWindowLevelForKey(.maximumWindow)))
			private func showOrFocusOverlay(preferredScreen: NSScreen? = nil) {
			overlayController.showOrFocus(preferredScreen: preferredScreen)
			}

			installOverlayKeyMonitor()

			overlayWindow?.makeKeyAndOrderFront(nil)
			overlayWindow?.orderFrontRegardless()
			private func showOverlay(
			initialQuickSearchSource: String? = nil,
			preferredScreen: NSScreen? = nil,
			stagedForAllSpaces: Bool = false
			) {
			overlayController.show(
			initialQuickSearchSource: initialQuickSearchSource,
			preferredScreen: preferredScreen,
			stagedForAllSpaces: stagedForAllSpaces
			)
			}

			private func installOverlayKeyMonitor() {
			guard overlayKeyMonitor == nil else { return }
			overlayKeyMonitor = NSEvent.addLocalMonitorForEvents(matching: .keyDown) { [weak self] event in
			guard let self else { return event }
			guard self.shouldHandleOverlayKeyEvent(event) else { return event }
			if event.keyCode == 53 { // Escape
			self?.hideOverlay()
			if self.isQuickSearchOpen {
			self.isQuickSearchOpen = false
			self.removeQuickSearchExternalMouseMonitor()
			self.updateOverlayLevelForTextInput()
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			return nil
			}
			self.hideOverlay(force: true)
			return nil
			}
			if self.shouldOpenQuickSearch(for: event) {
			self.requestQuickSearch(source: QuickSearchOpenSource.mainOverlay)
			return nil
			}
			return event
			}
			}

			private func requestQuickSearch(source: String) {
			isQuickSearchOpen = true
			promoteOverlayToForegroundInput()
			updateOverlayLevelForTextInput()
			installQuickSearchExternalMouseMonitor()
			DispatchQueue.main.async {
			NotificationCenter.default.post(
			name: .tagLauncherQuickSearchRequested,
			object: nil,
			userInfo: ["source": source]
			)
			}
			}

			private func shouldHandleOverlayKeyEvent(_ event: NSEvent) -> Bool {
			guard overlayWindow?.isVisible == true else { return false }
			if !isSettingsVisible && NSApp.isActive {
			return true
			}
			if event.window == overlayWindow { return true }
			return event.window == nil && NSApp.keyWindow == overlayWindow
			}

			private func shouldOpenQuickSearch(for event: NSEvent) -> Bool {
			guard event.keyCode == UInt16(kVK_Space),
			!event.isARepeat,
			event.modifierFlags.intersection(.deviceIndependentFlagsMask).isEmpty,
			overlayWindow?.isVisible == true,
			!isQuickSearchOpen,
			!isInEditMode,
			!isEditingAppNote,
			!isModalInteractionActive
			else { return false }

			return true
			}

			private func removeOverlayKeyMonitor() {
			@@ -456,93 +915,88 @@
			}
			}

			private func makeOverlayWindow(on screen: NSScreen) -> NSWindow {
			let panel = OverlayPanel(
			contentRect: screen.frame,
			styleMask: [.borderless, .fullSizeContentView, .nonactivatingPanel],
			backing: .buffered,
			defer: false
			)
			panel.isFloatingPanel = true
			panel.hidesOnDeactivate = false
			panel.collectionBehavior = [
			.moveToActiveSpace,
			.fullScreenAuxiliary,
			.stationary,
			.transient,
			.ignoresCycle
			]
			panel.isOpaque = false
			panel.backgroundColor = .clear
			panel.hasShadow = false
			panel.titlebarAppearsTransparent = true
			panel.titleVisibility = .hidden
			panel.isReleasedWhenClosed = false
			panel.contentView = DismissibleHostingView(
			rootView: ContentView(hideOverlay: { [weak self] in
			self?.hideOverlay(force: true)
			}),
			onBackdropTap: { [weak self] in
			self?.hideOverlay()
			}
			)
			return panel
			private func hideOverlay(force: Bool = false, discardWindow: Bool = false) {
			overlayController.hide(force: force, discardWindow: discardWindow)
			}

			private func hideOverlay(force: Bool = false) {
			guard force \|\| !isInEditMode else { return }
			if let settingsWindow, settingsWindow.parent == overlayWindow {
			detachSettingsWindow(settingsWindow)
			}
			overlayWindow?.orderOut(nil)
			removeOverlayKeyMonitor()
			if force {
			overlayWindow = nil
			}
			// MARK: - Global Hotkeys

			private func registerConfiguredHotkeys() {
			installHotkeyEventHandlerIfNeeded()
			registerFixedHotkey(.main)
			registerFixedHotkey(.quickSearch)
			}

			// MARK: - Global Hotkey (Shift+Option+Space)
			private func registerFixedHotkey(_ kind: LauncherHotkeyKind) {
			unregisterHotkey(for: kind)
			let hotkey = kind.hotkey

			/// Carbon RegisterEventHotKey. If it fails (sandbox, etc.), falls back to menu bar only.
			private func registerHotkey() {
			var hotkeyID = EventHotKeyID()
			hotkeyID.signature = OSType(0x41505447) // 'APTG'
			hotkeyID.id = 1
			hotkeyID.id = kind.eventID

			let modifiers = UInt32(shiftKey \| optionKey)

			var ref: EventHotKeyRef?
			var newRef: EventHotKeyRef?
			let status = RegisterEventHotKey(
			UInt32(kVK_Space),
			modifiers,
			hotkey.keyCode,
			hotkey.modifiers,
			hotkeyID,
			GetApplicationEventTarget(),
			0,
			&ref
			&newRef
			)
			hotkeyRef = ref

			if status != noErr {
			print("[TagLauncher] Hotkey registration failed: \(status). Falling back to menu bar only.")
			return
			if status == noErr, let newRef {
			setHotkeyRef(newRef, for: kind)
			LauncherHotkeyRegistrationStore.setActive(for: kind)
			} else {
			setHotkeyRef(nil, for: kind)
			LauncherHotkeyRegistrationStore.setFailed(status, for: kind)
			print("[TagLauncher] Fixed hotkey registration failed for \(kind.rawValue): \(status)")
			}
			}

			private func observeHotkeyStatusChanges() {
			NotificationCenter.default.addObserver(
			forName: .tagLauncherHotkeyRegistrationChanged,
			object: nil,
			queue: .main
			) { [weak self] _ in
			self?.setupMenuBar()
			self?.configureApplicationMenuWhenAvailable(retries: 2)
			}
			}

			private func installHotkeyEventHandlerIfNeeded() {
			guard !hotkeyEventHandlerInstalled else { return }
			hotkeyEventHandlerInstalled = true

			var eventSpec = EventTypeSpec(
			eventClass: OSType(kEventClassKeyboard),
			eventKind: UInt32(kEventHotKeyPressed)
			)

			let selfPtr = Unmanaged.passUnretained(self).toOpaque()

			InstallEventHandler(
			GetApplicationEventTarget(),
			{ (_, _, userData) -> OSStatus in
			guard let userData else { return noErr }
			{ (_, event, userData) -> OSStatus in
			guard let event, let userData else { return noErr }
			var hotkeyID = EventHotKeyID()
			let status = GetEventParameter(
			event,
			EventParamName(kEventParamDirectObject),
			EventParamType(typeEventHotKeyID),
			nil,
			MemoryLayout<EventHotKeyID>.size,
			nil,
			&hotkeyID
			)
			guard status == noErr else { return noErr }

			let delegate = Unmanaged<AppDelegate>
			.fromOpaque(userData)
			.takeUnretainedValue()
			DispatchQueue.main.async {
			delegate.toggleOverlay()
			delegate.handleHotkeyEvent(id: hotkeyID.id)
			}
			return noErr
			},
			@@ -551,6 +1005,47 @@
			selfPtr,
			nil
			)
			}

			private func handleHotkeyEvent(id: UInt32) {
			if id == LauncherHotkeyKind.quickSearch.eventID {
			showQuickSearchFromGlobalHotkey()
			} else {
			performToggleOverlay(preferredScreen: nil)
			}
			}

			private func showQuickSearchFromGlobalHotkey() {
			if overlayWindow?.isVisible == true {
			refreshLauncherChromeState(
			activate: !overlayAvoidsSpaceSwitch,
			avoidSpaceSwitch: overlayAvoidsSpaceSwitch
			)
			requestQuickSearch(source: QuickSearchOpenSource.globalVisible)
			return
			}
			showOverlay(initialQuickSearchSource: QuickSearchOpenSource.globalHidden)
			}

			private func hotkeyRef(for kind: LauncherHotkeyKind) -> EventHotKeyRef? {
			switch kind {
			case .main: return mainHotkeyRef
			case .quickSearch: return quickSearchHotkeyRef
			}
			}

			private func setHotkeyRef(_ ref: EventHotKeyRef?, for kind: LauncherHotkeyKind) {
			switch kind {
			case .main: mainHotkeyRef = ref
			case .quickSearch: quickSearchHotkeyRef = ref
			}
			}

			private func unregisterHotkey(for kind: LauncherHotkeyKind) {
			if let ref = hotkeyRef(for: kind) {
			UnregisterEventHotKey(ref)
			setHotkeyRef(nil, for: kind)
			}
			}

			// MARK: - Preferences
			@@ -569,6 +1064,23 @@
			!self.isInEditMode
			else { return }

			if self.isSettingsOwnedPanel(keyWindow) {
			return
			}

			if self.isMenuTrackingWindow(keyWindow) {
			return
			}

			if self.isAppOwnedDocumentWindow(keyWindow) {
			self.prepareSettingsWindow(keyWindow)
			return
			}

			if NSApp.windows.contains(keyWindow) {
			return
			}

			// Settings/Preferences window -> float it above overlay for real-time preview.
			if self.isSettingsWindowCandidate(keyWindow) {
			self.prepareSettingsWindow(keyWindow)
			@@ -581,6 +1093,7 @@

			/// Settings must always appear centered over the current overlay view and float above it.
			private func prepareSettingsWindow(_ window: NSWindow) {
			dismissQuickSearchIfNeeded()
			let settingsSize = NSSize(width: 880, height: 460)
			window.identifier = NSUserInterfaceItemIdentifier("TagLauncherPreferencesWindow")
			window.minSize = settingsSize
			@@ -604,11 +1117,20 @@

			var behavior = window.collectionBehavior
			behavior.remove(.canJoinAllSpaces)
			behavior.formUnion([.fullScreenAuxiliary, .moveToActiveSpace])
			if overlayAvoidsSpaceSwitch {
			behavior.remove(.moveToActiveSpace)
			behavior.formUnion([.fullScreenAuxiliary, .stationary, .transient, .ignoresCycle])
			} else {
			behavior.formUnion([.fullScreenAuxiliary, .moveToActiveSpace])
			}
			window.collectionBehavior = behavior
			window.makeKeyAndOrderFront(nil)
			window.orderFrontRegardless()
			settingsWindow = window
			refreshLauncherChromeState(
			activate: !overlayAvoidsSpaceSwitch,
			avoidSpaceSwitch: overlayAvoidsSpaceSwitch
			)
			}

			private func attachSettingsWindow(_ window: NSWindow, to overlayWindow: NSWindow) {
			@@ -625,12 +1147,56 @@
			private func isSettingsWindowCandidate(_ window: NSWindow) -> Bool {
			if window == settingsWindow { return true }
			if window.identifier?.rawValue == "TagLauncherPreferencesWindow" { return true }
			if isAppOwnedDocumentWindow(window) { return true }
			guard NSApp.windows.contains(window),
			window != overlayWindow,
			window.isVisible,
			!(window is NSPanel)
			else { return false }
			return true
			return settingsWindowTitleCandidates().contains(normalizedWindowTitle(window.title))
			}

			private func isAppOwnedDocumentWindow(_ window: NSWindow) -> Bool {
			NSApp.windows.contains(window)
			&& window != overlayWindow
			&& window.isVisible
			&& !(window is NSPanel)
			&& !isMenuTrackingWindow(window)
			&& window.styleMask.contains(.titled)
			}

			private func isMenuTrackingWindow(_ window: NSWindow) -> Bool {
			let className = NSStringFromClass(type(of: window))
			return className.localizedCaseInsensitiveContains("Menu")
			\|\| className.localizedCaseInsensitiveContains("Popup")
			}

			private func settingsWindowTitleCandidates() -> Set<String> {
			let keys = [
			"menu.preferences",
			"settings.language",
			"settings.general",
			"quickSearch.hotkeys",
			"settings.tags",
			"settings.data",
			"settings.about"
			]
			return Set(keys.map { normalizedWindowTitle(tr($0)) })
			}

			private func normalizedWindowTitle(_ title: String) -> String {
			title
			.replacingOccurrences(of: "…", with: "")
			.trimmingCharacters(in: .whitespacesAndNewlines)
			}

			private func isSettingsOwnedPanel(_ window: NSWindow) -> Bool {
			guard window is NSPanel else { return false }
			if window is NSSavePanel { return true }
			guard let settingsWindow else { return false }
			return window.sheetParent == settingsWindow
			\|\| settingsWindow.attachedSheet == window
			\|\| window.parent == settingsWindow
			}

			private func center(_ window: NSWindow, over rect: NSRect) {
			@@ -643,10 +1209,7 @@
			}

			private func screenUnderMouse() -> NSScreen? {
			let mousePoint = NSEvent.mouseLocation
			return NSScreen.screens.first(where: {
			NSMouseInRect(mousePoint, $0.frame, false)
			}) ?? NSScreen.main ?? NSScreen.screens.first
			overlayController.screenUnderMouse()
			}

			/// Clean up settingsWindow reference when the Settings window closes.
			@@ -660,8 +1223,18 @@
			let closingWindow = notification.object as? NSWindow,
			closingWindow == self.settingsWindow
			else { return }
			let shouldRefocusOverlay = self.isOverlayVisible
			let preferredScreen = self.overlayWindow?.screen
			self.detachSettingsWindow(closingWindow)
			self.settingsWindow = nil
			self.refreshLauncherChromeState(
			activate: shouldRefocusOverlay && !self.overlayAvoidsSpaceSwitch,
			avoidSpaceSwitch: self.overlayAvoidsSpaceSwitch
			)
			guard shouldRefocusOverlay else { return }
			DispatchQueue.main.asyncAfter(deadline: .now() + 0.12) { [weak self] in
			self?.showOrFocusOverlay(preferredScreen: preferredScreen)
			}
			}
			}

			@@ -676,27 +1249,183 @@
			}
			}

			@objc private func openPreferences() {
			/// Keep text-input overlays at the launcher level so Quick Search stays visible in fullscreen Spaces.
			private func observeAppNoteEditing() {
			NotificationCenter.default.addObserver(
			forName: .tagLauncherAppNoteEditingChanged,
			object: nil,
			queue: .main
			) { [weak self] notification in
			guard let self else { return }
			self.isEditingAppNote = (notification.userInfo?["active"] as? Bool) ?? false
			if self.isEditingAppNote {
			self.promoteOverlayToForegroundInput()
			}
			self.updateOverlayLevelForTextInput()
			}
			}

			private func promoteOverlayToForegroundInput() {
			if overlayAvoidsSpaceSwitch {
			refreshLauncherChromeState(activate: false, avoidSpaceSwitch: true)
			guard let overlayWindow else { return }
			overlayWindow.makeKeyAndOrderFront(nil)
			overlayWindow.orderFrontRegardless()
			return
			}
			beginLauncherForegroundOwnership()
			guard let overlayWindow else { return }
			overlayWindow.makeKeyAndOrderFront(nil)
			overlayWindow.orderFrontRegardless()
			}

			private func observeQuickSearch() {
			NotificationCenter.default.addObserver(
			forName: .tagLauncherQuickSearchVisibilityChanged,
			object: nil,
			queue: .main
			) { [weak self] notification in
			guard let self else { return }
			self.isQuickSearchOpen = (notification.userInfo?["active"] as? Bool) ?? false
			if self.isQuickSearchOpen {
			self.promoteOverlayToForegroundInput()
			}
			self.updateOverlayLevelForTextInput()
			if self.isQuickSearchOpen {
			self.installQuickSearchExternalMouseMonitor()
			} else {
			self.removeQuickSearchExternalMouseMonitor()
			}
			}

			NotificationCenter.default.addObserver(
			forName: .tagLauncherModalInteractionChanged,
			object: nil,
			queue: .main
			) { [weak self] notification in
			self?.isModalInteractionActive = (notification.userInfo?["active"] as? Bool) ?? false
			}

			NotificationCenter.default.addObserver(
			forName: NSApplication.didResignActiveNotification,
			object: NSApp,
			queue: .main
			) { [weak self] _ in
			self?.handleApplicationDidResignActive()
			}
			}

			private func installQuickSearchExternalMouseMonitor() {
			installQuickSearchLocalMouseMonitor()
			guard quickSearchExternalMouseMonitor == nil else { return }
			quickSearchExternalMouseMonitor = NSEvent.addGlobalMonitorForEvents(
			matching: [.leftMouseDown, .rightMouseDown, .otherMouseDown]
			) { [weak self] _ in
			DispatchQueue.main.async {
			guard self?.isQuickSearchOpen == true else { return }
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			}
			}
			}

			private func installQuickSearchLocalMouseMonitor() {
			guard quickSearchLocalMouseMonitor == nil else { return }
			quickSearchLocalMouseMonitor = NSEvent.addLocalMonitorForEvents(
			matching: [.leftMouseDown, .rightMouseDown, .otherMouseDown]
			) { [weak self] event in
			guard let self, self.isQuickSearchOpen else { return event }
			if event.window === self.overlayWindow {
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			return nil
			}
			return event
			}
			}

			private func removeQuickSearchExternalMouseMonitor() {
			if let quickSearchLocalMouseMonitor {
			NSEvent.removeMonitor(quickSearchLocalMouseMonitor)
			self.quickSearchLocalMouseMonitor = nil
			}
			if let quickSearchExternalMouseMonitor {
			NSEvent.removeMonitor(quickSearchExternalMouseMonitor)
			self.quickSearchExternalMouseMonitor = nil
			}
			}

			private func updateOverlayLevelForTextInput() {
			guard let overlayWindow else { return }
			overlayWindow.level = currentOverlayLevel
			if let settingsWindow, settingsWindow.parent == overlayWindow {
			settingsWindow.level = overlayWindow.level
			}
			}

			/// The overlay buttons live inside SwiftUI; use an app-level notification like edit mode does.
			private func observePreferencesRequests() {
			NotificationCenter.default.addObserver(
			forName: .tagLauncherOpenPreferencesRequested,
			object: nil,
			queue: .main
			) { [weak self] _ in
			self?.openPreferences()
			}
			}

			private func observeExternalActivationRequests() {
			DistributedNotificationCenter.default().addObserver(
			self,
			selector: #selector(handleExternalActivationRequest(_:)),
			name: Self.externalActivationNotification,
			object: Self.externalActivationObject
			)
			}

			@objc private func handleExternalActivationRequest(_ notification: Notification) {
			let shouldShowOverlay = notification.userInfo?["showOverlay"] as? Bool ?? true
			guard shouldShowOverlay else { return }
			showOrFocusOverlay()
			}

			@objc private func openPreferences(_ sender: Any? = nil) {
			dismissQuickSearchIfNeeded()
			TagDatabase.flushPendingCategorySchemeBackupBatch()
			if overlayAvoidsSpaceSwitch {
			refreshLauncherChromeState(activate: false, avoidSpaceSwitch: true)
			} else {
			beginLauncherForegroundOwnership()
			}
			// Don't hide overlay — keep it visible for real-time setting preview.
			if let overlayWindow, overlayWindow.isVisible {
			overlayWindow.makeKeyAndOrderFront(nil)
			overlayWindow.orderFrontRegardless()
			}
			NSApp.sendAction(Selector(("showSettingsWindow:")), to: nil, from: nil)
			prepareSettingsWindowWhenAvailable(retries: 10)

			if let settingsWindow {
			prepareSettingsWindow(settingsWindow)
			return
			}

			let settingsSize = NSSize(width: 880, height: 460)
			let window = NSWindow(
			contentRect: NSRect(origin: .zero, size: settingsSize),
			styleMask: [.titled, .closable],
			backing: .buffered,
			defer: false
			)
			window.title = tr("menu.preferences").replacingOccurrences(of: "…", with: "")
			window.contentView = NSHostingView(rootView: PreferencesView())
			window.isReleasedWhenClosed = false
			settingsWindow = window
			prepareSettingsWindow(window)
			}

			private func prepareSettingsWindowWhenAvailable(retries: Int) {
			DispatchQueue.main.asyncAfter(deadline: .now() + 0.03) { [weak self] in
			guard let self else { return }
			let candidates = NSApp.windows.filter { window in
			self.isSettingsWindowCandidate(window)
			}
			candidates.forEach { self.prepareSettingsWindow($0) }
			if candidates.isEmpty && retries > 0 {
			self.prepareSettingsWindowWhenAvailable(retries: retries - 1)
			}
			}
			private func dismissQuickSearchIfNeeded() {
			guard isQuickSearchOpen else { return }
			isQuickSearchOpen = false
			removeQuickSearchExternalMouseMonitor()
			updateOverlayLevelForTextInput()
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			}

			@objc private func switchLanguage(_ sender: NSMenuItem) {
			@@ -709,19 +1438,46 @@

			final class DismissibleHostingView<Content: View>: NSHostingView<Content> {
			private let onBackdropTap: () -> Void
			private var modalInteractionSuppressesBackdropDismiss = false
			private var quickSearchSuppressesBackdropDismiss = false
			private var modalInteractionObserver: NSObjectProtocol?
			private var quickSearchVisibilityObserver: NSObjectProtocol?

			private var suppressBackdropDismiss: Bool {
			modalInteractionSuppressesBackdropDismiss \|\| quickSearchSuppressesBackdropDismiss
			}

			@MainActor required init(rootView: Content) {
			self.onBackdropTap = {}
			super.init(rootView: rootView)
			installWindowServerAnchorLayer()
			observeBackdropDismissSuppressionChanges()
			}

			init(rootView: Content, onBackdropTap: @escaping () -> Void) {
			self.onBackdropTap = onBackdropTap
			super.init(rootView: rootView)
			installWindowServerAnchorLayer()
			observeBackdropDismissSuppressionChanges()
			}

			deinit {
			if let modalInteractionObserver {
			NotificationCenter.default.removeObserver(modalInteractionObserver)
			}
			if let quickSearchVisibilityObserver {
			NotificationCenter.default.removeObserver(quickSearchVisibilityObserver)
			}
			}

			@available(*, unavailable)
			required init?(coder: NSCoder) { fatalError() }

			private func installWindowServerAnchorLayer() {
			wantsLayer = true
			// A near-transparent backing pixel makes the WindowServer publish the panel immediately.
			layer?.backgroundColor = NSColor.black.withAlphaComponent(0.001).cgColor
			}

			override func mouseDown(with event: NSEvent) {
			let location = convert(event.locationInWindow, from: nil)
			@@ -730,7 +1486,19 @@
			return
			}
			if hit == self {
			if quickSearchSuppressesBackdropDismiss {
			NotificationCenter.default.post(name: .tagLauncherQuickSearchDismissRequested, object: nil)
			return
			}
			if suppressBackdropDismiss {
			super.mouseDown(with: event)
			return
			}
			onBackdropTap()
			return
			}
			if let floatingButton = findFloatingIconButton(at: event.locationInWindow, in: self) {
			floatingButton.mouseDown(with: event)
			return
			}
			// Recursively search hit subtree for TextFieldContainer or NSTextField.
			@@ -745,12 +1513,25 @@
			tf.mouseDown(with: event)
			return
			}
			// Forward to any other NSControl we find
			if let control = findNSControl(in: hit) {
			control.mouseDown(with: event)
			return
			}
			super.mouseDown(with: event)
			}

			private func observeBackdropDismissSuppressionChanges() {
			modalInteractionObserver = NotificationCenter.default.addObserver(
			forName: .tagLauncherModalInteractionChanged,
			object: nil,
			queue: .main
			) { [weak self] notification in
			self?.modalInteractionSuppressesBackdropDismiss = (notification.userInfo?["active"] as? Bool) ?? false
			}

			quickSearchVisibilityObserver = NotificationCenter.default.addObserver(
			forName: .tagLauncherQuickSearchVisibilityChanged,
			object: nil,
			queue: .main
			) { [weak self] notification in
			self?.quickSearchSuppressesBackdropDismiss = (notification.userInfo?["active"] as? Bool) ?? false
			}
			}

			private func findTextFieldContainer(in view: NSView) -> TextFieldContainer? {
			@@ -769,562 +1550,18 @@
			return nil
			}

			private func findNSControl(in view: NSView) -> NSControl? {
			if let control = view as? NSControl { return control }
			for sub in view.subviews {
			if let found = findNSControl(in: sub) { return found }
			private func findFloatingIconButton(at windowPoint: NSPoint, in view: NSView) -> FloatingIconButtonView? {
			for subview in view.subviews.reversed() where !subview.isHidden {
			if let found = findFloatingIconButton(at: windowPoint, in: subview) {
			return found
			}
			}
			guard let floatingButton = view as? FloatingIconButtonView else { return nil }
			let localPoint = floatingButton.convert(windowPoint, from: nil)
			if floatingButton.bounds.contains(localPoint) {
			return floatingButton
			}
			return nil
			}
			}

			// MARK: - Preferences View

			struct PreferencesView: View {
			private let settingsWindowWidth: CGFloat = 880
			private let settingsContentWidth: CGFloat = 820
			private let generalContentWidth: CGFloat = 720
			private let generalLabelWidth: CGFloat = 190
			private let generalControlWidth: CGFloat = 500
			private let compactPickerWidth: CGFloat = 320

			@AppStorage("tagFontSize") private var tagFontSize: Double = 18
			@AppStorage("iconSize") private var iconSize: Double = 56
			@AppStorage("tagPosition") private var tagPosition = "left"
			@AppStorage("defaultGroupName") private var defaultGroupName = "Other"
			@AppStorage("displayMode") private var displayMode = "flat"
			@AppStorage("hideAppNames") private var hideAppNames = false
			@AppStorage("showDockIcon") private var showDockIcon = false
			@AppStorage("launchAtLogin") private var launchAtLogin = true
			@AppStorage("showUncommonAppBubbles") private var showUncommonAppBubbles = true
			@State private var selectedLanguage = L10n.currentCode
			@State private var isRefreshingLanguage = false
			@State private var allApps: [AppInfo] = []
			@State private var tagColors: [String: Int] = [:]

			private func scanApps() {
			DispatchQueue.global(qos: .userInitiated).async {
			var apps = AppIndexer.scan()
			let store = TagDatabase.load()
			apps = TagEditor.annotate(apps: apps)
			let colors = store.tags.mapValues { $0.color }
			DispatchQueue.main.async {
			allApps = apps
			tagColors = colors
			}
			}
			}

			private func exportTags() {
			let panel = NSSavePanel()
			panel.title = tr("settings.export")
			panel.nameFieldStringValue = "TagLauncher-tags.json"
			panel.allowedContentTypes = [.json]
			panel.begin { response in
			guard response == .OK, let url = panel.url else { return }
			do {
			try TagDatabase.exportTo(url)
			} catch {
			fputs("[TagLauncher] Export failed: \(error)\n", stderr)
			showDataAlert(title: tr("settings.exportFailed"), message: error.localizedDescription)
			}
			}
			}

			private func importTags() {
			let panel = NSOpenPanel()
			panel.title = tr("settings.import")
			panel.allowedContentTypes = [.json]
			panel.allowsMultipleSelection = false
			panel.begin { response in
			guard response == .OK, let url = panel.url else { return }
			do {
			_ = try TagDatabase.importFrom(url)
			scanApps()
			} catch {
			fputs("[TagLauncher] Import failed: \(error)\n", stderr)
			showDataAlert(title: tr("settings.importFailed"), message: error.localizedDescription)
			}
			}
			}

			private func showDataAlert(title: String, message: String) {
			let alert = NSAlert()
			alert.messageText = title
			alert.informativeText = message
			alert.alertStyle = .warning
			alert.runModal()
			}

			private var appVersion: String {
			Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String ?? "?"
			}
			private var buildVersion: String {
			Bundle.main.infoDictionary?["CFBundleVersion"] as? String ?? "?"
			}
			private var languageColumns: [GridItem] {
			[
			GridItem(.flexible(minimum: 220), spacing: 18, alignment: .top),
			GridItem(.flexible(minimum: 220), spacing: 18, alignment: .top),
			]
			}
			private var displayModeColumns: [GridItem] {
			[
			GridItem(.flexible(minimum: 220), spacing: 10, alignment: .top),
			GridItem(.flexible(minimum: 220), spacing: 10, alignment: .top),
			]
			}
			private var displayModeOptions: [(id: String, title: String)] {
			[
			("flat", tr("settings.flat")),
			("container", tr("settings.container")),
			("coloredContainer", tr("settings.coloredContainer")),
			("gridContainer", tr("settings.gridContainer")),
			("coloredGridContainer", tr("settings.coloredGridContainer")),
			]
			}
			private var containerDisplayModeOptions: [(id: String, title: String)] {
			Array(displayModeOptions.dropFirst())
			}

			private func generalSettingRow<Control: View>(
			_ label: String,
			description: String,
			@ViewBuilder control: () -> Control
			) -> some View {
			HStack(alignment: .top, spacing: 16) {
			Text(label)
			.font(.system(size: 14, weight: .semibold))
			.multilineTextAlignment(.trailing)
			.lineLimit(2)
			.minimumScaleFactor(0.86)
			.frame(width: generalLabelWidth, alignment: .trailing)
			.padding(.top, 5)

			VStack(alignment: .leading, spacing: 6) {
			control()
			.frame(width: generalControlWidth, alignment: .leading)
			Text(description)
			.font(.caption)
			.foregroundStyle(.secondary)
			.multilineTextAlignment(.leading)
			.fixedSize(horizontal: false, vertical: true)
			.frame(width: generalControlWidth, alignment: .leading)
			}
			}
			.frame(width: generalContentWidth, alignment: .leading)
			}

			var body: some View {
			ZStack {
			TabView {
			// Tab 1: Language
			VStack(alignment: .leading, spacing: 10) {
			Text(tr("settings.language"))
			.font(.headline)
			Text(tr("settings.languageDesc"))
			.font(.caption)
			.foregroundStyle(.secondary)

			ScrollView {
			LazyVGrid(columns: languageColumns, alignment: .leading, spacing: 6) {
			ForEach(L10n.supported, id: \.code) { language in
			Button {
			selectedLanguage = language.code
			} label: {
			HStack(spacing: 8) {
			Image(systemName: selectedLanguage == language.code ? "checkmark" : "circle")
			.font(.system(size: 12, weight: .semibold))
			.foregroundStyle(selectedLanguage == language.code ? Color.accentColor : Color.secondary.opacity(0.28))
			.frame(width: 16)
			Text(language.name)
			.foregroundStyle(.primary)
			.lineLimit(1)
			.truncationMode(.tail)
			Spacer(minLength: 0)
			}
			.padding(.horizontal, 8)
			.padding(.vertical, 5)
			.contentShape(Rectangle())
			}
			.buttonStyle(.plain)
			.accessibilityLabel("\(tr("settings.languagePicker")) \(language.name)")
			}
			}
			.padding(.vertical, 4)
			}
			.frame(maxHeight: 250)

			Spacer(minLength: 0)
			ShortcutHintView()
			.frame(maxWidth: .infinity, alignment: .center)
			.padding(.bottom, 2)
			}
			.frame(maxWidth: settingsContentWidth, alignment: .leading)
			.tabItem { Label(tr("settings.language"), systemImage: "globe") }
			.padding()

			// Tab 2: General
			VStack(alignment: .leading, spacing: 0) {
			// Toggle row — centered as a rectangular block
			HStack(spacing: 20) {
			if AppDelegate.supportsLaunchAtLogin {
			Toggle(tr("settings.launchAtLogin"), isOn: $launchAtLogin)
			.onChange(of: launchAtLogin) { _, enabled in
			if enabled {
			AppDelegate.enableLaunchAtLogin()
			} else {
			AppDelegate.disableLaunchAtLogin()
			}
			}
			}
			Toggle(tr("settings.showInDock"), isOn: $showDockIcon)
			.onChange(of: showDockIcon) { _, _ in
			AppDelegate.refreshChromeSettings()
			}
			Toggle(tr("settings.hideAppNames"), isOn: $hideAppNames)
			}
			.frame(maxWidth: .infinity, alignment: .center)
			.padding(.bottom, 16)

			Divider()
			.padding(.bottom, 16)

			VStack(spacing: 18) {
			generalSettingRow(tr("settings.appListStyle"), description: tr("settings.flatDesc")) {
			VStack(spacing: 8) {
			DisplayModeOptionButton(
			mode: "flat",
			title: tr("settings.flat"),
			isSelected: displayMode == "flat"
			) {
			displayMode = "flat"
			}

			LazyVGrid(columns: displayModeColumns, alignment: .leading, spacing: 8) {
			ForEach(containerDisplayModeOptions, id: \.id) { option in
			DisplayModeOptionButton(
			mode: option.id,
			title: option.title,
			isSelected: displayMode == option.id
			) {
			displayMode = option.id
			}
			}
			}
			}
			.frame(width: generalControlWidth, alignment: .leading)
			}

			generalSettingRow(tr("settings.tagPosition"), description: tr("settings.tagPosDesc")) {
			Picker("", selection: $tagPosition) {
			Text(tr("settings.left")).tag("left")
			Text(tr("settings.right")).tag("right")
			Text(tr("settings.top")).tag("top")
			}
			.pickerStyle(.segmented)
			.frame(width: compactPickerWidth, alignment: .leading)
			}

			generalSettingRow(tr("settings.tagFontSize"), description: tr("settings.tagFontDesc")) {
			Picker("", selection: $tagFontSize) {
			ForEach([16.0, 18.0, 20.0, 22.0, 24.0, 26.0], id: \.self) { size in
			Text("\(Int(size))").tag(size)
			}
			}
			.pickerStyle(.segmented)
			.frame(width: compactPickerWidth, alignment: .leading)
			}

			generalSettingRow(tr("settings.iconSize"), description: tr("settings.iconSizeDesc")) {
			Picker("", selection: $iconSize) {
			ForEach([40.0, 48.0, 56.0, 64.0, 72.0, 80.0], id: \.self) { size in
			Text("\(Int(size))").tag(size)
			}
			}
			.pickerStyle(.segmented)
			.frame(width: compactPickerWidth, alignment: .leading)
			}
			}
			}
			.frame(maxWidth: generalContentWidth, alignment: .center)
			.padding()
			.tabItem { Label(tr("settings.general"), systemImage: "gearshape") }

			// Tab 3: Tags
			VStack(spacing: 0) {
			TagEditorView(
			tagColors: $tagColors,
			excludedTagNames: ["Mac自带", defaultGroupName],
			onRefresh: { scanApps() }
			)
			}
			.padding(.leading, 16)
			.tabItem { Label(tr("settings.tags"), systemImage: "tag.fill") }
			.onAppear { scanApps() }

			// Tab 4: Data
			VStack(spacing: 0) {
			Spacer(minLength: 54)

			VStack(alignment: .leading, spacing: 5) {
			Toggle(tr("settings.uncommonBubble"), isOn: $showUncommonAppBubbles)
			.font(.system(size: 13, weight: .medium))
			Text(tr("settings.uncommonBubbleDesc"))
			.font(.caption)
			.foregroundStyle(.secondary)
			.fixedSize(horizontal: false, vertical: true)
			}
			.frame(width: 420, alignment: .leading)

			Spacer(minLength: 28)

			VStack(alignment: .leading, spacing: 8) {
			Text(tr("settings.backup"))
			.font(.headline)
			HStack(spacing: 12) {
			Button(tr("settings.export")) { exportTags() }
			.buttonStyle(.bordered)
			Button(tr("settings.import")) { importTags() }
			.buttonStyle(.bordered)
			}
			Text(tr("settings.backupDesc"))
			.font(.caption)
			.foregroundStyle(.secondary)
			}
			.frame(width: 420, alignment: .leading)

			Spacer(minLength: 42)
			ShortcutHintView()
			.frame(maxWidth: .infinity, alignment: .center)
			Spacer(minLength: 18)
			}
			.tabItem { Label(tr("settings.data"), systemImage: "externaldrive.fill") }
			.padding()

			// Tab 5: About
			VStack(spacing: 0) {
			Spacer(minLength: 72)

			HStack {
			if let icon = NSImage(named: NSImage.applicationIconName) {
			Image(nsImage: icon)
			.resizable()
			.frame(width: 128, height: 128)
			}
			VStack(alignment: .leading, spacing: 4) {
			Text("TagLauncher")
			.font(.title2)
			.fontWeight(.semibold)
			Text(tr("app.description"))
			.font(.body)
			.foregroundStyle(.secondary)
			Text("\(tr("app.version")) \(appVersion) (\(tr("app.build")) \(buildVersion))")
			.font(.callout)
			.foregroundStyle(.tertiary)

			Divider()
			.padding(.vertical, 4)

			Text("万物之中，希望最美")
			.font(.caption)
			.foregroundStyle(.secondary)
			Text("永桔@2026-18602102518")
			.font(.caption)
			.foregroundStyle(.secondary)
			}
			}
			.frame(width: 560, alignment: .leading)

			Spacer(minLength: 30)
			ShortcutHintView()
			.frame(maxWidth: .infinity, alignment: .center)
			Spacer(minLength: 18)
			}
			.tabItem { Label(tr("settings.about"), systemImage: "info.circle") }
			.padding()
			}
			.onChange(of: selectedLanguage) { _, code in
			L10n.switchTo(code)
			}
			.onReceive(NotificationCenter.default.publisher(for: .appLanguageDidChange)) { notification in
			if let code = notification.userInfo?["code"] as? String {
			selectedLanguage = code
			}
			showLanguageRefresh()
			}

			if isRefreshingLanguage {
			ZStack {
			Color(nsColor: .windowBackgroundColor)
			.opacity(0.84)
			Image(systemName: "arrow.clockwise")
			.font(.system(size: 30, weight: .regular))
			.symbolRenderingMode(.hierarchical)
			.foregroundStyle(.secondary)
			}
			.transition(.opacity)
			}
			}
			.frame(width: settingsWindowWidth, height: 460)
			}

			private func showLanguageRefresh() {
			isRefreshingLanguage = true
			DispatchQueue.main.asyncAfter(deadline: .now() + 0.35) {
			withAnimation(.easeOut(duration: 0.18)) {
			isRefreshingLanguage = false
			}
			}
			}
			}

			private struct DisplayModeOptionButton: View {
			let mode: String
			let title: String
			let isSelected: Bool
			let action: () -> Void

			var body: some View {
			Button(action: action) {
			HStack(spacing: 7) {
			DisplayModeGlyph(mode: mode, isSelected: isSelected)
			.frame(width: 24, height: 18)
			Text(title)
			.font(.system(size: 13, weight: .semibold))
			.multilineTextAlignment(.center)
			.lineLimit(2)
			.minimumScaleFactor(0.82)
			.foregroundStyle(isSelected ? Color.white : Color.primary)
			.frame(maxWidth: .infinity)
			}
			.frame(maxWidth: .infinity, minHeight: 34)
			.padding(.horizontal, 9)
			.padding(.vertical, 2)
			.background(
			RoundedRectangle(cornerRadius: 7, style: .continuous)
			.fill(isSelected ? Color.accentColor : Color(nsColor: .controlBackgroundColor))
			)
			.overlay(
			RoundedRectangle(cornerRadius: 7, style: .continuous)
			.stroke(isSelected ? Color.accentColor : Color.secondary.opacity(0.18), lineWidth: 1)
			)
			.contentShape(RoundedRectangle(cornerRadius: 7, style: .continuous))
			}
			.buttonStyle(.plain)
			.accessibilityLabel(title)
			}
			}

			private struct DisplayModeGlyph: View {
			let mode: String
			let isSelected: Bool

			var body: some View {
			switch mode {
			case "flat":
			HStack(spacing: 2) {
			cell(index: 0, width: 5, height: 5, colored: false)
			cell(index: 1, width: 5, height: 5, colored: false)
			cell(index: 2, width: 5, height: 5, colored: false)
			}
			case "gridContainer", "coloredGridContainer":
			let colored = mode == "coloredGridContainer"
			VStack(spacing: 2) {
			HStack(spacing: 2) {
			cell(index: 0, width: 7, height: 6, colored: colored)
			cell(index: 1, width: 7, height: 6, colored: colored)
			}
			HStack(spacing: 2) {
			cell(index: 2, width: 7, height: 6, colored: colored)
			cell(index: 3, width: 7, height: 6, colored: colored)
			}
			}
			default:
			let colored = mode == "coloredContainer"
			HStack(alignment: .bottom, spacing: 2) {
			cell(index: 0, width: 5, height: 8, colored: colored)
			cell(index: 1, width: 5, height: 14, colored: colored)
			cell(index: 2, width: 5, height: 10, colored: colored)
			}
			}
			}

			private func cell(index: Int, width: CGFloat, height: CGFloat, colored: Bool) -> some View {
			let fill = fillColor(index: index, colored: colored)
			let stroke = isSelected ? Color.white.opacity(0.95) : Color.secondary.opacity(0.35)
			return RoundedRectangle(cornerRadius: 1.8, style: .continuous)
			.fill(fill)
			.overlay(
			RoundedRectangle(cornerRadius: 1.8, style: .continuous)
			.stroke(stroke, lineWidth: 0.8)
			)
			.frame(width: width, height: height)
			}

			private func fillColor(index: Int, colored: Bool) -> Color {
			if isSelected {
			return Color.white.opacity(colored ? 0.9 : 0.18)
			}
			guard colored else {
			return Color.secondary.opacity(0.12)
			}
			let palette: [Color] = [.green, .purple, .blue, .orange]
			return palette[index % palette.count].opacity(0.78)
			}
			}

			private struct ShortcutHintView: View {
			var body: some View {
			HStack(spacing: 12) {
			ShortcutKeycap(symbol: "⌥")
			Text("+")
			.font(.system(size: 22, weight: .semibold))
			.foregroundStyle(.tertiary)
			ShortcutKeycap(symbol: "⇧")
			Text("+")
			.font(.system(size: 22, weight: .semibold))
			.foregroundStyle(.tertiary)
			SpacebarKeycap()
			}
			.accessibilityLabel("⌥ ⇧ Space")
			.allowsHitTesting(false)
			}
			}

			private struct ShortcutKeycap: View {
			let symbol: String

			var body: some View {
			Text(symbol)
			.font(.system(size: 36, weight: .medium))
			.foregroundStyle(.secondary)
			.frame(width: 74, height: 58)
			.background(KeycapBackground())
			}
			}

			private struct SpacebarKeycap: View {
			var body: some View {
			ZStack {
			KeycapBackground()
			Capsule()
			.fill(Color.secondary.opacity(0.38))
			.frame(width: 72, height: 3)
			.offset(y: 13)
			}
			.frame(width: 190, height: 58)
			}
			}

			private struct KeycapBackground: View {
			var body: some View {
			RoundedRectangle(cornerRadius: 10, style: .continuous)
			.fill(Color(nsColor: .controlBackgroundColor))
			.overlay(
			RoundedRectangle(cornerRadius: 10, style: .continuous)
			.stroke(Color.primary.opacity(0.12), lineWidth: 1)
			)
			.shadow(color: .black.opacity(0.10), radius: 8, x: 0, y: 3)
			}
			}