@lattices/cli 0.4.2 → 0.4.6

package/docs/component-extraction-roadmap.md

@@ -0,0 +1,392 @@
+# Component Extraction Roadmap
+
+This note turns a codebase review into an incremental component plan for `lattices`.
+
+The goal is not to rewrite the app around a new architecture in one move. The goal is to extract a few reusable primitives that make future features cheaper:
+
+- a cmdcmd-style visual window or session switcher
+- one shared action model across hotkeys, palette, voice, daemon, and companion
+- less duplicated window lookup, space lookup, and preview logic
+
+## Why this exists
+
+Three pressure points showed up repeatedly:
+
+1. `WindowTiler.swift` acts like several libraries at once.
+2. action definitions exist in multiple parallel forms.
+3. overlay and panel shells are repeatedly rebuilt per surface.
+
+The result is that new UX surfaces often have to re-solve the same problems:
+
+- how to find a target window
+- how to map a user intent to a canonical action
+- how to show a floating interactive surface
+- how to capture and render previews
+
+## Current duplication seams
+
+### 1. Window and session lookup
+
+The same session-tagged window matching idea appears in multiple places:
+
+- `DesktopModel.windowForSession(...)`
+- tag parsing during desktop polling
+- CG window lookup paths in `WindowTiler`
+- AX window lookup paths in `WindowTiler`
+
+This is the strongest candidate for a single reusable locator.
+
+### 2. Space topology and window membership
+
+Display-space maps, current-space discovery, and window-space membership are rebuilt in several flows instead of being queried from one read model.
+
+This makes space-aware features harder than they need to be:
+
+- move window to space
+- present window on the current space
+- show where a session already lives
+- build a visual desktop map
+
+### 3. Window presentation and motion
+
+`tile`, `present`, `batchMoveAndRaiseWindows`, and related paths all contain their own versions of:
+
+- resolve target
+- move or resize
+- raise
+- activate app
+- mark interaction
+
+That sequencing should be owned by one operation layer.
+
+### 4. Preview capture and preview rendering
+
+The codebase already has useful preview pieces, but they live in separate pockets:
+
+- `WindowPreviewStore` in `HUDRightBar.swift`
+- preview placeholder and preview card variants in HUD
+- separate preview capture in `ScreenMapState.swift`
+
+This is a strong signal that preview should become its own reusable subsystem.
+
+### 5. Action definitions
+
+Action and intent metadata currently live in several places:
+
+- `HotkeyStore.swift`
+- `PaletteCommand.swift`
+- `IntentEngine.swift`
+- `Intents/LatticeIntent.swift`
+- `LatticesApi.swift`
+
+The sharpest duplication is that `IntentEngine.swift` and `Intents/LatticeIntent.swift` each define their own intent schema.
+
+### 6. Overlay and panel shells
+
+There is already a useful shared primitive for normal app windows in `AppWindowShell.swift`, but overlay surfaces still rebuild similar shell code:
+
+- `CommandPaletteWindow.swift`
+- `OmniSearchWindow.swift`
+- `VoiceCommandWindow.swift`
+- `LauncherHUD.swift`
+
+The repeated shell concerns are:
+
+- `NSPanel` setup
+- blur and rounded-mask container setup
+- screen placement
+- activation and dismissal behavior
+- event monitor lifecycle
+
+## Proposed reusable components
+
+This is the target component map.
+
+### Desktop substrate
+
+#### `SessionWindowLocator`
+
+Responsibility:
+
+- resolve a lattices session, title tag, app target, or explicit window id into a canonical window target
+- try fast cache lookup first
+- fall back through CG and AX in one place
+
+Why:
+
+- removes repeated session-tag matching logic
+- gives palette, daemon, voice, HUD, and future switchers the same targeting rules
+
+#### `SpaceTopologySnapshot`
+
+Responsibility:
+
+- expose a single read model for displays, spaces, current space, and window-to-space membership
+
+Why:
+
+- prevents repeated recomputation of display-space facts
+- makes space-aware UIs easier to build
+
+#### `WindowPresenter`
+
+Responsibility:
+
+- own the canonical move, resize, raise, activate, and interaction-marking flow
+- support both single-window and batched operations
+
+Why:
+
+- centralizes the side-effect sequence
+- makes future planners and higher-level actions less fragile
+
+#### `WindowPreviewProvider`
+
+Responsibility:
+
+- capture, cache, and serve still previews or live previews for windows
+- separate capture policy from UI rendering
+
+Why:
+
+- avoids HUD and Screen Map each inventing preview behavior
+- directly supports a visual selector or session fan-out
+
+### Action substrate
+
+#### `ActionRegistry`
+
+Responsibility:
+
+- define canonical verbs once
+- own parameter metadata, user-facing labels, phrase templates, and execution hooks
+
+Minimal shape:
+
+```swift
+enum ActionID: String {
+    case openPalette
+    case openSearch
+    case focusWindow
+    case placeWindow
+    case launchProject
+    case switchLayer
+    case killSession
+    case refreshProjects
+}
+
+struct ActionParam {
+    let name: String
+    let type: ActionParamType
+    let required: Bool
+    let values: [String]?
+}
+
+struct ActionDef {
+    let id: ActionID
+    let title: String
+    let params: [ActionParam]
+    let hotkey: HotkeyMeta?
+    let palette: PaletteMeta?
+    let phrases: [String]
+    let run: (ActionContext) throws -> JSON
+}
+```
+
+Why:
+
+- one action identity across hotkeys, palette, voice, daemon, and companion
+- palette rows become runtime bindings of a verb to a target, not bespoke actions
+
+#### `ActionContext`
+
+Responsibility:
+
+- carry structured arguments plus source information like `hotkey`, `palette`, `voice-local`, `daemon`, or `companion`
+
+Why:
+
+- makes execution and logging more consistent
+
+### Overlay substrate
+
+#### `OverlayPanelShell`
+
+Responsibility:
+
+- build a reusable floating `NSPanel` shell from configuration
+- own blur or plain background, corner radius, window level, collection behavior, and hosting setup
+
+Why:
+
+- extracts the shared Spotlight-style panel construction path
+
+#### `OverlayPlacement`
+
+Responsibility:
+
+- centralize placement policies like centered, spotlight offset, top-center, or mouse-screen placement
+
+Why:
+
+- removes repeated `visibleFrame` math
+
+#### `OverlayLifecycleController`
+
+Responsibility:
+
+- own local event monitors, Escape dismissal, deactivate behavior, and cleanup
+
+Why:
+
+- reduces panel-specific lifecycle glue
+
+### UI primitives
+
+#### `WindowPreviewCard`
+
+Responsibility:
+
+- render a window preview, loading state, and unavailable state consistently
+
+Why:
+
+- low-risk first UI extraction
+- immediately reduces duplicated HUD preview rendering
+
+## Recommended extraction order
+
+The sequence below favors leverage without taking unnecessary risk.
+
+### Slice 1: `WindowPreviewCard`
+
+Extract the repeated preview body and placeholder logic from HUD into a shared SwiftUI component.
+
+Why first:
+
+- UI-only
+- already duplicated
+- does not disturb CGS, AX, or window mutation paths
+
+### Slice 2: `OverlayPanelShell`
+
+Extract the shared panel-construction path from `CommandPaletteWindow` and `OmniSearchWindow`.
+
+Why second:
+
+- those two surfaces are the cleanest near-duplicates
+- builds a reusable shell for a future visual selector
+
+### Slice 3: unify intent schema
+
+Remove the parallel intent-definition structures by expanding or reusing the types in `Intents/LatticeIntent.swift` and pointing them at existing execution handlers.
+
+Why third:
+
+- high leverage
+- removes one entire duplicate definition system
+- proves the registry shape before migrating hotkeys or palette
+
+### Slice 4: `SessionWindowLocator`
+
+Centralize session-tagged lookup across DesktopModel and WindowTiler.
+
+Why fourth:
+
+- strongest desktop duplication seam
+- unlocks cleaner action execution and better future switcher targeting
+
+### Slice 5: `SpaceTopologySnapshot`
+
+Create one query layer for display and space topology.
+
+Why fifth:
+
+- stabilizes space-aware features before touching more motion logic
+
+### Slice 6: `WindowPresenter`
+
+Unify move, resize, raise, activate, and interaction-marking flows.
+
+Why sixth:
+
+- this is higher risk because it sits directly on side effects
+- it is safer after lookup and topology are centralized
+
+### Slice 7: `WindowPreviewProvider`
+
+Lift preview capture and caching out of HUD-specific code and reconcile it with Screen Map preview capture.
+
+Why seventh:
+
+- more useful after overlay shell and preview card exist
+- becomes the substrate for a visual window or session chooser
+
+## Features this should unlock
+
+Once the components above exist, the app can add new surfaces with much less bespoke code.
+
+### cmdcmd-style visual switcher
+
+Use:
+
+- `OverlayPanelShell`
+- `OverlayPlacement`
+- `SessionWindowLocator`
+- `WindowPreviewProvider`
+- `WindowPresenter`
+
+Possible behavior:
+
+- fan out lattices sessions or all windows
+- show live or cached previews
+- focus, tile, move to space, or close from one surface
+
+### Shared action surfaces
+
+Use:
+
+- `ActionRegistry`
+- `ActionContext`
+
+Possible behavior:
+
+- define `placeWindow` once
+- trigger it from voice, hotkey, palette, daemon, or companion
+- keep labels and phrases aligned across surfaces
+
+### Stronger planning and preview
+
+Use:
+
+- `ActionRegistry`
+- `WindowPresenter`
+- `SpaceTopologySnapshot`
+
+Possible behavior:
+
+- preview a multi-window action before applying it
+- build transactional-feeling UI around batched movement
+
+## Things not to do yet
+
+- do not rewrite `WindowTiler.swift` in one shot
+- do not migrate every overlay surface onto one abstraction immediately
+- do not force the palette to become purely registry-generated before the action model is proven
+
+The safer path is:
+
+1. extract small reusable pieces
+2. move one production surface onto them
+3. verify behavior
+4. repeat
+
+## Summary
+
+The strongest architectural opportunity here is not one big framework. It is three small substrates:
+
+- desktop targeting and motion
+- action definition and routing
+- overlay panel construction
+
+If those become reusable, `lattices` gets a much cleaner path to new features without making every new surface solve the same desktop and execution problems again.

