Preserve collapsible code blocks (#138)

Reapply the native traffic-light alignment after resize, focus, scale, and theme events so AppKit window-state transitions cannot leave the controls at their default position.

.gitignore

@@ -13,6 +13,9 @@ bun.lockb
 /.svelte-kit
 /build
 
+# Local tests
+/tests/
+
 # Nix
 /result
 

README.md

@@ -1,7 +1,7 @@
 # HelixNotes
 
-[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)
+[![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](https://gitlab.com/ArkHost/HelixNotes/-/blob/main/LICENSE)
-[![Latest Release](https://img.shields.io/badge/release-v1.3.2-green)](https://codeberg.org/ArkHost/HelixNotes/releases)
+[![Latest Release](https://img.shields.io/badge/release-v1.3.4-green)](https://gitlab.com/ArkHost/HelixNotes/-/releases/v1.3.4)
 [![Website](https://img.shields.io/badge/web-helixnotes.com-purple)](https://helixnotes.com)
 [![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20Windows%20%7C%20macOS%20%7C%20Android-lightgrey)]()
 
@@ -10,7 +10,7 @@ A local markdown note-taking app built with Tauri, SvelteKit, and Rust.
 Your notes are stored as standard Markdown files on your local filesystem.
 No cloud, no lock-in.
 
-## Download (v1.3.2)
+## Download (v1.3.4)
 
 ### Linux
 
@@ -42,7 +42,7 @@ sudo eopkg it helixnotes
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     helix-notes = {
-      url = "git+https://codeberg.org/ArkHost/HelixNotes";
+      url = "git+https://gitlab.com/ArkHost/HelixNotes";
       # inputs.nixpkgs.follows = "nixpkgs";
     }
   };
@@ -92,27 +92,37 @@ sudo eopkg it helixnotes
 
 #### AppImage (Arch, Fedora 43+, openSUSE Tumbleweed)
 
-[Download AppImage](https://download.helixnotes.com/releases/v1.3.2/HelixNotes_1.3.2_amd64.AppImage)
+[Download AppImage](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_amd64.AppImage)
 
 #### .deb (manual)
 
-[Download .deb](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.3.2/HelixNotes_1.3.2_amd64.deb) (Ubuntu 22.04+)
+[Download .deb](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_amd64.deb) (Ubuntu 22.04+)
+
+#### .rpm (manual)
+
+[Download .rpm](https://download.helixnotes.com/releases/v1.3.4/HelixNotes-1.3.4-1.x86_64.rpm)
 
 ### Windows
 
-[Download Installer](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.3.2/HelixNotes_1.3.2_x64-setup.exe) (Windows 10/11)
+[Download Installer](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_x64-setup.exe) (Windows 10/11)
 
 ### macOS
 
-[Download .dmg](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.3.2/HelixNotes_1.3.2_x64.dmg) (Intel, runs on Apple Silicon via Rosetta)
+[Download .dmg (Apple Silicon)](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_aarch64.dmg) (M-series Macs)
+
+> **"HelixNotes is damaged and can't be opened"?** The app isn't damaged. The macOS build isn't notarized by Apple yet, so Gatekeeper blocks it on Apple Silicon. Run this once in Terminal, then open it normally (you'll need to redo it after each update):
+>
+> ```bash
+> xattr -cr /Applications/HelixNotes.app
+> ```
 
 ### Android
 
-[Download APK](https://codeberg.org/ArkHost/HelixNotes/releases/download/v1.3.2/HelixNotes_1.3.2_android.apk)
+[Download APK](https://download.helixnotes.com/releases/v1.3.4/HelixNotes_1.3.4_android.apk)
 
 ---
 
-All releases: [codeberg.org/ArkHost/HelixNotes/releases](https://codeberg.org/ArkHost/HelixNotes/releases)
+All releases: [gitlab.com/ArkHost/HelixNotes/-/releases](https://gitlab.com/ArkHost/HelixNotes/-/releases)
 
 ## Features
 
@@ -175,4 +185,4 @@ pnpm tauri build
 
 ## License
 
-[AGPL-3.0](https://codeberg.org/ArkHost/HelixNotes/src/branch/main/LICENSE)
+[AGPL-3.0](https://gitlab.com/ArkHost/HelixNotes/-/blob/main/LICENSE)

flake.lock

@@ -20,11 +20,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1777268161,
+        "lastModified": 1785571196,
-        "narHash": "sha256-bxrdOn8SCOv8tN4JbTF/TXq7kjo9ag4M+C8yzzIRYbE=",
+        "narHash": "sha256-KoTsyMQqnXQZq8deCEnu4QkyldkwH/bpMMhUcfMdGIw=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "1c3fe55ad329cbcb28471bb30f05c9827f724c76",
+        "rev": "148bab9c1c3c53136ecb44a6ea356a0ed5b39b06",
         "type": "github"
       },
       "original": {

flake.nix

@@ -6,71 +6,77 @@
     flake-utils.url = "github:numtide/flake-utils";
   };
 
-  outputs = {
+  outputs =
-    self,
+    {
-    nixpkgs,
+      self,
-    flake-utils,
+      nixpkgs,
-  }:
+      flake-utils,
-    flake-utils.lib.eachDefaultSystem (system: let
+    }:
-      pkgs = import nixpkgs {inherit system;};
+    flake-utils.lib.eachDefaultSystem (
+      system:
+      let
+        pkgs = import nixpkgs { inherit system; };
 
-      cargoToml = builtins.fromTOML (builtins.readFile ./src-tauri/Cargo.toml);
+        cargoToml = builtins.fromTOML (builtins.readFile ./src-tauri/Cargo.toml);
-      pname = cargoToml.package.name;
+        pname = cargoToml.package.name;
-      version = cargoToml.package.version;
+        version = cargoToml.package.version;
-    in {
+      in
-      packages.default = pkgs.rustPlatform.buildRustPackage {
+      {
-        inherit pname version;
+        packages.default = pkgs.rustPlatform.buildRustPackage {
-        src = ./.;
-
-        cargoHash = "sha256-3ihGgdU/1WFa3aOeEi5AcwTFIyGQgxT7Ad0uVuFYB+4=";
-
-        pnpmDeps = pkgs.fetchPnpmDeps {
           inherit pname version;
           src = ./.;
-          fetcherVersion = 3;
-          hash = "sha256-Odmd1gwioCvnnExvCOQwDPCgLyrBfTpeUKHy3BrNtiM=";
-        };
 
-        nativeBuildInputs = with pkgs; [
+          cargoHash = "sha256-P0iXImWYKYPxVj7q2JSuDmd8JvjcKW4DzFUzXeUQZPk=C";
-          cargo-tauri.hook
 
-          pnpmConfigHook
+          pnpmDeps = pkgs.fetchPnpmDeps {
-          pnpm
+            inherit pname version;
-          nodejs
+            src = ./.;
+            fetcherVersion = 4;
+            hash = "sha256-odUNKO2D50DG+VpuoTEo5FLMYy5pQSHQBtfHJrhJt78=";
+          };
 
-          pkg-config
+          nativeBuildInputs = with pkgs; [
-          jq
+            cargo-tauri.hook
-          moreutils
-          wrapGAppsHook3
-        ];
 
-        buildInputs = with pkgs;
+            pnpmConfigHook
-          lib.optionals stdenv.hostPlatform.isLinux [
+            pnpm
-            webkitgtk_4_1
+            nodejs
-            libayatana-appindicator
+
+            pkg-config
+            jq
+            moreutils
+            wrapGAppsHook3
           ];
 
-        cargoRoot = "src-tauri";
+          buildInputs =
-        buildAndTestSubdir = self.packages.${system}.default.cargoRoot;
+            with pkgs;
+            lib.optionals stdenv.hostPlatform.isLinux [
+              webkitgtk_4_1
+              libayatana-appindicator
+            ];
 
-        # Deactivate the upstream update mechanism
+          cargoRoot = "src-tauri";
-        postPatch = ''
+          buildAndTestSubdir = self.packages.${system}.default.cargoRoot;
-          jq '
-            .bundle.createUpdaterArtifacts = false |
-            .plugins.updater = {"active": false, "pubkey": "", "endpoints": []}
-          ' \
-          src-tauri/tauri.conf.json | sponge src-tauri/tauri.conf.json
-        '';
 
-        meta = with pkgs.lib; {
+          # Deactivate the upstream update mechanism
-          description = "HelixNotes desktop application";
+          postPatch = ''
-          homepage = "https://helixnotes.com/";
+            jq '
-          license = licenses.agpl3Plus;
+              .bundle.createUpdaterArtifacts = false |
-          platforms = platforms.linux ++ platforms.darwin;
+              .plugins.updater = {"active": false, "pubkey": "", "endpoints": []}
-          mainProgram = "helixnotes";
+            ' \
+            src-tauri/tauri.conf.json | sponge src-tauri/tauri.conf.json
+          '';
+
+          meta = with pkgs.lib; {
+            description = "HelixNotes desktop application";
+            homepage = "https://helixnotes.com/";
+            license = licenses.agpl3Plus;
+            platforms = platforms.linux ++ platforms.darwin;
+            mainProgram = "helixnotes";
+          };
         };
-      };
 
-      formatter = pkgs.alejandra;
+        formatter = pkgs.nixfmt;
-    });
+      }
+    );
 }

package.json

@@ -2,7 +2,7 @@
   "name": "helixnotes",
   "private": true,
   "license": "AGPL-3.0-or-later",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "type": "module",
   "scripts": {
     "dev": "vite dev",

pnpm-workspace.yaml

@@ -0,0 +1,2 @@
+allowBuilds:
+  esbuild: true

src-tauri/Cargo.lock

@@ -1850,7 +1850,7 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
 name = "helixnotes"
-version = "1.3.2"
+version = "1.3.4"
 dependencies = [
  "arboard",
  "chrono",
@@ -1860,6 +1860,7 @@ dependencies = [
  "image",
  "log",
  "notify",
+ "objc2-app-kit",
  "png 0.17.16",
  "quick-xml 0.36.2",
  "rayon",
@@ -1876,6 +1877,7 @@ dependencies = [
  "tauri-build",
  "tauri-plugin-dialog",
  "tauri-plugin-fs",
+ "tauri-plugin-ios-vault-access",
  "tauri-plugin-log",
  "tauri-plugin-opener",
  "tauri-plugin-single-instance",
@@ -5201,6 +5203,15 @@ dependencies = [
  "url",
 ]
 
+[[package]]
+name = "tauri-plugin-ios-vault-access"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "tauri",
+ "tauri-plugin",
+]
+
 [[package]]
 name = "tauri-plugin-log"
 version = "2.8.0"

src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "helixnotes"
-version = "1.3.2"
+version = "1.3.4"
 description = "Local markdown note-taking app"
 authors = ["HelixNotes"]
 license = "AGPL-3.0-or-later"
@@ -42,6 +42,12 @@ quick-xml = "0.36"
 urlencoding = "2"
 sha2 = "0.10"
 rustls = { version = "0.23", default-features = false, features = ["ring", "logging", "std", "tls12"] }
+[target.'cfg(target_os = "macos")'.dependencies]
+objc2-app-kit = "0.3.2"
+
+[target.'cfg(target_os = "ios")'.dependencies]
+tauri-plugin-ios-vault-access = { path = "plugins/ios-vault-access" }
+
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
 tauri-plugin-updater = "2"
 tauri-plugin-single-instance = "2"

src-tauri/Info.ios.plist

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>UIFileSharingEnabled</key>
+    <true/>
+    <key>LSSupportsOpeningDocumentsInPlace</key>
+    <true/>
+</dict>
+</plist>

src-tauri/entitlements.plist

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <!-- Hardened runtime entitlements for Developer ID distribution (outside Mac App Store).
+         Required for notarization. These do NOT enable App Sandbox.
+         Without these, the WebKit webview and bundled Rust libraries get killed by the
+         hardened runtime's library validation. -->
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    <key>com.apple.security.cs.disable-library-validation</key>
+    <true/>
+    <!-- Network access for auto-updater, AI features, WebDAV sync, image proxy -->
+    <key>com.apple.security.network.client</key>
+    <true/>
+</dict>
+</plist>

src-tauri/gen/android/app/src/main/res/values/ic_launcher_background.xml

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-  <color name="ic_launcher_background">#fff</color>
+  <color name="ic_launcher_background">#626ED4</color>
 </resources>

src-tauri/icons/helixnotes-logo.svg

@@ -1,9 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="512" height="512" viewBox="0 0 512 512">
-    <rect width="512" height="512" rx="112" ry="112" fill="#626ED4"/>
-    <line x1="128" y1="128" x2="384" y2="384" stroke="#ffffff" stroke-width="8" stroke-opacity="0.5" stroke-linecap="round"/>
-    <line x1="384" y1="128" x2="128" y2="384" stroke="#ffffff" stroke-width="8" stroke-opacity="0.5" stroke-linecap="round"/>
-    <circle cx="128" cy="128" r="36" fill="#ffffff"/>
-    <circle cx="384" cy="128" r="36" fill="#ffffff"/>
-    <circle cx="128" cy="384" r="36" fill="#ffffff"/>
-    <circle cx="384" cy="384" r="36" fill="#ffffff"/>
-</svg>

src-tauri/icons/icon-foreground.svg

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="512" height="512" viewBox="0 0 512 512" xmlns="http://www.w3.org/2000/svg">
+  <g transform="translate(85.333 85.333) scale(0.666667)">
+  <line x1="178.45584" y1="178.45584" x2="333.54416" y2="333.54416" stroke="#ffffff" stroke-width="25" stroke-opacity="0.5" stroke-linecap="round"/>
+  <line x1="337.53708" y1="174.46292" x2="174.46294" y2="337.53708" stroke="#ffffff" stroke-width="25" stroke-opacity="0.5" stroke-linecap="round"/>
+  <circle cx="153" cy="153" r="36" fill="#ffffff"/>
+  <circle cx="359" cy="153" r="36" fill="#ffffff"/>
+  <circle cx="153" cy="359" r="36" fill="#ffffff"/>
+  <circle cx="359" cy="359" r="36" fill="#ffffff"/>
+  </g>
+</svg>

src-tauri/icons/icon.svg

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   width="512"
+   height="512"
+   viewBox="0 0 512 512"
+   version="1.1"
+   id="svg5"
+   xmlns="http://www.w3.org/2000/svg"><rect
+     width="512"
+     height="512"
+     rx="112"
+     ry="112"
+     fill="#626ED4"
+     id="rect1" /><line
+     x1="178.45584"
+     y1="178.45584"
+     x2="333.54416"
+     y2="333.54416"
+     stroke="#ffffff"
+     stroke-width="25"
+     stroke-opacity="0.5"
+     stroke-linecap="round"
+     id="line1" /><line
+     x1="337.53708"
+     y1="174.46292"
+     x2="174.46294"
+     y2="337.53708"
+     stroke="#ffffff"
+     stroke-width="25"
+     stroke-opacity="0.5"
+     stroke-linecap="round"
+     id="line2" /><circle
+     cx="153"
+     cy="153"
+     r="36"
+     fill="#ffffff"
+     id="circle2" /><circle
+     cx="359"
+     cy="153"
+     r="36"
+     fill="#ffffff"
+     id="circle3" /><circle
+     cx="153"
+     cy="359"
+     r="36"
+     fill="#ffffff"
+     id="circle4" /><circle
+     cx="359"
+     cy="359"
+     r="36"
+     fill="#ffffff"
+     id="circle5" /></svg>

src-tauri/my-theme.json

@@ -0,0 +1,21 @@
+{
+  "themes": [
+    {
+      "colors": {
+        "bg_active": "#373a52",
+        "bg_editor": "#1a1b26",
+        "bg_hover": "#2f3145",
+        "bg_primary": "#1a1b26",
+        "bg_secondary": "#1f2029",
+        "bg_tertiary": "#2a2b3d",
+        "border_color": "#2f3145",
+        "text_primary": "#c8cde4",
+        "text_secondary": "#6b7094"
+      },
+      "id": "custom-1782146306429",
+      "is_dark": true,
+      "name": "My theme"
+    }
+  ],
+  "version": 1
+}

src-tauri/plugins/ios-vault-access/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tauri-plugin-ios-vault-access"
+version = "0.1.0"
+authors = ["HelixNotes"]
+description = "iOS Files folder access for HelixNotes"
+edition = "2021"
+rust-version = "1.77.2"
+links = "tauri-plugin-ios-vault-access"
+
+[dependencies]
+tauri = "2"
+serde = { version = "1", features = ["derive"] }
+
+[build-dependencies]
+tauri-plugin = { version = "2", features = ["build"] }

src-tauri/plugins/ios-vault-access/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_plugin::Builder::new(&[]).ios_path("ios").build();
+}

src-tauri/plugins/ios-vault-access/ios/Package.swift

@@ -0,0 +1,24 @@
+// swift-tools-version:5.3
+import PackageDescription
+
+let package = Package(
+    name: "tauri-plugin-ios-vault-access",
+    platforms: [.iOS(.v14)],
+    products: [
+        .library(
+            name: "tauri-plugin-ios-vault-access",
+            type: .static,
+            targets: ["tauri-plugin-ios-vault-access"]
+        )
+    ],
+    dependencies: [
+        .package(name: "Tauri", path: "../.tauri/tauri-api")
+    ],
+    targets: [
+        .target(
+            name: "tauri-plugin-ios-vault-access",
+            dependencies: [.byName(name: "Tauri")],
+            path: "Sources"
+        )
+    ]
+)

src-tauri/plugins/ios-vault-access/ios/Sources/IosVaultAccessPlugin.swift

@@ -0,0 +1,312 @@
+import Foundation
+import SwiftRs
+import Tauri
+import UIKit
+import UniformTypeIdentifiers
+
+private struct BookmarkRequest: Decodable {
+    let bookmarkId: String
+}
+
+final class IosVaultAccessPlugin: Plugin, UIDocumentPickerDelegate {
+    private let fileManager = FileManager.default
+    private let lock = NSLock()
+    private var pickerInvoke: Invoke?
+    private var activeBookmarkId: String?
+    private var activeURL: URL?
+    private var stagedBookmarkId: String?
+    private var stagedURL: URL?
+
+    deinit {
+        rollbackStagedScope()
+        releaseCurrentScope()
+    }
+
+    @objc func chooseFolder(_ invoke: Invoke) {
+        DispatchQueue.main.async {
+            guard self.pickerInvoke == nil else {
+                invoke.reject("A folder picker is already open.")
+                return
+            }
+            guard let viewController = self.manager.viewController else {
+                self.pickerInvoke = nil
+                invoke.reject("Files is unavailable right now. Try again.")
+                return
+            }
+            self.pickerInvoke = invoke
+            let picker = UIDocumentPickerViewController(
+                forOpeningContentTypes: [.folder],
+                asCopy: false
+            )
+            picker.delegate = self
+            picker.allowsMultipleSelection = false
+            viewController.present(picker, animated: true)
+        }
+    }
+
+    @objc func resolveFolder(_ invoke: Invoke) throws {
+        let request = try invoke.parseArgs(BookmarkRequest.self)
+        do {
+            invoke.resolve(try resolveBookmark(request.bookmarkId))
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    @objc func releaseActive(_ invoke: Invoke) {
+        rollbackStagedScope()
+        releaseCurrentScope()
+        invoke.resolve()
+    }
+
+    @objc func commitStaged(_ invoke: Invoke) {
+        commitStagedScope()
+        invoke.resolve()
+    }
+
+    @objc func rollbackStaged(_ invoke: Invoke) {
+        rollbackStagedScope()
+        invoke.resolve()
+    }
+
+    @objc func forgetBookmark(_ invoke: Invoke) throws {
+        let request = try invoke.parseArgs(BookmarkRequest.self)
+        do {
+            let file = try bookmarkFile(for: request.bookmarkId, createDirectory: false)
+            lock.lock()
+            let isActive = activeBookmarkId == request.bookmarkId
+            let isStaged = stagedBookmarkId == request.bookmarkId
+            lock.unlock()
+            if fileManager.fileExists(atPath: file.path) {
+                try fileManager.removeItem(at: file)
+            }
+            if isActive {
+                releaseCurrentScope()
+            }
+            if isStaged {
+                rollbackStagedScope()
+            }
+            invoke.resolve()
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    func documentPicker(
+        _ controller: UIDocumentPickerViewController,
+        didPickDocumentsAt urls: [URL]
+    ) {
+        guard let invoke = takePickerInvoke() else { return }
+        guard let url = urls.first else {
+            invoke.resolve(cancelledResult())
+            return
+        }
+
+        do {
+            guard url.startAccessingSecurityScopedResource() else {
+                throw AccessError.denied
+            }
+            var adopted = false
+            defer {
+                if !adopted { url.stopAccessingSecurityScopedResource() }
+            }
+
+            let name = try validateFolder(url)
+            let bookmarkId = existingBookmarkId(for: url) ?? UUID().uuidString.lowercased()
+            let bookmark = try url.bookmarkData(
+                options: .minimalBookmark,
+                includingResourceValuesForKeys: nil,
+                relativeTo: nil
+            )
+            try bookmark.write(to: bookmarkFile(for: bookmarkId, createDirectory: true), options: .atomic)
+            stageScope(url: url, bookmarkId: bookmarkId)
+            adopted = true
+            invoke.resolve(result(bookmarkId: bookmarkId, url: url, name: name))
+        } catch {
+            invoke.reject(message(for: error))
+        }
+    }
+
+    func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        takePickerInvoke()?.resolve(cancelledResult())
+    }
+
+    private func resolveBookmark(_ bookmarkId: String) throws -> [String: Any] {
+        guard UUID(uuidString: bookmarkId) != nil else { throw AccessError.missing }
+
+        lock.lock()
+        let currentURL = activeBookmarkId == bookmarkId ? activeURL : nil
+        lock.unlock()
+        if let currentURL {
+            return result(bookmarkId: bookmarkId, url: currentURL, name: try validateFolder(currentURL))
+        }
+
+        let data = try Data(contentsOf: bookmarkFile(for: bookmarkId, createDirectory: false))
+        var stale = false
+        let url = try URL(
+            resolvingBookmarkData: data,
+            options: [],
+            relativeTo: nil,
+            bookmarkDataIsStale: &stale
+        )
+        guard url.startAccessingSecurityScopedResource() else { throw AccessError.denied }
+        var adopted = false
+        defer {
+            if !adopted { url.stopAccessingSecurityScopedResource() }
+        }
+
+        let name = try validateFolder(url)
+        if stale {
+            let refreshed = try url.bookmarkData(
+                options: .minimalBookmark,
+                includingResourceValuesForKeys: nil,
+                relativeTo: nil
+            )
+            try refreshed.write(to: bookmarkFile(for: bookmarkId, createDirectory: true), options: .atomic)
+        }
+        stageScope(url: url, bookmarkId: bookmarkId)
+        adopted = true
+        return result(bookmarkId: bookmarkId, url: url, name: name)
+    }
+
+    private func validateFolder(_ url: URL) throws -> String {
+        let values = try url.resourceValues(forKeys: [.isDirectoryKey, .nameKey])
+        guard values.isDirectory == true else { throw AccessError.notFolder }
+        guard try url.checkResourceIsReachable() else { throw AccessError.unavailable }
+        return values.name ?? url.lastPathComponent
+    }
+
+    private func stageScope(url: URL, bookmarkId: String) {
+        lock.lock()
+        let previous = stagedURL
+        stagedURL = url
+        stagedBookmarkId = bookmarkId
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func commitStagedScope() {
+        lock.lock()
+        guard let next = stagedURL else {
+            lock.unlock()
+            return
+        }
+        let previous = activeURL
+        activeURL = next
+        activeBookmarkId = stagedBookmarkId
+        stagedURL = nil
+        stagedBookmarkId = nil
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func rollbackStagedScope() {
+        lock.lock()
+        let staged = stagedURL
+        stagedURL = nil
+        stagedBookmarkId = nil
+        lock.unlock()
+        staged?.stopAccessingSecurityScopedResource()
+    }
+
+    private func releaseCurrentScope() {
+        lock.lock()
+        let previous = activeURL
+        activeURL = nil
+        activeBookmarkId = nil
+        lock.unlock()
+        previous?.stopAccessingSecurityScopedResource()
+    }
+
+    private func takePickerInvoke() -> Invoke? {
+        let invoke = pickerInvoke
+        pickerInvoke = nil
+        return invoke
+    }
+
+    private func bookmarkDirectory(create: Bool) throws -> URL {
+        let base = try fileManager.url(
+            for: .applicationSupportDirectory,
+            in: .userDomainMask,
+            appropriateFor: nil,
+            create: true
+        )
+        let directory = base.appendingPathComponent("VaultBookmarks", isDirectory: true)
+        if create {
+            try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+        }
+        return directory
+    }
+
+    private func bookmarkFile(for id: String, createDirectory: Bool) throws -> URL {
+        guard UUID(uuidString: id) != nil else { throw AccessError.missing }
+        let directory = try bookmarkDirectory(create: createDirectory)
+        return directory.appendingPathComponent("\(id).bookmark")
+    }
+
+    private func existingBookmarkId(for selectedURL: URL) -> String? {
+        guard
+            let directory = try? bookmarkDirectory(create: true),
+            let files = try? fileManager.contentsOfDirectory(
+                at: directory,
+                includingPropertiesForKeys: nil
+            )
+        else { return nil }
+
+        let selectedPath = selectedURL.standardizedFileURL.path
+        for file in files where file.pathExtension == "bookmark" {
+            guard let data = try? Data(contentsOf: file) else { continue }
+            var stale = false
+            guard
+                let resolved = try? URL(
+                    resolvingBookmarkData: data,
+                    options: [],
+                    relativeTo: nil,
+                    bookmarkDataIsStale: &stale
+                ),
+                resolved.standardizedFileURL.path == selectedPath
+            else { continue }
+            let id = file.deletingPathExtension().lastPathComponent
+            if UUID(uuidString: id) != nil { return id }
+        }
+        return nil
+    }
+
+    private func result(bookmarkId: String, url: URL, name: String) -> [String: Any] {
+        ["bookmarkId": bookmarkId, "path": url.path, "name": name, "cancelled": false]
+    }
+
+    private func cancelledResult() -> [String: Any] {
+        ["bookmarkId": "", "path": "", "name": "", "cancelled": true]
+    }
+
+    private func message(for error: Error) -> String {
+        if let accessError = error as? AccessError { return accessError.localizedDescription }
+        return "The selected folder is unavailable. Open Files and try again."
+    }
+}
+
+private enum AccessError: LocalizedError {
+    case denied
+    case missing
+    case notFolder
+    case unavailable
+
+    var errorDescription: String? {
+        switch self {
+        case .denied:
+            return "HelixNotes no longer has access to this folder. Choose it again in Files."
+        case .missing:
+            return "Saved access to this folder is missing. Choose it again in Files."
+        case .notFolder:
+            return "The selected item is not a folder."
+        case .unavailable:
+            return "The selected folder is unavailable. Open Files and try again."
+        }
+    }
+}
+
+@_cdecl("init_plugin_ios_vault_access")
+func initPlugin() -> Plugin {
+    IosVaultAccessPlugin()
+}

src-tauri/plugins/ios-vault-access/src/lib.rs

@@ -0,0 +1,84 @@
+use serde::{Deserialize, Serialize};
+use tauri::{
+    plugin::{Builder, PluginHandle, TauriPlugin},
+    Manager, Runtime,
+};
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FolderSelection {
+    pub bookmark_id: String,
+    pub path: String,
+    pub name: String,
+    #[serde(default)]
+    pub cancelled: bool,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+struct BookmarkRequest<'a> {
+    bookmark_id: &'a str,
+}
+
+#[cfg(target_os = "ios")]
+tauri::ios_plugin_binding!(init_plugin_ios_vault_access);
+
+pub struct IosVaultAccess<R: Runtime>(PluginHandle<R>);
+
+impl<R: Runtime> IosVaultAccess<R> {
+    pub fn choose_folder(&self) -> Result<FolderSelection, String> {
+        self.0
+            .run_mobile_plugin("chooseFolder", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn resolve_folder(&self, bookmark_id: &str) -> Result<FolderSelection, String> {
+        self.0
+            .run_mobile_plugin("resolveFolder", BookmarkRequest { bookmark_id })
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn release_active(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("releaseActive", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn commit_staged(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("commitStaged", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn rollback_staged(&self) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("rollbackStaged", ())
+            .map_err(|error| error.to_string())
+    }
+
+    pub fn forget_bookmark(&self, bookmark_id: &str) -> Result<(), String> {
+        self.0
+            .run_mobile_plugin("forgetBookmark", BookmarkRequest { bookmark_id })
+            .map_err(|error| error.to_string())
+    }
+}
+
+pub trait IosVaultAccessExt<R: Runtime> {
+    fn ios_vault_access(&self) -> &IosVaultAccess<R>;
+}
+
+impl<R: Runtime, T: Manager<R>> IosVaultAccessExt<R> for T {
+    fn ios_vault_access(&self) -> &IosVaultAccess<R> {
+        self.state::<IosVaultAccess<R>>().inner()
+    }
+}
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    Builder::new("ios-vault-access")
+        .setup(|app, api| {
+            let handle = api.register_ios_plugin(init_plugin_ios_vault_access)?;
+            app.manage(IosVaultAccess(handle));
+            Ok(())
+        })
+        .build()
+}

src-tauri/src/ai.rs

@@ -405,7 +405,7 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
 
     let body = json!({
         "model": model,
-        "max_tokens": 10,
+        "max_tokens": 20,
         "messages": [
             {
                 "role": "user",
@@ -434,12 +434,14 @@ async fn test_anthropic(api_key: &str, model: &str) -> Result<String, String> {
 }
 
 async fn test_openai(url: &str, api_key: Option<&str>, model: &str) -> Result<String, String> {
-    let client = Client::new();
+	let client = Client::new();
+	let is_gpt5 = model.starts_with("gpt-5");
+	let token_key = if is_gpt5 { "max_completion_tokens" } else { "max_tokens" };
 
-    let body = json!({
+	let body = json!({
-        "model": model,
+		"model": model,
-        "max_tokens": 10,
+		token_key: 20,
-        "messages": [
+		"messages": [
             {
                 "role": "user",
                 "content": "Hi"

src-tauri/src/lib.rs

@@ -38,11 +38,38 @@ pub fn run() {
     let close_to_tray = config.close_to_tray && show_tray;
     let app_state = AppState::new(config);
 
+    // Inject the compile-time platform so the frontend never sniffs the (sometimes
+    // mobile-looking) WebKitGTK user-agent. (#63)
+    let platform_init = format!(
+        "window.__HELIX_PLATFORM__={{mobile:{},android:{},ios:{}}};",
+        cfg!(mobile),
+        cfg!(target_os = "android"),
+        cfg!(target_os = "ios"),
+    );
+
     let mut builder = tauri::Builder::default()
+        .plugin(
+            tauri::plugin::Builder::<tauri::Wry>::new("helix-platform")
+                .js_init_script(platform_init)
+                .build(),
+        )
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_fs::init())
         .plugin(tauri_plugin_opener::init())
+        .on_page_load(|webview, payload| {
+            #[cfg(target_os = "macos")]
+            if webview.label() == "main"
+                && matches!(payload.event(), tauri::webview::PageLoadEvent::Finished)
+            {
+                queue_macos_traffic_light_fix(&webview.window());
+            }
+            #[cfg(not(target_os = "macos"))]
+            let _ = (webview, payload);
+        })
         .setup(move |app| {
+            #[cfg(target_os = "ios")]
+            app.handle().plugin(tauri_plugin_ios_vault_access::init())?;
+
             if cfg!(debug_assertions) {
                 app.handle().plugin(
                     tauri_plugin_log::Builder::default()
@@ -98,10 +125,16 @@ pub fn run() {
         .manage(app_state)
         .invoke_handler(tauri::generate_handler![
             commands::open_vault,
+            commands::choose_external_vault,
+            commands::restore_external_vault,
             commands::remove_vault,
             commands::get_app_config,
             commands::set_theme,
             commands::set_accent_color,
+            commands::save_custom_theme,
+            commands::delete_custom_theme,
+            commands::export_custom_theme,
+            commands::import_custom_themes,
             commands::set_font_size,
             commands::set_font_family,
             commands::set_line_height,
@@ -137,6 +170,7 @@ pub fn run() {
             commands::empty_trash,
             commands::load_vault_state,
             commands::save_vault_state,
+            commands::copy_text_to_clipboard,
             commands::read_clipboard_image,
             commands::copy_image_to_clipboard,
             commands::save_image,
@@ -281,6 +315,21 @@ pub fn run() {
         builder = builder.plugin(tauri_plugin_window_state::Builder::default().build());
 
         builder = builder.on_window_event(move |window, event| {
+            #[cfg(target_os = "macos")]
+            if window.label() == "main"
+                && matches!(
+                    event,
+                    tauri::WindowEvent::Resized(_)
+                        | tauri::WindowEvent::Focused(true)
+                        | tauri::WindowEvent::ScaleFactorChanged { .. }
+                        | tauri::WindowEvent::ThemeChanged(_)
+                )
+            {
+                // AppKit can restore the default button Y position after window-state
+                // changes. Queue this pass so it runs after AppKit finishes its layout.
+                queue_macos_traffic_light_fix(window);
+            }
+
             match event {
                 tauri::WindowEvent::CloseRequested { api, .. } => {
                     // Only hide to tray for the main window
@@ -369,3 +418,59 @@ fn percent_decode(input: &str) -> String {
     }
     String::from_utf8_lossy(&output).to_string()
 }
+
+#[cfg(target_os = "macos")]
+fn queue_macos_traffic_light_fix(window: &tauri::Window) {
+    let window_on_main = window.clone();
+    let _ = window.run_on_main_thread(move || {
+        fix_macos_traffic_lights(&window_on_main);
+    });
+}
+
+#[cfg(target_os = "macos")]
+fn fix_macos_traffic_lights(window: &tauri::Window) {
+    use objc2_app_kit::{NSView, NSWindow, NSWindowButton};
+
+    const TITLEBAR_HEIGHT: f64 = 34.0;
+    const LEFT_INSET: f64 = 12.0;
+
+    let ns_window_ptr = match window.ns_window() {
+        Ok(ptr) => ptr,
+        Err(_) => return,
+    };
+    let ns_window: &NSWindow = unsafe { &*(ns_window_ptr as *const NSWindow) };
+
+    let close = match ns_window.standardWindowButton(NSWindowButton::CloseButton) {
+        Some(button) => button,
+        None => return,
+    };
+    let miniaturize = match ns_window.standardWindowButton(NSWindowButton::MiniaturizeButton) {
+        Some(button) => button,
+        None => return,
+    };
+    let zoom = match ns_window.standardWindowButton(NSWindowButton::ZoomButton) {
+        Some(button) => button,
+        None => return,
+    };
+
+    let window_height = ns_window.frame().size.height;
+    if window_height <= 0.0 {
+        return;
+    }
+
+    let close_frame = NSView::frame(&close);
+    let button_spacing = NSView::frame(&miniaturize).origin.x - close_frame.origin.x;
+    for (index, button) in [&close, &miniaturize, &zoom].into_iter().enumerate() {
+        let button_superview = match unsafe { button.superview() } {
+            Some(view) => view,
+            None => return,
+        };
+        let mut frame = NSView::frame(button);
+        let top_inset = ((TITLEBAR_HEIGHT - frame.size.height) / 2.0).max(0.0);
+        let mut target = frame.origin;
+        target.y = window_height - top_inset - frame.size.height;
+        frame.origin.y = button_superview.convertPoint_fromView(target, None).y;
+        frame.origin.x = LEFT_INSET + index as f64 * button_spacing;
+        button.setFrameOrigin(frame.origin);
+    }
+}

src-tauri/src/state.rs

@@ -1,14 +1,15 @@
 use crate::search::SearchIndex;
 use crate::types::AppConfig;
-use notify::RecommendedWatcher;
+use crate::vault::watcher::VaultWatcher;
 use std::sync::atomic::AtomicBool;
-use std::sync::Mutex;
 use std::sync::Arc;
+use std::sync::Mutex;
 
 pub struct AppState {
     pub config: Mutex<AppConfig>,
     pub search_index: Mutex<Option<Arc<SearchIndex>>>,
-    pub watcher: Mutex<Option<RecommendedWatcher>>,
+    pub watcher: Mutex<Option<VaultWatcher>>,
+    pub vault_transition: tokio::sync::Mutex<()>,
     pub importing: AtomicBool,
     pub syncing: AtomicBool,
     pub pending_open_file: Mutex<Option<String>>,
@@ -20,6 +21,7 @@ impl AppState {
             config: Mutex::new(config),
             search_index: Mutex::new(None),
             watcher: Mutex::new(None),
+            vault_transition: tokio::sync::Mutex::new(()),
             importing: AtomicBool::new(false),
             syncing: AtomicBool::new(false),
             pending_open_file: Mutex::new(None),

src-tauri/src/sync.rs

@@ -6,9 +6,9 @@
 // vs manifest) and resolve each file as upload/download/delete, with keep-both
 // conflict copies so nothing is ever lost.
 //
-// Synced set: every `*.md` in the vault tree, plus `.helixnotes/attachments/`.
+// Synced set: every `*.md` in the vault tree, `.helixnotes/attachments/`, and
-// Everything else under `.helixnotes/` (search_index, trash, history, *.json, the
+// `.helixnotes/notebook_icons.json`. Search indexes, trash, history, other metadata,
-// manifest itself) is local-only and never synced.
+// and the manifest itself remain local-only.
 
 use crate::state::AppState;
 use crate::vault::operations::helixnotes_dir;
@@ -119,12 +119,12 @@ struct LocalFile {
     path: PathBuf,
 }
 
-/// The synced set: `*.md` anywhere outside `.helixnotes/`, plus everything under
+/// The synced set: `*.md` anywhere outside `.helixnotes/`, everything under
-/// `.helixnotes/attachments/`. Applied to BOTH local and remote so pointing at a
+/// `.helixnotes/attachments/`, and the notebook icon mapping. Applied to BOTH local
-/// folder with unrelated files never drags them into the vault.
+/// and remote so pointing at a folder with unrelated files never imports them.
 fn is_synced_relpath(rel: &str) -> bool {
     if rel.starts_with(".helixnotes/") {
-        rel.starts_with(".helixnotes/attachments/")
+        rel.starts_with(".helixnotes/attachments/") || rel == ".helixnotes/notebook_icons.json"
     } else {
         rel.ends_with(".md")
     }
@@ -312,8 +312,9 @@ impl WebdavClient {
             .send()
             .map_err(|e| e.to_string())?;
         let s = resp.status().as_u16();
-        // 201 created; 405 already exists; 301 redirect-to-existing.
+        // 201 created; 405 already exists; 301 redirect-to-existing;
-        if resp.status().is_success() || s == 405 || s == 301 {
+        // 403 some servers (openmediavault et al.) return 403 instead of 405.
+        if resp.status().is_success() || s == 405 || s == 301 || s == 403 {
             Ok(())
         } else {
             Err(format!("MKCOL {} failed: HTTP {}", relpath, s))
@@ -723,3 +724,28 @@ pub fn run_sync(app: tauri::AppHandle, vault: String, cfg: WebdavConfig) -> Resu
     );
     Ok(summary)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::is_synced_relpath;
+
+    #[test]
+    fn syncs_notebook_icon_mapping_and_assets_only() {
+        for path in [
+            "Notes/plan.md",
+            ".helixnotes/attachments/notebook-icon.png",
+            ".helixnotes/notebook_icons.json",
+        ] {
+            assert!(is_synced_relpath(path), "expected {path} to be synced");
+        }
+
+        for path in [
+            "Notes/image.png",
+            ".helixnotes/sync_state.json",
+            ".helixnotes/notebook_icons.json.bak",
+            ".helixnotes/attachments-old/icon.png",
+        ] {
+            assert!(!is_synced_relpath(path), "expected {path} to stay local");
+        }
+    }
+}

src-tauri/src/types.rs

@@ -50,16 +50,69 @@ pub struct NoteContent {
     pub raw: String,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct VaultConfig {
     pub path: String,
     pub name: String,
+    #[serde(default)]
+    pub bookmark_id: Option<String>,
+    // Per-vault WebDAV sync (was previously global on AppConfig; those fields are kept deprecated for migration).
+    #[serde(default)]
+    pub sync_provider: Option<String>,
+    #[serde(default)]
+    pub webdav_url: Option<String>,
+    #[serde(default)]
+    pub webdav_username: Option<String>,
+    #[serde(default)]
+    pub webdav_password: Option<String>,
+    #[serde(default)]
+    pub sync_on_open: bool,
+    #[serde(default)]
+    pub sync_on_change: bool,
+    #[serde(default)]
+    pub sync_interval_minutes: u32,
+    #[serde(default)]
+    pub last_sync_time: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CustomThemeColors {
+    pub bg_primary: String,
+    pub bg_secondary: String,
+    pub bg_tertiary: String,
+    pub bg_hover: String,
+    pub bg_active: String,
+    pub bg_editor: String,
+    pub text_primary: String,
+    pub text_secondary: String,
+    pub border_color: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CustomTheme {
+    pub id: String,
+    pub name: String,
+    pub is_dark: bool,
+    pub colors: CustomThemeColors,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum StartupView {
+    Daily,
+    QuickAccess,
+    Tasks,
+    #[default]
+    #[serde(other)]
+    All,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct AppConfig {
     pub vaults: Vec<VaultConfig>,
     pub active_vault: Option<String>,
+    #[serde(default)]
+    pub active_bookmark_id: Option<String>,
     pub theme: String,
     #[serde(default)]
     pub accent_color: Option<String>,
@@ -150,8 +203,10 @@ pub struct AppConfig {
     #[serde(default = "default_true")]
     pub enable_wiki_links: bool,
     #[serde(default)]
+    pub startup_view: StartupView,
+    #[serde(default)]
     pub restore_last_session: bool,
-    // WebDAV sync (opt-in; all off by default). Endpoint is fully user-configured.
+    // DEPRECATED: WebDAV sync moved to per-vault VaultConfig. Kept for one release to migrate old configs.
     #[serde(default)]
     pub sync_provider: Option<String>,
     #[serde(default)]
@@ -168,12 +223,18 @@ pub struct AppConfig {
     pub sync_interval_minutes: u32,
     #[serde(default)]
     pub last_sync_time: Option<String>,
+    #[serde(default)]
+    pub custom_themes: Vec<CustomTheme>,
 }
 
 fn default_true() -> bool {
     true
 }
 
+fn default_outline_width() -> f64 {
+    220.0
+}
+
 fn default_pdf_height() -> u32 {
     600
 }
@@ -211,6 +272,7 @@ impl Default for AppConfig {
         Self {
             vaults: Vec::new(),
             active_vault: None,
+            active_bookmark_id: None,
             theme: "system".to_string(),
             accent_color: None,
             font_size: None,
@@ -256,6 +318,7 @@ impl Default for AppConfig {
             show_tray_icon: false,
             close_to_tray: false,
             enable_wiki_links: true,
+            startup_view: StartupView::All,
             restore_last_session: false,
             sync_provider: None,
             webdav_url: None,
@@ -265,6 +328,7 @@ impl Default for AppConfig {
             sync_on_change: false,
             sync_interval_minutes: 0,
             last_sync_time: None,
+            custom_themes: Vec::new(),
         }
     }
 }
@@ -274,6 +338,8 @@ pub struct VaultState {
     pub last_open_note: Option<String>,
     pub sidebar_width: f64,
     pub notelist_width: f64,
+    #[serde(default = "default_outline_width")]
+    pub outline_width: f64,
     pub sidebar_collapsed: bool,
     #[serde(default)]
     pub notelist_collapsed: bool,
@@ -309,6 +375,7 @@ impl Default for VaultState {
             last_open_note: None,
             sidebar_width: 220.0,
             notelist_width: 280.0,
+            outline_width: default_outline_width(),
             sidebar_collapsed: false,
             notelist_collapsed: false,
             collapsed_notebooks: Vec::new(),
@@ -345,6 +412,9 @@ pub struct FileEvent {
 pub struct ImportResult {
     pub files_converted: u64,
     pub links_converted: u64,
+    pub frontmatter_normalized: u64,
+    pub syntax_converted: u64,
+    pub attachments_moved: u64,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -413,3 +483,28 @@ pub struct TaskItem {
     pub due: Option<String>,
     pub priority: Option<String>,
 }
+
+#[cfg(test)]
+mod startup_view_tests {
+    use super::StartupView;
+
+    #[test]
+    fn serializes_supported_startup_views() {
+        for (view, expected) in [
+            (StartupView::All, "\"all\""),
+            (StartupView::QuickAccess, "\"quickaccess\""),
+            (StartupView::Tasks, "\"tasks\""),
+            (StartupView::Daily, "\"daily\""),
+        ] {
+            assert_eq!(serde_json::to_string(&view).unwrap(), expected);
+        }
+    }
+
+    #[test]
+    fn unknown_startup_view_falls_back_to_all_notes() {
+        assert_eq!(
+            serde_json::from_str::<StartupView>("\"future-view\"").unwrap(),
+            StartupView::All
+        );
+    }
+}

src-tauri/src/vault/frontmatter.rs

@@ -15,7 +15,7 @@ struct RawFrontmatter {
 }
 
 /// Try to parse a date string in multiple common formats.
-fn parse_date_flexible(s: &str) -> Option<chrono::DateTime<Utc>> {
+pub fn parse_date_flexible(s: &str) -> Option<chrono::DateTime<Utc>> {
     let s = s.trim();
     // RFC 3339 / ISO 8601 with timezone (e.g. 2024-01-15T10:30:00+00:00)
     if let Ok(dt) = s.parse::<chrono::DateTime<Utc>>() {
@@ -191,7 +191,7 @@ pub fn merge_frontmatter(original_raw: &str, meta: &NoteMeta, body: &str) -> Str
     format!("---\n{}---\n{}", yaml_str, body_with_heading)
 }
 
-fn filename_to_title(filename: &str) -> String {
+pub fn filename_to_title(filename: &str) -> String {
     let stem = filename.trim_end_matches(".md");
     // Only replace dashes/underscores acting as word separators (between non-space chars).
     // Keep dashes that are surrounded by spaces (e.g. "Title - Subtitle").

src-tauri/src/vault/mod.rs

@@ -1,3 +1,4 @@
 pub mod frontmatter;
+pub mod import;
 pub mod operations;
 pub mod watcher;

src-tauri/src/vault/operations.rs

@@ -52,11 +52,10 @@ pub fn scan_notebooks(vault_path: &str) -> Result<Vec<NotebookEntry>, String> {
 }
 
 fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
-    let mut entries = Vec::new();
     let root = Path::new(vault_root);
 
     let Ok(read_dir) = fs::read_dir(dir) else {
-        return entries;
+        return Vec::new();
     };
 
     // Collect subdirs (root level only lists directories, note counts come from scan_dir_with_count)
@@ -76,29 +75,29 @@ fn scan_dir_recursive(dir: &Path, vault_root: &str) -> Vec<NotebookEntry> {
             .cmp(&b.file_name().to_string_lossy().to_lowercase())
     });
 
-    // Store note_count for the parent directory (used when this is the top-level call)
+    // Scan sibling notebooks in parallel: each subtree is independent, so
-    // Each directory pushes its own entry with its own note_count
+    // overlapping the per-directory read_dir calls hides FUSE latency on Android.
-    for dir_entry in dirs {
+    // par_iter().collect() preserves the (already-sorted) order.
-        let path = dir_entry.path();
+    let paths: Vec<PathBuf> = dirs.iter().map(|e| e.path()).collect();
-        let name = dir_entry.file_name().to_string_lossy().to_string();
+    paths
-        let relative = path
+        .par_iter()
-            .strip_prefix(root)
+        .map(|path| {
-            .unwrap_or(&path)
+            let name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
-            .to_string_lossy()
+            let relative = path
-            .to_string();
+                .strip_prefix(root)
-
+                .unwrap_or(path)
-        let (children, child_note_count) = scan_dir_with_count(&path, vault_root);
+                .to_string_lossy()
-
+                .to_string();
-        entries.push(NotebookEntry {
+            let (children, child_note_count) = scan_dir_with_count(path, vault_root);
-            name,
+            NotebookEntry {
-            path: path.to_string_lossy().to_string(),
+                name,
-            relative_path: relative,
+                path: path.to_string_lossy().to_string(),
-            children,
+                relative_path: relative,
-            note_count: child_note_count,
+                children,
-        });
+                note_count: child_note_count,
-    }
+            }
-
+        })
-    entries
+        .collect()
 }
 
 /// Combined scan: returns (children, note_count) in a single read_dir pass.
@@ -130,26 +129,26 @@ fn scan_dir_with_count(dir: &Path, vault_root: &str) -> (Vec<NotebookEntry>, usi
             .cmp(&b.file_name().to_string_lossy().to_lowercase())
     });
 
-    let mut entries = Vec::new();
+    let paths: Vec<PathBuf> = subdirs.iter().map(|e| e.path()).collect();
-    for dir_entry in subdirs {
+    let entries: Vec<NotebookEntry> = paths
-        let path = dir_entry.path();
+        .par_iter()
-        let name = dir_entry.file_name().to_string_lossy().to_string();
+        .map(|path| {
-        let relative = path
+            let name = path.file_name().unwrap_or_default().to_string_lossy().to_string();
-            .strip_prefix(root)
+            let relative = path
-            .unwrap_or(&path)
+                .strip_prefix(root)
-            .to_string_lossy()
+                .unwrap_or(path)
-            .to_string();
+                .to_string_lossy()
-
+                .to_string();
-        let (children, child_note_count) = scan_dir_with_count(&path, vault_root);
+            let (children, child_note_count) = scan_dir_with_count(path, vault_root);
-
+            NotebookEntry {
-        entries.push(NotebookEntry {
+                name,
-            name,
+                path: path.to_string_lossy().to_string(),
-            path: path.to_string_lossy().to_string(),
+                relative_path: relative,
-            relative_path: relative,
+                children,
-            children,
+                note_count: child_note_count,
-            note_count: child_note_count,
+            }
-        });
+        })
-    }
+        .collect();
 
     (entries, note_count)
 }
@@ -197,47 +196,36 @@ pub fn scan_notes(vault_path: &str, notebook_path: Option<&str>) -> Result<Vec<N
     // On mobile, use metadata-only scan (no file reads) for fast listing on sandboxed FS
     #[cfg(mobile)]
     {
-        let mut notes = Vec::new();
+        // Collect candidate .md paths first, then read their metadata in parallel.
-        // Log what read_dir sees
+        // Overlapping the per-file reads hides FUSE latency on Android (matches the
-        if let Ok(rd) = fs::read_dir(root) {
+        // desktop path below). The previous version also did an extra read_dir purely
-            let items: Vec<_> = rd.filter_map(|e| e.ok()).collect();
+        // for debug logging, which doubled the directory I/O on the sandboxed FS.
-            log::info!("scan_notes: read_dir found {} entries in {:?}", items.len(), root);
+        let paths: Vec<PathBuf> = if notebook_path.is_some() {
-            for (i, entry) in items.iter().enumerate().take(5) {
+            match fs::read_dir(root) {
-                let ft = entry.file_type().map(|ft| if ft.is_file() { "file" } else if ft.is_dir() { "dir" } else { "other" }).unwrap_or("err");
+                Ok(rd) => rd
-                log::info!("  [{}] {:?} type={}", i, entry.file_name(), ft);
+                    .filter_map(|e| e.ok())
-            }
+                    .map(|e| e.path())
-        } else {
+                    .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
-            log::info!("scan_notes: read_dir FAILED for {:?}", root);
+                    .collect(),
-        }
+                Err(_) => Vec::new(),
-
-        if notebook_path.is_some() {
-            if let Ok(rd) = fs::read_dir(root) {
-                for entry in rd.filter_map(|e| e.ok()) {
-                    let is_file = entry.file_type().map(|ft| ft.is_file()).unwrap_or(false);
-                    if is_file && entry.path().extension().and_then(|x| x.to_str()) == Some("md") {
-                        if let Ok(note) = read_note_entry_metadata_only(&entry.path(), vault_root) {
-                            notes.push(note);
-                        }
-                    }
-                }
             }
         } else {
             let hn_dir = helixnotes_dir(vault_path);
-            for entry in WalkDir::new(root)
+            WalkDir::new(root)
                 .into_iter()
                 // filter_entry skips descending into hidden dirs (unlike filter)
                 .filter_entry(|e| !is_hidden(e.path()) && !e.path().starts_with(&hn_dir))
                 .filter_map(|e| e.ok())
-                .filter(|e| {
+                .map(|e| e.path().to_path_buf())
-                    e.file_type().is_file()
+                .filter(|p| p.is_file() && p.extension().and_then(|x| x.to_str()) == Some("md"))
-                        && e.path().extension().and_then(|x| x.to_str()) == Some("md")
+                .collect()
-                })
+        };
-            {
+
-                if let Ok(note) = read_note_entry_metadata_only(entry.path(), vault_root) {
+        let mut notes: Vec<NoteEntry> = paths
-                    notes.push(note);
+            .par_iter()
-                }
+            .filter_map(|path| read_note_entry_metadata_only(path, vault_root).ok())
-            }
+            .collect();
-        }
+
         log::info!("scan_notes: mobile scan found {} notes", notes.len());
         notes.sort_by(|a, b| b.meta.modified.cmp(&a.meta.modified));
         return Ok(notes);
@@ -1249,3 +1237,30 @@ pub fn sanitize_filename(name: &str) -> String {
         .trim()
         .to_string()
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{helixnotes_dir, load_notebook_icons, set_notebook_icon};
+    use std::fs;
+    use uuid::Uuid;
+
+    #[test]
+    fn persists_and_removes_builtin_notebook_icons() {
+        let vault =
+            std::env::temp_dir().join(format!("helixnotes-notebook-icon-test-{}", Uuid::new_v4()));
+        let vault_path = vault.to_string_lossy();
+        fs::create_dir_all(helixnotes_dir(&vault_path)).unwrap();
+
+        set_notebook_icon(&vault_path, "Projects", Some("builtin:briefcase")).unwrap();
+        let icons = load_notebook_icons(&vault_path).unwrap();
+        assert_eq!(
+            icons.get("Projects").map(String::as_str),
+            Some("builtin:briefcase")
+        );
+
+        set_notebook_icon(&vault_path, "Projects", None).unwrap();
+        assert!(load_notebook_icons(&vault_path).unwrap().is_empty());
+
+        fs::remove_dir_all(vault).unwrap();
+    }
+}

src-tauri/src/vault/watcher.rs

@@ -1,4 +1,4 @@
-use notify::{Config, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
+use notify::{Config, EventKind, PollWatcher, RecommendedWatcher, RecursiveMode, Watcher};
 use std::path::Path;
 use std::sync::mpsc;
 use std::time::Duration;
@@ -8,14 +8,57 @@ use crate::state::AppState;
 use crate::types::FileEvent;
 use crate::vault::operations::helixnotes_dir;
 
-pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWatcher, String> {
+const IOS_POLL_INTERVAL: Duration = Duration::from_secs(10);
+const NATIVE_POLL_INTERVAL: Duration = Duration::from_secs(1);
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum WatcherBackend {
+    Recommended,
+    Poll,
+}
+
+const fn watcher_backend_for_target(is_ios: bool) -> WatcherBackend {
+    if is_ios {
+        WatcherBackend::Poll
+    } else {
+        WatcherBackend::Recommended
+    }
+}
+
+const fn poll_interval_for_backend(backend: WatcherBackend) -> Duration {
+    match backend {
+        WatcherBackend::Recommended => NATIVE_POLL_INTERVAL,
+        WatcherBackend::Poll => IOS_POLL_INTERVAL,
+    }
+}
+
+pub enum VaultWatcher {
+    Recommended(RecommendedWatcher),
+    Poll(PollWatcher),
+}
+
+impl VaultWatcher {
+    fn watch(&mut self, path: &Path, recursive_mode: RecursiveMode) -> notify::Result<()> {
+        match self {
+            Self::Recommended(watcher) => watcher.watch(path, recursive_mode),
+            Self::Poll(watcher) => watcher.watch(path, recursive_mode),
+        }
+    }
+}
+
+pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<VaultWatcher, String> {
     let (tx, rx) = mpsc::channel();
 
-    let mut watcher = RecommendedWatcher::new(
+    let backend = watcher_backend_for_target(cfg!(target_os = "ios"));
-        tx,
+    let config = Config::default().with_poll_interval(poll_interval_for_backend(backend));
-        Config::default().with_poll_interval(Duration::from_secs(1)),
+    let mut watcher = match backend {
-    )
+        WatcherBackend::Recommended => VaultWatcher::Recommended(
-    .map_err(|e| e.to_string())?;
+            RecommendedWatcher::new(tx, config).map_err(|e| e.to_string())?,
+        ),
+        WatcherBackend::Poll => {
+            VaultWatcher::Poll(PollWatcher::new(tx, config).map_err(|e| e.to_string())?)
+        }
+    };
 
     watcher
         .watch(Path::new(&vault_path), RecursiveMode::Recursive)
@@ -61,6 +104,15 @@ pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWa
                         };
                         let _ = app.emit("file-changed", &fe);
                     }
+
+                    // On mobile, throttle event emission to prevent IPC flooding
+                    // on FUSE filesystems where Syncthing/other apps generate
+                    // constant file activity that blocks the Tauri command channel.
+                    #[cfg(mobile)]
+                    {
+                        std::thread::sleep(Duration::from_secs(2));
+                        while rx.try_recv().is_ok() {}
+                    }
                 }
                 Err(e) => {
                     log::error!("File watcher error: {}", e);
@@ -71,3 +123,33 @@ pub fn start_watcher(app: AppHandle, vault_path: String) -> Result<RecommendedWa
 
     Ok(watcher)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ios_uses_polling_backend() {
+        assert_eq!(watcher_backend_for_target(true), WatcherBackend::Poll);
+    }
+
+    #[test]
+    fn other_platforms_keep_recommended_backend() {
+        assert_eq!(
+            watcher_backend_for_target(false),
+            WatcherBackend::Recommended
+        );
+    }
+
+    #[test]
+    fn watcher_backends_use_the_expected_intervals() {
+        assert_eq!(
+            poll_interval_for_backend(WatcherBackend::Poll),
+            Duration::from_secs(10)
+        );
+        assert_eq!(
+            poll_interval_for_backend(WatcherBackend::Recommended),
+            Duration::from_secs(1)
+        );
+    }
+}

src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../node_modules/@tauri-apps/cli/config.schema.json",
   "productName": "HelixNotes",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "identifier": "com.helixnotes.app",
   "build": {
     "frontendDist": "../build",
@@ -55,6 +55,9 @@
       "appimage": {
         "bundleMediaFramework": false
       }
+    },
+    "macOS": {
+      "entitlements": "entitlements.plist"
     }
   }
 }

src/app.css

@@ -173,6 +173,21 @@
   --danger-hover: #d43d3d;
   --success: #40c057;
   --warning: #fab005;
+  /* Obsidian-style callout accent hues (RGB triplets; mixed with the background via opacity, so one set works on every theme) */
+  --callout-note: 68, 138, 255;
+  --callout-abstract: 0, 191, 188;
+  --callout-info: 0, 184, 212;
+  --callout-todo: 0, 184, 212;
+  --callout-tip: 0, 191, 188;
+  --callout-success: 8, 185, 78;
+  --callout-question: 236, 191, 0;
+  --callout-warning: 236, 117, 0;
+  --callout-failure: 233, 49, 71;
+  --callout-danger: 233, 49, 71;
+  --callout-bug: 233, 49, 71;
+  --callout-example: 120, 82, 238;
+  --callout-quote: 158, 158, 158;
+  --callout-custom: 124, 134, 156;
   --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.05);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.08);
   --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.12);
@@ -204,6 +219,20 @@
   --danger-hover: #eba0ac;
   --success: #a6e3a1;
   --warning: #f9e2af;
+  --callout-note: 100, 160, 255;
+  --callout-abstract: 60, 209, 205;
+  --callout-info: 60, 200, 224;
+  --callout-todo: 60, 200, 224;
+  --callout-tip: 60, 209, 205;
+  --callout-success: 80, 205, 120;
+  --callout-question: 240, 205, 80;
+  --callout-warning: 245, 150, 60;
+  --callout-failure: 240, 95, 115;
+  --callout-danger: 240, 95, 115;
+  --callout-bug: 240, 95, 115;
+  --callout-example: 165, 135, 245;
+  --callout-quote: 150, 150, 162;
+  --callout-custom: 150, 160, 182;
   --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.2);
   --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.3);
   --shadow-lg: 0 8px 24px rgba(0, 0, 0, 0.4);
@@ -1113,10 +1142,6 @@ body.resizing {
 /* ── Mobile (Android/iOS) ── */
 @media (max-width: 768px) {
   body {
-    padding-top: env(safe-area-inset-top);
-    padding-bottom: env(safe-area-inset-bottom);
-    padding-left: env(safe-area-inset-left);
-    padding-right: env(safe-area-inset-right);
     -webkit-tap-highlight-color: transparent;
     touch-action: manipulation;
   }

src/lib/api.ts

@@ -1,6 +1,7 @@
 import { invoke } from "@tauri-apps/api/core";
 import type {
   AppConfig,
+  CustomTheme,
   NoteContent,
   NoteEntry,
   NoteMeta,
@@ -14,14 +15,24 @@ import type {
   BackupEntry,
   VersionEntry,
   TaskItem,
+  ExternalVaultResult,
+  StartupView,
 } from "./types";
 
 export async function openVault(path: string): Promise<void> {
   return invoke("open_vault", { path });
 }
 
-export async function removeVault(path: string): Promise<void> {
+export async function chooseExternalVault(): Promise<ExternalVaultResult | null> {
-  return invoke("remove_vault", { path });
+  return invoke("choose_external_vault");
+}
+
+export async function restoreExternalVault(bookmarkId: string): Promise<ExternalVaultResult> {
+  return invoke("restore_external_vault", { bookmarkId });
+}
+
+export async function removeVault(path: string, bookmarkId?: string | null): Promise<void> {
+  return invoke("remove_vault", { path, bookmarkId: bookmarkId ?? null });
 }
 
 export async function getAppConfig(): Promise<AppConfig> {
@@ -36,6 +47,22 @@ export async function setAccentColor(color: string): Promise<void> {
   return invoke("set_accent_color", { color });
 }
 
+export async function saveCustomTheme(theme: CustomTheme): Promise<void> {
+  return invoke("save_custom_theme", { theme });
+}
+
+export async function deleteCustomTheme(id: string): Promise<void> {
+  return invoke("delete_custom_theme", { id });
+}
+
+export async function exportCustomTheme(id: string, path: string): Promise<void> {
+  return invoke("export_custom_theme", { id, path });
+}
+
+export async function importCustomThemes(path: string): Promise<CustomTheme[]> {
+  return invoke("import_custom_themes", { path });
+}
+
 export async function setFontSize(size: number): Promise<void> {
   return invoke("set_font_size", { size });
 }
@@ -190,6 +217,10 @@ export async function saveVaultState(vaultState: VaultState): Promise<void> {
   return invoke("save_vault_state", { vaultState });
 }
 
+export async function copyTextToClipboard(text: string): Promise<void> {
+  return invoke("copy_text_to_clipboard", { text });
+}
+
 export async function readClipboardImage(): Promise<number[]> {
   return invoke("read_clipboard_image");
 }
@@ -238,6 +269,7 @@ export async function setGeneralSettings(
   closeToTray: boolean,
   enableWikiLinks: boolean,
   showNoteDates: boolean,
+  startupView: StartupView,
   restoreLastSession: boolean,
   showAllNotes: boolean,
   showQuickAccess: boolean,
@@ -263,6 +295,7 @@ export async function setGeneralSettings(
     closeToTray,
     enableWikiLinks,
     showNoteDates,
+    startupView,
     restoreLastSession,
     showAllNotes,
     showQuickAccess,

src/lib/components/AppLayout.svelte

@@ -14,6 +14,7 @@
 	import {
 		sidebarWidth,
 		notelistWidth,
+		outlineWidth,
 		sidebarCollapsed,
 		notelistCollapsed,
 		collapsedNotebooks,
@@ -38,6 +39,7 @@
 		rootNoteCount,
 		viewMode,
 		sortMode,
+		groupNotesByDate,
 		tasksLayout,
 		tasksHideCompleted,
 		tasksOnlyFlagged,
@@ -51,20 +53,22 @@
 		notebookOrder,
 		noteOrder,
 		syncState,
-		platformIsMobile
+		platformIsMobile,
+		activeVaultConfig,
 	} from '$lib/stores/app';
 	import { keybindings, matchAction } from '$lib/keybindings';
 
 	const appWindow = getCurrentWindow();
 	const isMac = navigator.platform.startsWith('Mac');
 	const isMobile = $derived($platformIsMobile);
-	const isAndroid = /android/i.test(navigator.userAgent);
+	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess, setTheme, syncNow, getAppConfig, setTaskDone, setTaskPriority, setTaskDue, findOrphanedAttachments, trashOrphanedAttachments } from '$lib/api';
-	import { loadVaultState, saveVaultState, readNote, createDailyNote, createBackup, getPendingOpenFile, addQuickAccess, removeQuickAccess, getQuickAccess, setTheme, syncNow, setTaskDone, setTaskPriority, setTaskDue } from '$lib/api';
+	import { darkThemes, isAndroid } from '$lib/platform';
-	import { darkThemes } from '$lib/platform';
 	import { debounce } from '$lib/utils/debounce';
 	import { openNoteWindow } from '$lib/utils/window';
+	import { normalizeStartupView, resolveStartupTarget } from '$lib/utils/startup-view';
 	import { get } from 'svelte/store';
 	import type { VaultState, FileEvent, NotebookEntry, TaskItem } from '$lib/types';
+	import type { StartupTarget } from '$lib/utils/startup-view';
 
 	function findNotebookByPath(list: NotebookEntry[], relPath: string): NotebookEntry | null {
 		for (const nb of list) {
@@ -79,6 +83,38 @@
 	let noteList: NoteList;
 	let editor: Editor;
 	let unlistenFileChange: (() => void) | null = null;
+	async function applyStartupTarget(target: StartupTarget): Promise<boolean> {
+		if (target.mode === 'notebook') {
+			const vault = $appConfig?.active_vault;
+			const notebook = target.notebookPath === '' && vault
+				? { name: 'Unfiled Notes', path: vault, relative_path: '', children: [], note_count: $rootNoteCount }
+				: findNotebookByPath($notebooks, target.notebookPath);
+			if (!notebook) return false;
+			const changed = $viewMode !== 'notebook' || $activeNotebook?.relative_path !== notebook.relative_path;
+			$viewMode = 'notebook';
+			$activeNotebook = notebook;
+			$activeTag = null;
+			if (changed) await noteList?.refresh();
+			return true;
+		}
+
+		if (target.mode === 'tag') {
+			const changed = $viewMode !== 'tag' || $activeTag !== target.tag;
+			$viewMode = 'tag';
+			$activeTag = target.tag;
+			$activeNotebook = null;
+			if (changed) await noteList?.refresh();
+			return true;
+		}
+
+		const changed = $viewMode !== target.mode || $activeNotebook !== null || $activeTag !== null;
+		$viewMode = target.mode;
+		$activeNotebook = null;
+		$activeTag = null;
+		if (changed) await noteList?.refresh();
+		return true;
+	}
+
 	let unlistenOpenFile: (() => void) | null = null;
 
 	// Mobile editor header helpers
@@ -120,16 +156,16 @@
 	}
 
 	function syncConfigured(): boolean {
-		return get(appConfig)?.sync_provider === 'webdav';
+		return activeVaultConfig(get(appConfig))?.sync_provider === 'webdav';
 	}
 
 	// Auto-sync on a timer (only when configured and an interval is set).
 	async function checkScheduledSync() {
-		const config = get(appConfig);
+		const vc = activeVaultConfig(get(appConfig));
-		if (config?.sync_provider !== 'webdav') return;
+		if (vc?.sync_provider !== 'webdav') return;
-		const mins = config.sync_interval_minutes ?? 0;
+		const mins = vc.sync_interval_minutes ?? 0;
 		if (!mins || get(syncState).running) return;
-		const last = config.last_sync_time ? new Date(config.last_sync_time).getTime() : 0;
+		const last = vc.last_sync_time ? new Date(vc.last_sync_time).getTime() : 0;
 		if (Date.now() - last >= mins * 60 * 1000) {
 			try { await syncNow(); } catch (_) {}
 		}
@@ -202,6 +238,7 @@
 			last_open_note: $activeNotePath,
 			sidebar_width: $sidebarWidth,
 			notelist_width: $notelistWidth,
+			outline_width: $outlineWidth,
 			sidebar_collapsed: $sidebarCollapsed,
 			notelist_collapsed: $notelistCollapsed,
 			collapsed_notebooks: $collapsedNotebooks,
@@ -209,6 +246,7 @@
 			notebook_order: $notebookOrder,
 			note_order: $noteOrder,
 			sort_mode: $sortMode,
+			group_notes_by_date: $groupNotesByDate,
 			last_view_mode: $viewMode,
 			last_notebook: $activeNotebook?.relative_path ?? null,
 			last_tag: $activeTag,
@@ -248,11 +286,11 @@
 	// Tasks view: the editor pane shows a placeholder until a task is opened from the list.
 	let taskNoteOpened = $state(false);
 
-	function handleNoteSelected(path: string, content: string) {
+	function handleNoteSelected(path: string, content: string, task?: TaskItem) {
 		// Selecting a real vault note exits viewer mode
 		$viewerNote = null;
 		taskNoteOpened = true;
-		editor?.loadNote(path, content);
+		editor?.loadNote(path, content, task);
 		if (isMobile) $mobileView = 'editor';
 	}
 
@@ -426,6 +464,13 @@
 			editor?.addLinkFromToolbar();
 		}
 
+		// Ctrl/Cmd+Shift+Delete: move the open note to the trash.
+		if (mod && e.shiftKey && code === 'Delete' && $activeNotePath) {
+			e.preventDefault();
+			noteList?.trashActiveNote();
+			return;
+		}
+
 		const action = matchAction(e, $keybindings);
 		if (action) {
 			e.preventDefault();
@@ -528,6 +573,7 @@
 	$effect(() => {
 		$sidebarCollapsed;
 		$notelistCollapsed;
+		$outlineWidth;
 		persistState();
 	});
 
@@ -544,6 +590,7 @@
 
 	$effect(() => {
 		$sortMode;
+		$groupNotesByDate;
 		$tasksLayout;
 		$tasksHideCompleted;
 		$tasksOnlyFlagged;
@@ -567,6 +614,7 @@
 			const state = await loadVaultState();
 			$sidebarWidth = state.sidebar_width;
 			$notelistWidth = state.notelist_width;
+			if (typeof state.outline_width === 'number') $outlineWidth = state.outline_width;
 			$sidebarCollapsed = state.sidebar_collapsed;
 			$notelistCollapsed = state.notelist_collapsed ?? false;
 			$collapsedNotebooks = state.collapsed_notebooks ?? [];
@@ -574,6 +622,7 @@
 			$notebookOrder = state.notebook_order ?? {};
 			$noteOrder = state.note_order ?? {};
 			if (state.sort_mode === 'created' || state.sort_mode === 'title' || state.sort_mode === 'modified' || state.sort_mode === 'custom') $sortMode = state.sort_mode;
+			if (typeof state.group_notes_by_date === 'boolean') $groupNotesByDate = state.group_notes_by_date;
 			if (state.tasks_layout === 'calendar' || state.tasks_layout === 'list') $tasksLayout = state.tasks_layout;
 			if (typeof state.tasks_hide_completed === 'boolean') $tasksHideCompleted = state.tasks_hide_completed;
 			if (typeof state.tasks_only_flagged === 'boolean') $tasksOnlyFlagged = state.tasks_only_flagged;
@@ -584,9 +633,11 @@
 			lastTag = state.last_tag ?? null;
 		} catch (_) {}
 
+		const restoreLastSession = $appConfig?.restore_last_session === true;
+
 		// On mobile, prefetch last-opened note so first tap is instant
 		let prefetchPromise: Promise<any> | null = null;
-		if (isMobile && lastNotePath) {
+		if (isMobile && restoreLastSession && lastNotePath) {
 			prefetchPromise = readNote(lastNotePath).catch(() => null);
 		}
 
@@ -599,32 +650,49 @@
 		// Run sidebar and note list refresh in parallel
 		await Promise.all([sidebar?.refresh(), noteList?.refresh()]);
 
-		// Restore the last session (view + open note) if enabled.
+		// Full-vault attachment scans cause navigation stalls on mobile storage.
-		if ($appConfig?.restore_last_session) {
+		// Mobile users can run the same cleanup explicitly from the Info panel.
-			const vault = $appConfig?.active_vault;
+		if (!isMobile) {
-			if (lastViewMode === 'notebook' && lastNotebook === '' && vault) {
+			setTimeout(async () => {
-				$viewMode = 'notebook';
+				if (get(editorDirty)) return; // skip if user is actively editing
-				$activeNotebook = { name: 'Unfiled Notes', path: vault, relative_path: '', children: [], note_count: $rootNoteCount };
-				$activeTag = null;
-				await noteList?.refresh();
-			} else if (lastViewMode === 'notebook' && lastNotebook) {
-				const nb = findNotebookByPath($notebooks, lastNotebook);
-				if (nb) { $viewMode = 'notebook'; $activeNotebook = nb; $activeTag = null; await noteList?.refresh(); }
-			} else if (lastViewMode === 'tag' && lastTag) {
-				$viewMode = 'tag'; $activeTag = lastTag; $activeNotebook = null; await noteList?.refresh();
-			} else if (lastViewMode === 'quickaccess') {
-				$viewMode = 'quickaccess'; $activeNotebook = null; $activeTag = null; await noteList?.refresh();
-			}
-			// Open the last note on desktop (mobile reopens it via its own prefetch path below).
-			if (!isMobile && lastNotePath) {
 				try {
-					const content = await readNote(lastNotePath);
+					const orphans = await findOrphanedAttachments();
-					$activeNote = content;
+					if (orphans.length > 0) {
-					$activeNotePath = lastNotePath;
+						if (get(editorDirty)) return; // re-check after async scan
-					$editorDirty = false;
+						const moved = await trashOrphanedAttachments(orphans.map((o) => o.name));
-					editor?.loadNote(lastNotePath, content.content);
+						if (moved > 0) {
+							const toast = document.createElement('div');
+							toast.style.cssText = 'position:fixed;bottom:24px;left:50%;transform:translateX(-50%);background:var(--bg-secondary);color:var(--text-primary);padding:10px 18px;border-radius:8px;box-shadow:0 4px 12px rgba(0,0,0,.15);border:1px solid var(--border-color);font-size:13px;z-index:10000;opacity:0;transition:opacity .3s;pointer-events:none';
+							toast.textContent = `Moved ${moved} orphaned attachment${moved > 1 ? 's' : ''} to trash`;
+							document.body.appendChild(toast);
+							requestAnimationFrame(() => (toast.style.opacity = '1'));
+							setTimeout(() => { toast.style.opacity = '0'; setTimeout(() => toast.remove(), 300); }, 4000);
+						}
+					}
 				} catch (_) {}
-			}
+			}, 3000);
+		}
+
+		const startupTarget = resolveStartupTarget({
+			startupView: $appConfig?.startup_view,
+			restoreLastSession,
+			lastViewMode,
+			lastNotebook,
+			lastTag
+		});
+		if (!(await applyStartupTarget(startupTarget))) {
+			await applyStartupTarget({ mode: normalizeStartupView($appConfig?.startup_view) });
+		}
+
+		// Reopen the last note only when session restoration is enabled.
+		if (restoreLastSession && !isMobile && lastNotePath) {
+			try {
+				const content = await readNote(lastNotePath);
+				$activeNote = content;
+				$activeNotePath = lastNotePath;
+				$editorDirty = false;
+				editor?.loadNote(lastNotePath, content.content);
+			} catch (_) {}
 		}
 
 		// On mobile, derive tags from the scanned notes (avoids a separate full-scan Rust call)
@@ -664,7 +732,7 @@
 					}
 				}
 				tags.set(Array.from(tagMap.entries()).sort((a, b) => a[0].localeCompare(b[0])));
-			}, 3000);
+		}, 10000);
 			unlistenFileChange = await listen<FileEvent>('file-changed', () => {
 				debouncedRefresh();
 			});
@@ -694,15 +762,16 @@
 
 		// ── WebDAV sync: global status + auto-sync triggers ──
 		unlistenSync.push(await listen('sync-progress', () => syncState.set({ running: true, error: null })));
-		unlistenSync.push(await listen('sync-done', (event: any) => {
+		unlistenSync.push(await listen('sync-done', async () => {
 			syncState.set({ running: false, error: null });
-			const cur = get(appConfig);
+			try {
-			if (cur && event.payload?.last_sync_time) appConfig.set({ ...cur, last_sync_time: event.payload.last_sync_time });
+				appConfig.set(await getAppConfig());
+			} catch {}
 		}));
 		unlistenSync.push(await listen('sync-error', (event: any) => syncState.set({ running: false, error: event.payload?.error ?? 'Sync failed' })));
 
 		// Sync when the vault opens (if enabled)
-		if (syncConfigured() && get(appConfig)?.sync_on_open) {
+		if (syncConfigured() && activeVaultConfig(get(appConfig))?.sync_on_open) {
 			try { await syncNow(); } catch (_) {}
 		}
 
@@ -712,8 +781,8 @@
 
 		// Auto-sync on note change: a save flips editorDirty true -> false. Debounce a sync.
 		unsubDirty = editorDirty.subscribe((d) => {
-			const config = get(appConfig);
+			const vc = activeVaultConfig(get(appConfig));
-			if (prevDirty && !d && config?.sync_provider === 'webdav' && config?.sync_on_change) {
+			if (prevDirty && !d && vc?.sync_provider === 'webdav' && vc?.sync_on_change) {
 				if (onChangeSyncTimer) clearTimeout(onChangeSyncTimer);
 				onChangeSyncTimer = setTimeout(() => { if (!get(syncState).running) syncNow().catch(() => {}); }, 15000);
 			}
@@ -829,7 +898,7 @@
 						</svg>
 					</button>
 					{/if}
-					{#if $appConfig?.sync_provider === 'webdav'}
+					{#if activeVaultConfig($appConfig)?.sync_provider === 'webdav'}
 					<button class="mobile-header-btn" class:active={$syncState.running} onclick={triggerSyncNow} disabled={$syncState.running} title={$syncState.error ? `Sync error: ${$syncState.error}` : ($syncState.running ? 'Syncing...' : 'Sync now')}>
 						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class:sync-spin={$syncState.running}>
 							<path d="M21 2v6h-6"/><path d="M3 12a9 9 0 0115-6.7L21 8"/><path d="M3 22v-6h6"/><path d="M21 12a9 9 0 01-15 6.7L3 16"/>
@@ -856,6 +925,13 @@
 							<line x1="3" y1="10" x2="21" y2="10" />
 						</svg>
 					</button>
+					<button class="mobile-header-btn" onclick={() => ($showInfo = true)} title="Info">
+						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+							<circle cx="12" cy="12" r="10" />
+							<line x1="12" y1="16" x2="12" y2="12" />
+							<line x1="12" y1="8" x2="12.01" y2="8" />
+						</svg>
+					</button>
 					<button class="mobile-header-btn" onclick={() => ($showSettings = true)} title="Settings">
 						<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 							<circle cx="12" cy="12" r="3" />
@@ -872,7 +948,7 @@
 				<Sidebar bind:this={sidebar} onViewChanged={handleViewChanged} />
 			</div>
 			<div class="mobile-panel" class:active={$mobileView === 'notelist'}>
-				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); sidebar?.refresh(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
+				<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
 			</div>
 			<div class="mobile-panel" class:active={$mobileView === 'editor'}>
 				<Editor bind:this={editor} />
@@ -933,7 +1009,7 @@
 
 				{#if !$notelistCollapsed}
 					<div class="notelist-panel" style="width: {$notelistWidth}px">
-						<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); sidebar?.refresh(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
+						<NoteList bind:this={noteList} onNoteSelected={handleNoteSelected} onBeforeNoteSwitch={() => editor?.flushSave()} onNoteMoved={() => sidebar?.refresh()} onNoteCreated={() => { editor?.focusTitle(); }} onToggleTask={toggleTask} onSetTaskPriority={changeTaskPriority} onSetTaskDue={changeTaskDue} />
 					</div>
 
 					<ResizeHandle onResize={handleNotelistResize} />
@@ -1114,7 +1190,13 @@
 	.mobile-shell {
 		display: flex;
 		flex-direction: column;
-		height: 100vh;
+		height: 100dvh;
+		box-sizing: border-box;
+		padding:
+			env(safe-area-inset-top, 0px)
+			env(safe-area-inset-right, 0px)
+			env(safe-area-inset-bottom, 0px)
+			env(safe-area-inset-left, 0px);
 		overflow: hidden;
 		background: var(--bg-primary);
 	}

src/lib/components/GraphView.svelte

@@ -2,14 +2,13 @@
 	import { onDestroy } from 'svelte';
 	import { getGraphData } from '$lib/api';
 	import { activeNotePath, appConfig } from '$lib/stores/app';
+	import { isMobile } from '$lib/platform';
 
 	let { onclose, onnavigate }: {
 		onclose: () => void;
 		onnavigate: (path: string, title: string) => void;
 	} = $props();
 
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
-
 	let canvas = $state<HTMLCanvasElement>(null!);
 	let loading = $state(true);
 	let searchQuery = $state('');

src/lib/components/InfoPanel.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { showInfo, appConfig } from '$lib/stores/app';
+	import { showInfo } from '$lib/stores/app';
 	import { getVaultStats, findOrphanedAttachments, trashOrphanedAttachments } from '$lib/api';
 	import type { OrphanAttachment } from '$lib/api';
 	import { openUrl } from '$lib/api';
@@ -15,9 +15,9 @@
 		bindingsEqual,
 		type ActionDef,
 	} from '$lib/keybindings';
+	import { isMobile } from '$lib/platform';
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
 
 	// Customizable shortcuts, grouped for display.
 	const actionGroups: { title: string; actions: ActionDef[] }[] = [
@@ -96,7 +96,7 @@
 
 	function close() {
 		$showInfo = false;
-		activeTab = 'shortcuts';
+		activeTab = isMobile ? 'about' : 'shortcuts';
 	}
 
 	function openLink(url: string) {
@@ -144,7 +144,7 @@
 		<div class="info-panel" onclick={(e) => e.stopPropagation()}>
 			<div class="info-header">
 				<h2>Info</h2>
-				<button class="close-btn" onclick={close}>
+				<button class="close-btn" onclick={close} aria-label="Close info">
 					<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 						<line x1="18" y1="6" x2="6" y2="18" />
 						<line x1="6" y1="6" x2="18" y2="18" />
@@ -273,6 +273,7 @@
 						<div class="shortcut-row"><span class="shortcut-desc">Strikethrough</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>X</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Code</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>E</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Link</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>K</kbd></span></div>
+						<div class="shortcut-row"><span class="shortcut-desc">Collapsible section</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>.</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Undo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Z</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Redo</span><span class="shortcut-keys"><kbd>{modKey}</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd></span></div>
 						<div class="shortcut-row"><span class="shortcut-desc">Move line up / down</span><span class="shortcut-keys"><kbd>Alt</kbd>+<kbd>↑↓</kbd></span></div>

src/lib/components/NoteList.svelte

@@ -9,6 +9,7 @@
 		activeNotebook,
 		activeTag,
 		sortMode,
+		groupNotesByDate,
 		editorDirty,
 		quickAccessPaths,
 		appConfig,
@@ -37,15 +38,17 @@
 		getAllTags,
 		createDailyNote
 	} from '$lib/api';
-	import { formatRelativeTime, formatDate } from '$lib/utils/time';
+	import { formatRelativeTime, formatDate, dateBucketLabel } from '$lib/utils/time';
 	import { openNoteWindow } from '$lib/utils/window';
+	import { encodeNoteDragPaths } from '$lib/utils/note-drag';
 	import { revealItemInDir } from '@tauri-apps/plugin-opener';
 	import type { NoteEntry, TrashNotebookEntry, SortMode, TaskItem } from '$lib/types';
 	import TasksView from './TasksView.svelte';
 	import TagSuggestInput from './TagSuggestInput.svelte';
+	import { isMobile, isAndroid } from '$lib/platform';
 
-	let { onNoteSelected = (_path: string, _content: string) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {}, onNoteCreated = () => {}, onToggleTask = async (_t: TaskItem) => {}, onSetTaskPriority = async (_t: TaskItem, _p: string | null) => {}, onSetTaskDue = async (_t: TaskItem, _d: string | null) => {} }: {
+	let { onNoteSelected = (_path: string, _content: string, _task?: TaskItem) => {}, onNoteMoved = () => {}, onBeforeNoteSwitch = () => {}, onNoteCreated = () => {}, onToggleTask = async (_t: TaskItem) => {}, onSetTaskPriority = async (_t: TaskItem, _p: string | null) => {}, onSetTaskDue = async (_t: TaskItem, _d: string | null) => {} }: {
-		onNoteSelected?: (path: string, content: string) => void;
+		onNoteSelected?: (path: string, content: string, task?: TaskItem) => void;
 		onNoteMoved?: () => void;
 		onBeforeNoteSwitch?: () => void;
 		onNoteCreated?: () => void;
@@ -55,8 +58,6 @@
 	} = $props();
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
-	const isAndroid = /android/i.test(navigator.userAgent);
 	let multiSelectMode = $state(false);
 	let trashNotebooks = $state<TrashNotebookEntry[]>([]);
 	let trashBusy = $state<string | null>(null);
@@ -213,6 +214,24 @@
 	const customOrderViews = new Set(['all', 'notebook', 'tag']);
 	let canCustomReorder = $derived($sortMode === 'custom' && customOrderViews.has($viewMode));
 
+	// Relative-date grouping (All Notes + date sorts only). Pinned notes form their own leading group.
+	let groupingActive = $derived($groupNotesByDate && $viewMode === 'all' && ($sortMode === 'created' || $sortMode === 'modified'));
+	let noteGroups = $derived.by(() => {
+		if (!groupingActive) return [] as { label: string; notes: NoteEntry[] }[];
+		const pinned: NoteEntry[] = [];
+		const rest: NoteEntry[] = [];
+		for (const n of $sortedNotes) (n.meta.pinned ? pinned : rest).push(n);
+		const groups: { label: string; notes: NoteEntry[] }[] = [];
+		if (pinned.length) groups.push({ label: 'Pinned', notes: pinned });
+		let cur: { label: string; notes: NoteEntry[] } | null = null;
+		for (const n of rest) {
+			const label = dateBucketLabel($sortMode === 'created' ? n.meta.created : n.meta.modified);
+			if (!cur || cur.label !== label) { cur = { label, notes: [] }; groups.push(cur); }
+			cur.notes.push(n);
+		}
+		return groups;
+	});
+
 	// Virtual scroll
 	let listContainer = $state<HTMLDivElement>(null!);
 	let scrollTop = $state(0);
@@ -247,6 +266,19 @@
 		if (listContainer) listContainer.scrollTop = 0;
 	});
 
+	// Notes can also be removed from this list by a drop handled in the sidebar.
+	$effect(() => {
+		if (selectedPaths.size === 0) return;
+		const availablePaths = new Set($notes.map((note) => note.path));
+		const remaining = new Set([...selectedPaths].filter((path) => availablePaths.has(path)));
+		if (remaining.size === selectedPaths.size) return;
+		if (remaining.size === 0) {
+			clearSelection();
+		} else {
+			selectedPaths = remaining;
+		}
+	});
+
 	// Invalidate quickaccess cache when starred notes change (e.g. from Editor star toggle)
 	$effect(() => {
 		$quickAccessPaths;
@@ -391,13 +423,14 @@
 			$activeNote = content;
 			$activeNotePath = task.note_path;
 			$editorDirty = false;
-			onNoteSelected(task.note_path, content.content);
+			onNoteSelected(task.note_path, content.content, task);
 		} catch (e) {
 			console.error('Failed to open task note:', e);
 		}
 	}
 
 	export async function handleCreateNote() {
+		if ($viewMode === 'quickaccess' || $viewMode === 'trash') return;
 		if ($viewMode === 'daily') {
 			const today = new Date();
 			const date = `${today.getFullYear()}-${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
@@ -423,14 +456,26 @@
 			const entry = await createNote(nbRelative, 'Untitled');
 			if ($sortMode === 'custom') appendManualNoteOrder(entry.path);
 			noteCache.clear();
-			await refresh();
+			$notes = [entry, ...$notes];
-			await selectNote(entry);
+			onBeforeNoteSwitch();
+			$activeNote = { path: entry.path, meta: entry.meta, content: '\n', raw: '' };
+			$activeNotePath = entry.path;
+			$editorDirty = false;
+			onNoteSelected(entry.path, '\n');
 			onNoteCreated();
 		} catch (e) {
 			console.error('Failed to create note:', e);
 		}
 	}
 
+	function handleListDoubleClick(e: MouseEvent) {
+		const target = e.target as HTMLElement | null;
+		if (target?.closest('button, input, .note-item, .context-menu, .sort-menu, .batch-move-picker, .cal')) return;
+		e.stopPropagation();
+		if ($viewMode === 'tasks' || $viewMode === 'trash' || $viewMode === 'quickaccess') return;
+		handleCreateNote();
+	}
+
 	async function handleRename(note: NoteEntry) {
 		if (!editValue.trim() || editValue.trim() === note.meta.title) {
 			editingNote = null;
@@ -474,6 +519,13 @@
 		}
 	}
 
+	// Move the currently open note to the trash (keyboard shortcut from the editor).
+	export async function trashActiveNote() {
+		if ($viewMode === 'trash' || !$activeNotePath) return;
+		const note = $notes.find(n => n.path === $activeNotePath);
+		if (note) await handleDelete(note);
+	}
+
 	async function handleRestore(note: NoteEntry) {
 		contextMenu = null;
 		try {
@@ -749,6 +801,19 @@
 		}
 	}
 
+	function isFiled(note: NoteEntry): boolean {
+		const vaultRoot = $appConfig?.active_vault?.replace(/\\/g, '/').replace(/\/$/, '');
+		if (!vaultRoot) return false;
+		const normalizedPath = note.path.replace(/\\/g, '/');
+		const noteDir = normalizedPath.substring(0, normalizedPath.lastIndexOf('/'));
+		return noteDir !== vaultRoot;
+	}
+
+	function unfileNote(note: NoteEntry) {
+		const vaultRoot = $appConfig?.active_vault;
+		if (vaultRoot) handleMoveNote(note, vaultRoot);
+	}
+
 	function clampMenu(x: number, y: number, menuWidth = 220, menuHeight = 400): { x: number; y: number } {
 		if (x + menuWidth > window.innerWidth) x = window.innerWidth - menuWidth - 8;
 		if (y + menuHeight > window.innerHeight) y = window.innerHeight - menuHeight - 8;
@@ -949,7 +1014,14 @@
 					<line x1="4" y1="6" x2="11" y2="6" /><line x1="4" y1="12" x2="15" y2="12" /><line x1="4" y1="18" x2="20" y2="18" />
 				</svg>
 			</button>
-			{#if $viewMode !== 'trash'}
+			{#if $viewMode === 'all' && ($sortMode === 'created' || $sortMode === 'modified')}
+				<button class="icon-btn" class:active-toggle={$groupNotesByDate} onclick={() => { $groupNotesByDate = !$groupNotesByDate; }} title="Group by date">
+					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+						<line x1="8" y1="6" x2="21" y2="6" /><line x1="8" y1="12" x2="21" y2="12" /><line x1="8" y1="18" x2="21" y2="18" /><line x1="3" y1="6" x2="3.01" y2="6" /><line x1="3" y1="12" x2="3.01" y2="12" /><line x1="3" y1="18" x2="3.01" y2="18" />
+					</svg>
+				</button>
+			{/if}
+			{#if $viewMode !== 'trash' && $viewMode !== 'quickaccess'}
 				<button class={isMobile ? 'mobile-create-btn' : 'icon-btn'} onclick={handleCreateNote} title={`New note (${modKey}+N)`}>
 					<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width={isMobile ? '3' : '2'} stroke-linecap="round" stroke-linejoin="round">
 						<line x1="12" y1="5" x2="12" y2="19" /><line x1="5" y1="12" x2="19" y2="12" />
@@ -965,8 +1037,14 @@
 			<span class="selection-count">{selectedPaths.size} selected</span>
 			<div class="selection-actions">
 				{#if $viewMode === 'trash'}
-					<button class="selection-action" onclick={handleBatchRestore}>Restore</button>
+					<button class="selection-action" onclick={handleBatchRestore} title="Restore selected">
-					<button class="selection-action danger" onclick={handleBatchPermanentDelete}>Delete</button>
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>
+						Restore
+					</button>
+					<button class="selection-action danger" onclick={handleBatchPermanentDelete} title="Delete permanently">
+						<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-2 14a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2L5 6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"/></svg>
+						Delete
+					</button>
 				{:else}
 					<button class="selection-action" onclick={() => { batchMovePicker = true; }}>Move</button>
 					<button class="selection-action" onclick={() => openBatchTagEdit()}>Tag</button>
@@ -1047,7 +1125,8 @@
 		</div>
 	{/if}
 
-	<div class="list-content" bind:this={listContainer} onscroll={onListScroll}>
+	<!-- svelte-ignore a11y_no_static_element_interactions -->
+	<div class="list-content" class:tasks-mode={$viewMode === 'tasks'} bind:this={listContainer} onscroll={onListScroll} ondblclick={handleListDoubleClick}>
 		{#if $viewMode === 'tasks'}
 			<TasksView onOpenTask={openTask} onToggleTask={onToggleTask} onSetTaskPriority={onSetTaskPriority} onSetTaskDue={onSetTaskDue} />
 		{/if}
@@ -1089,6 +1168,8 @@
 			<div class="empty-state">
 				{#if $viewMode === 'trash'}
 					<p>Trash is empty</p>
+				{:else if $viewMode === 'quickaccess'}
+					<p>No starred notes</p>
 				{:else}
 					<p>No notes yet</p>
 					<button class="btn-link" onclick={handleCreateNote}>Create your first note</button>
@@ -1127,9 +1208,7 @@
 			{/each}
 		{/if}
 
-		<div style="height: {topPad}px"></div>
+		{#snippet noteRow(note: NoteEntry, noteIndex: number)}
-		{#each visibleNotes as note, i (note.path)}
-			{@const noteIndex = startIndex + i}
 			{#if editingNote === note.path}
 				<div class="note-item active">
 					<input
@@ -1194,11 +1273,10 @@
 							e.dataTransfer!.effectAllowed = 'move';
 							return;
 						}
-						if (selectedPaths.size > 1 && selectedPaths.has(note.path)) {
+						const dragPaths = selectedPaths.size > 1 && selectedPaths.has(note.path)
-							e.dataTransfer!.setData('text/plain', [...selectedPaths].join('\n'));
+							? selectedPaths
-						} else {
+							: [note.path];
-							e.dataTransfer!.setData('text/plain', note.path);
+						e.dataTransfer!.setData('text/plain', encodeNoteDragPaths(dragPaths));
-						}
 						e.dataTransfer!.effectAllowed = 'move';
 					}}
 					ondragover={(e) => {
@@ -1280,11 +1358,35 @@
 								</span>
 							{/if}
 						</div>
-					{/if}
+				{/if}
-				</button>
+				{#if $viewMode === 'trash'}
+					<span class="trash-row-actions">
+						<span class="trash-row-btn" role="button" tabindex="0" onclick={(e) => { e.stopPropagation(); handleRestore(note); }} title="Restore" onkeydown={(e) => { if (e.key === 'Enter') { e.stopPropagation(); handleRestore(note); } }}>
+							<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 12a9 9 0 1 0 9-9 9.75 9.75 0 0 0-6.74 2.74L3 8"/><path d="M3 3v5h5"/></svg>
+						</span>
+						<span class="trash-row-btn danger" role="button" tabindex="0" onclick={(e) => { e.stopPropagation(); handlePermanentDelete(note); }} title="Delete permanently" onkeydown={(e) => { if (e.key === 'Enter') { e.stopPropagation(); handlePermanentDelete(note); } }}>
+							<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"/><path d="M19 6l-2 14a2 2 0 0 1-2 2H9a2 2 0 0 1-2-2L5 6"/><path d="M10 11v6"/><path d="M14 11v6"/><path d="M9 6V4h6v2"/></svg>
+						</span>
+					</span>
+				{/if}
+			</button>
 			{/if}
-		{/each}
+		{/snippet}
-		<div style="height: {bottomPad}px"></div>
+
+		{#if groupingActive}
+			{#each noteGroups as group (group.label)}
+				<div class="note-list-section">{group.label}</div>
+				{#each group.notes as note (note.path)}
+					{@render noteRow(note, -1)}
+				{/each}
+			{/each}
+		{:else}
+			<div style="height: {topPad}px"></div>
+			{#each visibleNotes as note, i (note.path)}
+				{@render noteRow(note, startIndex + i)}
+			{/each}
+			<div style="height: {bottomPad}px"></div>
+		{/if}
 	</div>
 </div>
 
@@ -1459,6 +1561,14 @@
 				</svg>
 				Move to...
 			</button>
+			{#if isFiled(contextMenu.note)}
+			<button onclick={() => unfileNote(contextMenu!.note)}>
+				<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+					<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z"/><path d="M9 13h6"/>
+				</svg>
+				Unfile Note
+			</button>
+			{/if}
 			{#if !isMobile}
 			<button onclick={async () => { const n = contextMenu!.note; contextMenu = null; await selectNote(n); setTimeout(() => window.print(), 300); }}>
 				<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
@@ -1581,17 +1691,19 @@
 		padding: 4px;
 	}
 
-	.list-content::-webkit-scrollbar {
+	.note-list-section {
-		width: 8px;
+		padding: 14px 12px 4px;
+		font-size: 0.7rem;
+		font-weight: 700;
+		letter-spacing: 0.06em;
+		text-transform: uppercase;
+		color: var(--accent);
+		border-bottom: 1px solid var(--border-light);
+		margin-bottom: 2px;
+		user-select: none;
 	}
-
+	.note-list-section:first-child {
-	.list-content::-webkit-scrollbar-thumb {
+		padding-top: 6px;
-		background: var(--text-tertiary);
-		border-radius: 4px;
-	}
-
-	.list-content::-webkit-scrollbar-thumb:hover {
-		background: var(--text-secondary);
 	}
 
 	.note-item {
@@ -1605,6 +1717,7 @@
 		text-align: left;
 		margin-bottom: 1px;
 		contain: content;
+		position: relative;
 	}
 
 	.note-item:hover {
@@ -1651,6 +1764,9 @@
 	}
 
 	.selection-action {
+		display: inline-flex;
+		align-items: center;
+		gap: 4px;
 		background: none;
 		border: 1px solid var(--border-color);
 		color: var(--text-primary);
@@ -1665,6 +1781,37 @@
 		background: var(--bg-hover);
 	}
 
+	.trash-row-actions {
+		position: absolute;
+		right: 6px;
+		top: 50%;
+		transform: translateY(-50%);
+		display: none;
+		gap: 2px;
+	}
+	.note-item:hover .trash-row-actions {
+		display: flex;
+	}
+	.trash-row-btn {
+		cursor: pointer;
+		padding: 4px;
+		border-radius: 4px;
+		color: var(--text-secondary);
+		display: flex;
+		align-items: center;
+	}
+	.trash-row-btn:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+	.trash-row-btn.danger:hover {
+		color: var(--danger);
+		background: color-mix(in srgb, var(--danger) 10%, transparent);
+	}
+	.note-list.mobile .trash-row-actions {
+		display: flex;
+	}
+
 	.selection-action.danger {
 		color: var(--danger);
 		border-color: color-mix(in srgb, var(--danger) 30%, var(--border-color));
@@ -2079,6 +2226,11 @@
 		padding: 4px 8px 180px;
 	}
 
+	.note-list.mobile .list-content.tasks-mode {
+		padding-bottom: 0;
+		overflow: hidden;
+	}
+
 	.note-list.mobile .note-item {
 		padding: 14px 16px;
 		min-height: 56px;

src/lib/components/NoteWindow.svelte

@@ -103,8 +103,11 @@
 				if (!$editorDirty) {
 					try {
 						const content = await readNote(notePath);
-						$activeNote = content;
+						// Ignore the file-watcher echo of our own save; only reload genuine external edits.
-						editor?.loadNote(notePath, content.content);
+						if (content.content.trim() !== (editor?.getCurrentBody() ?? '').trim()) {
+							$activeNote = content;
+							editor?.loadNote(notePath, content.content);
+						}
 					} catch (_) {}
 				}
 			}

src/lib/components/NotebookGlyph.svelte

@@ -0,0 +1,61 @@
+<script lang="ts">
+  import type { NotebookIconId } from '$lib/utils/notebook-icons';
+
+  let { icon, size = 18 }: { icon: NotebookIconId; size?: number } = $props();
+</script>
+
+<svg
+  width={size}
+  height={size}
+  viewBox="0 0 24 24"
+  fill="none"
+  stroke="currentColor"
+  stroke-width="1.8"
+  stroke-linecap="round"
+  stroke-linejoin="round"
+  aria-hidden="true"
+>
+  {#if icon === 'book'}
+    <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20" />
+    <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2Z" />
+  {:else if icon === 'folder'}
+    <path d="M3 6.5A2.5 2.5 0 0 1 5.5 4H9l2 2.5h7.5A2.5 2.5 0 0 1 21 9v8.5a2.5 2.5 0 0 1-2.5 2.5h-13A2.5 2.5 0 0 1 3 17.5Z" />
+  {:else if icon === 'briefcase'}
+    <rect x="3" y="7" width="18" height="13" rx="2" />
+    <path d="M8 7V5a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2M3 12h18M10 12v2h4v-2" />
+  {:else if icon === 'home'}
+    <path d="m3 11 9-8 9 8" />
+    <path d="M5 10v11h14V10M9 21v-7h6v7" />
+  {:else if icon === 'star'}
+    <path d="m12 2 3.1 6.3 6.9 1-5 4.8 1.2 6.9-6.2-3.3L5.8 21 7 14.1l-5-4.8 6.9-1Z" />
+  {:else if icon === 'heart'}
+    <path d="M20.8 4.6a5.5 5.5 0 0 0-7.8 0L12 5.7l-1.1-1.1a5.5 5.5 0 0 0-7.8 7.8l1.1 1.1L12 21l7.8-7.5 1.1-1.1a5.5 5.5 0 0 0-.1-7.8Z" />
+  {:else if icon === 'lightbulb'}
+    <path d="M9 18h6M10 22h4" />
+    <path d="M8.2 15.5A7 7 0 1 1 15.8 15.5c-.7.5-.8 1.1-.8 2.5H9c0-1.4-.1-2-.8-2.5Z" />
+  {:else if icon === 'code'}
+    <path d="m8 9-4 3 4 3M16 9l4 3-4 3M14 5l-4 14" />
+  {:else if icon === 'flask'}
+    <path d="M9 3h6M10 3v6l-5.5 9.5A1.7 1.7 0 0 0 6 21h12a1.7 1.7 0 0 0 1.5-2.5L14 9V3" />
+    <path d="M7 16h10" />
+  {:else if icon === 'graduation'}
+    <path d="m2 9 10-5 10 5-10 5Z" />
+    <path d="M6 11.5V16c3.5 2.7 8.5 2.7 12 0v-4.5M22 9v6" />
+  {:else if icon === 'calendar'}
+    <rect x="3" y="5" width="18" height="16" rx="2" />
+    <path d="M16 3v4M8 3v4M3 10h18M8 14h.01M12 14h.01M16 14h.01M8 18h.01M12 18h.01" />
+  {:else if icon === 'tasks'}
+    <rect x="3" y="3" width="18" height="18" rx="2" />
+    <path d="m7 8 1.5 1.5L11 7M13 9h4M7 14l1.5 1.5L11 13M13 15h4" />
+  {:else if icon === 'archive'}
+    <path d="M4 8v12h16V8M3 4h18v4H3ZM9 12h6" />
+  {:else if icon === 'globe'}
+    <circle cx="12" cy="12" r="9" />
+    <path d="M3 12h18M12 3a14 14 0 0 1 0 18M12 3a14 14 0 0 0 0 18" />
+  {:else if icon === 'plane'}
+    <path d="M22 2 9.5 14.5M22 2l-7 20-4-8-8-4Z" />
+  {:else}
+    <path d="M12 3a9 9 0 1 0 0 18h1.5a1.5 1.5 0 0 0 0-3H12a1.5 1.5 0 0 1 0-3h3a6 6 0 0 0 0-12Z" />
+    <path d="M7.5 10h.01M9.5 6.5h.01M14.5 6.5h.01M17 10h.01" />
+  {/if}
+</svg>

src/lib/components/SearchPanel.svelte

@@ -1,8 +1,9 @@
 <script lang="ts">
-	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig, mobileView } from '$lib/stores/app';
+	import { showSearch, activeNote, activeNotePath, editorDirty, appConfig, mobileView, notebooks, activeNotebook, activeTag, viewMode } from '$lib/stores/app';
 	import { searchNotes, readNote } from '$lib/api';
 	import { debounce } from '$lib/utils/debounce';
-	import type { SearchResult } from '$lib/types';
+	import type { SearchResult, NotebookEntry } from '$lib/types';
+	import { isMobile } from '$lib/platform';
 
 	let query = $state('');
 	let results = $state<SearchResult[]>([]);
@@ -83,7 +84,16 @@
 		return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 	}
 
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
+	function findNotebookByPath(nbs: NotebookEntry[], target: string): NotebookEntry | null {
+		for (const nb of nbs) {
+			if (nb.path === target) return nb;
+			if (nb.children.length) {
+				const found = findNotebookByPath(nb.children, target);
+				if (found) return found;
+			}
+		}
+		return null;
+	}
 
 	async function openResult(result: SearchResult) {
 		try {
@@ -92,6 +102,19 @@
 			$activeNotePath = result.path;
 			$editorDirty = false;
 			$showSearch = false;
+			// Reveal the note in the notes list: switch to its notebook (or All Notes).
+			const sep = result.path.includes('\\') ? '\\' : '/';
+			const parentDir = result.path.slice(0, result.path.lastIndexOf(sep));
+			const nb = parentDir ? findNotebookByPath($notebooks, parentDir) : null;
+			if (nb) {
+				$activeNotebook = nb;
+				$activeTag = null;
+				$viewMode = 'notebook';
+			} else {
+				$activeNotebook = null;
+				$activeTag = null;
+				$viewMode = 'all';
+			}
 			if (isMobile) $mobileView = 'editor';
 		} catch (e) {
 			console.error('Failed to open search result:', e);

src/lib/components/Sidebar.svelte

@@ -26,13 +26,21 @@
 	import { readFile } from '@tauri-apps/plugin-fs';
 	import { convertFileSrc } from '@tauri-apps/api/core';
 	import type { NotebookEntry } from '$lib/types';
+	import { isMobile } from '$lib/platform';
+	import { decodeNoteDragPaths } from '$lib/utils/note-drag';
+	import NotebookGlyph from './NotebookGlyph.svelte';
+	import {
+		NOTEBOOK_ICON_OPTIONS,
+		decodeBuiltinNotebookIcon,
+		encodeBuiltinNotebookIcon,
+		type NotebookIconId
+	} from '$lib/utils/notebook-icons';
 
 	let { onViewChanged = () => {} }: {
 		onViewChanged?: () => void;
 	} = $props();
 
 	const modKey = navigator.platform.startsWith('Mac') ? '⌘' : 'Ctrl';
-	const isMobile = /android|iphone|ipad|ipod/i.test(navigator.userAgent);
 
 	// Whether any top nav item (All Notes, Quick Access, Tasks, Daily Notes, Trash) is visible.
 	// When all are hidden we drop the empty <nav> and its divider so the tree sits flush.
@@ -53,6 +61,15 @@
 	let dropTargetPath = $state<string | null>(null);
 	let dropPosition = $state<'above' | 'into' | 'below' | null>(null);
 	let draggedNotebookPath = $state<string | null>(null);
+	let nbPointer: { src: string } | null = null;
+
+	// Notebook paths arrive from Rust with native separators (backslashes on Windows), so path math must be separator-agnostic.
+	const norm = (p: string) => (p ?? '').replace(/\\/g, '/');
+	const lastSep = (p: string) => Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+	const parentOf = (p: string) => { const i = lastSep(p); return i < 0 ? '' : p.slice(0, i); };
+	const baseOf = (p: string) => p.slice(lastSep(p) + 1);
+	const joinPath = (parent: string, name: string) => parent + (parent.includes('\\') ? '\\' : '/') + name;
+	const isDescendant = (child: string, anc: string) => child.startsWith(anc + '/') || child.startsWith(anc + '\\');
 
 	// Apply manual ordering recursively when in 'manual' sort mode.
 	// In 'alphabetical' mode the Rust scanner already sorts, so we pass through unchanged.
@@ -69,15 +86,11 @@
 	}
 	let sortedNotebooks = $derived(sortNotebooksTree($notebooks));
 	let contextMenu = $state<{ x: number; y: number; notebook: NotebookEntry } | null>(null);
+	let iconPickerNotebook = $state<NotebookEntry | null>(null);
+	let iconPickerElement = $state<HTMLDivElement | null>(null);
 	let trashContextMenu = $state<{ x: number; y: number } | null>(null);
 	let tagsCollapsed = $state(true);
 	let deleteConfirm = $state<NotebookEntry | null>(null);
-	function expandNotebook(nb: NotebookEntry) {
-		if ($collapsedNotebooks.includes(nb.path)) {
-			$collapsedNotebooks = $collapsedNotebooks.filter(p => p !== nb.path);
-		}
-	}
-
 	function toggleCollapse(nb: NotebookEntry, e: Event) {
 		e.stopPropagation();
 		if ($collapsedNotebooks.includes(nb.path)) {
@@ -143,6 +156,10 @@
 		const vault = $appConfig?.active_vault;
 		if (!vault) return;
 		if ($viewMode === 'notebook' && $activeNotebook?.relative_path === '') {
+			if (isMobile) {
+				onViewChanged();
+				return;
+			}
 			selectAllNotes();
 			return;
 		}
@@ -153,22 +170,15 @@
 	}
 
 	async function selectNotebook(nb: NotebookEntry) {
-		const hasVisibleChildren = nb.children.length > 0;
+		// Deselect if clicking the already-active notebook; expand/collapse is the chevron's job
-		const wasCollapsed = $collapsedNotebooks.includes(nb.path);
-		// Deselect if clicking the already-active notebook
 		if ($viewMode === 'notebook' && $activeNotebook?.path === nb.path) {
-			if (hasVisibleChildren) {
+			if (isMobile) {
-				if (wasCollapsed) {
+				onViewChanged();
-					await expandNotebook(nb);
-				} else {
-					$collapsedNotebooks = [...$collapsedNotebooks, nb.path];
-				}
 				return;
 			}
 			selectAllNotes();
 			return;
 		}
-		if (hasVisibleChildren) await expandNotebook(nb);
 		$viewMode = 'notebook';
 		$activeNotebook = nb;
 		$activeTag = null;
@@ -340,50 +350,64 @@
 	async function handleNoteDrop(e: DragEvent, nb: NotebookEntry) {
 		e.preventDefault();
 		dropTargetPath = null;
-		const notePath = e.dataTransfer?.getData('text/plain');
+		const payload = e.dataTransfer?.getData('text/plain') ?? '';
-		if (!notePath) return;
+		const notePaths = [...new Set(decodeNoteDragPaths(payload))]
-		// Don't move if already in this notebook
+			.filter((path) => norm(parentOf(path)) !== norm(nb.path));
-		const noteDir = notePath.substring(0, notePath.lastIndexOf('/'));
+		if (notePaths.length === 0) return;
-		if (noteDir === nb.path) return;
+
-		try {
+		const movedPaths = new Map<string, string>();
-			const newPath = await moveNote(notePath, nb.path);
+		for (const notePath of notePaths) {
-			$notes = $notes.filter(n => n.path !== notePath);
+			try {
-			if ($activeNotePath === notePath) {
+				movedPaths.set(notePath, await moveNote(notePath, nb.path));
-				$activeNotePath = newPath;
+			} catch (e) {
-				$activeNote = await readNote(newPath);
+				console.error('Failed to move note:', notePath, e);
 			}
-			await refresh();
-		} catch (e) {
-			console.error('Failed to move note:', e);
 		}
+		if (movedPaths.size === 0) return;
+
+		$notes = $notes.filter((note) => !movedPaths.has(note.path));
+		const activeNewPath = $activeNotePath ? movedPaths.get($activeNotePath) : undefined;
+		if (activeNewPath) {
+			$activeNotePath = activeNewPath;
+			try {
+				$activeNote = await readNote(activeNewPath);
+			} catch (e) {
+				console.error('Failed to reload moved note:', e);
+			}
+		}
+		await refresh();
 	}
 
 	async function handleNotebookDrop(e: DragEvent, destPath: string) {
 		e.preventDefault();
-		dropTargetPath = null;
 		const srcPath = e.dataTransfer?.getData('text/plain');
-		if (!srcPath) return;
+		if (srcPath) await nestNotebook(srcPath, destPath);
+	}
+
+	async function nestNotebook(srcPath: string, destPath: string) {
+		dropTargetPath = null;
+		dropPosition = null;
 		draggedNotebookPath = null;
 		// Don't move onto self or descendant
-		if (destPath === srcPath || destPath.startsWith(srcPath + '/')) return;
+		if (destPath === srcPath || isDescendant(destPath, srcPath)) return;
 		// Don't move if already in that parent
-		const parentDir = srcPath.substring(0, srcPath.lastIndexOf('/'));
+		const parentDir = parentOf(srcPath);
 		if (parentDir === destPath) return;
 		try {
-			const oldName = srcPath.split('/').pop() || '';
+			const oldName = baseOf(srcPath);
-			const newBasePath = destPath + '/' + oldName;
+			const newBasePath = joinPath(destPath, oldName);
 			await moveNotebook(srcPath, destPath);
 			// Update collapsedNotebooks paths
 			$collapsedNotebooks = $collapsedNotebooks.map(p => {
 				if (p === srcPath) return newBasePath;
-				if (p.startsWith(srcPath + '/')) return newBasePath + p.slice(srcPath.length);
+				if (isDescendant(p, srcPath)) return newBasePath + p.slice(srcPath.length);
 				return p;
 			});
 			// Update active notebook/note if inside the moved notebook
-			if ($activeNotebook?.path === srcPath || $activeNotebook?.path.startsWith(srcPath + '/')) {
+			if ($activeNotebook?.path === srcPath || isDescendant($activeNotebook?.path ?? '', srcPath)) {
 				selectAllNotes();
 			}
-			if ($activeNotePath && $activeNotePath.startsWith(srcPath + '/')) {
+			if ($activeNotePath && isDescendant($activeNotePath, srcPath)) {
 				const newNotePath = newBasePath + $activeNotePath.slice(srcPath.length);
 				$activeNotePath = newNotePath;
 				$activeNote = await readNote(newNotePath);
@@ -395,10 +419,74 @@
 		}
 	}
 
+	function nbStopDragListeners() {
+		window.removeEventListener('pointermove', nbPointerMove);
+		window.removeEventListener('pointerup', nbDragEnd);
+		window.removeEventListener('pointercancel', nbDragEnd);
+		window.removeEventListener('mouseup', nbDragEnd);
+	}
+
+	function nbHandleDown(e: PointerEvent, nb: NotebookEntry) {
+		if (e.pointerType === 'mouse' && e.button !== 0) return;
+		e.stopPropagation();
+		e.preventDefault();
+		nbStopDragListeners();
+		nbPointer = { src: nb.path };
+		draggedNotebookPath = nb.path;
+		// Capture helps touch hold the gesture; on Windows mouse it makes WebView2 swallow the release, so skip it there.
+		if (e.pointerType === 'touch') {
+			try { (e.currentTarget as HTMLElement).setPointerCapture(e.pointerId); } catch {}
+		}
+		window.addEventListener('pointermove', nbPointerMove, { passive: false });
+		window.addEventListener('pointerup', nbDragEnd);
+		window.addEventListener('pointercancel', nbDragEnd);
+		window.addEventListener('mouseup', nbDragEnd);
+	}
+
+	function nbPointerMove(e: PointerEvent) {
+		if (!nbPointer) return;
+		e.preventDefault();
+		const el = document.elementFromPoint(e.clientX, e.clientY) as HTMLElement | null;
+		if (el?.closest('[data-nb-root]')) { dropTargetPath = '__root__'; dropPosition = null; return; }
+		const row = el?.closest('[data-nb-path]') as HTMLElement | null;
+		const path = row?.getAttribute('data-nb-path');
+		if (!path) { dropTargetPath = null; dropPosition = null; return; }
+		const src = nbPointer.src;
+		if (path === src || path.startsWith(src + '/')) { dropTargetPath = null; dropPosition = null; return; }
+		const rect = row!.getBoundingClientRect();
+		const relY = (e.clientY - rect.top) / rect.height;
+		const pos: 'above' | 'into' | 'below' = relY < 0.3 ? 'above' : relY > 0.7 ? 'below' : 'into';
+		if (pos === 'into' && src.substring(0, src.lastIndexOf('/')) === path) { dropTargetPath = null; dropPosition = null; return; }
+		dropTargetPath = path;
+		dropPosition = pos;
+	}
+
+	function nbDragEnd() {
+		if (!nbPointer) return;
+		nbStopDragListeners();
+		const src = nbPointer.src;
+		const target = dropTargetPath;
+		const pos = dropPosition;
+		nbPointer = null;
+		draggedNotebookPath = null;
+		dropTargetPath = null;
+		dropPosition = null;
+		if (!target) return;
+		if (target === '__root__') {
+			const vaultRoot = $appConfig?.active_vault;
+			if (vaultRoot) nestNotebook(src, vaultRoot);
+		} else if (pos === 'above' || pos === 'below') {
+			handleNotebookReorder(src, target, pos);
+		} else if (pos === 'into') {
+			nestNotebook(src, target);
+		}
+	}
+
 	function findSiblingsOfPath(tree: NotebookEntry[], parentPath: string, vaultRoot: string): NotebookEntry[] {
-		if (parentPath === vaultRoot) return tree;
+		const target = norm(parentPath);
+		if (target === norm(vaultRoot)) return tree;
 		for (const nb of tree) {
-			if (nb.path === parentPath) return nb.children;
+			if (norm(nb.path) === target) return nb.children;
 			if (nb.children.length > 0) {
 				const found = findSiblingsOfPath(nb.children, parentPath, vaultRoot);
 				if (found.length > 0) return found;
@@ -412,41 +500,39 @@
 		dropPosition = null;
 		draggedNotebookPath = null;
 		if (srcPath === targetPath) return;
-		if (targetPath.startsWith(srcPath + '/')) return; // can't move into descendant
+		if (isDescendant(targetPath, srcPath)) return; // can't move into descendant
 		const vaultRoot = $appConfig?.active_vault;
 		if (!vaultRoot) return;
 
-		const srcParent = srcPath.substring(0, srcPath.lastIndexOf('/'));
+		const srcParent = parentOf(srcPath);
-		const targetParent = targetPath.substring(0, targetPath.lastIndexOf('/'));
+		const targetParent = parentOf(targetPath);
 		let actualSrcPath = srcPath;
 
 		try {
 			// Step 1: if different parents, move src into target's parent first
 			if (srcParent !== targetParent) {
-				const oldName = srcPath.split('/').pop() || '';
+				const oldName = baseOf(srcPath);
-				const newPath = targetParent === vaultRoot
+				const newPath = joinPath(targetParent, oldName);
-					? vaultRoot + '/' + oldName
-					: targetParent + '/' + oldName;
 				await moveNotebook(srcPath, targetParent);
 				// Migrate paths in collapsedNotebooks
 				$collapsedNotebooks = $collapsedNotebooks.map(p => {
 					if (p === srcPath) return newPath;
-					if (p.startsWith(srcPath + '/')) return newPath + p.slice(srcPath.length);
+					if (isDescendant(p, srcPath)) return newPath + p.slice(srcPath.length);
 					return p;
 				});
 				// Migrate paths in notebookOrder
 				const migrated: Record<string, number> = {};
 				for (const [p, v] of Object.entries($notebookOrder)) {
 					if (p === srcPath) migrated[newPath] = v;
-					else if (p.startsWith(srcPath + '/')) migrated[newPath + p.slice(srcPath.length)] = v;
+					else if (isDescendant(p, srcPath)) migrated[newPath + p.slice(srcPath.length)] = v;
 					else migrated[p] = v;
 				}
 				$notebookOrder = migrated;
 				// Update active notebook/note
-				if ($activeNotebook?.path === srcPath || $activeNotebook?.path.startsWith(srcPath + '/')) {
+				if ($activeNotebook?.path === srcPath || isDescendant($activeNotebook?.path ?? '', srcPath)) {
 					selectAllNotes();
 				}
-				if ($activeNotePath && $activeNotePath.startsWith(srcPath + '/')) {
+				if ($activeNotePath && isDescendant($activeNotePath, srcPath)) {
 					const newNotePath = newPath + $activeNotePath.slice(srcPath.length);
 					$activeNotePath = newNotePath;
 					$activeNote = await readNote(newNotePath);
@@ -492,21 +578,38 @@
 		renameInput?.select();
 	}
 
-	async function handleSetIcon(nb: NotebookEntry) {
+	async function openIconPicker(nb: NotebookEntry) {
 		contextMenu = null;
+		iconPickerNotebook = nb;
+		await tick();
+		iconPickerElement?.focus();
+	}
+
+	async function handleBuiltinIcon(nb: NotebookEntry, icon: NotebookIconId) {
+		try {
+			const value = encodeBuiltinNotebookIcon(icon);
+			await setNotebookIcon(nb.relative_path, value);
+			$notebookIcons = { ...$notebookIcons, [nb.relative_path]: value };
+			iconPickerNotebook = null;
+		} catch (e) {
+			console.error('Failed to set notebook icon:', e);
+		}
+	}
+
+	async function handleCustomIcon(nb: NotebookEntry) {
+		iconPickerNotebook = null;
 		try {
 			const selected = await openDialog({
 				multiple: false,
 				filters: [{ name: 'Images', extensions: ['png', 'jpg', 'jpeg', 'gif', 'svg', 'webp', 'ico'] }]
 			});
 			if (!selected) return;
-			const filePath = typeof selected === 'string' ? selected : selected;
+			const filePath = selected as string;
-			// Read the file and save as attachment
+			const data = await readFile(filePath);
-			const data = await readFile(filePath as string);
+			const fileName = baseOf(filePath) || 'icon.png';
-			const fileName = (filePath as string).split('/').pop() || 'icon.png';
 			const iconRelative = await saveAttachment(`notebook-icon-${fileName}`, Array.from(data));
 			await setNotebookIcon(nb.relative_path, iconRelative);
-			$notebookIcons = await getNotebookIcons();
+			$notebookIcons = { ...$notebookIcons, [nb.relative_path]: iconRelative };
 		} catch (e) {
 			console.error('Failed to set notebook icon:', e);
 		}
@@ -514,9 +617,12 @@
 
 	async function handleRemoveIcon(nb: NotebookEntry) {
 		contextMenu = null;
+		iconPickerNotebook = null;
 		try {
 			await setNotebookIcon(nb.relative_path, null);
-			$notebookIcons = await getNotebookIcons();
+			const icons = { ...$notebookIcons };
+			delete icons[nb.relative_path];
+			$notebookIcons = icons;
 		} catch (e) {
 			console.error('Failed to remove notebook icon:', e);
 		}
@@ -524,7 +630,7 @@
 
 	function getNotebookIconSrc(nb: NotebookEntry): string | null {
 		const iconPath = $notebookIcons[nb.relative_path];
-		if (!iconPath) return null;
+		if (!iconPath || iconPath.startsWith('builtin:')) return null;
 		const vaultRoot = $appConfig?.active_vault;
 		if (!vaultRoot) return null;
 		return convertFileSrc(`${vaultRoot}/${iconPath}`);
@@ -544,6 +650,14 @@
 		contextMenu = { x, y, notebook: nb };
 	}
 
+	function openNotebookMenu(e: Event, nb: NotebookEntry) {
+		e.preventDefault();
+		e.stopPropagation();
+		const rect = (e.currentTarget as HTMLElement).getBoundingClientRect();
+		const { x, y } = clampMenu(rect.right - 200, rect.bottom + 4, 200, 280);
+		contextMenu = { x, y, notebook: nb };
+	}
+
 	function closeContextMenu() {
 		contextMenu = null;
 	}
@@ -576,9 +690,9 @@
 	}
 </script>
 
-<svelte:window onclick={handleWindowClick} />
+<svelte:window onclick={handleWindowClick} onkeydown={(e) => { if (e.key === 'Escape') iconPickerNotebook = null; }} />
 
-<aside class="sidebar" class:collapsed={$sidebarCollapsed} class:mobile={isMobile} class:nav-empty={!anyNavItem} ondblclick={startNewNotebookFromSidebar}>
+<aside class="sidebar" class:collapsed={$sidebarCollapsed} class:mobile={isMobile} class:nav-empty={!anyNavItem}>
 	{#if !isMobile}
 	<div class="sidebar-header">
 		<button class="collapse-btn" onclick={() => ($sidebarCollapsed = !$sidebarCollapsed)} title="Toggle sidebar">
@@ -675,11 +789,13 @@
 		</nav>
 		{/if}
 
-		<div class="section">
+		<!-- svelte-ignore a11y_no_static_element_interactions -->
+		<div class="section" ondblclick={startNewNotebookFromSidebar}>
 			<!-- svelte-ignore a11y_no_static_element_interactions -->
 			<div
 				class="section-header"
 				class:drop-target={dropTargetPath === '__root__'}
+				data-nb-root
 				ondragover={(e) => {
 					if (draggedNotebookPath) {
 						e.preventDefault();
@@ -739,13 +855,14 @@
 						class="notebook-item"
 						class:active={$viewMode === 'notebook' && $activeNotebook?.relative_path === ''}
 						onclick={selectUnfiled}
+						style="padding-left: 4px"
 					>
-						<span style="width:13px;flex-shrink:0"></span>
+					<span style="width:14px;flex-shrink:0"></span>
-						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink:0;opacity:0.6">
+					<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="flex-shrink:0;opacity:0.6">
-							<path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z" />
+						<path d="M22 12h-6l-2 3h-4l-2-3H2" />
-							<polyline points="14 2 14 8 20 8" />
+						<path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" />
-						</svg>
+					</svg>
-						<span class="notebook-name">Unfiled Notes <span class="notebook-count">{$rootNoteCount}</span></span>
+					<span class="notebook-name">Unfiled Notes <span class="notebook-count">{$rootNoteCount}</span></span>
 					</button>
 				{/if}
 				{#each sortedNotebooks as nb (nb.path)}
@@ -823,8 +940,11 @@
 </aside>
 
 {#if contextMenu}
+	{#if isMobile}
+		<button type="button" class="context-menu-backdrop" aria-label="Close notebook actions" onclick={closeContextMenu}></button>
+	{/if}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
-	<div class="context-menu" style="left: {contextMenu.x}px; top: {contextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
+	<div class="context-menu" class:mobile={isMobile} style="left: {contextMenu.x}px; top: {contextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
 		<button onclick={() => startNewSubNotebook(contextMenu!.notebook)}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z" /><line x1="12" y1="11" x2="12" y2="17" /><line x1="9" y1="14" x2="15" y2="14" /></svg>
 			New Sub-notebook
@@ -833,16 +953,10 @@
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7" /><path d="M18.5 2.5a2.121 2.121 0 013 3L12 15l-4 1 1-4 9.5-9.5z" /></svg>
 			Rename
 		</button>
-		<button onclick={() => handleSetIcon(contextMenu!.notebook)}>
+		<button onclick={() => openIconPicker(contextMenu!.notebook)}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10" /><path d="M8 14s1.5 2 4 2 4-2 4-2" /><line x1="9" y1="9" x2="9.01" y2="9" /><line x1="15" y1="9" x2="15.01" y2="9" /></svg>
-			Set Icon
+			{$notebookIcons[contextMenu.notebook.relative_path] ? 'Change Icon...' : 'Set Icon...'}
 		</button>
-		{#if $notebookIcons[contextMenu.notebook.relative_path]}
-			<button onclick={() => handleRemoveIcon(contextMenu!.notebook)}>
-				<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10" /><line x1="15" y1="9" x2="9" y2="15" /><line x1="9" y1="9" x2="15" y2="15" /></svg>
-				Remove Icon
-			</button>
-		{/if}
 		<button class="danger" onclick={() => handleDelete(contextMenu!.notebook)}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6" /><path d="M19 6l-1 14a2 2 0 01-2 2H8a2 2 0 01-2-2L5 6" /><path d="M10 11v6" /><path d="M14 11v6" /><path d="M9 6V4a1 1 0 011-1h4a1 1 0 011 1v2" /></svg>
 			Delete
@@ -850,9 +964,56 @@
 	</div>
 {/if}
 
+{#if iconPickerNotebook}
+	<div class="icon-picker-overlay" class:mobile={isMobile}>
+		<button class="icon-picker-backdrop" aria-label="Close icon picker" onclick={() => iconPickerNotebook = null}></button>
+		<div bind:this={iconPickerElement} class="icon-picker" role="dialog" aria-modal="true" aria-label={`Choose an icon for ${iconPickerNotebook.name}`} tabindex="-1">
+			<header class="icon-picker-header">
+				<div>
+					<h3>Notebook icon</h3>
+					<p>{iconPickerNotebook.name}</p>
+				</div>
+				<button class="icon-picker-close" aria-label="Close icon picker" onclick={() => iconPickerNotebook = null}>
+					<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><path d="M18 6 6 18M6 6l12 12" /></svg>
+				</button>
+			</header>
+			<div class="icon-picker-grid">
+				{#each NOTEBOOK_ICON_OPTIONS as option}
+					<button
+						class="icon-picker-option"
+						class:active={$notebookIcons[iconPickerNotebook.relative_path] === encodeBuiltinNotebookIcon(option.id)}
+						aria-label={option.label}
+						title={option.label}
+						onclick={() => handleBuiltinIcon(iconPickerNotebook!, option.id)}
+					>
+						<NotebookGlyph icon={option.id} size={20} />
+						<span>{option.label}</span>
+					</button>
+				{/each}
+			</div>
+			<div class="icon-picker-actions">
+				<button onclick={() => handleCustomIcon(iconPickerNotebook!)}>
+					<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="3" y="3" width="18" height="18" rx="2" /><circle cx="8.5" cy="8.5" r="1.5" /><path d="m21 15-5-5L5 21" /></svg>
+					Custom image...
+				</button>
+				{#if $notebookIcons[iconPickerNotebook.relative_path]}
+					<button class="remove" onclick={() => handleRemoveIcon(iconPickerNotebook!)}>
+						<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"><path d="M4 7h16M9 7V4h6v3M7 7l1 13h8l1-13" /></svg>
+						Use default
+					</button>
+				{/if}
+				<p class="icon-picker-recommendation">Recommended size: <strong>1:1 aspect ratio</strong></p>
+			</div>
+		</div>
+	</div>
+{/if}
+
 {#if trashContextMenu}
+	{#if isMobile}
+		<button type="button" class="context-menu-backdrop" aria-label="Close trash actions" onclick={() => trashContextMenu = null}></button>
+	{/if}
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
-	<div class="context-menu" style="left: {trashContextMenu.x}px; top: {trashContextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
+	<div class="context-menu" class:mobile={isMobile} style="left: {trashContextMenu.x}px; top: {trashContextMenu.y}px" onmousedown={(e) => e.stopPropagation()}>
 		<button class="danger" onclick={handleEmptyTrash}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
 				<polyline points="3 6 5 6 21 6" /><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2" /><line x1="10" y1="11" x2="10" y2="17" /><line x1="14" y1="11" x2="14" y2="17" />
@@ -866,7 +1027,7 @@
 	<!-- svelte-ignore a11y_no_static_element_interactions -->
 	<div class="delete-confirm-overlay" onclick={() => deleteConfirm = null}>
 		<!-- svelte-ignore a11y_no_static_element_interactions -->
-		<div class="delete-confirm" onclick={(e) => e.stopPropagation()}>
+		<div class="delete-confirm" class:mobile={isMobile} onclick={(e) => e.stopPropagation()}>
 			<h4>Delete "{deleteConfirm.name}"?</h4>
 			<p>This notebook contains {countNotesRecursive(deleteConfirm)} note{countNotesRecursive(deleteConfirm) === 1 ? '' : 's'} that will be permanently deleted.</p>
 			<div class="delete-confirm-actions">
@@ -881,8 +1042,9 @@
 	{@const hasChildren = nb.children.length > 0}
 	{@const isCollapsed = $collapsedNotebooks.includes(nb.path)}
 	{@const iconSrc = getNotebookIconSrc(nb)}
+	{@const builtinIcon = decodeBuiltinNotebookIcon($notebookIcons[nb.relative_path])}
 	{#if editingNotebook === nb.path}
-		<div class="notebook-item" style="padding-left: {8 + depth * 16}px">
+		<div class="notebook-item" style="padding-left: {4 + depth * 16}px">
 			<input
 				type="text"
 				class="rename-input"
@@ -896,14 +1058,15 @@
 			/>
 		</div>
 	{:else}
+		<div class="notebook-row" data-nb-path={nb.path}>
 		<button
 			class="notebook-item"
 			class:active={$viewMode === 'notebook' && $activeNotebook?.path === nb.path}
 			class:drop-target={dropTargetPath === nb.path && dropPosition === 'into'}
 			class:drop-above={dropTargetPath === nb.path && dropPosition === 'above'}
 			class:drop-below={dropTargetPath === nb.path && dropPosition === 'below'}
-			style="padding-left: {8 + depth * 16}px"
+			style="padding-left: {4 + depth * 16}px"
-			draggable="true"
+			data-nb-path={nb.path}
 			onclick={() => selectNotebook(nb)}
 			onkeydown={(e) => {
 				if (e.key === 'F2') {
@@ -912,8 +1075,6 @@
 				}
 			}}
 			oncontextmenu={(e) => onContextMenu(e, nb)}
-			ondragstart={(e) => { draggedNotebookPath = nb.path; e.dataTransfer!.setData('text/plain', nb.path); e.dataTransfer!.effectAllowed = 'move'; }}
-			ondragend={() => { draggedNotebookPath = null; dropPosition = null; }}
 			ondragover={(e) => {
 				e.preventDefault();
 				if (draggedNotebookPath) {
@@ -970,15 +1131,46 @@
 			{:else}
 				<span class="chevron-spacer"></span>
 			{/if}
-			{#if iconSrc}
+		{#if builtinIcon}
-				<img class="notebook-icon" src={iconSrc} alt="" />
+			<span class="notebook-builtin-icon"><NotebookGlyph icon={builtinIcon} size={18} /></span>
-			{:else}
+		{:else if iconSrc}
-				<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" opacity="0.6">
+			<img class="notebook-icon" src={iconSrc} alt="" />
-					<path d="M22 19a2 2 0 01-2 2H4a2 2 0 01-2-2V5a2 2 0 012-2h5l2 3h9a2 2 0 012 2z" />
+		{:else if isCollapsed || nb.children.length === 0}
-				</svg>
+			<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="opacity:0.6;flex-shrink:0">
-			{/if}
+				<path d="M2 6h4"/><path d="M2 10h4"/><path d="M2 14h4"/><path d="M2 18h4"/>
+				<path d="M6 2h12a2 2 0 012 2v16a2 2 0 01-2 2H6a2 2 0 01-2-2V4a2 2 0 012-2z"/>
+			</svg>
+		{:else}
+			<svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" style="opacity:0.6;flex-shrink:0">
+				<path d="M2 6h4"/><path d="M2 10h4"/><path d="M2 14h4"/><path d="M2 18h4"/>
+				<path d="M6 2h12a2 2 0 012 2v16a2 2 0 01-2 2H6a2 2 0 01-2-2V4a2 2 0 012-2z"/>
+				<path d="M10 9h8"/><path d="M10 13h8"/><path d="M10 17h5"/>
+			</svg>
+		{/if}
 			<span class="notebook-name">{nb.name} <span class="notebook-count">{nb.note_count}</span></span>
+			{#if $notebookSortMode === 'manual'}
+				<!-- svelte-ignore a11y_no_static_element_interactions a11y_click_events_have_key_events -->
+				<span
+					class="nb-drag-handle"
+					title="Drag to reorder"
+					onpointerdown={(e) => nbHandleDown(e, nb)}
+					onclick={(e) => e.stopPropagation()}
+				>
+					<svg width="12" height="12" viewBox="0 0 24 24" fill="currentColor"><circle cx="9" cy="5" r="1.6"/><circle cx="15" cy="5" r="1.6"/><circle cx="9" cy="12" r="1.6"/><circle cx="15" cy="12" r="1.6"/><circle cx="9" cy="19" r="1.6"/><circle cx="15" cy="19" r="1.6"/></svg>
+				</span>
+			{/if}
 		</button>
+		{#if isMobile}
+			<button
+				type="button"
+				class="notebook-actions-btn"
+				aria-label={`Actions for ${nb.name}`}
+				onclick={(e) => openNotebookMenu(e, nb)}
+			>
+				<svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><circle cx="5" cy="12" r="1.8"/><circle cx="12" cy="12" r="1.8"/><circle cx="19" cy="12" r="1.8"/></svg>
+			</button>
+		{/if}
+		</div>
 	{/if}
 	{#if hasChildren && !isCollapsed}
 		{#each nb.children as child (child.path)}
@@ -1070,7 +1262,7 @@
 	.section {
 		flex: 1;
 		overflow-y: auto;
-		padding: 4px 0;
+		padding: 0 0 4px;
 		border-top: 1px solid var(--border-light);
 	}
 
@@ -1221,12 +1413,16 @@
 		padding: 0 2px;
 	}
 
+	.notebook-row {
+		position: relative;
+	}
+
 	.notebook-item {
 		display: flex;
 		align-items: center;
 		gap: 6px;
 		width: 100%;
-		padding: 5px 8px;
+		padding: 5px 8px 5px 4px;
 		border: none;
 		background: none;
 		border-radius: 6px;
@@ -1293,6 +1489,15 @@
 		flex-shrink: 0;
 	}
 
+	.notebook-builtin-icon {
+		width: 20px;
+		height: 20px;
+		display: grid;
+		place-items: center;
+		color: var(--text-secondary);
+		flex-shrink: 0;
+	}
+
 	.notebook-name {
 		flex: 1;
 		text-align: left;
@@ -1307,6 +1512,49 @@
 		margin-left: 2px;
 	}
 
+	.nb-drag-handle {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		flex: 0 0 auto;
+		padding: 2px;
+		margin-left: 2px;
+		color: var(--text-tertiary);
+		opacity: 0.45;
+		cursor: grab;
+		touch-action: none;
+	}
+
+	.nb-drag-handle:hover {
+		opacity: 1;
+	}
+
+	.nb-drag-handle:active {
+		cursor: grabbing;
+	}
+
+	.notebook-actions-btn {
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		position: absolute;
+		right: 4px;
+		top: 50%;
+		transform: translateY(-50%);
+		width: 44px;
+		height: 44px;
+		padding: 0;
+		border: none;
+		border-radius: 8px;
+		background: none;
+		color: var(--text-tertiary);
+	}
+
+	.notebook-actions-btn:active {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
 	.tag-list {
 		padding: 0 4px;
 	}
@@ -1375,6 +1623,15 @@
 		min-width: 140px;
 	}
 
+	.context-menu-backdrop {
+		position: fixed;
+		inset: 0;
+		z-index: 999;
+		padding: 0;
+		border: none;
+		background: rgba(0, 0, 0, 0.18);
+	}
+
 	.context-menu button {
 		display: flex;
 		align-items: center;
@@ -1402,6 +1659,195 @@
 		background: color-mix(in srgb, var(--danger) 10%, transparent);
 	}
 
+	.icon-picker-overlay {
+		position: fixed;
+		inset: 0;
+		z-index: 1100;
+		display: grid;
+		place-items: center;
+		padding: 20px;
+	}
+
+	.icon-picker-backdrop {
+		position: absolute;
+		inset: 0;
+		width: 100%;
+		height: 100%;
+		padding: 0;
+		border: none;
+		background: rgba(8, 10, 18, 0.42);
+		cursor: default;
+	}
+
+	.icon-picker {
+		position: relative;
+		z-index: 1;
+		width: min(360px, 100%);
+		max-height: calc(100dvh - 40px);
+		overflow-y: auto;
+		background: var(--bg-primary);
+		border: 1px solid var(--border-color);
+		border-radius: 14px;
+		box-shadow: var(--shadow-lg);
+	}
+
+	.icon-picker-header {
+		display: flex;
+		align-items: center;
+		justify-content: space-between;
+		gap: 16px;
+		padding: 16px 18px 12px;
+		border-bottom: 1px solid var(--border-light);
+	}
+
+	.icon-picker-header h3,
+	.icon-picker-header p {
+		margin: 0;
+	}
+
+	.icon-picker-header h3 {
+		color: var(--text-primary);
+		font-size: 15px;
+		font-weight: 650;
+	}
+
+	.icon-picker-header p {
+		margin-top: 2px;
+		color: var(--text-tertiary);
+		font-size: 12px;
+	}
+
+	.icon-picker-close {
+		width: 32px;
+		height: 32px;
+		display: grid;
+		place-items: center;
+		padding: 0;
+		border: none;
+		border-radius: 8px;
+		background: transparent;
+		color: var(--text-tertiary);
+		cursor: pointer;
+	}
+
+	.icon-picker-close:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.icon-picker-grid {
+		display: grid;
+		grid-template-columns: repeat(4, minmax(0, 1fr));
+		gap: 7px;
+		padding: 14px;
+	}
+
+	.icon-picker-option {
+		min-width: 0;
+		min-height: 60px;
+		display: flex;
+		flex-direction: column;
+		align-items: center;
+		justify-content: center;
+		gap: 5px;
+		padding: 7px 3px 6px;
+		border: 1px solid transparent;
+		border-radius: 9px;
+		background: var(--bg-secondary);
+		color: var(--text-secondary);
+		cursor: pointer;
+	}
+
+	.icon-picker-option span {
+		max-width: 100%;
+		overflow: hidden;
+		color: var(--text-tertiary);
+		font-size: 10px;
+		line-height: 1.1;
+		text-overflow: ellipsis;
+		white-space: nowrap;
+	}
+
+	.icon-picker-option:hover {
+		border-color: var(--border-color);
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.icon-picker-option.active {
+		border-color: var(--accent);
+		background: var(--accent-light);
+		color: var(--accent);
+	}
+
+	.icon-picker-option.active span {
+		color: var(--accent);
+	}
+
+	.icon-picker-actions {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 8px;
+		padding: 12px 14px 14px;
+		border-top: 1px solid var(--border-light);
+	}
+
+	.icon-picker-recommendation {
+		flex: 0 0 100%;
+		margin: 2px 0 0;
+		color: var(--text-tertiary);
+		font-size: 11px;
+		line-height: 1.3;
+		text-align: center;
+	}
+
+	.icon-picker-actions button {
+		flex: 1;
+		display: flex;
+		align-items: center;
+		justify-content: center;
+		gap: 7px;
+		padding: 9px 12px;
+		border: 1px solid var(--border-color);
+		border-radius: 8px;
+		background: var(--bg-secondary);
+		color: var(--text-secondary);
+		font-size: 12px;
+		cursor: pointer;
+	}
+
+	.icon-picker-actions button:hover {
+		background: var(--bg-hover);
+		color: var(--text-primary);
+	}
+
+	.icon-picker-actions button.remove {
+		background: transparent;
+	}
+
+	.icon-picker-overlay.mobile {
+		place-items: end center;
+		padding:
+			20px
+			calc(12px + env(safe-area-inset-right, 0px))
+			calc(12px + env(safe-area-inset-bottom, 0px))
+			calc(12px + env(safe-area-inset-left, 0px));
+	}
+
+	.icon-picker-overlay.mobile .icon-picker {
+		width: 100%;
+		max-height: calc(100dvh - 32px - env(safe-area-inset-top, 0px) - env(safe-area-inset-bottom, 0px));
+	}
+
+	.icon-picker-overlay.mobile .icon-picker-option {
+		min-height: 64px;
+	}
+
+	.icon-picker-overlay.mobile .icon-picker-actions button {
+		min-height: 44px;
+		font-size: 14px;
+	}
+
 	.delete-confirm-overlay {
 		position: fixed;
 		inset: 0;
@@ -1529,7 +1975,7 @@
 	}
 
 	.sidebar.mobile .notebook-item {
-		padding: 12px 12px;
+		padding: 2px 56px 2px 12px;
 		min-height: 48px;
 		gap: 10px;
 		font-size: 15px;
@@ -1540,6 +1986,11 @@
 		height: 24px;
 	}
 
+	.sidebar.mobile .notebook-builtin-icon {
+		width: 24px;
+		height: 24px;
+	}
+
 	.sidebar.mobile .new-notebook-input {
 		padding: 4px 12px;
 	}
@@ -1570,34 +2021,40 @@
 		display: none;
 	}
 
-	.sidebar.mobile .context-menu {
+	.context-menu.mobile {
-		min-width: 200px;
+		left: calc(12px + env(safe-area-inset-left, 0px)) !important;
+		right: calc(12px + env(safe-area-inset-right, 0px));
+		top: auto !important;
+		bottom: calc(12px + env(safe-area-inset-bottom, 0px));
+		min-width: 0;
+		max-height: calc(100dvh - 24px - env(safe-area-inset-top, 0px) - env(safe-area-inset-bottom, 0px));
+		overflow-y: auto;
 		border-radius: 12px;
 		padding: 6px;
 	}
 
-	.sidebar.mobile .context-menu button {
+	.context-menu.mobile button {
 		padding: 12px 16px;
 		font-size: 15px;
 		min-height: 44px;
 		border-radius: 8px;
 	}
 
-	.sidebar.mobile .delete-confirm {
+	.delete-confirm.mobile {
 		max-width: calc(100vw - 40px);
 		padding: 24px;
 	}
 
-	.sidebar.mobile .delete-confirm h4 {
+	.delete-confirm.mobile h4 {
 		font-size: 16px;
 	}
 
-	.sidebar.mobile .delete-confirm p {
+	.delete-confirm.mobile p {
 		font-size: 14px;
 	}
 
-	.sidebar.mobile .delete-confirm-cancel,
+	.delete-confirm.mobile .delete-confirm-cancel,
-	.sidebar.mobile .delete-confirm-btn {
+	.delete-confirm.mobile .delete-confirm-btn {
 		padding: 10px 20px;
 		font-size: 14px;
 		min-height: 44px;

src/lib/components/TagSuggestInput.svelte

@@ -16,11 +16,10 @@
 	// Existing tags that match what's typed, prefix matches first, already-applied ones excluded.
 	const suggestions = $derived.by(() => {
 		const q = query.trim().toLowerCase();
-		if (!q) return [];
 		const taken = new Set(existing);
 		const names = $tags
 			.map(([name]) => name)
-			.filter((name) => !taken.has(name) && name.toLowerCase().includes(q));
+			.filter((name) => !taken.has(name) && (!q || name.toLowerCase().includes(q)));
 		names.sort((a, b) => {
 			const ap = a.toLowerCase().startsWith(q) ? 0 : 1;
 			const bp = b.toLowerCase().startsWith(q) ? 0 : 1;

src/lib/components/TitleBar.svelte

@@ -1,6 +1,6 @@
 <script lang="ts">
 	import { getCurrentWindow } from '@tauri-apps/api/window';
-	import { vaultReady, focusMode, readOnly, updateAvailable, showSettings, settingsTab, appConfig, syncState } from '$lib/stores/app';
+	import { vaultReady, focusMode, readOnly, updateAvailable, showSettings, settingsTab, appConfig, activeVaultConfig, syncState } from '$lib/stores/app';
 	import { syncNow } from '$lib/api';
 
 	let { onNewNote = () => {}, onDailyNote = () => {} }: {
@@ -112,7 +112,7 @@
 				<line x1="3" y1="10" x2="21" y2="10" />
 			</svg>
 		</button>
-		{#if $appConfig?.sync_provider === 'webdav'}
+		{#if activeVaultConfig($appConfig)?.sync_provider === 'webdav'}
 		<button class="switch-vault-btn" class:active={$syncState.running} onclick={() => { if (!$syncState.running) syncNow().catch(() => {}); }} disabled={$syncState.running} title={$syncState.error ? `Sync error: ${$syncState.error}` : ($syncState.running ? 'Syncing vault...' : 'Sync vault now')}>
 			<svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class:sync-spin={$syncState.running}>
 				<path d="M21 2v6h-6"/><path d="M3 12a9 9 0 0115-6.7L21 8"/><path d="M3 22v-6h6"/><path d="M21 12a9 9 0 01-15 6.7L3 16"/>

src/lib/components/VaultPicker.svelte

@@ -2,11 +2,13 @@
 	import { open } from '@tauri-apps/plugin-dialog';
 	import { getCurrentWindow } from '@tauri-apps/api/window';
 	import { documentDir } from '@tauri-apps/api/path';
-	import { openVault, removeVault, getAppConfig } from '$lib/api';
+	import { chooseExternalVault, getAppConfig, openVault, removeVault, restoreExternalVault } from '$lib/api';
 	import { appConfig, vaultReady } from '$lib/stores/app';
 	import { isAndroid, isIOS, isMobile } from '$lib/platform';
 	import type { VaultConfig } from '$lib/types';
 
+	let { initialError = '' }: { initialError?: string } = $props();
+
 	const appWindow = getCurrentWindow();
 
 	let recentVaults: VaultConfig[] = $derived($appConfig?.vaults ?? []);
@@ -15,6 +17,10 @@
 	let vaultName = $state('HelixNotes');
 	let hasPermission = $state(!isAndroid);
 	let selectedLocation = $state('Documents');
+
+	$effect(() => {
+		if (initialError && !error) error = initialError;
+	});
 	let customPath = $state('');
 	let iosBasePath = $state('');
 
@@ -108,14 +114,63 @@
 		}
 	}
 
-	async function forgetVault(path: string) {
+	async function pickExternalFolder() {
+		loading = true;
+		error = '';
 		try {
-			await removeVault(path);
+			const selected = await chooseExternalVault();
+			if (!selected) return;
 			$appConfig = await getAppConfig();
+			$vaultReady = true;
 		} catch (e) {
 			error = String(e);
+		} finally {
+			loading = false;
 		}
 	}
+
+	async function openRecentVault(vault: VaultConfig) {
+		if (loading) return;
+		if (!isIOS || !vault.bookmark_id) {
+			await openSelectedVault(vault.path);
+			return;
+		}
+
+		loading = true;
+		error = '';
+		try {
+			await restoreExternalVault(vault.bookmark_id);
+			$appConfig = await getAppConfig();
+			$vaultReady = true;
+		} catch (e) {
+			error = String(e);
+		} finally {
+			loading = false;
+		}
+	}
+
+	async function forgetVault(vault: VaultConfig) {
+		if (loading) return;
+		loading = true;
+		error = '';
+		try {
+			const wasActive = isActiveVault(vault);
+			await removeVault(vault.path, vault.bookmark_id);
+			$appConfig = await getAppConfig();
+			if (wasActive) $vaultReady = false;
+		} catch (e) {
+			error = String(e);
+		} finally {
+			loading = false;
+		}
+	}
+
+	function isActiveVault(vault: VaultConfig): boolean {
+		if (vault.bookmark_id) {
+			return vault.bookmark_id === $appConfig?.active_bookmark_id;
+		}
+		return !$appConfig?.active_bookmark_id && vault.path === $appConfig?.active_vault;
+	}
 </script>
 
 <!-- svelte-ignore a11y_no_static_element_interactions -->
@@ -146,7 +201,7 @@
 		<p class="subtitle">Local markdown notes</p>
 		{#if isMobile}
 			{#if isIOS}
-				<p class="description">Your notes are saved in the app's folder and appear in the Files app under "On My iPhone &rarr; HelixNotes".</p>
+				<p class="description">Keep notes in HelixNotes, or use an existing folder from iCloud Drive or Files.</p>
 			{:else}
 				<p class="description">Choose where to store your notes. Sync with Syncthing, Nextcloud, or any file sync app.</p>
 			{/if}
@@ -197,6 +252,8 @@
 		<button class="btn-primary" onclick={pickFolder} disabled={loading}>
 			{#if loading}
 				Opening...
+			{:else if isIOS}
+				Use Local Folder
 			{:else if isMobile}
 				Get Started
 			{:else}
@@ -204,6 +261,12 @@
 			{/if}
 		</button>
 
+		{#if isIOS}
+			<button class="btn-back" onclick={pickExternalFolder} disabled={loading}>
+				Choose Folder in Files
+			</button>
+		{/if}
+
 		{#if $appConfig?.active_vault}
 			<button class="btn-back" onclick={() => ($vaultReady = true)}>
 				Back
@@ -215,11 +278,11 @@
 				<span class="recent-label">Recent</span>
 				{#each recentVaults as vault}
 					<div class="vault-row">
-						<button class="vault-item" class:current={vault.path === $appConfig?.active_vault} onclick={() => openSelectedVault(vault.path)}>
+						<button class="vault-item" class:current={isActiveVault(vault)} onclick={() => openRecentVault(vault)} disabled={loading}>
-							<span class="vault-name">{vault.name}{#if vault.path === $appConfig?.active_vault}<span class="vault-current-badge">Current</span>{/if}</span>
+							<span class="vault-name">{vault.name}{#if isActiveVault(vault)}<span class="vault-current-badge">Current</span>{/if}</span>
-							<span class="vault-path">{vault.path}</span>
+							<span class="vault-path">{vault.bookmark_id ? `Files · ${vault.path}` : vault.path}</span>
 						</button>
-						<button class="vault-remove" title="Remove from list" aria-label="Remove from list" onclick={() => forgetVault(vault.path)}>
+						<button class="vault-remove" title="Remove from list" aria-label="Remove from list" onclick={() => forgetVault(vault)} disabled={loading}>
 							<svg width="12" height="12" viewBox="0 0 10 10">
 								<line x1="1.5" y1="1.5" x2="8.5" y2="8.5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" />
 								<line x1="8.5" y1="1.5" x2="1.5" y2="8.5" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" />

src/lib/editor/callouts.ts

@@ -0,0 +1,171 @@
+// Obsidian-compatible callouts.
+//
+// Callouts are written as blockquotes whose first line is `[!type]`:
+//
+//     > [!warning] Optional title
+//     > Body markdown...
+//
+// A trailing `+` / `-` on the type makes the callout foldable
+// (`+` = expanded, `-` = collapsed). Types are case-insensitive and have
+// aliases. Callouts round-trip to this exact syntax so notes stay portable
+// (no lock-in) and stay compatible with Obsidian.
+
+// alias (lowercase) -> canonical group used for icon + colour
+const ALIASES: Record<string, string> = {
+	note: 'note',
+	abstract: 'abstract', summary: 'abstract', tldr: 'abstract',
+	info: 'info',
+	todo: 'todo',
+	tip: 'tip', hint: 'tip', important: 'tip',
+	success: 'success', check: 'success', done: 'success',
+	question: 'question', help: 'question', faq: 'question',
+	warning: 'warning', caution: 'warning', attention: 'warning',
+	failure: 'failure', fail: 'failure', missing: 'failure',
+	danger: 'danger', error: 'danger',
+	bug: 'bug',
+	example: 'example',
+	quote: 'quote', cite: 'quote',
+};
+
+/**
+ * Resolve a (possibly aliased / cased) type to its canonical styling group.
+ * Unknown / user-defined types resolve to 'custom' (neutral accent + tag icon)
+ * so a `[!decision]` reads as intentional rather than masquerading as a note.
+ */
+export function calloutGroup(type: string): string {
+	return ALIASES[(type || '').trim().toLowerCase()] || 'custom';
+}
+
+/** Default header label shown when no custom title is set (matches Obsidian). */
+export function calloutLabel(type: string): string {
+	const t = (type || 'note').trim();
+	return t ? t.charAt(0).toUpperCase() + t.slice(1) : 'Note';
+}
+
+// Inner SVG markup per canonical group (24x24, stroke = currentColor).
+const ICONS: Record<string, string> = {
+	note: '<path d="M12 20h9"/><path d="M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4Z"/>',
+	abstract: '<rect x="8" y="2" width="8" height="4" rx="1"/><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"/><path d="M9 12h6"/><path d="M9 16h6"/>',
+	info: '<circle cx="12" cy="12" r="10"/><line x1="12" y1="11" x2="12" y2="16"/><line x1="12" y1="8" x2="12.01" y2="8"/>',
+	todo: '<circle cx="12" cy="12" r="10"/><path d="m9 12 2 2 4-4"/>',
+	tip: '<path d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.07-2.14-.22-4.05 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.15.43-2.29 1-3a2.5 2.5 0 0 0 2.5 2.5Z"/>',
+	success: '<polyline points="20 6 9 17 4 12"/>',
+	question: '<circle cx="12" cy="12" r="10"/><path d="M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+	warning: '<path d="m21.73 18-8-14a2 2 0 0 0-3.46 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/>',
+	failure: '<circle cx="12" cy="12" r="10"/><line x1="15" y1="9" x2="9" y2="15"/><line x1="9" y1="9" x2="15" y2="15"/>',
+	danger: '<polygon points="13 2 3 14 12 14 11 22 21 10 12 10 13 2"/>',
+	bug: '<rect x="8" y="6" width="8" height="14" rx="4"/><path d="m19 8-3 2"/><path d="m5 8 3 2"/><path d="m19 16-3-2"/><path d="m5 16 3-2"/><path d="M21 13h-5"/><path d="M3 13h5"/><path d="m15 4-1.5 2.5"/><path d="m9 4 1.5 2.5"/>',
+	example: '<line x1="8" y1="6" x2="21" y2="6"/><line x1="8" y1="12" x2="21" y2="12"/><line x1="8" y1="18" x2="21" y2="18"/><line x1="3" y1="6" x2="3.01" y2="6"/><line x1="3" y1="12" x2="3.01" y2="12"/><line x1="3" y1="18" x2="3.01" y2="18"/>',
+	quote: '<path d="M3 21c3 0 7-1 7-8V5c0-1.25-.76-2.02-2-2H4c-1.25 0-2 .75-2 1.97V11c0 1.25.75 2 2 2 1 0 1 0 1 1v1c0 1-1 2-2 2s-1 0-1 1.03V20c0 1 0 1 1 1z"/><path d="M15 21c3 0 7-1 7-8V5c0-1.25-.76-2.02-2-2h-4c-1.25 0-2 .75-2 1.97V11c0 1.25.75 2 2 2h.75c0 2.25.25 4-2.75 4v3c0 1 0 1 1 1z"/>',
+	custom: '<path d="M20.59 13.41 13.42 20.58a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z"/><line x1="7" y1="7" x2="7.01" y2="7"/>',
+};
+
+/** Full SVG icon string for a callout type, at the given pixel size. */
+export function calloutIcon(type: string, size = 18): string {
+	const inner = ICONS[calloutGroup(type)] || ICONS.note;
+	return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">${inner}</svg>`;
+}
+
+/** Ordered list of types offered in the type picker. */
+export const CALLOUT_MENU: { type: string; label: string }[] = [
+	{ type: 'note', label: 'Note' },
+	{ type: 'abstract', label: 'Abstract' },
+	{ type: 'info', label: 'Info' },
+	{ type: 'todo', label: 'Todo' },
+	{ type: 'tip', label: 'Tip' },
+	{ type: 'success', label: 'Success' },
+	{ type: 'question', label: 'Question' },
+	{ type: 'warning', label: 'Warning' },
+	{ type: 'failure', label: 'Failure' },
+	{ type: 'danger', label: 'Danger' },
+	{ type: 'bug', label: 'Bug' },
+	{ type: 'example', label: 'Example' },
+	{ type: 'quote', label: 'Quote' },
+];
+
+// First line of a callout: [!type], optional +/- fold marker, optional title.
+const CALLOUT_RE = /^\s*\[!([\w-]+)\]([-+]?)[ \t]*(.*)$/;
+
+const BLOCK_SELECTOR =
+	'p,ul,ol,blockquote,pre,h1,h2,h3,h4,h5,h6,table,hr,div[data-callout],div[data-secret-block],div[data-math-block],div[data-pdf-src],div[data-page-break]';
+
+/**
+ * Convert callout blockquotes produced by markdown-it into
+ * `<div data-callout=...>` blocks that the Callout node parses. Operates in
+ * place on a detached container element. Processes depth-first so nested
+ * callouts (`> > [!todo]`) are converted before their parents.
+ */
+export function transformCalloutBlockquotes(root: Element): void {
+	const walk = (el: Element) => {
+		for (const child of Array.from(el.children)) walk(child);
+		if (el.tagName === 'BLOCKQUOTE') convertBlockquote(el);
+	};
+	walk(root);
+}
+
+function convertBlockquote(bq: Element): void {
+	const first = bq.firstElementChild;
+	if (!first || first.tagName !== 'P') return;
+
+	// markdown-it merges the title line and any immediately-following body lines
+	// into one paragraph (separated by "\n"). Split off the first line.
+	const innerHtml = (first as HTMLElement).innerHTML;
+	const nlIdx = innerHtml.indexOf('\n');
+	const firstLineHtml = nlIdx === -1 ? innerHtml : innerHtml.slice(0, nlIdx);
+	const restHtml = nlIdx === -1 ? '' : innerHtml.slice(nlIdx + 1);
+
+	const probe = document.createElement('div');
+	probe.innerHTML = firstLineHtml;
+	const m = (probe.textContent || '').match(CALLOUT_RE);
+	if (!m) return;
+
+	const type = m[1].toLowerCase();
+	const foldChar = m[2];
+	const title = (m[3] || '').trim();
+	const foldable = foldChar === '+' || foldChar === '-';
+	const folded = foldChar === '-';
+
+	const div = document.createElement('div');
+	div.setAttribute('data-callout', type);
+	div.setAttribute('data-callout-foldable', foldable ? 'true' : 'false');
+	div.setAttribute('data-callout-folded', folded ? 'true' : 'false');
+	if (title) div.setAttribute('data-callout-title', title);
+
+	if (restHtml.trim()) {
+		(first as HTMLElement).innerHTML = restHtml;
+		div.appendChild(first);
+	} else {
+		first.remove();
+	}
+	while (bq.firstChild) div.appendChild(bq.firstChild);
+
+	// content is `block+`; guarantee at least one block.
+	if (!div.querySelector(BLOCK_SELECTOR)) div.appendChild(document.createElement('p'));
+
+	bq.replaceWith(div);
+}
+
+/**
+ * Serialize a Callout ProseMirror node back to `> [!type] ...` markdown.
+ * `serializeChild` serializes a child block (the editor's own serializer),
+ * which makes nesting fall out automatically (each `>` line gains another `>`).
+ */
+export function serializeCallout(node: any, serializeChild: (child: any) => string): string {
+	const type = node.attrs.type || 'note';
+	const foldable = !!node.attrs.foldable;
+	const folded = !!node.attrs.folded;
+	const title = (node.attrs.title || '').trim();
+	const suffix = foldable ? (folded ? '-' : '+') : '';
+	const header = `[!${type}]${suffix}${title ? ' ' + title : ''}`;
+
+	const parts: string[] = [];
+	node.forEach((child: any) => parts.push(serializeChild(child).replace(/\n+$/, '')));
+	while (parts.length && parts[parts.length - 1] === '') parts.pop();
+
+	const out = [`> ${header}`];
+	const inner = parts.join('\n\n');
+	if (inner.length) {
+		for (const line of inner.split('\n')) out.push(line.length ? `> ${line}` : '>');
+	}
+	return out.join('\n') + '\n';
+}

src/lib/editor/mixedLists.ts

@@ -0,0 +1,27 @@
+import type { Node as ProseMirrorNode, Schema } from '@tiptap/pm/model';
+
+export type MixedListName = 'bulletList' | 'taskList';
+
+export function convertListNode(
+  schema: Schema,
+  listNode: ProseMirrorNode,
+  targetListName: MixedListName,
+): ProseMirrorNode | null {
+  if (
+    (listNode.type.name !== 'bulletList' && listNode.type.name !== 'taskList') ||
+    listNode.type.name === targetListName
+  ) {
+    return null;
+  }
+
+  const targetListType = schema.nodes[targetListName];
+  const targetItemType = schema.nodes[targetListName === 'taskList' ? 'taskItem' : 'listItem'];
+  if (!targetListType || !targetItemType) return null;
+
+  const itemAttrs = targetListName === 'taskList' ? { checked: false } : null;
+  const convertedItems = listNode.content.content.map((item) =>
+    targetItemType.create(itemAttrs, item.content, item.marks)
+  );
+
+  return targetListType.create(null, convertedItems, listNode.marks);
+}

src/lib/platform.ts

@@ -1,10 +1,19 @@
-// Centralized platform detection. iOS WebViews report iPhone/iPad/iPod in the user
+// Platform is the compile-time build target, injected by the backend into
-// agent (not the literal "ios"), so they must be matched explicitly.
+// window.__HELIX_PLATFORM__ before app scripts run (see src-tauri/src/lib.rs). The UA is only a
+// fallback when that global is absent (SSR/prerender, plain-browser dev): some desktop WebKitGTK
+// builds report a mobile-looking user-agent. (#63)
+type HelixPlatform = { mobile: boolean; android: boolean; ios: boolean };
+
+const injected: HelixPlatform | undefined =
+	typeof window !== 'undefined'
+		? (window as unknown as { __HELIX_PLATFORM__?: HelixPlatform }).__HELIX_PLATFORM__
+		: undefined;
+
 const ua = typeof navigator !== 'undefined' ? navigator.userAgent : '';
 
-export const isAndroid = /android/i.test(ua);
+export const isAndroid = injected ? injected.android : /android/i.test(ua);
-export const isIOS = /iphone|ipad|ipod/i.test(ua);
+export const isIOS = injected ? injected.ios : /iphone|ipad|ipod/i.test(ua);
-export const isMobile = isAndroid || isIOS;
+export const isMobile = injected ? injected.mobile : isAndroid || isIOS;
 
 // Themes that use the dark color scheme. Used by applyTheme() to toggle the
 // `dark` class on the root element. Keep this in sync when adding new themes.