package/docs/config.md

@@ -131,10 +131,13 @@ Run `lattices init` in your project directory to generate a starter
 | `lattices sync`              | Reconcile session to match declared config        |
 | `lattices restart [pane]`    | Restart a pane's process (by name or index)       |
 | `lattices tile <position>`   | Tile the frontmost window to a screen position    |
+| `lattices tile family [app] [region]` | Smart-grid the frontmost app family, or a named app |
+| `lattices distribute [app] [region]` | Smart-grid visible windows or just one app      |
 | `lattices group [id]`        | List tab groups or launch/attach a group          |
 | `lattices groups`            | List all tab groups with status                   |
 | `lattices tab <group> [tab]` | Switch tab within a group (by label or index)     |
 | `lattices app`               | Launch the menu bar companion app                 |
+| `lattices app update`        | Download the latest menu bar app and relaunch     |
 | `lattices app build`         | Rebuild the menu bar app from source              |
 | `lattices app restart`       | Rebuild and relaunch the menu bar app             |
 | `lattices layer [name\|index]` | Switch to a workspace layer by name or index      |
@@ -149,6 +152,7 @@ Run `lattices init` in your project directory to generate a starter
 | `lattices scan search <query>` | Search indexed screen text                       |
 | `lattices diag [limit]`       | Show recent diagnostic entries                   |
 | `lattices app`               | Launch the menu bar companion app                 |
+| `lattices app update`        | Download the latest menu bar app and relaunch     |
 | `lattices app build`         | Rebuild the menu bar app from source              |
 | `lattices app restart`       | Rebuild and relaunch the menu bar app             |
 | `lattices app quit`          | Stop the menu bar app                             |
@@ -247,3 +251,24 @@ Aliases: `left-half`/`left`, `right-half`/`right`, `top-half`/`top`,
 
 Tiling respects the menu bar and dock. It uses the visible desktop
 area, not the full screen.
+
+### Smart app tiling
+
+Use `lattices tile family` when you want lattices to arrange a whole
+window family instead of just moving the frontmost window.
+
+Examples:
+
+```bash
+lattices tile family
+lattices tile family right
+lattices tile family iTerm2
+lattices tile family "Google Chrome" left
+```
+
+- With no app name, `family` means the **frontmost app**. If iTerm is
+  frontmost, lattices grids your visible iTerm windows.
+- If you pass a region (`left`, `right`, `top`, `bottom`, etc.), the
+  smart grid is constrained to that part of the screen.
+- `lattices distribute` uses the same smart grid engine, but defaults to
+  **all visible windows** instead of the current app family.

package/docs/tiling-reference.md

@@ -81,6 +81,56 @@ typed placement model internally:
 
 That is what keeps CLI, daemon, voice, and hands-off execution aligned.
 
+## Drag Snap Zones
+
+The menu bar app can also use placement specs as drag-to-snap targets.
+When you drag a window, Lattices shows faint landing zones plus a live
+preview of the resulting frame. Releasing over a zone tiles the dragged
+window to that placement. Hold `Command` while dragging to reveal snap
+mode, and release `Command` to drop back to a normal free drag without
+ending the gesture.
+
+The recommended agent-owned config lives in `~/.lattices/snap-zones.json`:
+
+```json
+{
+  "enabled": true,
+  "modifier": "command",
+  "zoneOpacity": 0.08,
+  "highlightOpacity": 0.18,
+  "previewOpacity": 0.14,
+  "rules": [
+    {
+      "id": "left-edge",
+      "label": "Left",
+      "placement": "left",
+      "trigger": { "x": 0.0, "y": 0.18, "w": 0.12, "h": 0.64 },
+      "priority": 10
+    },
+    {
+      "id": "notes-rail",
+      "label": "Notes",
+      "placement": { "x": 0.68, "y": 0.0, "w": 0.32, "h": 1.0 },
+      "trigger": { "x": 0.88, "y": 0.18, "w": 0.12, "h": 0.64 },
+      "priority": 30
+    }
+  ]
+}
+```
+
+Notes:
+
+- `rules` is the preferred list key. `zones` is still accepted for backward compatibility.
+- `modifier` accepts `command`, `option`, `control`, or `shift`.
+- `placement` can be a named placement/preset string or raw fractions.
+- `trigger` uses normalized `(x, y, w, h)` fractions of the screen's
+  visible area, with `y = 0` at the top.
+- `priority` breaks ties when trigger regions overlap.
+- `trigger` can also be a named placement or preset string if you want
+  the trigger region itself to reuse an existing tile definition.
+- The older `~/.lattices/grid.json` `snapZones` section still works, but
+  `~/.lattices/snap-zones.json` is the cleaner file for agents to edit.
+
 ## Execution Paths
 
 The old split-brain tiling logic has been collapsed toward a shared path.
@@ -146,6 +196,11 @@ These are composed from multiple `tile_window` actions:
 | Eight-up (4×2) | All eight `*-*-fourth` positions |
 | Distribute | Single `distribute` intent (auto-grid) |
 
+CLI shortcuts compile into the same distributor:
+
+- `lattices tile family` → smart-grid the frontmost app's visible windows
+- `lattices distribute iTerm2 right` → smart-grid visible iTerm windows inside the right half
+
 ## HandsOff Smart Distribution
 
 When the LLM sends multiple `tile_window` actions targeting the **same position**, `HandsOffSession.distributeTileActions()` subdivides:

package/docs/voice-error-model.md

@@ -0,0 +1,73 @@
+# Voice Error Model
+
+## Goal + anchors
+
+Use one error vocabulary for Mac voice capture/execution and iPad relay/status. The canonical protocol says Lattices borrows Vox for capture and never owns the mic directly (`docs/voice-command-protocol.md:5-7`), but the shared runtime already has a cross-platform `DeckVoiceState` slot (`swift/Sources/DeckKit/DeckRuntimeSnapshot.swift:49-68`). Current Mac code exposes local strings (`VoxError`, `executionResult`) instead of structured errors (`app/Sources/VoxClient.swift:43-59`, `app/Sources/AudioProvider.swift:343-349`); iPad has only a generic `errorMessage` (`iOS/LatticesCompanion/Sources/DeckStore.swift:18`). Normalize at DeckKit, then let each surface render the same object.
+
+## Error structure
+
+Prefer `DeckVoiceError` now; if later reused for trackpad/deck actions, lift the same shape to `LatsError`.
+
+```swift
+public struct DeckVoiceError: Codable, Equatable, Identifiable, Sendable {
+    public var id: String              // uuid or request id
+    public var code: DeckVoiceErrorCode
+    public var severity: DeckErrorSeverity
+    public var recoverable: Bool
+    public var retry: DeckRetryHint?
+    public var source: DeckErrorSource // mac, ipad, vox, daemon, intent, bridge
+    public var owner: String?          // e.g. "Vox", "Lattices", "Bridge"
+    public var message: String         // cockpit copy, already human-readable
+    public var remediation: DeckRemediationAction?
+    public var occurredAt: Date
+    public var detail: String?         // diagnostic-only
+}
+
+public enum DeckVoiceErrorCode: String, Codable, Sendable { case vox_unreachable, daemon_unreachable, network, connection_lost, mic_denied, accessibility_denied, mic_busy, no_active_target, vox_not_running, vox_loading, intent_unresolved, action_failed, transcription_failed, empty_transcript, language_unsupported }
+public enum DeckErrorSeverity: String, Codable, Sendable { case info, warning, error, blocked }
+public enum DeckRetryHint: String, Codable, Sendable { case silent, immediate, afterLaunch, userAction }
+public enum DeckErrorSource: String, Codable, Sendable { case mac, ipad, vox, daemon, intent, bridge }
+public enum DeckRemediationAction: Codable, Equatable, Sendable {
+    case openVox, openSystemSettings(kind: String), retryVoice, openDiagnostics, chooseTarget
+}
+```
+
+Add `var error: DeckVoiceError?` and optionally `var lastError: DeckVoiceError?` to `DeckVoiceState`, preserving existing `phase`, transcript, and provider fields (`swift/Sources/DeckKit/DeckRuntimeSnapshot.swift:49-68`). Codes should stay stable string raw values for JSON logs and iPad bridge snapshots.
+
+## Categories
+
+| Category | Codes | Recovery rule |
+|---|---|---|
+| Connection | `vox_unreachable`, `daemon_unreachable`, `network`, `connection_lost` | Recoverable unless active capture was lost. Silent reconnect when idle; visible banner during `listening`/`transcribing`. |
+| Permission | `mic_denied`, `accessibility_denied` | Needs user action. `mic_denied` is Mac/Vox-owned; iPad only relays it. `accessibility_denied` blocks execution/navigation. |
+| State | `mic_busy { owner }`, `no_active_target`, `vox_not_running`, `vox_loading` | Usually recoverable. `mic_busy` waits for owner; `vox_not_running` supports launch-on-demand. |
+| Execution | `intent_unresolved`, `action_failed`, `transcription_failed` | Recoverable by retry or edited command; escalate to log if repeated. |
+| Validation | `empty_transcript`, `language_unsupported` | Recoverable; no scary chrome. Treat as a missed command, not a crash. |
+
+Copy examples: `Mic in use by Vox — finish memo first`, `No target window`, `Vox offline — starting`, `Connection lost — press again`, `Intent not found`.
+
+## Presentation patterns
+
+**Mac VoiceCommandWindow.** Keep the three-column cockpit. The top mic bar already owns live state (`connecting...`, `processing...`; `app/Sources/VoiceCommandWindow.swift:692-719`); render the active error as a compact red/amber status chip there. The center column uses `commandSection` cards (`app/Sources/VoiceCommandWindow.swift:1287-1304`): show a single `blocked`/`needs action` card only when the user can do something. The footer already has key chips (`app/Sources/VoiceCommandWindow.swift:1308-1348`); replace the generic command list with contextual remediation: `⌥ Retry`, `Return Open Vox`, `⌘, Permissions`. Logs stay in the right rail, using existing level colors (`app/Sources/VoiceCommandWindow.swift:1112-1150`).
+
+**Mac HUD.** `HUDTopBar.voiceStatus` already has dot, label, transcript, response (`app/Sources/HUDTopBar.swift:134-198`). Add severity tint: green idle/listening, amber connecting/recoverable, red blocked. For active voice errors, HUD shows a one-line banner in the top bar; no sheet.
+
+**iPad Home.** Add `HomeVoiceOverlay` as the full voice modal for active relay: title row `VOICE`, phase, transcript, Mac owner, and one remediation button. The bottom bar already has dense status slots and `hold·space` (`iOS/LatticesCompanion/Sources/Home/HomeBottomBar.swift:58-68`, `iOS/LatticesCompanion/Sources/Home/HomeBottomBar.swift:129-148`); render idle/recoverable errors inline there (`voice · reconnecting`, `voice · Vox offline`). Use a deck overlay banner only when an issued iPad action failed. Use sheets only for permissions/pairing because they need human action. This follows the chrome rule: do not remove noisy UI; replace it with state that answers “what am I controlling, who is listening, what failed?” (`/Users/arach/.claude/projects/-Users-arach-dev-lattices/memory/feedback_chrome_design.md:11-13`).
+
+## Unhappy-path prescriptions
+
+**Launch Vox on demand.** Spec flow is detect installed/not running, open Vox, show `Starting Vox...`, wait up to 10s, retry `startDictation`, then fail with manual-open copy (`docs/voice-command-protocol.md:73-89`). Current Mac waits 2s after `connect()` (`app/Sources/VoiceCommandWindow.swift:290-313`); design target is `vox_not_running` → `vox_loading` → retry → either clear error or `vox_unreachable` with `openVox`.
+
+**Mic busy.** Preserve owner attribution from protocol (`docs/voice-command-protocol.md:127-135`). `mic_busy(owner: "Vox")` is warning, recoverable, retry hint `userAction`; message: `Mic in use by Vox — finish memo first`. If owner is unknown: `Mic busy — wait for current recording`.
+
+**Connection recovery.** If idle, reconnect silently and write log only. If active, show red `Connection lost`; do not auto-retry captured audio because Vox cancels dropped sockets (`docs/voice-command-protocol.md:174-188`). iPad shows `Mac voice link lost` if bridge lost, not `network` unless the iPad transport failed.
+
+**JSONL.** Add `~/.lattices/voice.jsonl` beside `lattices.log` (current log path is `~/.lattices/lattices.log`; `app/Sources/DiagnosticLog.swift:40-59`). Shape:
+
+```json
+{"ts":"2026-04-27T14:03:11.120Z","platform":"mac","sessionId":"...","phase":"listening","event":"error","error":{"code":"mic_busy","severity":"warning","recoverable":true,"source":"vox","owner":"Vox","message":"Mic in use by Vox — finish memo first"},"transcript":null,"intent":null,"durationMs":820}
+```
+
+## Cross-platform conventions
+
+Tone: terse cockpit, no apologies. Prefer noun-state-action: `Vox offline — starting`, `No target — pick window`, `Access denied — enable Accessibility`. Tint maps to existing palettes: Mac `Palette.detach` amber and `Palette.kill` red (`app/Sources/Theme.swift:19-23`); iPad `LatsPalette.amber/red` (`iOS/LatticesCompanion/Sources/LatsDeckScreen.swift:19-25`). Icons: `mic.fill` live, `mic.slash` denied, `waveform.badge.exclamationmark` transcription, `bolt.trianglebadge.exclamationmark` execution, `wifi.exclamationmark` connection, `scope` target. Ownership: Mac owns Vox, mic, Accessibility, intent execution, and JSONL. iPad owns relay/bridge/network presentation and never claims direct mic capture.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lattices/cli",
-  "version": "0.4.2",
+  "version": "0.4.6",
   "description": "Agentic window manager for macOS — programmable workspace, smart layouts, managed tmux sessions, and a 35+-method agent API",
   "bin": {
     "lattices": "./bin/lattices.ts",
@@ -22,11 +22,14 @@
   "license": "MIT",
   "exports": {
     ".": "./bin/client.ts",
+    "./assistant-intelligence": "./bin/assistant-intelligence.ts",
     "./daemon-client": "./bin/daemon-client.ts",
     "./project-twin": "./bin/project-twin.ts"
   },
   "scripts": {
     "dev": "bun --cwd docs-site dev",
+    "test:e2e": "node --experimental-strip-types --test test/e2e-daemon.test.mjs",
+    "test:e2e:voice": "node --experimental-strip-types test/eval-voice.js",
     "typecheck": "tsc --noEmit",
     "build:app-bundle": "bash ./bin/lattices-dev build",
     "prepack": "bash ./bin/lattices-dev build"

package/app/Sources/App.swift

@@ -1,10 +0,0 @@
-import SwiftUI
-
-@main
-struct LatticesApp: App {
-    @NSApplicationDelegateAdaptor(AppDelegate.self) var delegate
-
-    var body: some Scene {
-        Settings { EmptyView() }
-    }
-}