chore(release): prepare for v0.97.2

Currently translated at 9.1% (142 of 1559 strings)

Translation: Trilium Notes/Client
Translate-URL: https://hosted.weblate.org/projects/trilium/client/sr/

.github/FUNDING.yml

@@ -2,3 +2,5 @@
 
 github: [eliandoran]
 custom: ["https://paypal.me/eliandoran"]
+liberapay: ElianDoran
+buy_me_a_coffee: eliandoran

.github/instructions/nx.instructions.md

@@ -0,0 +1,40 @@
+---
+applyTo: '**'
+---
+
+// This file is automatically generated by Nx Console
+
+You are in an nx workspace using Nx 21.3.9 and pnpm as the package manager.
+
+You have access to the Nx MCP server and the tools it provides. Use them. Follow these guidelines in order to best help the user:
+
+# General Guidelines
+- When answering questions, use the nx_workspace tool first to gain an understanding of the workspace architecture
+- For questions around nx configuration, best practices or if you're unsure, use the nx_docs tool to get relevant, up-to-date docs!! Always use this instead of assuming things about nx configuration
+- If the user needs help with an Nx configuration or project graph error, use the 'nx_workspace' tool to get any errors
+- To help answer questions about the workspace structure or simply help with demonstrating how tasks depend on each other, use the 'nx_visualize_graph' tool
+
+# Generation Guidelines
+If the user wants to generate something, use the following flow:
+
+- learn about the nx workspace and any specifics the user needs by using the 'nx_workspace' tool and the 'nx_project_details' tool if applicable
+- get the available generators using the 'nx_generators' tool
+- decide which generator to use. If no generators seem relevant, check the 'nx_available_plugins' tool to see if the user could install a plugin to help them
+- get generator details using the 'nx_generator_schema' tool
+- you may use the 'nx_docs' tool to learn more about a specific generator or technology if you're unsure
+- decide which options to provide in order to best complete the user's request. Don't make any assumptions and keep the options minimalistic
+- open the generator UI using the 'nx_open_generate_ui' tool
+- wait for the user to finish the generator
+- read the generator log file using the 'nx_read_generator_log' tool
+- use the information provided in the log file to answer the user's question or continue with what they were doing
+
+# Running Tasks Guidelines
+If the user wants help with tasks or commands (which include keywords like "test", "build", "lint", or other similar actions), use the following flow:
+- Use the 'nx_current_running_tasks_details' tool to get the list of tasks (this can include tasks that were completed, stopped or failed).
+- If there are any tasks, ask the user if they would like help with a specific task then use the 'nx_current_running_task_output' tool to get the terminal output for that task/command
+- Use the terminal output from 'nx_current_running_task_output' to see what's wrong and help the user fix their problem. Use the appropriate tools if necessary
+- If the user would like to rerun the task or command, always use `nx run <taskId>` to rerun in the terminal. This will ensure that the task will run in the nx context and will be run the same way it originally executed
+- If the task was marked as "continuous" do not offer to rerun the task. This task is already running and the user can see the output in the terminal. You can use 'nx_current_running_task_output' to get the output of the task to verify the output. 
+
+
+

.github/workflows/checks.yml

@@ -0,0 +1,17 @@
+name: Checks
+on:
+  push:
+  pull_request_target:
+    types: [synchronize]
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Check if PRs have conflicts
+        uses: eps1lon/actions-label-merge-conflict@v3
+        with:
+          dirtyLabel: "merge-conflicts"
+          repoToken: "${{ secrets.MERGE_CONFLICT_LABEL_PAT }}"

.mailmap

@@ -1,2 +1,2 @@
-Adam Zivner <adam.zivner@gmail.com>
-Adam Zivner <zadam.apps@gmail.com>
+zadam <adam.zivner@gmail.com>
+zadam <zadam.apps@gmail.com>

.nvmrc

@@ -1 +1 @@
-22.17.0
+22.18.0

.vscode/mcp.json

@@ -0,0 +1,8 @@
+{
+  "servers": {
+    "nx-mcp": {
+      "type": "http",
+      "url": "http://localhost:9461/mcp"
+    }
+  }
+}

.vscode/settings.json

@@ -28,5 +28,13 @@
     "typescript.validate.enable": true,
     "typescript.tsserver.experimental.enableProjectDiagnostics": true,
     "typescript.tsdk": "node_modules/typescript/lib",
-    "typescript.enablePromptUseWorkspaceTsdk": true
+    "typescript.enablePromptUseWorkspaceTsdk": true,
+    "search.exclude": {
+        "**/node_modules": true,
+        "docs/**/*.html": true,
+        "docs/**/*.png": true,
+        "apps/server/src/assets/doc_notes/**": true,
+        "apps/edit-docs/demo/**": true
+    },
+    "nxConsole.generateAiAgentRules": true
 }

CLAUDE.md

@@ -0,0 +1,161 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+Trilium Notes is a hierarchical note-taking application with advanced features like synchronization, scripting, and rich text editing. It's built as a TypeScript monorepo using NX, with multiple applications and shared packages.
+
+## Development Commands
+
+### Setup
+- `pnpm install` - Install all dependencies
+- `corepack enable` - Enable pnpm if not available
+
+### Running Applications
+- `pnpm run server:start` - Start development server (http://localhost:8080)
+- `pnpm nx run server:serve` - Alternative server start command
+- `pnpm nx run desktop:serve` - Run desktop Electron app
+- `pnpm run server:start-prod` - Run server in production mode
+
+### Building
+- `pnpm nx build <project>` - Build specific project (server, client, desktop, etc.)
+- `pnpm run client:build` - Build client application
+- `pnpm run server:build` - Build server application
+- `pnpm run electron:build` - Build desktop application
+
+### Testing
+- `pnpm test:all` - Run all tests (parallel + sequential)
+- `pnpm test:parallel` - Run tests that can run in parallel
+- `pnpm test:sequential` - Run tests that must run sequentially (server, ckeditor5-mermaid, ckeditor5-math)
+- `pnpm nx test <project>` - Run tests for specific project
+- `pnpm coverage` - Generate coverage reports
+
+### Linting & Type Checking
+- `pnpm nx run <project>:lint` - Lint specific project
+- `pnpm nx run <project>:typecheck` - Type check specific project
+
+## Architecture Overview
+
+### Monorepo Structure
+- **apps/**: Runnable applications
+  - `client/` - Frontend application (shared by server and desktop)
+  - `server/` - Node.js server with web interface
+  - `desktop/` - Electron desktop application
+  - `web-clipper/` - Browser extension for saving web content
+  - Additional tools: `db-compare`, `dump-db`, `edit-docs`
+
+- **packages/**: Shared libraries
+  - `commons/` - Shared interfaces and utilities
+  - `ckeditor5/` - Custom rich text editor with Trilium-specific plugins
+  - `codemirror/` - Code editor customizations
+  - `highlightjs/` - Syntax highlighting
+  - Custom CKEditor plugins: `ckeditor5-admonition`, `ckeditor5-footnotes`, `ckeditor5-math`, `ckeditor5-mermaid`
+
+### Core Architecture Patterns
+
+#### Three-Layer Cache System
+- **Becca** (Backend Cache): Server-side entity cache (`apps/server/src/becca/`)
+- **Froca** (Frontend Cache): Client-side mirror of backend data (`apps/client/src/services/froca.ts`)
+- **Shaca** (Share Cache): Optimized cache for shared/published notes (`apps/server/src/share/`)
+
+#### Entity System
+Core entities are defined in `apps/server/src/becca/entities/`:
+- `BNote` - Notes with content and metadata
+- `BBranch` - Hierarchical relationships between notes (allows multiple parents)
+- `BAttribute` - Key-value metadata attached to notes
+- `BRevision` - Note version history
+- `BOption` - Application configuration
+
+#### Widget-Based UI
+Frontend uses a widget system (`apps/client/src/widgets/`):
+- `BasicWidget` - Base class for all UI components
+- `NoteContextAwareWidget` - Widgets that respond to note changes
+- `RightPanelWidget` - Widgets displayed in the right panel
+- Type-specific widgets in `type_widgets/` directory
+
+#### API Architecture
+- **Internal API**: REST endpoints in `apps/server/src/routes/api/`
+- **ETAPI**: External API for third-party integrations (`apps/server/src/etapi/`)
+- **WebSocket**: Real-time synchronization (`apps/server/src/services/ws.ts`)
+
+### Key Files for Understanding Architecture
+
+1. **Application Entry Points**:
+   - `apps/server/src/main.ts` - Server startup
+   - `apps/client/src/desktop.ts` - Client initialization
+
+2. **Core Services**:
+   - `apps/server/src/becca/becca.ts` - Backend data management
+   - `apps/client/src/services/froca.ts` - Frontend data synchronization
+   - `apps/server/src/services/backend_script_api.ts` - Scripting API
+
+3. **Database Schema**:
+   - `apps/server/src/assets/db/schema.sql` - Core database structure
+
+4. **Configuration**:
+   - `nx.json` - NX workspace configuration
+   - `package.json` - Project dependencies and scripts
+
+## Note Types and Features
+
+Trilium supports multiple note types, each with specialized widgets:
+- **Text**: Rich text with CKEditor5 (markdown import/export)
+- **Code**: Syntax-highlighted code editing with CodeMirror
+- **File**: Binary file attachments
+- **Image**: Image display with editing capabilities
+- **Canvas**: Drawing/diagramming with Excalidraw
+- **Mermaid**: Diagram generation
+- **Relation Map**: Visual note relationship mapping
+- **Web View**: Embedded web pages
+- **Doc/Book**: Hierarchical documentation structure
+
+## Development Guidelines
+
+### Testing Strategy
+- Server tests run sequentially due to shared database
+- Client tests can run in parallel
+- E2E tests use Playwright for both server and desktop apps
+- Build validation tests check artifact integrity
+
+### Scripting System
+Trilium provides powerful user scripting capabilities:
+- Frontend scripts run in browser context
+- Backend scripts run in Node.js context with full API access
+- Script API documentation available in `docs/Script API/`
+
+### Internationalization
+- Translation files in `apps/client/src/translations/`
+- Supported languages: English, German, Spanish, French, Romanian, Chinese
+
+### Security Considerations
+- Per-note encryption with granular protected sessions
+- CSRF protection for API endpoints
+- OpenID and TOTP authentication support
+- Sanitization of user-generated content
+
+## Common Development Tasks
+
+### Adding New Note Types
+1. Create widget in `apps/client/src/widgets/type_widgets/`
+2. Register in `apps/client/src/services/note_types.ts`
+3. Add backend handling in `apps/server/src/services/notes.ts`
+
+### Extending Search
+- Search expressions handled in `apps/server/src/services/search/`
+- Add new search operators in search context files
+
+### Custom CKEditor Plugins
+- Create new package in `packages/` following existing plugin structure
+- Register in `packages/ckeditor5/src/plugins.ts`
+
+### Database Migrations
+- Add migration scripts in `apps/server/src/migrations/`
+- Update schema in `apps/server/src/assets/db/schema.sql`
+
+## Build System Notes
+- Uses NX for monorepo management with build caching
+- Vite for fast development builds
+- ESBuild for production optimization
+- pnpm workspaces for dependency management
+- Docker support with multi-stage builds

README.md

@@ -1,9 +1,9 @@
 # Trilium Notes
 
-![GitHub Sponsors](https://img.shields.io/github/sponsors/eliandoran?style=flat-square)
-![Docker Pulls](https://img.shields.io/docker/pulls/triliumnext/notes?style=flat-square)
-![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/triliumnext/notes/total?style=flat-square)
-[![RelativeCI](https://badges.relative-ci.com/badges/Di5q7dz9daNDZ9UXi0Bp?branch=develop&style=flat-square)](https://app.relative-ci.com/projects/Di5q7dz9daNDZ9UXi0Bp)
+![GitHub Sponsors](https://img.shields.io/github/sponsors/eliandoran) ![LiberaPay patrons](https://img.shields.io/liberapay/patrons/ElianDoran)  
+![Docker Pulls](https://img.shields.io/docker/pulls/triliumnext/notes)
+![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/triliumnext/notes/total)  
+[![RelativeCI](https://badges.relative-ci.com/badges/Di5q7dz9daNDZ9UXi0Bp?branch=develop)](https://app.relative-ci.com/projects/Di5q7dz9daNDZ9UXi0Bp) [![Translation status](https://hosted.weblate.org/widget/trilium/svg-badge.svg)](https://hosted.weblate.org/engage/trilium/)
 
 [English](./README.md) | [Chinese](./docs/README-ZH_CN.md) | [Russian](./docs/README.ru.md) | [Japanese](./docs/README.ja.md) | [Italian](./docs/README.it.md) | [Spanish](./docs/README.es.md)
 
@@ -115,12 +115,20 @@ To install TriliumNext on your own server (including via Docker from [Dockerhub]
 
 ## 💻 Contribute
 
+### Translations
+
+If you are a native speaker, help us translate Trilium by heading over to our [Weblate page](https://hosted.weblate.org/engage/trilium/).
+
+Here's the language coverage we have so far:
+
+[![Translation status](https://hosted.weblate.org/widget/trilium/multi-auto.svg)](https://hosted.weblate.org/engage/trilium/)
+
 ### Code
 
 Download the repository, install dependencies using `pnpm` and then run the server (available at http://localhost:8080):
 ```shell
-git clone https://github.com/TriliumNext/Notes.git
-cd Notes
+git clone https://github.com/TriliumNext/Trilium.git
+cd Trilium
 pnpm install
 pnpm run server:start
 ```
@@ -129,8 +137,8 @@ pnpm run server:start
 
 Download the repository, install dependencies using `pnpm` and then run the environment required to edit the documentation:
 ```shell
-git clone https://github.com/TriliumNext/Notes.git
-cd Notes
+git clone https://github.com/TriliumNext/Trilium.git
+cd Trilium
 pnpm install
 pnpm nx run edit-docs:edit-docs
 ```
@@ -138,8 +146,8 @@ pnpm nx run edit-docs:edit-docs
 ### Building the Executable
 Download the repository, install dependencies using `pnpm` and then build the desktop app for Windows:
 ```shell
-git clone https://github.com/TriliumNext/Notes.git
-cd Notes
+git clone https://github.com/TriliumNext/Trilium.git
+cd Trilium
 pnpm install
 pnpm nx --project=desktop electron-forge:make -- --arch=x64 --platform=win32
 ```

_regroup/package.json

@@ -35,13 +35,13 @@
     "chore:generate-openapi": "tsx bin/generate-openapi.js"
   },
   "devDependencies": {    
-    "@playwright/test": "1.53.2",
-    "@stylistic/eslint-plugin": "5.1.0",        
+    "@playwright/test": "1.54.2",
+    "@stylistic/eslint-plugin": "5.2.2",        
     "@types/express": "5.0.3",    
-    "@types/node": "22.16.2",    
+    "@types/node": "22.17.0",    
     "@types/yargs": "17.0.33",
     "@vitest/coverage-v8": "3.2.4",
-    "eslint": "9.30.1",
+    "eslint": "9.32.0",
     "eslint-plugin-simple-import-sort": "12.1.1",
     "esm": "3.2.25",
     "jsdoc": "4.0.4",
@@ -49,7 +49,7 @@
     "rcedit": "4.0.1",
     "rimraf": "6.0.1",    
     "tslib": "2.8.1",    
-    "typedoc": "0.28.7",
+    "typedoc": "0.28.9",
     "typedoc-plugin-missing-exports": "4.0.0"
   },
   "optionalDependencies": {

apps/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triliumnext/client",
-  "version": "0.96.0",
+  "version": "0.97.2",
   "description": "JQuery-based client for TriliumNext, used for both web and desktop (via Electron)",
   "private": true,
   "license": "AGPL-3.0-only",
@@ -10,7 +10,7 @@
     "url": "https://github.com/TriliumNext/Notes"
   },
   "dependencies": {
-    "@eslint/js": "9.30.1",
+    "@eslint/js": "9.32.0",
     "@excalidraw/excalidraw": "0.18.0",
     "@fullcalendar/core": "6.1.18",
     "@fullcalendar/daygrid": "6.1.18",
@@ -18,6 +18,7 @@
     "@fullcalendar/list": "6.1.18",
     "@fullcalendar/multimonth": "6.1.18",
     "@fullcalendar/timegrid": "6.1.18",
+    "@maplibre/maplibre-gl-leaflet": "0.1.3",
     "@mermaid-js/layout-elk": "0.1.8",
     "@mind-elixir/node-menu": "5.0.0",
     "@popperjs/core": "2.11.8",
@@ -38,7 +39,6 @@
     "i18next": "25.3.2",
     "i18next-http-backend": "3.0.2",
     "jquery": "3.7.1",
-    "jquery-hotkeys": "0.2.2",
     "jquery.fancytree": "2.38.5",
     "jsplumb": "2.15.6",
     "katex": "0.16.22",
@@ -46,29 +46,29 @@
     "leaflet": "1.9.4",
     "leaflet-gpx": "2.2.0",
     "mark.js": "8.11.1",
-    "marked": "16.0.0",
-    "mermaid": "11.8.1",
-    "mind-elixir": "5.0.1",
+    "marked": "16.1.1",
+    "mermaid": "11.9.0",
+    "mind-elixir": "5.0.4",
     "normalize.css": "8.0.1",
     "panzoom": "9.4.3",
-    "preact": "10.26.9",
+    "preact": "10.27.0",
     "split.js": "1.6.5",
     "svg-pan-zoom": "3.6.2",
     "tabulator-tables": "6.3.1",
     "vanilla-js-wheel-zoom": "9.0.4"
   },
   "devDependencies": {
-    "@ckeditor/ckeditor5-inspector": "4.1.0",
+    "@ckeditor/ckeditor5-inspector": "5.0.0",
     "@types/bootstrap": "5.2.10",
     "@types/jquery": "3.5.32",
     "@types/leaflet": "1.9.20",
     "@types/leaflet-gpx": "1.3.7",
     "@types/mark.js": "8.11.12",
-    "@types/tabulator-tables": "6.2.7",
+    "@types/tabulator-tables": "6.2.9",
     "copy-webpack-plugin": "13.0.0",
     "happy-dom": "18.0.1",
     "script-loader": "0.7.2",
-    "vite-plugin-static-copy": "3.1.0"
+    "vite-plugin-static-copy": "3.1.1"
   },
   "nx": {
     "name": "client",

apps/client/src/components/app_context.ts

@@ -28,6 +28,8 @@ import TouchBarComponent from "./touch_bar.js";
 import type { CKTextEditor } from "@triliumnext/ckeditor5";
 import type CodeMirror from "@triliumnext/codemirror";
 import { StartupChecks } from "./startup_checks.js";
+import type { CreateNoteOpts } from "../services/note_create.js";
+import { ColumnComponent } from "tabulator-tables";
 
 interface Layout {
     getRootWidget: (appContext: AppContext) => RootWidget;
@@ -131,6 +133,8 @@ export type CommandMappings = {
     hideLeftPane: CommandData;
     showCpuArchWarning: CommandData;
     showLeftPane: CommandData;
+    showAttachments: CommandData;
+    showSearchHistory: CommandData;
     hoistNote: CommandData & { noteId: string };
     leaveProtectedSession: CommandData;
     enterProtectedSession: CommandData;
@@ -171,7 +175,7 @@ export type CommandMappings = {
     deleteNotes: ContextMenuCommandData;
     importIntoNote: ContextMenuCommandData;
     exportNote: ContextMenuCommandData;
-    searchInSubtree: ContextMenuCommandData;
+    searchInSubtree: CommandData & { notePath: string; };
     moveNoteUp: ContextMenuCommandData;
     moveNoteDown: ContextMenuCommandData;
     moveNoteUpInHierarchy: ContextMenuCommandData;
@@ -260,6 +264,73 @@ export type CommandMappings = {
     closeThisNoteSplit: CommandData;
     moveThisNoteSplit: CommandData & { isMovingLeft: boolean };
     jumpToNote: CommandData;
+    commandPalette: CommandData;
+
+    // Keyboard shortcuts
+    backInNoteHistory: CommandData;
+    forwardInNoteHistory: CommandData;
+    forceSaveRevision: CommandData;
+    scrollToActiveNote: CommandData;
+    quickSearch: CommandData;
+    collapseTree: CommandData;
+    createNoteAfter: CommandData;
+    createNoteInto: CommandData;
+    addNoteAboveToSelection: CommandData;
+    addNoteBelowToSelection: CommandData;
+    openNewTab: CommandData;
+    activateNextTab: CommandData;
+    activatePreviousTab: CommandData;
+    openNewWindow: CommandData;
+    toggleTray: CommandData;
+    firstTab: CommandData;
+    secondTab: CommandData;
+    thirdTab: CommandData;
+    fourthTab: CommandData;
+    fifthTab: CommandData;
+    sixthTab: CommandData;
+    seventhTab: CommandData;
+    eigthTab: CommandData;
+    ninthTab: CommandData;
+    lastTab: CommandData;
+    showNoteSource: CommandData;
+    showSQLConsole: CommandData;
+    showBackendLog: CommandData;
+    showCheatsheet: CommandData;
+    showHelp: CommandData;
+    addLinkToText: CommandData;
+    followLinkUnderCursor: CommandData;
+    insertDateTimeToText: CommandData;
+    pasteMarkdownIntoText: CommandData;
+    cutIntoNote: CommandData;
+    addIncludeNoteToText: CommandData;
+    editReadOnlyNote: CommandData;
+    toggleRibbonTabClassicEditor: CommandData;
+    toggleRibbonTabBasicProperties: CommandData;
+    toggleRibbonTabBookProperties: CommandData;
+    toggleRibbonTabFileProperties: CommandData;
+    toggleRibbonTabImageProperties: CommandData;
+    toggleRibbonTabOwnedAttributes: CommandData;
+    toggleRibbonTabInheritedAttributes: CommandData;
+    toggleRibbonTabPromotedAttributes: CommandData;
+    toggleRibbonTabNoteMap: CommandData;
+    toggleRibbonTabNoteInfo: CommandData;
+    toggleRibbonTabNotePaths: CommandData;
+    toggleRibbonTabSimilarNotes: CommandData;
+    toggleRightPane: CommandData;
+    printActiveNote: CommandData;
+    exportAsPdf: CommandData;
+    openNoteExternally: CommandData;
+    renderActiveNote: CommandData;
+    unhoist: CommandData;
+    reloadFrontendApp: CommandData;
+    openDevTools: CommandData;
+    findInText: CommandData;
+    toggleLeftPane: CommandData;
+    toggleFullscreen: CommandData;
+    zoomOut: CommandData;
+    zoomIn: CommandData;
+    zoomReset: CommandData;
+    copyWithoutFormatting: CommandData;
 
     // Geomap
     deleteFromMap: { noteId: string };
@@ -276,6 +347,21 @@ export type CommandMappings = {
 
     geoMapCreateChildNote: CommandData;
 
+    // Table view
+    addNewRow: CommandData & {
+        customOpts: CreateNoteOpts;
+        parentNotePath?: string;
+    };
+    addNewTableColumn: CommandData & {
+        columnToEdit?: ColumnComponent;
+        referenceColumn?: ColumnComponent;
+        direction?: "before" | "after";
+        type?: "label" | "relation";
+    };
+    deleteTableColumn: CommandData & {
+        columnToDelete?: ColumnComponent;
+    };
+
     buildTouchBar: CommandData & {
         TouchBar: typeof TouchBar;
         buildIcon(name: string): NativeImage;

apps/client/src/components/entrypoints.ts

@@ -30,13 +30,6 @@ interface CreateChildrenResponse {
 export default class Entrypoints extends Component {
     constructor() {
         super();
-
-        if (jQuery.hotkeys) {
-            // hot keys are active also inside inputs and content editables
-            jQuery.hotkeys.options.filterInputAcceptingElements = false;
-            jQuery.hotkeys.options.filterContentEditable = false;
-            jQuery.hotkeys.options.filterTextInputs = false;
-        }
     }
 
     openDevToolsCommand() {
@@ -113,7 +106,9 @@ export default class Entrypoints extends Component {
             if (win.isFullScreenable()) {
                 win.setFullScreen(!win.isFullScreen());
             }
-        } // outside of electron this is handled by the browser
+        } else {
+            document.documentElement.requestFullscreen();
+        }
     }
 
     reloadFrontendAppCommand() {

apps/client/src/components/note_context.ts

@@ -325,8 +325,9 @@ class NoteContext extends Component implements EventListener<"entitiesReloaded">
             return false;
         }
 
-        // Some book types must always display a note list, even if no children.
-        if (["calendar", "table", "geoMap"].includes(note.getLabelValue("viewType") ?? "")) {
+        // Collections must always display a note list, even if no children.
+        const viewType = note.getLabelValue("viewType") ?? "grid";
+        if (!["list", "grid"].includes(viewType)) {
             return true;
         }
 

apps/client/src/desktop.ts

@@ -13,7 +13,6 @@ import type ElectronRemote from "@electron/remote";
 import type Electron from "electron";
 import "./stylesheets/bootstrap.scss";
 import "boxicons/css/boxicons.min.css";
-import "jquery-hotkeys";
 import "autocomplete.js/index_jquery.js";
 
 await appContext.earlyInit();

apps/client/src/entities/fnote.ts

@@ -256,6 +256,20 @@ class FNote {
         return this.children;
     }
 
+    async getSubtreeNoteIds() {
+        let noteIds: (string | string[])[] = [];
+        for (const child of await this.getChildNotes()) {
+            noteIds.push(child.noteId);
+            noteIds.push(await child.getSubtreeNoteIds());
+        }
+        return noteIds.flat();
+    }
+
+    async getSubtreeNotes() {
+        const noteIds = await this.getSubtreeNoteIds();
+        return this.froca.getNotes(noteIds);
+    }
+
     async getChildNotes() {
         return await this.froca.getNotes(this.children);
     }

apps/client/src/menus/context_menu.ts

@@ -26,6 +26,11 @@ export interface MenuCommandItem<T> {
     title: string;
     command?: T;
     type?: string;
+    /**
+     * The icon to display in the menu item.
+     *
+     * If not set, no icon is displayed and the item will appear shifted slightly to the left if there are other items with icons. To avoid this, use `bx bx-empty`.
+     */
     uiIcon?: string;
     badges?: MenuItemBadge[];
     templateNoteId?: string;

apps/client/src/menus/tree_context_menu.ts

@@ -23,7 +23,7 @@ let lastTargetNode: HTMLElement | null = null;
 
 // This will include all commands that implement ContextMenuCommandData, but it will not work if it additional options are added via the `|` operator,
 // so they need to be added manually.
-export type TreeCommandNames = FilteredCommandNames<ContextMenuCommandData> | "openBulkActionsDialog";
+export type TreeCommandNames = FilteredCommandNames<ContextMenuCommandData> | "openBulkActionsDialog" | "searchInSubtree";
 
 export default class TreeContextMenu implements SelectMenuItemEventListener<TreeCommandNames> {
     private treeWidget: NoteTreeWidget;
@@ -129,12 +129,6 @@ export default class TreeContextMenu implements SelectMenuItemEventListener<Tree
                         enabled: isNotRoot && parentNotSearch && noSelectedNotes && notOptionsOrHelp
                     },
                     { title: t("tree-context-menu.convert-to-attachment"), command: "convertNoteToAttachment", uiIcon: "bx bx-paperclip", enabled: isNotRoot && !isHoisted && notOptionsOrHelp },
-                    {
-                        title: `${t("tree-context-menu.duplicate-subtree")} <kbd data-command="duplicateSubtree">`,
-                        command: "duplicateSubtree",
-                        uiIcon: "bx bx-outline",
-                        enabled: parentNotSearch && isNotRoot && !isHoisted && notOptionsOrHelp
-                    },
 
                     { title: "----" },
 
@@ -188,6 +182,13 @@ export default class TreeContextMenu implements SelectMenuItemEventListener<Tree
 
             { title: `${t("tree-context-menu.clone-to")} <kbd data-command="cloneNotesTo"></kbd>`, command: "cloneNotesTo", uiIcon: "bx bx-duplicate", enabled: isNotRoot && !isHoisted },
 
+            {
+                title: `${t("tree-context-menu.duplicate")} <kbd data-command="duplicateSubtree">`,
+                command: "duplicateSubtree",
+                uiIcon: "bx bx-outline",
+                enabled: parentNotSearch && isNotRoot && !isHoisted && notOptionsOrHelp
+            },
+
             {
                 title: `${t("tree-context-menu.delete")} <kbd data-command="deleteNotes"></kbd>`,
                 command: "deleteNotes",

apps/client/src/services/attribute_renderer.ts

@@ -79,7 +79,19 @@ async function renderAttributes(attributes: FAttribute[], renderIsInheritable: b
     return $container;
 }
 
-const HIDDEN_ATTRIBUTES = ["originalFileName", "fileSize", "template", "inherit", "cssClass", "iconClass", "pageSize", "viewType", "geolocation", "docName"];
+const HIDDEN_ATTRIBUTES = [
+    "originalFileName",
+    "fileSize",
+    "template",
+    "inherit",
+    "cssClass",
+    "iconClass",
+    "pageSize",
+    "viewType",
+    "geolocation",
+    "docName",
+    "webViewSrc"
+];
 
 async function renderNormalAttributes(note: FNote) {
     const promotedDefinitionAttributes = note.getPromotedDefinitionAttributes();

apps/client/src/services/attributes.ts

@@ -12,11 +12,12 @@ async function addLabel(noteId: string, name: string, value: string = "", isInhe
     });
 }
 
-export async function setLabel(noteId: string, name: string, value: string = "") {
+export async function setLabel(noteId: string, name: string, value: string = "", isInheritable = false) {
     await server.put(`notes/${noteId}/set-attribute`, {
         type: "label",
         name: name,
-        value: value
+        value: value,
+        isInheritable
     });
 }
 

apps/client/src/services/branches.ts

@@ -95,7 +95,15 @@ async function moveToParentNote(branchIdsToMove: string[], newParentBranchId: st
     }
 }
 
-async function deleteNotes(branchIdsToDelete: string[], forceDeleteAllClones = false) {
+/**
+ * Shows the delete confirmation screen
+ *
+ * @param branchIdsToDelete the list of branch IDs to delete.
+ * @param forceDeleteAllClones whether to check by default the "Delete also all clones" checkbox.
+ * @param moveToParent whether to automatically go to the parent note path after a succesful delete. Usually makes sense if deleting the active note(s).
+ * @returns promise that returns false if the operation was cancelled or there was nothing to delete, true if the operation succeeded.
+ */
+async function deleteNotes(branchIdsToDelete: string[], forceDeleteAllClones = false, moveToParent = true) {
     branchIdsToDelete = filterRootNote(branchIdsToDelete);
 
     if (branchIdsToDelete.length === 0) {
@@ -110,10 +118,12 @@ async function deleteNotes(branchIdsToDelete: string[], forceDeleteAllClones = f
         return false;
     }
 
-    try {
-        await activateParentNotePath();
-    } catch (e) {
-        console.error(e);
+    if (moveToParent) {
+        try {
+            await activateParentNotePath();
+        } catch (e) {
+            console.error(e);
+        }
     }
 
     const taskId = utils.randomString(10);

apps/client/src/services/bulk_action.ts

@@ -15,6 +15,8 @@ import AddRelationBulkAction from "../widgets/bulk_actions/relation/add_relation
 import RenameNoteBulkAction from "../widgets/bulk_actions/note/rename_note.js";
 import { t } from "./i18n.js";
 import type FNote from "../entities/fnote.js";
+import toast from "./toast.js";
+import { BulkAction } from "@triliumnext/commons";
 
 const ACTION_GROUPS = [
     {
@@ -89,6 +91,17 @@ function parseActions(note: FNote) {
         .filter((action) => !!action);
 }
 
+export async function executeBulkActions(targetNoteIds: string[], actions: BulkAction[], includeDescendants = false) {
+    await server.post("bulk-action/execute", {
+        noteIds: targetNoteIds,
+        includeDescendants,
+        actions
+    });
+
+    await ws.waitForMaxKnownEntityChangeId();
+    toast.showMessage(t("bulk_actions.bulk_actions_executed"), 3000);
+}
+
 export default {
     addAction,
     parseActions,

apps/client/src/services/command_registry.ts

@@ -0,0 +1,295 @@
+import { ActionKeyboardShortcut } from "@triliumnext/commons";
+import appContext, { type CommandNames } from "../components/app_context.js";
+import type NoteTreeWidget from "../widgets/note_tree.js";
+import { t, translationsInitializedPromise } from "./i18n.js";
+import keyboardActions from "./keyboard_actions.js";
+import utils from "./utils.js";
+
+export interface CommandDefinition {
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    shortcut?: string;
+    commandName?: CommandNames;
+    handler?: () => Promise<unknown> | null | undefined | void;
+    aliases?: string[];
+    source?: "manual" | "keyboard-action";
+    /** Reference to the original keyboard action for scope checking. */
+    keyboardAction?: ActionKeyboardShortcut;
+}
+
+class CommandRegistry {
+    private commands: Map<string, CommandDefinition> = new Map();
+    private aliases: Map<string, string> = new Map();
+
+    constructor() {
+        this.loadCommands();
+    }
+
+    private async loadCommands() {
+        await translationsInitializedPromise;
+        this.registerDefaultCommands();
+        await this.loadKeyboardActionsAsync();
+    }
+
+    private registerDefaultCommands() {
+        this.register({
+            id: "export-note",
+            name: t("command_palette.export_note_title"),
+            description: t("command_palette.export_note_description"),
+            icon: "bx bx-export",
+            handler: () => {
+                const notePath = appContext.tabManager.getActiveContextNotePath();
+                if (notePath) {
+                    appContext.triggerCommand("showExportDialog", {
+                        notePath,
+                        defaultType: "single"
+                    });
+                }
+            }
+        });
+
+        this.register({
+            id: "show-attachments",
+            name: t("command_palette.show_attachments_title"),
+            description: t("command_palette.show_attachments_description"),
+            icon: "bx bx-paperclip",
+            handler: () => appContext.triggerCommand("showAttachments")
+        });
+
+        // Special search commands with custom logic
+        this.register({
+            id: "search-notes",
+            name: t("command_palette.search_notes_title"),
+            description: t("command_palette.search_notes_description"),
+            icon: "bx bx-search",
+            handler: () => appContext.triggerCommand("searchNotes", {})
+        });
+
+        this.register({
+            id: "search-in-subtree",
+            name: t("command_palette.search_subtree_title"),
+            description: t("command_palette.search_subtree_description"),
+            icon: "bx bx-search-alt",
+            handler: () => {
+                const notePath = appContext.tabManager.getActiveContextNotePath();
+                if (notePath) {
+                    appContext.triggerCommand("searchInSubtree", { notePath });
+                }
+            }
+        });
+
+        this.register({
+            id: "show-search-history",
+            name: t("command_palette.search_history_title"),
+            description: t("command_palette.search_history_description"),
+            icon: "bx bx-history",
+            handler: () => appContext.triggerCommand("showSearchHistory")
+        });
+
+        this.register({
+            id: "show-launch-bar",
+            name: t("command_palette.configure_launch_bar_title"),
+            description: t("command_palette.configure_launch_bar_description"),
+            icon: "bx bx-sidebar",
+            handler: () => appContext.triggerCommand("showLaunchBarSubtree")
+        });
+    }
+
+    private async loadKeyboardActionsAsync() {
+        try {
+            const actions = await keyboardActions.getActions();
+            this.registerKeyboardActions(actions);
+        } catch (error) {
+            console.error("Failed to load keyboard actions:", error);
+        }
+    }
+
+    private registerKeyboardActions(actions: ActionKeyboardShortcut[]) {
+        for (const action of actions) {
+            // Skip actions that we've already manually registered
+            if (this.commands.has(action.actionName)) {
+                continue;
+            }
+
+            // Skip actions that don't have a description (likely separators)
+            if (!action.description) {
+                continue;
+            }
+
+            // Skip Electron-only actions if not in Electron environment
+            if (action.isElectronOnly && !utils.isElectron()) {
+                continue;
+            }
+
+            // Skip actions that should not appear in the command palette
+            if (action.ignoreFromCommandPalette) {
+                continue;
+            }
+
+            // Get the primary shortcut (first one in the list)
+            const primaryShortcut = action.effectiveShortcuts?.[0];
+
+            let name = action.friendlyName;
+            if (action.scope === "note-tree") {
+                name = t("command_palette.tree-action-name", { name: action.friendlyName });
+            }
+
+            // Create a command definition from the keyboard action
+            const commandDef: CommandDefinition = {
+                id: action.actionName,
+                name,
+                description: action.description,
+                icon: action.iconClass,
+                shortcut: primaryShortcut ? this.formatShortcut(primaryShortcut) : undefined,
+                commandName: action.actionName as CommandNames,
+                source: "keyboard-action",
+                keyboardAction: action
+            };
+
+            this.register(commandDef);
+        }
+    }
+
+    private formatShortcut(shortcut: string): string {
+        // Convert electron accelerator format to display format
+        return shortcut
+            .replace(/CommandOrControl/g, 'Ctrl')
+            .replace(/\+/g, ' + ');
+    }
+
+    register(command: CommandDefinition) {
+        this.commands.set(command.id, command);
+
+        // Register aliases
+        if (command.aliases) {
+            for (const alias of command.aliases) {
+                this.aliases.set(alias.toLowerCase(), command.id);
+            }
+        }
+    }
+
+    getCommand(id: string): CommandDefinition | undefined {
+        return this.commands.get(id);
+    }
+
+    getAllCommands(): CommandDefinition[] {
+        const commands = Array.from(this.commands.values());
+
+        // Sort commands by name
+        commands.sort((a, b) => a.name.localeCompare(b.name));
+
+        return commands;
+    }
+
+    searchCommands(query: string): CommandDefinition[] {
+        const normalizedQuery = query.toLowerCase();
+        const results: { command: CommandDefinition; score: number }[] = [];
+
+        for (const command of this.commands.values()) {
+            let score = 0;
+
+            // Exact match on name
+            if (command.name.toLowerCase() === normalizedQuery) {
+                score = 100;
+            }
+            // Name starts with query
+            else if (command.name.toLowerCase().startsWith(normalizedQuery)) {
+                score = 80;
+            }
+            // Name contains query
+            else if (command.name.toLowerCase().includes(normalizedQuery)) {
+                score = 60;
+            }
+            // Description contains query
+            else if (command.description?.toLowerCase().includes(normalizedQuery)) {
+                score = 40;
+            }
+            // Check aliases
+            else if (command.aliases?.some(alias => alias.toLowerCase().includes(normalizedQuery))) {
+                score = 50;
+            }
+
+            if (score > 0) {
+                results.push({ command, score });
+            }
+        }
+
+        // Sort by score (highest first) and then by name
+        results.sort((a, b) => {
+            if (a.score !== b.score) {
+                return b.score - a.score;
+            }
+            return a.command.name.localeCompare(b.command.name);
+        });
+
+        return results.map(r => r.command);
+    }
+
+    async executeCommand(commandId: string) {
+        const command = this.getCommand(commandId);
+        if (!command) {
+            console.error(`Command not found: ${commandId}`);
+            return;
+        }
+
+        // Execute custom handler if provided
+        if (command.handler) {
+            await command.handler();
+            return;
+        }
+
+        // Handle keyboard action with scope-aware execution
+        if (command.keyboardAction && command.commandName) {
+            if (command.keyboardAction.scope === "note-tree") {
+                this.executeWithNoteTreeFocus(command.commandName);
+            } else if (command.keyboardAction.scope === "text-detail") {
+                this.executeWithTextDetail(command.commandName);
+            } else {
+                appContext.triggerCommand(command.commandName, {
+                    ntxId: appContext.tabManager.activeNtxId
+                });
+            }
+            return;
+        }
+
+        // Fallback for commands without keyboard action reference
+        if (command.commandName) {
+            appContext.triggerCommand(command.commandName, {
+                ntxId: appContext.tabManager.activeNtxId
+            });
+            return;
+        }
+
+        console.error(`Command ${commandId} has no handler or commandName`);
+    }
+
+    private executeWithNoteTreeFocus(actionName: CommandNames) {
+        const tree = document.querySelector(".tree-wrapper") as HTMLElement;
+        if (!tree) {
+            return;
+        }
+
+        const treeComponent = appContext.getComponentByEl(tree) as NoteTreeWidget;
+        const activeNode = treeComponent.getActiveNode();
+        treeComponent.triggerCommand(actionName, {
+            ntxId: appContext.tabManager.activeNtxId,
+            node: activeNode
+        });
+    }
+
+    private async executeWithTextDetail(actionName: CommandNames) {
+        const typeWidget = await appContext.tabManager.getActiveContext()?.getTypeWidget();
+        if (!typeWidget) {
+            return;
+        }
+
+        typeWidget.triggerCommand(actionName, {
+            ntxId: appContext.tabManager.activeNtxId
+        });
+    }
+}
+
+const commandRegistry = new CommandRegistry();
+export default commandRegistry;

apps/client/src/services/content_renderer.ts

@@ -65,6 +65,9 @@ async function getRenderedContent(this: {} | { ctx: string }, entity: FNote | FA
 
         $renderedContent.append($("<div>").append("<div>This note is protected and to access it you need to enter password.</div>").append("<br/>").append($button));
     } else if (entity instanceof FNote) {
+        $renderedContent
+            .css("display", "flex")
+            .css("flex-direction", "column");
         $renderedContent.append(
             $("<div>")
                 .css("display", "flex")
@@ -72,8 +75,33 @@ async function getRenderedContent(this: {} | { ctx: string }, entity: FNote | FA
                 .css("align-items", "center")
                 .css("height", "100%")
                 .css("font-size", "500%")
+                .css("flex-grow", "1")
                 .append($("<span>").addClass(entity.getIcon()))
         );
+
+        if (entity.type === "webView" && entity.hasLabel("webViewSrc")) {
+            const $footer = $("<footer>")
+                .addClass("webview-footer");
+            const $openButton = $(`
+                <button class="file-open btn btn-primary" type="button">
+                    <span class="bx bx-link-external"></span>
+                    ${t("content_renderer.open_externally")}
+                </button>
+            `)
+                .appendTo($footer)
+                .on("click", () => {
+                    const webViewSrc = entity.getLabelValue("webViewSrc");
+                    if (webViewSrc) {
+                        if (utils.isElectron()) {
+                            const electron = utils.dynamicRequire("electron");
+                            electron.shell.openExternal(webViewSrc);
+                        } else {
+                            window.open(webViewSrc, '_blank', 'noopener,noreferrer');
+                        }
+                    }
+                });
+            $footer.appendTo($renderedContent);
+        }
     }
 
     if (entity instanceof FNote) {

apps/client/src/services/dialog.ts

@@ -41,8 +41,14 @@ async function info(message: string) {
     return new Promise((res) => appContext.triggerCommand("showInfoDialog", { message, callback: res }));
 }
 
+/**
+ * Displays a confirmation dialog with the given message.
+ *
+ * @param message the message to display in the dialog.
+ * @returns A promise that resolves to true if the user confirmed, false otherwise.
+ */
 async function confirm(message: string) {
-    return new Promise((res) =>
+    return new Promise<boolean>((res) =>
         appContext.triggerCommand("showConfirmDialog", <ConfirmWithMessageOptions>{
             message,
             callback: (x: false | ConfirmDialogOptions) => res(x && x.confirmed)

apps/client/src/services/i18n.ts

@@ -6,6 +6,11 @@ import type { Locale } from "@triliumnext/commons";
 
 let locales: Locale[] | null;
 
+/**
+ * A deferred promise that resolves when translations are initialized.
+ */
+export let translationsInitializedPromise = $.Deferred();
+
 export async function initLocale() {
     const locale = (options.get("locale") as string) || "en";
 
@@ -19,6 +24,8 @@ export async function initLocale() {
         },
         returnEmptyString: false
     });
+
+    translationsInitializedPromise.resolve();
 }
 
 export function getAvailableLocales() {

apps/client/src/services/keyboard_actions.ts

@@ -2,21 +2,15 @@ import server from "./server.js";
 import appContext, { type CommandNames } from "../components/app_context.js";
 import shortcutService from "./shortcuts.js";
 import type Component from "../components/component.js";
+import type { ActionKeyboardShortcut } from "@triliumnext/commons";
 
-const keyboardActionRepo: Record<string, Action> = {};
+const keyboardActionRepo: Record<string, ActionKeyboardShortcut> = {};
 
-// TODO: Deduplicate with server.
-export interface Action {
-    actionName: CommandNames;
-    effectiveShortcuts: string[];
-    scope: string;
-}
-
-const keyboardActionsLoaded = server.get<Action[]>("keyboard-actions").then((actions) => {
+const keyboardActionsLoaded = server.get<ActionKeyboardShortcut[]>("keyboard-actions").then((actions) => {
     actions = actions.filter((a) => !!a.actionName); // filter out separators
 
     for (const action of actions) {
-        action.effectiveShortcuts = action.effectiveShortcuts.filter((shortcut) => !shortcut.startsWith("global:"));
+        action.effectiveShortcuts = (action.effectiveShortcuts ?? []).filter((shortcut) => !shortcut.startsWith("global:"));
 
         keyboardActionRepo[action.actionName] = action;
     }
@@ -38,7 +32,7 @@ async function setupActionsForElement(scope: string, $el: JQuery<HTMLElement>, c
     const actions = await getActionsForScope(scope);
 
     for (const action of actions) {
-        for (const shortcut of action.effectiveShortcuts) {
+        for (const shortcut of action.effectiveShortcuts ?? []) {
             shortcutService.bindElShortcut($el, shortcut, () => component.triggerCommand(action.actionName, { ntxId: appContext.tabManager.activeNtxId }));
         }
     }
@@ -46,7 +40,7 @@ async function setupActionsForElement(scope: string, $el: JQuery<HTMLElement>, c
 
 getActionsForScope("window").then((actions) => {
     for (const action of actions) {
-        for (const shortcut of action.effectiveShortcuts) {
+        for (const shortcut of action.effectiveShortcuts ?? []) {
             shortcutService.bindGlobalShortcut(shortcut, () => appContext.triggerCommand(action.actionName, { ntxId: appContext.tabManager.activeNtxId }));
         }
     }
@@ -80,7 +74,7 @@ function updateDisplayedShortcuts($container: JQuery<HTMLElement>) {
         const action = await getAction(actionName, true);
 
         if (action) {
-            const keyboardActions = action.effectiveShortcuts.join(", ");
+            const keyboardActions = (action.effectiveShortcuts ?? []).join(", ");
 
             if (keyboardActions || $(el).text() !== "not set") {
                 $(el).text(keyboardActions);
@@ -99,7 +93,7 @@ function updateDisplayedShortcuts($container: JQuery<HTMLElement>) {
 
         if (action) {
             const title = $(el).attr("title");
-            const shortcuts = action.effectiveShortcuts.join(", ");
+            const shortcuts = (action.effectiveShortcuts ?? []).join(", ");
 
             if (title?.includes(shortcuts)) {
                 return;

apps/client/src/services/link.ts

@@ -316,7 +316,7 @@ function goToLinkExt(evt: MouseEvent | JQuery.ClickEvent | JQuery.MouseDownEvent
     const openInNewWindow = isLeftClick && evt?.shiftKey && !ctrlKey;
 
     if (notePath) {
-        if (openInPopup) {
+        if (isLeftClick && openInPopup) {
             appContext.triggerCommand("openInPopup", { noteIdOrPath: notePath });
         } else if (openInNewWindow) {
             appContext.triggerCommand("openInWindow", { notePath, viewScope });
@@ -405,7 +405,7 @@ function linkContextMenu(e: PointerEvent) {
     linkContextMenuService.openContextMenu(notePath, e, viewScope, null);
 }
 
-export async function loadReferenceLinkTitle($el: JQuery<HTMLElement>, href: string | null | undefined = null) {
+async function loadReferenceLinkTitle($el: JQuery<HTMLElement>, href: string | null | undefined = null) {
     const $link = $el[0].tagName === "A" ? $el : $el.find("a");
 
     href = href || $link.attr("href");

apps/client/src/services/note_autocomplete.ts

@@ -3,6 +3,7 @@ import appContext from "../components/app_context.js";
 import noteCreateService from "./note_create.js";
 import froca from "./froca.js";
 import { t } from "./i18n.js";
+import commandRegistry from "./command_registry.js";
 import type { MentionFeedObjectItem } from "@triliumnext/ckeditor5";
 
 // this key needs to have this value, so it's hit by the tooltip
@@ -29,9 +30,12 @@ export interface Suggestion {
     notePathTitle?: string;
     notePath?: string;
     highlightedNotePathTitle?: string;
-    action?: string | "create-note" | "search-notes" | "external-link";
+    action?: string | "create-note" | "search-notes" | "external-link" | "command";
     parentNoteId?: string;
     icon?: string;
+    commandId?: string;
+    commandDescription?: string;
+    commandShortcut?: string;
 }
 
 interface Options {
@@ -40,7 +44,12 @@ interface Options {
     allowCreatingNotes?: boolean;
     allowJumpToSearchNotes?: boolean;
     allowExternalLinks?: boolean;
+    /** If set, hides the right-side button corresponding to go to selected note. */
     hideGoToSelectedNoteButton?: boolean;
+    /** If set, hides all right-side buttons in the autocomplete dropdown */
+    hideAllButtons?: boolean;
+    /** If set, enables command palette mode */
+    isCommandPalette?: boolean;
 }
 
 async function autocompleteSourceForCKEditor(queryText: string) {
@@ -70,6 +79,31 @@ async function autocompleteSourceForCKEditor(queryText: string) {
 }
 
 async function autocompleteSource(term: string, cb: (rows: Suggestion[]) => void, options: Options = {}) {
+    // Check if we're in command mode
+    if (options.isCommandPalette && term.startsWith(">")) {
+        const commandQuery = term.substring(1).trim();
+        
+        // Get commands (all if no query, filtered if query provided)
+        const commands = commandQuery.length === 0 
+            ? commandRegistry.getAllCommands()
+            : commandRegistry.searchCommands(commandQuery);
+            
+        // Convert commands to suggestions
+        const commandSuggestions: Suggestion[] = commands.map(cmd => ({
+            action: "command",
+            commandId: cmd.id,
+            noteTitle: cmd.name,
+            notePathTitle: `>${cmd.name}`,
+            highlightedNotePathTitle: cmd.name,
+            commandDescription: cmd.description,
+            commandShortcut: cmd.shortcut,
+            icon: cmd.icon
+        }));
+        
+        cb(commandSuggestions);
+        return;
+    }
+
     const fastSearch = options.fastSearch === false ? false : true;
     if (fastSearch === false) {
         if (term.trim().length === 0) {
@@ -143,6 +177,12 @@ function showRecentNotes($el: JQuery<HTMLElement>) {
     $el.trigger("focus");
 }
 
+function showAllCommands($el: JQuery<HTMLElement>) {
+    searchDelay = 0;
+    $el.setSelectedNotePath("");
+    $el.autocomplete("val", ">").autocomplete("open");
+}
+
 function fullTextSearch($el: JQuery<HTMLElement>, options: Options) {
     const searchString = $el.autocomplete("val") as unknown as string;
     if (options.fastSearch === false || searchString?.trim().length === 0) {
@@ -190,9 +230,11 @@ function initNoteAutocomplete($el: JQuery<HTMLElement>, options?: Options) {
 
     const $goToSelectedNoteButton = $("<a>").addClass("input-group-text go-to-selected-note-button bx bx-arrow-to-right");
 
-    $el.after($clearTextButton).after($showRecentNotesButton).after($fullTextSearchButton);
+    if (!options.hideAllButtons) {
+        $el.after($clearTextButton).after($showRecentNotesButton).after($fullTextSearchButton);
+    }
 
-    if (!options.hideGoToSelectedNoteButton) {
+    if (!options.hideGoToSelectedNoteButton && !options.hideAllButtons) {
         $el.after($goToSelectedNoteButton);
     }
 
@@ -265,7 +307,24 @@ function initNoteAutocomplete($el: JQuery<HTMLElement>, options?: Options) {
                 },
                 displayKey: "notePathTitle",
                 templates: {
-                    suggestion: (suggestion) => `<span class="${suggestion.icon ?? "bx bx-note"}"></span> ${suggestion.highlightedNotePathTitle}`
+                    suggestion: (suggestion) => {
+                        if (suggestion.action === "command") {
+                            let html = `<div class="command-suggestion">`;
+                            html += `<span class="command-icon ${suggestion.icon || "bx bx-terminal"}"></span>`;
+                            html += `<div class="command-content">`;
+                            html += `<div class="command-name">${suggestion.highlightedNotePathTitle}</div>`;
+                            if (suggestion.commandDescription) {
+                                html += `<div class="command-description">${suggestion.commandDescription}</div>`;
+                            }
+                            html += `</div>`;
+                            if (suggestion.commandShortcut) {
+                                html += `<kbd class="command-shortcut">${suggestion.commandShortcut}</kbd>`;
+                            }
+                            html += '</div>';
+                            return html;
+                        }
+                        return `<span class="${suggestion.icon ?? "bx bx-note"}"></span> ${suggestion.highlightedNotePathTitle}`;
+                    }
                 },
                 // we can't cache identical searches because notes can be created / renamed, new recent notes can be added
                 cache: false
@@ -275,6 +334,12 @@ function initNoteAutocomplete($el: JQuery<HTMLElement>, options?: Options) {
 
     // TODO: Types fail due to "autocomplete:selected" not being registered in type definitions.
     ($el as any).on("autocomplete:selected", async (event: Event, suggestion: Suggestion) => {
+        if (suggestion.action === "command") {
+            $el.autocomplete("close");
+            $el.trigger("autocomplete:commandselected", [suggestion]);
+            return;
+        }
+
         if (suggestion.action === "external-link") {
             $el.setSelectedNotePath(null);
             $el.setSelectedExternalLink(suggestion.externalLink);
@@ -391,6 +456,7 @@ export default {
     autocompleteSourceForCKEditor,
     initNoteAutocomplete,
     showRecentNotes,
+    showAllCommands,
     setText,
     init
 };

apps/client/src/services/note_create.ts

@@ -11,7 +11,7 @@ import type FBranch from "../entities/fbranch.js";
 import type { ChooseNoteTypeResponse } from "../widgets/dialogs/note_type_chooser.js";
 import type { CKTextEditor } from "@triliumnext/ckeditor5";
 
-interface CreateNoteOpts {
+export interface CreateNoteOpts {
     isProtected?: boolean;
     saveSelection?: boolean;
     title?: string | null;

apps/client/src/services/note_list_renderer.ts

@@ -1,4 +1,5 @@
 import type FNote from "../entities/fnote.js";
+import BoardView from "../widgets/view_widgets/board_view/index.js";
 import CalendarView from "../widgets/view_widgets/calendar_view.js";
 import GeoView from "../widgets/view_widgets/geo_view/index.js";
 import ListOrGridView from "../widgets/view_widgets/list_or_grid_view.js";
@@ -6,39 +7,25 @@ import TableView from "../widgets/view_widgets/table_view/index.js";
 import type { ViewModeArgs } from "../widgets/view_widgets/view_mode.js";
 import type ViewMode from "../widgets/view_widgets/view_mode.js";
 
-export type ViewTypeOptions = "list" | "grid" | "calendar" | "table" | "geoMap";
+const allViewTypes = ["list", "grid", "calendar", "table", "geoMap", "board"] as const;
+export type ArgsWithoutNoteId = Omit<ViewModeArgs, "noteIds">;
+export type ViewTypeOptions = typeof allViewTypes[number];
 
 export default class NoteListRenderer {
 
     private viewType: ViewTypeOptions;
-    public viewMode: ViewMode<any> | null;
+    private args: ArgsWithoutNoteId;
+    public viewMode?: ViewMode<any>;
 
-    constructor(args: ViewModeArgs) {
+    constructor(args: ArgsWithoutNoteId) {
+        this.args = args;
         this.viewType = this.#getViewType(args.parentNote);
-
-        switch (this.viewType) {
-            case "list":
-            case "grid":
-                this.viewMode = new ListOrGridView(this.viewType, args);
-                break;
-            case "calendar":
-                this.viewMode = new CalendarView(args);
-                break;
-            case "table":
-                this.viewMode = new TableView(args);
-                break;
-            case "geoMap":
-                this.viewMode = new GeoView(args);
-                break;
-            default:
-                this.viewMode = null;
-        }
     }
 
     #getViewType(parentNote: FNote): ViewTypeOptions {
         const viewType = parentNote.getLabelValue("viewType");
 
-        if (!["list", "grid", "calendar", "table", "geoMap"].includes(viewType || "")) {
+        if (!(allViewTypes as readonly string[]).includes(viewType || "")) {
             // when not explicitly set, decide based on the note type
             return parentNote.type === "search" ? "list" : "grid";
         } else {
@@ -47,15 +34,38 @@ export default class NoteListRenderer {
     }
 
     get isFullHeight() {
-        return this.viewMode?.isFullHeight;
+        switch (this.viewType) {
+            case "list":
+            case "grid":
+                return false;
+            default:
+                return true;
+        }
     }
 
     async renderList() {
-        if (!this.viewMode) {
-            return null;
-        }
+        const args = this.args;
+        const viewMode = this.#buildViewMode(args);
+        this.viewMode = viewMode;
+        await viewMode.beforeRender();
+        return await viewMode.renderList();
+    }
 
-        return await this.viewMode.renderList();
+    #buildViewMode(args: ViewModeArgs) {
+        switch (this.viewType) {
+            case "calendar":
+                return new CalendarView(args);
+            case "table":
+                return new TableView(args);
+            case "geoMap":
+                return new GeoView(args);
+            case "board":
+                return new BoardView(args);
+            case "list":
+            case "grid":
+            default:
+                return new ListOrGridView(this.viewType, args);
+        }
     }
 
 }

apps/client/src/services/note_tooltip.ts

@@ -13,8 +13,8 @@ let openTooltipElements: JQuery<HTMLElement>[] = [];
 let dismissTimer: ReturnType<typeof setTimeout>;
 
 function setupGlobalTooltip() {
-    $(document).on("mouseenter", "a", mouseEnterHandler);
-    $(document).on("mouseenter", "[data-href]", mouseEnterHandler);
+    $(document).on("mouseenter", "a:not(.no-tooltip-preview)", mouseEnterHandler);
+    $(document).on("mouseenter", "[data-href]:not(.no-tooltip-preview)", mouseEnterHandler);
 
     // close any note tooltip after click, this fixes the problem that sometimes tooltips remained on the screen
     $(document).on("click", (e) => {

apps/client/src/services/promoted_attribute_definition_parser.ts

@@ -1,4 +1,4 @@
-export type LabelType = "text" | "number" | "boolean" | "date" | "datetime" | "time" | "url";
+export type LabelType = "text" | "number" | "boolean" | "date" | "datetime" | "time" | "url" | "color";
 type Multiplicity = "single" | "multi";
 
 export interface DefinitionObject {
@@ -17,7 +17,7 @@ function parse(value: string) {
     for (const token of tokens) {
         if (token === "promoted") {
             defObj.isPromoted = true;
-        } else if (["text", "number", "boolean", "date", "datetime", "time", "url"].includes(token)) {
+        } else if (["text", "number", "boolean", "date", "datetime", "time", "url", "color"].includes(token)) {
             defObj.labelType = token as LabelType;
         } else if (["single", "multi"].includes(token)) {
             defObj.multiplicity = token as Multiplicity;

apps/client/src/services/shortcuts.spec.ts

@@ -0,0 +1,323 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import shortcuts, { keyMatches, matchesShortcut } from "./shortcuts.js";
+
+// Mock utils module
+vi.mock("./utils.js", () => ({
+    default: {
+        isDesktop: () => true
+    }
+}));
+
+// Mock jQuery globally since it's used in the shortcuts module
+const mockElement = {
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn()
+};
+
+const mockJQuery = vi.fn(() => [mockElement]);
+(mockJQuery as any).length = 1;
+mockJQuery[0] = mockElement;
+
+(global as any).$ = mockJQuery as any;
+global.document = mockElement as any;
+
+describe("shortcuts", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    afterEach(() => {
+        // Clean up any active bindings after each test
+        shortcuts.removeGlobalShortcut("test-namespace");
+    });
+
+    describe("normalizeShortcut", () => {
+        it("should normalize shortcut to lowercase and remove whitespace", () => {
+            expect(shortcuts.normalizeShortcut("Ctrl + A")).toBe("ctrl+a");
+            expect(shortcuts.normalizeShortcut("  SHIFT + F1  ")).toBe("shift+f1");
+            expect(shortcuts.normalizeShortcut("Alt+Space")).toBe("alt+space");
+        });
+
+        it("should handle empty or null shortcuts", () => {
+            expect(shortcuts.normalizeShortcut("")).toBe("");
+            expect(shortcuts.normalizeShortcut(null as any)).toBe(null);
+            expect(shortcuts.normalizeShortcut(undefined as any)).toBe(undefined);
+        });
+
+        it("should handle shortcuts with multiple spaces", () => {
+            expect(shortcuts.normalizeShortcut("Ctrl   +   Shift   +   A")).toBe("ctrl+shift+a");
+        });
+
+        it("should warn about malformed shortcuts", () => {
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+            shortcuts.normalizeShortcut("ctrl+");
+            shortcuts.normalizeShortcut("+a");
+            shortcuts.normalizeShortcut("ctrl++a");
+
+            expect(consoleSpy).toHaveBeenCalledTimes(3);
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe("keyMatches", () => {
+        const createKeyboardEvent = (key: string, code?: string) => ({
+            key,
+            code: code || `Key${key.toUpperCase()}`
+        } as KeyboardEvent);
+
+        it("should match regular letter keys using key code", () => {
+            const event = createKeyboardEvent("a", "KeyA");
+            expect(keyMatches(event, "a")).toBe(true);
+            expect(keyMatches(event, "A")).toBe(true);
+        });
+
+        it("should match number keys using digit codes", () => {
+            const event = createKeyboardEvent("1", "Digit1");
+            expect(keyMatches(event, "1")).toBe(true);
+        });
+
+        it("should match special keys using key mapping", () => {
+            expect(keyMatches({ key: "Enter" } as KeyboardEvent, "return")).toBe(true);
+            expect(keyMatches({ key: "Enter" } as KeyboardEvent, "enter")).toBe(true);
+            expect(keyMatches({ key: "Delete" } as KeyboardEvent, "del")).toBe(true);
+            expect(keyMatches({ key: "Escape" } as KeyboardEvent, "esc")).toBe(true);
+            expect(keyMatches({ key: " " } as KeyboardEvent, "space")).toBe(true);
+            expect(keyMatches({ key: "ArrowUp" } as KeyboardEvent, "up")).toBe(true);
+        });
+
+        it("should match function keys", () => {
+            expect(keyMatches({ key: "F1" } as KeyboardEvent, "f1")).toBe(true);
+            expect(keyMatches({ key: "F12" } as KeyboardEvent, "f12")).toBe(true);
+        });
+
+        it("should handle undefined or null keys", () => {
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+            expect(keyMatches({} as KeyboardEvent, null as any)).toBe(false);
+            expect(keyMatches({} as KeyboardEvent, undefined as any)).toBe(false);
+
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe("matchesShortcut", () => {
+        const createKeyboardEvent = (options: {
+            key: string;
+            code?: string;
+            ctrlKey?: boolean;
+            altKey?: boolean;
+            shiftKey?: boolean;
+            metaKey?: boolean;
+        }) => ({
+            key: options.key,
+            code: options.code || `Key${options.key.toUpperCase()}`,
+            ctrlKey: options.ctrlKey || false,
+            altKey: options.altKey || false,
+            shiftKey: options.shiftKey || false,
+            metaKey: options.metaKey || false
+        } as KeyboardEvent);
+
+        it("should match simple key shortcuts", () => {
+            const event = createKeyboardEvent({ key: "a", code: "KeyA" });
+            expect(matchesShortcut(event, "a")).toBe(true);
+        });
+
+        it("should match shortcuts with modifiers", () => {
+            const event = createKeyboardEvent({ key: "a", code: "KeyA", ctrlKey: true });
+            expect(matchesShortcut(event, "ctrl+a")).toBe(true);
+
+            const shiftEvent = createKeyboardEvent({ key: "a", code: "KeyA", shiftKey: true });
+            expect(matchesShortcut(shiftEvent, "shift+a")).toBe(true);
+        });
+
+        it("should match complex modifier combinations", () => {
+            const event = createKeyboardEvent({
+                key: "a",
+                code: "KeyA",
+                ctrlKey: true,
+                shiftKey: true
+            });
+            expect(matchesShortcut(event, "ctrl+shift+a")).toBe(true);
+        });
+
+        it("should not match when modifiers don't match", () => {
+            const event = createKeyboardEvent({ key: "a", code: "KeyA", ctrlKey: true });
+            expect(matchesShortcut(event, "alt+a")).toBe(false);
+            expect(matchesShortcut(event, "a")).toBe(false);
+        });
+
+        it("should handle alternative modifier names", () => {
+            const ctrlEvent = createKeyboardEvent({ key: "a", code: "KeyA", ctrlKey: true });
+            expect(matchesShortcut(ctrlEvent, "control+a")).toBe(true);
+
+            const metaEvent = createKeyboardEvent({ key: "a", code: "KeyA", metaKey: true });
+            expect(matchesShortcut(metaEvent, "cmd+a")).toBe(true);
+            expect(matchesShortcut(metaEvent, "command+a")).toBe(true);
+        });
+
+        it("should handle empty or invalid shortcuts", () => {
+            const event = createKeyboardEvent({ key: "a", code: "KeyA" });
+            expect(matchesShortcut(event, "")).toBe(false);
+            expect(matchesShortcut(event, null as any)).toBe(false);
+        });
+
+        it("should handle invalid events", () => {
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+            expect(matchesShortcut(null as any, "a")).toBe(false);
+            expect(matchesShortcut({} as KeyboardEvent, "a")).toBe(false);
+
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+
+        it("should warn about invalid shortcut formats", () => {
+            const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+            const event = createKeyboardEvent({ key: "a", code: "KeyA" });
+
+            matchesShortcut(event, "ctrl+");
+            matchesShortcut(event, "+");
+
+            expect(consoleSpy).toHaveBeenCalled();
+            consoleSpy.mockRestore();
+        });
+    });
+
+    describe("bindGlobalShortcut", () => {
+        it("should bind a global shortcut", () => {
+            const handler = vi.fn();
+            shortcuts.bindGlobalShortcut("ctrl+a", handler, "test-namespace");
+
+            expect(mockElement.addEventListener).toHaveBeenCalledWith("keydown", expect.any(Function));
+        });
+
+        it("should not bind shortcuts when handler is null", () => {
+            shortcuts.bindGlobalShortcut("ctrl+a", null, "test-namespace");
+
+            expect(mockElement.addEventListener).not.toHaveBeenCalled();
+        });
+
+        it("should remove previous bindings when namespace is reused", () => {
+            const handler1 = vi.fn();
+            const handler2 = vi.fn();
+
+            shortcuts.bindGlobalShortcut("ctrl+a", handler1, "test-namespace");
+            expect(mockElement.addEventListener).toHaveBeenCalledTimes(1);
+
+            shortcuts.bindGlobalShortcut("ctrl+b", handler2, "test-namespace");
+            expect(mockElement.removeEventListener).toHaveBeenCalledTimes(1);
+            expect(mockElement.addEventListener).toHaveBeenCalledTimes(2);
+        });
+    });
+
+    describe("bindElShortcut", () => {
+        it("should bind shortcut to specific element", () => {
+            const mockEl = { addEventListener: vi.fn(), removeEventListener: vi.fn() };
+            const mockJQueryEl = [mockEl] as any;
+            mockJQueryEl.length = 1;
+
+            const handler = vi.fn();
+            shortcuts.bindElShortcut(mockJQueryEl, "ctrl+a", handler, "test-namespace");
+
+            expect(mockEl.addEventListener).toHaveBeenCalledWith("keydown", expect.any(Function));
+        });
+
+        it("should fall back to document when element is empty", () => {
+            const emptyJQuery = [] as any;
+            emptyJQuery.length = 0;
+
+            const handler = vi.fn();
+            shortcuts.bindElShortcut(emptyJQuery, "ctrl+a", handler, "test-namespace");
+
+            expect(mockElement.addEventListener).toHaveBeenCalledWith("keydown", expect.any(Function));
+        });
+    });
+
+    describe("removeGlobalShortcut", () => {
+        it("should remove shortcuts for a specific namespace", () => {
+            const handler = vi.fn();
+            shortcuts.bindGlobalShortcut("ctrl+a", handler, "test-namespace");
+
+            shortcuts.removeGlobalShortcut("test-namespace");
+
+            expect(mockElement.removeEventListener).toHaveBeenCalledWith("keydown", expect.any(Function));
+        });
+    });
+
+    describe("event handling", () => {
+        it.skip("should call handler when shortcut matches", () => {
+            const handler = vi.fn();
+            shortcuts.bindGlobalShortcut("ctrl+a", handler, "test-namespace");
+
+            // Get the listener that was registered
+            expect(mockElement.addEventListener.mock.calls).toHaveLength(1);
+            const [, listener] = mockElement.addEventListener.mock.calls[0];
+
+            // First verify that matchesShortcut works directly
+            const testEvent = {
+                type: "keydown",
+                key: "a",
+                code: "KeyA",
+                ctrlKey: true,
+                altKey: false,
+                shiftKey: false,
+                metaKey: false,
+                preventDefault: vi.fn(),
+                stopPropagation: vi.fn()
+            } as any;
+
+            // Test matchesShortcut directly first
+            expect(matchesShortcut(testEvent, "ctrl+a")).toBe(true);
+
+            // Now test the actual listener
+            listener(testEvent);
+
+            expect(handler).toHaveBeenCalled();
+            expect(testEvent.preventDefault).toHaveBeenCalled();
+            expect(testEvent.stopPropagation).toHaveBeenCalled();
+        });
+
+        it("should not call handler for non-keyboard events", () => {
+            const handler = vi.fn();
+            shortcuts.bindGlobalShortcut("ctrl+a", handler, "test-namespace");
+
+            const [, listener] = mockElement.addEventListener.mock.calls[0];
+
+            // Simulate a non-keyboard event
+            const event = {
+                type: "click"
+            } as any;
+
+            listener(event);
+
+            expect(handler).not.toHaveBeenCalled();
+        });
+
+        it("should not call handler when shortcut doesn't match", () => {
+            const handler = vi.fn();
+            shortcuts.bindGlobalShortcut("ctrl+a", handler, "test-namespace");
+
+            const [, listener] = mockElement.addEventListener.mock.calls[0];
+
+            // Simulate a non-matching keydown event
+            const event = {
+                type: "keydown",
+                key: "b",
+                code: "KeyB",
+                ctrlKey: true,
+                altKey: false,
+                shiftKey: false,
+                metaKey: false,
+                preventDefault: vi.fn(),
+                stopPropagation: vi.fn()
+            } as any;
+
+            listener(event);
+
+            expect(handler).not.toHaveBeenCalled();
+            expect(event.preventDefault).not.toHaveBeenCalled();
+        });
+    });
+});

apps/client/src/services/shortcuts.ts

@@ -1,7 +1,18 @@
 import utils from "./utils.js";
 
 type ElementType = HTMLElement | Document;
-type Handler = (e: JQuery.TriggeredEvent<ElementType | Element, string, ElementType | Element, ElementType | Element>) => void;
+type Handler = (e: KeyboardEvent) => void;
+
+interface ShortcutBinding {
+    element: HTMLElement | Document;
+    shortcut: string;
+    handler: Handler;
+    namespace: string | null;
+    listener: (evt: Event) => void;
+}
+
+// Store all active shortcut bindings for management
+const activeBindings: Map<string, ShortcutBinding[]> = new Map();
 
 function removeGlobalShortcut(namespace: string) {
     bindGlobalShortcut("", null, namespace);
@@ -15,38 +26,167 @@ function bindElShortcut($el: JQuery<ElementType | Element>, keyboardShortcut: st
     if (utils.isDesktop()) {
         keyboardShortcut = normalizeShortcut(keyboardShortcut);
 
-        let eventName = "keydown";
-
+        // If namespace is provided, remove all previous bindings for this namespace
         if (namespace) {
-            eventName += `.${namespace}`;
-
-            // if there's a namespace, then we replace the existing event handler with the new one
-            $el.off(eventName);
+            removeNamespaceBindings(namespace);
         }
 
-        // method can be called to remove the shortcut (e.g. when keyboardShortcut label is deleted)
-        if (keyboardShortcut) {
-            $el.bind(eventName, keyboardShortcut, (e) => {
-                if (handler) {
-                    handler(e);
+        // Method can be called to remove the shortcut (e.g. when keyboardShortcut label is deleted)
+        if (keyboardShortcut && handler) {
+            const element = $el.length > 0 ? $el[0] as (HTMLElement | Document) : document;
+
+            const listener = (evt: Event) => {
+                // Only handle keyboard events
+                if (evt.type !== 'keydown' || !(evt instanceof KeyboardEvent)) {
+                    return;
                 }
 
-                e.preventDefault();
-                e.stopPropagation();
-            });
+                const e = evt as KeyboardEvent;
+                if (matchesShortcut(e, keyboardShortcut)) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    handler(e);
+                }
+            };
+
+            // Add the event listener
+            element.addEventListener('keydown', listener);
+
+            // Store the binding for later cleanup
+            const binding: ShortcutBinding = {
+                element,
+                shortcut: keyboardShortcut,
+                handler,
+                namespace,
+                listener
+            };
+
+            const key = namespace || 'global';
+            if (!activeBindings.has(key)) {
+                activeBindings.set(key, []);
+            }
+            activeBindings.get(key)!.push(binding);
         }
     }
 }
 
+function removeNamespaceBindings(namespace: string) {
+    const bindings = activeBindings.get(namespace);
+    if (bindings) {
+        // Remove all event listeners for this namespace
+        bindings.forEach(binding => {
+            binding.element.removeEventListener('keydown', binding.listener);
+        });
+        activeBindings.delete(namespace);
+    }
+}
+
+export function matchesShortcut(e: KeyboardEvent, shortcut: string): boolean {
+    if (!shortcut) return false;
+
+    // Ensure we have a proper KeyboardEvent with key property
+    if (!e || typeof e.key !== 'string') {
+        console.warn('matchesShortcut called with invalid event:', e);
+        return false;
+    }
+
+    const parts = shortcut.toLowerCase().split('+');
+    const key = parts[parts.length - 1]; // Last part is the actual key
+    const modifiers = parts.slice(0, -1); // Everything before is modifiers
+
+    // Defensive check - ensure we have a valid key
+    if (!key || key.trim() === '') {
+        console.warn('Invalid shortcut format:', shortcut);
+        return false;
+    }
+
+    // Check if the main key matches
+    if (!keyMatches(e, key)) {
+        return false;
+    }
+
+    // Check modifiers
+    const expectedCtrl = modifiers.includes('ctrl') || modifiers.includes('control');
+    const expectedAlt = modifiers.includes('alt');
+    const expectedShift = modifiers.includes('shift');
+    const expectedMeta = modifiers.includes('meta') || modifiers.includes('cmd') || modifiers.includes('command');
+
+    return e.ctrlKey === expectedCtrl &&
+           e.altKey === expectedAlt &&
+           e.shiftKey === expectedShift &&
+           e.metaKey === expectedMeta;
+}
+
+export function keyMatches(e: KeyboardEvent, key: string): boolean {
+    // Defensive check for undefined/null key
+    if (!key) {
+        console.warn('keyMatches called with undefined/null key');
+        return false;
+    }
+
+    // Handle special key mappings and aliases
+    const keyMap: { [key: string]: string[] } = {
+        'return': ['Enter'],
+        'enter': ['Enter'],  // alias for return
+        'del': ['Delete'],
+        'delete': ['Delete'], // alias for del
+        'esc': ['Escape'],
+        'escape': ['Escape'], // alias for esc
+        'space': [' ', 'Space'],
+        'tab': ['Tab'],
+        'backspace': ['Backspace'],
+        'home': ['Home'],
+        'end': ['End'],
+        'pageup': ['PageUp'],
+        'pagedown': ['PageDown'],
+        'up': ['ArrowUp'],
+        'down': ['ArrowDown'],
+        'left': ['ArrowLeft'],
+        'right': ['ArrowRight']
+    };
+
+    // Function keys
+    for (let i = 1; i <= 19; i++) {
+        keyMap[`f${i}`] = [`F${i}`];
+    }
+
+    const mappedKeys = keyMap[key.toLowerCase()];
+    if (mappedKeys) {
+        return mappedKeys.includes(e.key) || mappedKeys.includes(e.code);
+    }
+
+    // For number keys, use the physical key code regardless of modifiers
+    // This works across all keyboard layouts
+    if (key >= '0' && key <= '9') {
+        return e.code === `Digit${key}`;
+    }
+
+    // For letter keys, use the physical key code for consistency
+    if (key.length === 1 && key >= 'a' && key <= 'z') {
+        return e.code === `Key${key.toUpperCase()}`;
+    }
+
+    // For regular keys, check both key and code as fallback
+    return e.key.toLowerCase() === key.toLowerCase() ||
+           e.code.toLowerCase() === key.toLowerCase();
+}
+
 /**
- * Normalize to the form expected by the jquery.hotkeys.js
+ * Simple normalization - just lowercase and trim whitespace
  */
 function normalizeShortcut(shortcut: string): string {
     if (!shortcut) {
         return shortcut;
     }
 
-    return shortcut.toLowerCase().replace("enter", "return").replace("delete", "del").replace("ctrl+alt", "alt+ctrl").replace("meta+alt", "alt+meta"); // alt needs to be first;
+    const normalized = shortcut.toLowerCase().trim().replace(/\s+/g, '');
+
+    // Warn about potentially problematic shortcuts
+    if (normalized.endsWith('+') || normalized.startsWith('+') || normalized.includes('++')) {
+        console.warn('Potentially malformed shortcut:', shortcut, '-> normalized to:', normalized);
+    }
+
+    return normalized;
 }
 
 export default {

apps/client/src/services/spaced_update.ts

@@ -51,6 +51,14 @@ export default class SpacedUpdate {
         this.lastUpdated = Date.now();
     }
 
+    /**
+     * Sets the update interval for the spaced update.
+     * @param interval The update interval in milliseconds.
+     */
+    setUpdateInterval(interval: number) {
+        this.updateInterval = interval;
+    }
+
     triggerUpdate() {
         if (!this.changed) {
             return;

apps/client/src/services/syntax_highlight.ts

@@ -36,7 +36,9 @@ export function applyCopyToClipboardButton($codeBlock: JQuery<HTMLElement>) {
     const $copyButton = $("<button>")
         .addClass("bx component icon-action tn-tool-button bx-copy copy-button")
         .attr("title", t("code_block.copy_title"))
-        .on("click", () => {
+        .on("click", (e) => {
+            e.stopPropagation();
+
             if (!isShare) {
                 copyTextWithToast($codeBlock.text());
             } else {

apps/client/src/setup.ts

@@ -1,5 +1,4 @@
 import "jquery";
-import "jquery-hotkeys";
 import utils from "./services/utils.js";
 import ko from "knockout";
 import "./stylesheets/bootstrap.scss";

apps/client/src/share.ts

@@ -29,6 +29,14 @@ async function formatCodeBlocks() {
     await formatCodeBlocks($("#content"));
 }
 
+async function setupTextNote() {
+    formatCodeBlocks();
+    applyMath();
+
+    const setupMermaid = (await import("./share/mermaid.js")).default;
+    setupMermaid();
+}
+
 /**
  * Fetch note with given ID from backend
  *
@@ -47,8 +55,11 @@ async function fetchNote(noteId: string | null = null) {
 document.addEventListener(
     "DOMContentLoaded",
     () => {
-        formatCodeBlocks();
-        applyMath();
+        const noteType = determineNoteType();
+
+        if (noteType === "text") {
+            setupTextNote();
+        }
 
         const toggleMenuButton = document.getElementById("toggleMenuButton");
         const layout = document.getElementById("layout");
@@ -60,6 +71,12 @@ document.addEventListener(
     false
 );
 
+function determineNoteType() {
+    const bodyClass = document.body.className;
+    const match = bodyClass.match(/type-([^\s]+)/);
+    return match ? match[1] : null;
+}
+
 // workaround to prevent webpack from removing "fetchNote" as dead code:
 // add fetchNote as property to the window object
 Object.defineProperty(window, "fetchNote", {

apps/client/src/share/mermaid.ts

@@ -0,0 +1,17 @@
+import mermaid from "mermaid";
+
+export default function setupMermaid() {
+    for (const codeBlock of document.querySelectorAll("#content pre code.language-mermaid")) {
+        const parentPre = codeBlock.parentElement;
+        if (!parentPre) {
+            continue;
+        }
+
+        const mermaidDiv = document.createElement("div");
+        mermaidDiv.classList.add("mermaid");
+        mermaidDiv.innerHTML = codeBlock.innerHTML;
+        parentPre.replaceWith(mermaidDiv);
+    }
+
+    mermaid.init();
+}

apps/client/src/stylesheets/ckeditor-theme.css

@@ -81,8 +81,8 @@ body {
 
     /* -- Overrides the default colors used by the ckeditor5-image package. --------------------- */
 
-    --ck-color-image-caption-background: var(--main-background-color);
-    --ck-color-image-caption-text: var(--main-text-color);
+    --ck-content-color-image-caption-background: var(--main-background-color);
+    --ck-content-color-image-caption-text: var(--main-text-color);
 
     /* -- Overrides the default colors used by the ckeditor5-widget package. -------------------- */
 

apps/client/src/stylesheets/print.css

@@ -320,3 +320,8 @@ h6 {
     page-break-after: avoid;
     break-after: avoid;
 }
+
+figure.table {
+    /* Workaround for https://github.com/ckeditor/ckeditor5/issues/18903. Remove once official fix is released */
+    display: table !important;
+}

apps/client/src/stylesheets/style.css

@@ -139,12 +139,6 @@ textarea,
     color: var(--muted-text-color);
 }
 
-/* Restore default apperance */
-input[type="number"],
-input[type="checkbox"] {
-    appearance: auto !important;
-}
-
 /* Add a gap between consecutive radios / check boxes */
 label.tn-radio + label.tn-radio,
 label.tn-checkbox + label.tn-checkbox {
@@ -327,7 +321,8 @@ button kbd {
     }
 }
 
-.dropdown-menu {
+.dropdown-menu,
+.tabulator-popup-container {
     color: var(--menu-text-color) !important;
     font-size: inherit;
     background-color: var(--menu-background-color) !important;
@@ -342,7 +337,8 @@ button kbd {
     break-after: avoid;
 }
 
-body.desktop .dropdown-menu {
+body.desktop .dropdown-menu,
+body.desktop .tabulator-popup-container {
     border: 1px solid var(--dropdown-border-color);
     box-shadow: 0px 10px 20px rgba(0, 0, 0, var(--dropdown-shadow-opacity));
     animation: dropdown-menu-opening 100ms ease-in;
@@ -385,7 +381,8 @@ body.desktop .dropdown-menu {
 }
 
 .dropdown-menu a:hover:not(.disabled),
-.dropdown-item:hover:not(.disabled, .dropdown-item-container) {
+.dropdown-item:hover:not(.disabled, .dropdown-item-container),
+.tabulator-menu-item:hover {
     color: var(--hover-item-text-color) !important;
     background-color: var(--hover-item-background-color) !important;
     border-color: var(--hover-item-border-color) !important;
@@ -921,6 +918,13 @@ div[data-notify="container"] {
     font-family: var(--monospace-font-family);
 }
 
+.ck-content {
+    --ck-content-font-family: var(--detail-font-family);
+    --ck-content-font-size: 1.1em;
+    --ck-content-font-color: var(--main-text-color);
+    --ck-content-line-height: var(--bs-body-line-height);
+}
+
 .ck-content .table table th {
     background-color: var(--accented-background-color);
 }
@@ -1207,12 +1211,14 @@ body.mobile .dropdown-submenu > .dropdown-menu {
 }
 
 #context-menu-container,
-#context-menu-container .dropdown-menu {
-    padding: 3px 0 0;
+#context-menu-container .dropdown-menu,
+.tabulator-popup-container {
+    padding: 3px 0;
     z-index: 2000;
 }
 
-#context-menu-container .dropdown-item {
+#context-menu-container .dropdown-item,
+.tabulator-menu .tabulator-menu-item {
     padding: 0 7px 0 10px;
     cursor: pointer;
     user-select: none;
@@ -1774,6 +1780,54 @@ textarea {
     padding: 1rem;
 }
 
+/* Command palette styling */
+.jump-to-note-dialog .command-suggestion {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    font-size: 0.9em;
+}
+
+.jump-to-note-dialog .aa-suggestion .command-suggestion,
+.jump-to-note-dialog .aa-suggestion .command-suggestion div {
+    padding: 0;
+}
+
+.jump-to-note-dialog .aa-cursor .command-suggestion,
+.jump-to-note-dialog .aa-suggestion:hover .command-suggestion {
+    border-left-color: var(--link-color);
+    background-color: var(--hover-background-color);
+}
+
+.jump-to-note-dialog .command-icon {
+    color: var(--muted-text-color);
+    font-size: 1.125rem;
+    flex-shrink: 0;
+    margin-top: 0.125rem;
+}
+
+.jump-to-note-dialog .command-content {
+    flex-grow: 1;
+    min-width: 0;
+}
+
+.jump-to-note-dialog .command-name {
+    font-weight: bold;
+}
+
+.jump-to-note-dialog .command-description {
+    font-size: 0.8em;
+    line-height: 1.3;
+    opacity: 0.75;
+}
+
+.jump-to-note-dialog kbd.command-shortcut {
+    background-color: transparent;
+    color: inherit;
+    opacity: 0.75;
+    font-family: inherit !important;
+}
+
 .empty-table-placeholder {
     text-align: center;
     color: var(--muted-text-color);
@@ -1883,12 +1937,14 @@ body.zen .note-title-widget input {
 
 /* Content renderer */
 
-footer.file-footer {
+footer.file-footer,
+footer.webview-footer {
     display: flex;
     justify-content: center;
 }
 
-footer.file-footer button {
+footer.file-footer button,
+footer.webview-footer button {
     margin: 5px;
 }
 

apps/client/src/stylesheets/table.css

@@ -0,0 +1,199 @@
+.tabulator {
+    --table-background-color: var(--main-background-color);
+
+    --col-header-background-color: var(--main-background-color);
+    --col-header-hover-background-color: var(--accented-background-color);
+    --col-header-text-color: var(--main-text-color);
+    --col-header-arrow-active-color: var(--main-text-color);
+    --col-header-arrow-inactive-color: var(--more-accented-background-color);
+    --col-header-separator-border: none;
+    --col-header-bottom-border: 2px solid var(--main-border-color);
+
+    --row-background-color: var(--main-background-color);
+    --row-alternate-background-color: var(--main-background-color);
+    --row-moving-background-color: var(--accented-background-color);
+    --row-text-color: var(--main-text-color);
+    --row-delimiter-color: var(--more-accented-background-color);
+    
+    --cell-horiz-padding-size: 8px;
+    --cell-vert-padding-size: 8px;
+    
+    --cell-editable-hover-outline-color: var(--main-border-color);
+    --cell-read-only-text-color: var(--muted-text-color);
+    
+    --cell-editing-border-color: var(--main-border-color);
+    --cell-editing-border-width: 2px;
+    --cell-editing-background-color: var(--ck-color-selector-focused-cell-background);
+    --cell-editing-text-color: initial;
+
+    background: unset;
+    border: unset;
+}
+
+.tabulator .tabulator-tableholder .tabulator-table {
+    background: var(--table-background-color);
+}
+
+/* Column headers */
+
+.tabulator div.tabulator-header {
+    border-bottom: var(--col-header-bottom-border);
+    background: var(--col-header-background-color);
+    color: var(--col-header-text-color);
+}
+
+.tabulator .tabulator-col-content {
+    padding: 8px 4px !important;
+}
+
+@media (hover: hover) and (pointer: fine) {
+  .tabulator .tabulator-header .tabulator-col.tabulator-sortable.tabulator-col-sorter-element:hover {
+    background-color: var(--col-header-hover-background-color);
+  }
+}
+
+.tabulator div.tabulator-header .tabulator-col.tabulator-moving {
+    border: none;
+    background: var(--col-header-hover-background-color);
+}
+
+.tabulator .tabulator-header .tabulator-col.tabulator-sortable[aria-sort] .tabulator-col-content .tabulator-col-sorter .tabulator-arrow {
+    border-bottom-color: var(--col-header-arrow-active-color);
+    border-top-color: var(--col-header-arrow-active-color);
+}
+
+.tabulator .tabulator-header .tabulator-col.tabulator-sortable[aria-sort="none"] .tabulator-col-content .tabulator-col-sorter .tabulator-arrow {
+    border-bottom-color: var(--col-header-arrow-inactive-color);
+}
+
+.tabulator div.tabulator-header .tabulator-frozen.tabulator-frozen-left {
+    margin-left: var(--cell-editing-border-width);
+}
+
+.tabulator div.tabulator-header .tabulator-col,
+.tabulator div.tabulator-header .tabulator-frozen.tabulator-frozen-left {
+    background: var(--col-header-background-color);
+    border-right: var(--col-header-separator-border);
+}
+
+/* Table body */
+
+.tabulator-tableholder {
+    padding-top: 10px;
+    height: unset !important; /* Don't extend on the full height */
+}
+
+/* Rows */
+
+.tabulator-row .tabulator-cell {
+    padding: var(--cell-vert-padding-size) var(--cell-horiz-padding-size);
+}
+
+.tabulator-row .tabulator-cell input {
+    padding-left: var(--cell-horiz-padding-size) !important;
+    padding-right: var(--cell-horiz-padding-size) !important;
+}
+
+.tabulator-row {
+    background: transparent;
+    border-top: none;
+    border-bottom: 1px solid var(--row-delimiter-color);
+    color: var(--row-text-color);
+}
+
+.tabulator-row.tabulator-row-odd {
+    background: var(--row-background-color);
+}
+
+.tabulator-row.tabulator-row-even {
+    background: var(--row-alternate-background-color);
+}
+
+.tabulator-row.tabulator-moving {
+    border-color: transparent;
+    background-color: var(--row-moving-background-color);
+}
+
+/* Cell */
+
+.tabulator-row .tabulator-cell.tabulator-frozen.tabulator-frozen-left {
+    margin-right: var(--cell-editing-border-width);
+}
+
+.tabulator-row .tabulator-cell.tabulator-frozen.tabulator-frozen-left,
+.tabulator-row .tabulator-cell {
+    border-right-color: transparent;
+}
+
+.tabulator-row .tabulator-cell:not(.tabulator-editable) {
+    color: var(--cell-read-only-text-color);
+}
+
+.tabulator:not(.tabulator-editing) .tabulator-row .tabulator-cell.tabulator-editable:hover {
+    outline: 2px solid var(--cell-editable-hover-outline-color);
+    outline-offset: -1px;
+}
+
+.tabulator-row .tabulator-cell.tabulator-editing {
+    border-color: transparent;
+}
+
+.tabulator-row:not(.tabulator-moving) .tabulator-cell.tabulator-editing {
+    outline: calc(var(--cell-editing-border-width) - 1px) solid var(--cell-editing-border-color);
+    border-color: var(--cell-editing-border-color);
+    background: var(--cell-editing-background-color);
+}
+
+.tabulator-row:not(.tabulator-moving) .tabulator-cell.tabulator-editing > * {
+    color: var(--cell-editing-text-color);
+}
+
+.tabulator .tree-collapse,
+.tabulator .tree-expand {
+    color: var(--row-text-color);
+}
+
+/* Align items without children/expander to the ones with. */
+.tabulator-cell[tabulator-field="title"] > span:first-child,         /* 1st level */
+.tabulator-cell[tabulator-field="title"] > div:first-child + span {  /* sub-level */
+    padding-left: 21px;
+}
+
+/* Checkbox cells */
+
+.tabulator .tabulator-cell:has(svg),
+.tabulator .tabulator-cell:has(input[type="checkbox"]) {
+    padding-left: 8px;
+    display: inline-flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: flex-start;
+}
+
+.tabulator .tabulator-cell input[type="checkbox"] {
+    margin: 0;
+}
+
+.tabulator .tabulator-footer {
+    color: var(--main-text-color);
+}
+
+/* Context menus */
+
+.tabulator-popup-container {
+    min-width: 10em;
+    border-radius: var(--bs-border-radius);
+}
+
+.tabulator-menu .tabulator-menu-item {
+    border: 1px solid transparent;
+    color: var(--menu-text-color);
+    font-size: 16px;
+}
+
+/* Footer */
+
+:root .tabulator .tabulator-footer {
+    border-top: unset;
+    padding: 10px 0;
+}

apps/client/src/stylesheets/theme-next/base.css

@@ -4,6 +4,7 @@
 @import url(./pages.css);
 @import url(./ribbon.css);
 @import url(./notes/text.css);
+@import url(./notes/collections/table.css);
 
 @font-face {
     font-family: "Inter";
@@ -183,7 +184,7 @@ html body .dropdown-item[disabled] {
 
 /* Menu item icon */
 .dropdown-item .bx {
-    transform: translateY(var(--menu-item-icon-vert-offset));
+    translate: 0 var(--menu-item-icon-vert-offset);
     color: var(--menu-item-icon-color) !important;
     font-size: 1.1em;
 }
@@ -457,6 +458,11 @@ body.mobile .dropdown-menu .dropdown-item.submenu-open .dropdown-toggle::after {
     padding: 1rem;
 }
 
+.note-list-wrapper .note-book-card .note-book-content.type-image .rendered-content,
+.note-list-wrapper .note-book-card .note-book-content.type-pdf .rendered-content {
+    padding: 0;
+}
+
 .note-list-wrapper .note-book-card .note-book-content .rendered-content.text-with-ellipsis {
     padding: 1rem !important;
 }

apps/client/src/stylesheets/theme-next/dialogs.css

@@ -128,10 +128,15 @@ div.tn-tool-dialog {
 
 .jump-to-note-dialog .modal-header {
     padding: unset !important;
+    padding-bottom: 26px !important;
 }
 
 .jump-to-note-dialog .modal-body {
-    padding: 26px 0 !important;
+    padding: 0 !important;
+}
+
+.jump-to-note-dialog .modal-footer {
+    padding-top: 26px;
 }
 
 /* Search box wrapper */

apps/client/src/stylesheets/theme-next/notes/collections/table.css

@@ -0,0 +1,13 @@
+:root .tabulator {
+    --col-header-hover-background-color: var(--hover-item-background-color);
+    --col-header-arrow-active-color: var(--active-item-text-color);
+    --col-header-arrow-inactive-color: var(--main-border-color);
+
+    --row-moving-background-color: var(--more-accented-background-color);
+
+    --cell-editable-hover-outline-color: var(--input-focus-outline-color);
+
+    --cell-editing-border-color: var(--input-focus-outline-color);
+    --cell-editing-background-color: var(--input-background-color);
+    --cell-editing-text-color: var(--input-text-color);
+}

apps/client/src/stylesheets/theme-next/shell.css

@@ -1678,4 +1678,42 @@ div.find-replace-widget div.find-widget-found-wrapper > span {
 #right-pane .highlights-list li:active {
     background: transparent;
     transition: none;
+}
+
+/** Canvas **/
+
+.excalidraw {
+    --border-radius-lg: 6px;
+}
+
+.excalidraw .Island {
+    backdrop-filter: var(--dropdown-backdrop-filter);
+}
+
+.excalidraw .Island.App-toolbar {
+    --island-bg-color: var(--floating-button-background-color);
+    --shadow-island: 1px 1px 1px var(--floating-button-shadow-color);
+}
+
+.excalidraw .dropdown-menu {
+    border: unset !important;
+    box-shadow: unset !important;    
+    background-color: transparent !important;
+    --island-bg-color: var(--menu-background-color);
+    --shadow-island: 0px 10px 20px rgba(0, 0, 0, var(--dropdown-shadow-opacity));
+    --default-border-color: var(--bs-dropdown-divider-bg);
+    --button-hover-bg: var(--hover-item-background-color);
+}
+
+.excalidraw .dropdown-menu .dropdown-menu-container {
+    border-radius: var(--dropdown-border-radius);
+}
+
+.excalidraw .dropdown-menu .dropdown-menu-container > div:not([class]):not(:last-child) {
+    margin-left: calc(var(--padding) * var(--space-factor) * -1) !important;
+    margin-right: calc(var(--padding) * var(--space-factor) * -1) !important;
+}
+
+.excalidraw .dropdown-menu:before {
+    content: unset !important;
 }

apps/client/src/translations/en/translation.json

@@ -211,7 +211,7 @@
     "okButton": "OK"
   },
   "jump_to_note": {
-    "search_placeholder": "search for note by its name",
+    "search_placeholder": "Search for note by its name or type > for commands...",
     "close": "Close",
     "search_button": "Search in full text <kbd>Ctrl+Enter</kbd>"
   },
@@ -443,7 +443,8 @@
     "other_notes_with_name": "Other notes with {{attributeType}} name \"{{attributeName}}\"",
     "and_more": "... and {{count}} more.",
     "print_landscape": "When exporting to PDF, changes the orientation of the page to landscape instead of portrait.",
-    "print_page_size": "When exporting to PDF, changes the size of the page. Supported values: <code>A0</code>, <code>A1</code>, <code>A2</code>, <code>A3</code>, <code>A4</code>, <code>A5</code>, <code>A6</code>, <code>Legal</code>, <code>Letter</code>, <code>Tabloid</code>, <code>Ledger</code>."
+    "print_page_size": "When exporting to PDF, changes the size of the page. Supported values: <code>A0</code>, <code>A1</code>, <code>A2</code>, <code>A3</code>, <code>A4</code>, <code>A5</code>, <code>A6</code>, <code>Legal</code>, <code>Letter</code>, <code>Tabloid</code>, <code>Ledger</code>.",
+    "color_type": "Color"
   },
   "attribute_editor": {
     "help_text_body1": "To add label, just type e.g. <code>#rock</code> or if you want to add also value then e.g. <code>#year = 2020</code>",
@@ -762,7 +763,8 @@
     "invalid_view_type": "Invalid view type '{{type}}'",
     "calendar": "Calendar",
     "table": "Table",
-    "geo-map": "Geo Map"
+    "geo-map": "Geo Map",
+    "board": "Board"
   },
   "edited_notes": {
     "no_edited_notes_found": "No edited notes on this day yet...",
@@ -839,7 +841,8 @@
     "unknown_label_type": "Unknown label type '{{type}}'",
     "unknown_attribute_type": "Unknown attribute type '{{type}}'",
     "add_new_attribute": "Add new attribute",
-    "remove_this_attribute": "Remove this attribute"
+    "remove_this_attribute": "Remove this attribute",
+    "remove_color": "Remove the color label"
   },
   "script_executor": {
     "query": "Query",
@@ -1595,7 +1598,7 @@
     "move-to": "Move to...",
     "paste-into": "Paste into",
     "paste-after": "Paste after",
-    "duplicate-subtree": "Duplicate subtree",
+    "duplicate": "Duplicate",
     "export": "Export",
     "import-into-note": "Import into note",
     "apply-bulk-actions": "Apply bulk actions",
@@ -1615,7 +1618,7 @@
     "relation-map": "Relation Map",
     "note-map": "Note Map",
     "render-note": "Render Note",
-    "book": "Book",
+    "book": "Collection",
     "mermaid-diagram": "Mermaid Diagram",
     "canvas": "Canvas",
     "web-view": "Web View",
@@ -1944,10 +1947,63 @@
   },
   "table_view": {
     "new-row": "New row",
-    "new-column": "New column"
+    "new-column": "New column",
+    "sort-column-by": "Sort by \"{{title}}\"",
+    "sort-column-ascending": "Ascending",
+    "sort-column-descending": "Descending",
+    "sort-column-clear": "Clear sorting",
+    "hide-column": "Hide column \"{{title}}\"",
+    "show-hide-columns": "Show/hide columns",
+    "row-insert-above": "Insert row above",
+    "row-insert-below": "Insert row below",
+    "row-insert-child": "Insert child note",
+    "add-column-to-the-left": "Add column to the left",
+    "add-column-to-the-right": "Add column to the right",
+    "edit-column": "Edit column",
+    "delete_column_confirmation": "Are you sure you want to delete this column? The corresponding attribute will be removed from all notes.",
+    "delete-column": "Delete column",
+    "new-column-label": "Label",
+    "new-column-relation": "Relation"
   },
   "book_properties_config": {
     "hide-weekends": "Hide weekends",
-    "display-week-numbers": "Display week numbers"
+    "display-week-numbers": "Display week numbers",
+    "map-style": "Map style:",
+    "max-nesting-depth": "Max nesting depth:",
+    "raster": "Raster",
+    "vector_light": "Vector (Light)",
+    "vector_dark": "Vector (Dark)",
+    "show-scale": "Show scale"
+  },
+  "table_context_menu": {
+    "delete_row": "Delete row"
+  },
+  "board_view": {
+    "delete-note": "Delete Note",
+    "move-to": "Move to",
+    "insert-above": "Insert above",
+    "insert-below": "Insert below",
+    "delete-column": "Delete column",
+    "delete-column-confirmation": "Are you sure you want to delete this column? The corresponding attribute will be deleted in the notes under this column as well.",
+    "new-item": "New item",
+    "add-column": "Add Column"
+  },
+  "command_palette": {
+    "tree-action-name": "Tree: {{name}}",
+    "export_note_title": "Export Note",
+    "export_note_description": "Export current note",
+    "show_attachments_title": "Show Attachments",
+    "show_attachments_description": "View note attachments",
+    "search_notes_title": "Search Notes",
+    "search_notes_description": "Open advanced search",
+    "search_subtree_title": "Search in Subtree",
+    "search_subtree_description": "Search within current subtree",
+    "search_history_title": "Show Search History",
+    "search_history_description": "View previous searches",
+    "configure_launch_bar_title": "Configure Launch Bar",
+    "configure_launch_bar_description": "Open the launch bar configuration, to add or remove items."
+  },
+  "content_renderer": {
+    "open_externally": "Open externally"
   }
 }

apps/client/src/translations/pt_br/translation.json

@@ -1,10 +1,7 @@
 {
-  "revisions": {
-    "delete_button": ""
-  },
-  "code_block": {
-    "theme_none": "Sem destaque de sintaxe",
-    "theme_group_light": "Temas claros",
-    "theme_group_dark": "Temas escuros"
-  }
+    "code_block": {
+        "theme_none": "Sem destaque de sintaxe",
+        "theme_group_light": "Temas claros",
+        "theme_group_dark": "Temas escuros"
+    }
 }

apps/client/src/translations/sr/translation.json

@@ -0,0 +1,170 @@
+{
+    "about": {
+        "title": "O Trilium Belеškama",
+        "close": "Zatvori",
+        "homepage": "Početna stranica:",
+        "app_version": "Verzija aplikacije:",
+        "db_version": "Verzija baze podataka:",
+        "sync_version": "Verzija sinhronizacije:",
+        "build_date": "Datum izgradnje:",
+        "build_revision": "Revizija izgradnje:",
+        "data_directory": "Direktorijum sa podacima:"
+    },
+    "toast": {
+        "critical-error": {
+            "title": "Kritična greška",
+            "message": "Došlo je do kritične greške koja sprečava pokretanje klijentske aplikacije.\n\n{{message}}\n\nOva greška je najverovatnije izazvana neočekivanim problemom prilikom izvršavanja skripte. Pokušajte da pokrenete aplikaciju u bezbednom režimu i da pronađete šta izaziva grešku."
+        },
+        "widget-error": {
+            "title": "Pokretanje vidžeta nije uspelo",
+            "message-custom": "Prilagođeni viđet sa beleške sa ID-jem \"{{id}}\", nazivom \"{{title}}\" nije uspeo da se pokrene zbog:\n\n{{message}}",
+            "message-unknown": "Nepoznati vidžet nije mogao da se pokrene zbog:\n\n{{message}}"
+        },
+        "bundle-error": {
+            "title": "Pokretanje prilagođene skripte neuspešno",
+            "message": "Skripta iz beleške sa ID-jem \"{{id}}\", naslovom \"{{title}}\" nije mogla da se izvrši zbog:\n\n{{message}}"
+        }
+    },
+    "add_link": {
+        "add_link": "Dodaj link",
+        "help_on_links": "Pomoć na linkovima",
+        "close": "Zatvori",
+        "note": "Beleška",
+        "search_note": "potražite belešku po njenom imenu",
+        "link_title_mirrors": "naziv linka preslikava trenutan naziv beleške",
+        "link_title_arbitrary": "naziv linka se može proizvoljno menjati",
+        "link_title": "Naziv linka",
+        "button_add_link": "Dodaj link <kbd>enter</kbd>"
+    },
+    "branch_prefix": {
+        "edit_branch_prefix": "Izmeni prefiks grane",
+        "help_on_tree_prefix": "Pomoć na prefiksu Drveta",
+        "close": "Zatvori",
+        "prefix": "Prefiks: ",
+        "save": "Sačuvaj",
+        "branch_prefix_saved": "Prefiks grane je sačuvan."
+    },
+    "bulk_actions": {
+        "bulk_actions": "Grupne akcije",
+        "close": "Zatvori",
+        "affected_notes": "Pogođene beleške",
+        "include_descendants": "Obuhvati potomke izabranih beleški",
+        "available_actions": "Dostupne akcije",
+        "chosen_actions": "Izabrane akcije",
+        "execute_bulk_actions": "Izvrši grupne akcije",
+        "bulk_actions_executed": "Grupne akcije su uspešno izvršene.",
+        "none_yet": "Nijedna za sad... dodajte akciju tako što ćete pritisnuti na neku od dostupnih akcija iznad.",
+        "labels": "Oznake",
+        "relations": "Odnosi",
+        "notes": "Beleške",
+        "other": "Ostalo"
+    },
+    "clone_to": {
+        "clone_notes_to": "Klonirajte beleške u...",
+        "close": "Zatvori",
+        "help_on_links": "Pomoć na linkovima",
+        "notes_to_clone": "Beleške za kloniranje",
+        "target_parent_note": "Ciljna nadređena beleška",
+        "search_for_note_by_its_name": "potražite belešku po njenom imenu",
+        "cloned_note_prefix_title": "Klonirana beleška će biti prikazana u drvetu beleški sa datim prefiksom",
+        "prefix_optional": "Prefiks (opciono)",
+        "clone_to_selected_note": "Kloniranje u izabranu belešku <kbd>enter</kbd>",
+        "no_path_to_clone_to": "Nema putanje za kloniranje.",
+        "note_cloned": "Beleška \"{{clonedTitle}}\" je klonirana u \"{{targetTitle}}\""
+    },
+    "confirm": {
+        "confirmation": "Potvrda",
+        "close": "Zatvori",
+        "cancel": "Otkaži",
+        "ok": "U redu",
+        "are_you_sure_remove_note": "Da li ste sigurni da želite da uklonite belešku \"{{title}}\" iz mape odnosa? ",
+        "if_you_dont_check": "Ako ne izaberete ovo, beleška će biti uklonjena samo sa mape odnosa.",
+        "also_delete_note": "Takođe obriši belešku"
+    },
+    "delete_notes": {
+        "delete_notes_preview": "Obriši pregled beleške",
+        "close": "Zatvori",
+        "delete_all_clones_description": "Obriši i sve klonove (može biti poništeno u skorašnjim izmenama)",
+        "erase_notes_description": "Normalno (blago) brisanje samo označava beleške kao obrisane i one mogu biti vraćene (u dijalogu skorašnjih izmena) u određenom vremenskom periodu. Biranje ove opcije će momentalno obrisati beleške i ove beleške neće biti moguće vratiti.",
+        "erase_notes_warning": "Trajno obriši beleške (ne može se opozvati), uključujući sve klonove. Ovo će prisiliti aplikaciju da se ponovo pokrene.",
+        "notes_to_be_deleted": "Sledeće beleške će biti obrisane ({{- noteCount}})",
+        "no_note_to_delete": "Nijedna beleška neće biti obrisana (samo klonovi).",
+        "broken_relations_to_be_deleted": "Sledeći odnosi će biti prekinuti i obrisani ({{- relationCount}})",
+        "cancel": "Otkaži",
+        "ok": "U redu",
+        "deleted_relation_text": "Beleška {{- note}} (za brisanje) je referencirana sa odnosom {{- relation}} koji potiče iz {{- source}}."
+    },
+    "export": {
+        "export_note_title": "Izvezi belešku",
+        "close": "Zatvori",
+        "export_type_subtree": "Ova beleška i svi njeni potomci",
+        "format_html": "HTML - preporučuje se jer čuva formatiranje",
+        "format_html_zip": "HTML u ZIP arhivi - ovo se preporučuje jer se na taj način čuva celokupno formatiranje.",
+        "format_markdown": "Markdown - ovo čuva većinu formatiranja.",
+        "format_opml": "OPML - format za razmenu okvira samo za tekst. Formatiranje, slike i datoteke nisu uključeni.",
+        "opml_version_1": "OPML v1.0 - samo običan tekst",
+        "opml_version_2": "OPML v2.0 - dozvoljava i HTML",
+        "export_type_single": "Samo ovu belešku bez njenih potomaka",
+        "export": "Izvoz",
+        "choose_export_type": "Molimo vas da prvo izaberete tip izvoza",
+        "export_status": "Status izvoza",
+        "export_in_progress": "Izvoz u toku: {{progressCount}}",
+        "export_finished_successfully": "Izvoz je uspešno završen.",
+        "format_pdf": "PDF - za namene štampanja ili deljenja."
+    },
+    "help": {
+        "fullDocumentation": "Pomoć (puna dokumentacija je dostupna <a class=\"external\" href=\"https://triliumnext.github.io/Docs/\">online</a>)",
+        "close": "Zatvori",
+        "noteNavigation": "Navigacija beleški",
+        "goUpDown": "<kbd>UP</kbd>, <kbd>DOWN</kbd> - kretanje gore/dole u listi sa beleškama",
+        "collapseExpand": "<kbd>LEFT</kbd>, <kbd>RIGHT</kbd> - sakupi/proširi čvor",
+        "notSet": "nije podešeno",
+        "goBackForwards": "idi u nazad/napred kroz istoriju",
+        "showJumpToNoteDialog": "prikaži <a class=\"external\" href=\"https://triliumnext.github.io/Docs/Wiki/note-navigation.html#jump-to-note\">\"Idi na\" dijalog</a>",
+        "scrollToActiveNote": "skroluj do aktivne beleške",
+        "jumpToParentNote": "<kbd>Backspace</kbd> - idi do nadređene beleške",
+        "collapseWholeTree": "sakupi celo drvo beleški",
+        "collapseSubTree": "sakupi pod-drvo",
+        "tabShortcuts": "Prečice na karticama",
+        "newTabNoteLink": "<kbd>Ctrl+click</kbd> - (ili <kbd>middle mouse click</kbd>) na link beleške otvara belešku u novoj kartici",
+        "newTabWithActivationNoteLink": "<kbd>Ctrl+Shift+click</kbd> - (ili <kbd>Shift+middle mouse click</kbd>) na link beleške otvara i aktivira belešku u novoj kartici",
+        "onlyInDesktop": "Samo na dektop-u (Electron verzija)",
+        "openEmptyTab": "otvori praznu karticu",
+        "closeActiveTab": "zatvori aktivnu karticu",
+        "activateNextTab": "aktiviraj narednu karticu",
+        "activatePreviousTab": "aktiviraj prethodnu karticu",
+        "creatingNotes": "Pravljenje beleški",
+        "createNoteAfter": "napravi novu belešku nakon aktivne beleške",
+        "createNoteInto": "napravi novu pod-belešku u aktivnoj belešci",
+        "editBranchPrefix": "izmeni <a class=\"external\" href=\"https://triliumnext.github.io/Docs/Wiki/tree-concepts.html#prefix\">prefiks</a> klona aktivne beleške",
+        "movingCloningNotes": "Premeštanje / kloniranje beleški",
+        "moveNoteUpDown": "pomeri belešku gore/dole u listi beleški",
+        "moveNoteUpHierarchy": "pomeri belešku na gore u hijerarhiji",
+        "multiSelectNote": "višestruki izbor beleški iznad/ispod",
+        "selectAllNotes": "izaberi sve beleške u trenutnom nivou",
+        "selectNote": "<kbd>Shift+click</kbd> - izaberi belešku",
+        "copyNotes": "kopiraj aktivnu belešku (ili trenutni izbor) u privremenu memoriju (koristi se za <a class=\"external\" href=\"https://triliumnext.github.io/Docs/Wiki/cloning-notes.html#cloning-notes\">kloniranje</a>)",
+        "cutNotes": "iseci trenutnu belešku (ili trenutni izbor) u privremenu memoriju (koristi se za premeštanje beleški)",
+        "pasteNotes": "nalepi belešku/e kao podbelešku u aktivnoj belešci (koja se ili premešta ili klonira u zavisnosti od toga da li je beleška kopirana ili isečena u privremenu memoriju)",
+        "deleteNotes": "obriši belešku / podstablo",
+        "editingNotes": "Izmena beleški",
+        "editNoteTitle": "u ravni drveta će se prebaciti sa ravni drveta na naslov beleške. Ulaz sa naslova beleške će prebaciti fokus na uređivač teksta. <kbd>Ctrl+.</kbd> će se vratiti sa uređivača na ravan drveta.",
+        "createEditLink": "<kbd>Ctrl+K</kbd> - napravi / izmeni spoljašnji link",
+        "createInternalLink": "napravi unutrašnji link",
+        "followLink": "prati link ispod kursora",
+        "insertDateTime": "ubaci trenutan datum i vreme na poziciju kursora",
+        "jumpToTreePane": "idi na ravan stabla i pomeri se do aktivne beleške",
+        "markdownAutoformat": "Autoformatiranje kao u Markdown-u",
+        "headings": "<code>##</code>, <code>###</code>, <code>####</code>  itd. praćeno razmakom za naslove",
+        "bulletList": "<code>*</code> ili <code>-</code> praćeno razmakom za listu sa tačkama",
+        "numberedList": "<code>1.</code> ili <code>1)</code> praćeno razmakom za numerisanu listu",
+        "blockQuote": "započnite liniju sa <code>></code> praćeno sa razmakom za blok citat",
+        "troubleshooting": "Rešavanje problema",
+        "reloadFrontend": "ponovo učitaj Trilium frontend",
+        "showDevTools": "prikaži alate za programere",
+        "showSQLConsole": "prikaži SQL konzolu",
+        "other": "Ostalo",
+        "quickSearch": "fokus na unos za brzu pretragu",
+        "inPageSearch": "pretraga unutar stranice"
+    }
+}

apps/client/src/types-assets.d.ts

@@ -3,6 +3,11 @@ declare module "*.png" {
     export default path;
 }
 
+declare module "*.json" {
+    var content: any;
+    export default content;
+}
+
 declare module "*?url" {
     var path: string;
     export default path;

apps/client/src/types.d.ts

@@ -97,16 +97,6 @@ declare global {
         setNote(noteId: string);
     }
 
-    interface JQueryStatic {
-        hotkeys: {
-            options: {
-                filterInputAcceptingElements: boolean;
-                filterContentEditable: boolean;
-                filterTextInputs: boolean;
-            }
-        }
-    }
-
     var logError: (message: string, e?: Error | string) => void;
     var logInfo: (message: string) => void;
     var glob: CustomGlobals;

apps/client/src/widgets/attribute_widgets/attribute_detail.ts

@@ -78,7 +78,7 @@ const TPL = /*html*/`
         }
     </style>
 
-    <div style="display: flex; justify-content: space-between; margin-bottom: 8px;">
+    <div style="display: flex; justify-content: space-between; align-items: start; margin-bottom: 8px;">
         <h5 class="attr-detail-title">${t("attribute_detail.attr_detail_title")}</h5>
 
         <span class="bx bx-x close-attr-detail-button tn-tool-button" title="${t("attribute_detail.close_button_title")}"></span>
@@ -142,6 +142,7 @@ const TPL = /*html*/`
                   <option value="datetime">${t("attribute_detail.date_time")}</option>
                   <option value="time">${t("attribute_detail.time")}</option>
                   <option value="url">${t("attribute_detail.url")}</option>
+                  <option value="color">${t("attribute_detail.color_type")}</option>
                 </select>
             </td>
         </tr>
@@ -295,6 +296,8 @@ interface AttributeDetailOpts {
     x: number;
     y: number;
     focus?: "name";
+    parent?: HTMLElement;
+    hideMultiplicity?: boolean;
 }
 
 interface SearchRelatedResponse {
@@ -477,7 +480,7 @@ export default class AttributeDetailWidget extends NoteContextAwareWidget {
         });
     }
 
-    async showAttributeDetail({ allAttributes, attribute, isOwned, x, y, focus }: AttributeDetailOpts) {
+    async showAttributeDetail({ allAttributes, attribute, isOwned, x, y, focus, hideMultiplicity }: AttributeDetailOpts) {
         if (!attribute) {
             this.hide();
 
@@ -528,7 +531,7 @@ export default class AttributeDetailWidget extends NoteContextAwareWidget {
         this.$rowPromotedAlias.toggle(!!definition.isPromoted);
         this.$inputPromotedAlias.val(definition.promotedAlias || "").attr("disabled", disabledFn);
 
-        this.$rowMultiplicity.toggle(["label-definition", "relation-definition"].includes(this.attrType || ""));
+        this.$rowMultiplicity.toggle(["label-definition", "relation-definition"].includes(this.attrType || "") && !hideMultiplicity);
         this.$inputMultiplicity.val(definition.multiplicity || "").attr("disabled", disabledFn);
 
         this.$rowLabelType.toggle(this.attrType === "label-definition");
@@ -560,19 +563,22 @@ export default class AttributeDetailWidget extends NoteContextAwareWidget {
 
         this.toggleInt(true);
 
-        const offset = this.parent?.$widget.offset() || { top: 0, left: 0 };
+        const offset = this.parent?.$widget?.offset() || { top: 0, left: 0 };
         const detPosition = this.getDetailPosition(x, offset);
         const outerHeight = this.$widget.outerHeight();
         const height = $(window).height();
 
-        if (detPosition && outerHeight && height) {
-            this.$widget
-                .css("left", detPosition.left)
-                .css("right", detPosition.right)
-                .css("top", y - offset.top + 70)
-                .css("max-height", outerHeight + y > height - 50 ? height - y - 50 : 10000);
+        if (!detPosition || !outerHeight || !height) {
+            console.warn("Can't position popup, is it attached?");
+            return;
         }
 
+        this.$widget
+            .css("left", detPosition.left)
+            .css("right", detPosition.right)
+            .css("top", y - offset.top + 70)
+            .css("max-height", outerHeight + y > height - 50 ? height - y - 50 : 10000);
+
         if (focus === "name") {
             this.$inputName.trigger("focus").trigger("select");
         }

apps/client/src/widgets/attribute_widgets/attribute_editor.ts

@@ -4,7 +4,7 @@ import noteAutocompleteService, { type Suggestion } from "../../services/note_au
 import server from "../../services/server.js";
 import contextMenuService from "../../menus/context_menu.js";
 import attributeParser, { type Attribute } from "../../services/attribute_parser.js";
-import { AttributeEditor, type EditorConfig, type Element, type MentionFeed, type Node, type Position } from "@triliumnext/ckeditor5";
+import { AttributeEditor, type EditorConfig, type ModelElement, type MentionFeed, type ModelNode, type ModelPosition } from "@triliumnext/ckeditor5";
 import froca from "../../services/froca.js";
 import attributeRenderer from "../../services/attribute_renderer.js";
 import noteCreateService from "../../services/note_create.js";
@@ -417,16 +417,16 @@ export default class AttributeEditorWidget extends NoteContextAwareWidget implem
         this.$editor.tooltip("show");
     }
 
-    getClickIndex(pos: Position) {
+    getClickIndex(pos: ModelPosition) {
         let clickIndex = pos.offset - (pos.textNode?.startOffset ?? 0);
 
-        let curNode: Node | Text | Element | null = pos.textNode;
+        let curNode: ModelNode | Text | ModelElement | null = pos.textNode;
 
         while (curNode?.previousSibling) {
             curNode = curNode.previousSibling;
 
-            if ((curNode as Element).name === "reference") {
-                clickIndex += (curNode.getAttribute("notePath") as string).length + 1;
+            if ((curNode as ModelElement).name === "reference") {
+                clickIndex += (curNode.getAttribute("href") as string).length + 1;
             } else if ("data" in curNode) {
                 clickIndex += (curNode.data as string).length;
             }

apps/client/src/widgets/buttons/command_button.ts

@@ -1,9 +1,10 @@
+import { ActionKeyboardShortcut } from "@triliumnext/commons";
 import type { CommandNames } from "../../components/app_context.js";
-import keyboardActionsService, { type Action } from "../../services/keyboard_actions.js";
+import keyboardActionsService from "../../services/keyboard_actions.js";
 import AbstractButtonWidget, { type AbstractButtonWidgetSettings } from "./abstract_button.js";
 import type { ButtonNoteIdProvider } from "./button_from_note.js";
 
-let actions: Action[];
+let actions: ActionKeyboardShortcut[];
 
 keyboardActionsService.getActions().then((as) => (actions = as));
 
@@ -49,7 +50,7 @@ export default class CommandButtonWidget extends AbstractButtonWidget<CommandBut
 
         const action = actions.find((act) => act.actionName === this._command);
 
-        if (action && action.effectiveShortcuts.length > 0) {
+        if (action?.effectiveShortcuts && action.effectiveShortcuts.length > 0) {
             return `${title} (${action.effectiveShortcuts.join(", ")})`;
         } else {
             return title;

apps/client/src/widgets/buttons/note_actions.ts

@@ -186,7 +186,7 @@ export default class NoteActionsWidget extends NoteContextAwareWidget {
 
         this.$convertNoteIntoAttachmentButton.toggle(note.isEligibleForConversionToAttachment());
 
-        this.toggleDisabled(this.$findInTextButton, ["text", "code", "book", "mindMap"].includes(note.type));
+        this.toggleDisabled(this.$findInTextButton, ["text", "code", "book", "mindMap", "doc"].includes(note.type));
 
         this.toggleDisabled(this.$showAttachmentsButton, !isInOptions);
         this.toggleDisabled(this.$showSourceButton, ["text", "code", "relationMap", "mermaid", "canvas", "mindMap"].includes(note.type));

apps/client/src/widgets/containers/ribbon_container.ts

@@ -268,7 +268,7 @@ export default class RibbonContainer extends NoteContextAwareWidget {
                     const action = actions.find((act) => act.actionName === toggleCommandName);
                     const title = $(this).attr("data-title");
 
-                    if (action && action.effectiveShortcuts.length > 0) {
+                    if (action?.effectiveShortcuts && action.effectiveShortcuts.length > 0) {
                         return `${title} (${action.effectiveShortcuts.join(", ")})`;
                     } else {
                         return title ?? "";

apps/client/src/widgets/dialogs/jump_to_note.ts

@@ -6,6 +6,7 @@ import BasicWidget from "../basic_widget.js";
 import shortcutService from "../../services/shortcuts.js";
 import { Modal } from "bootstrap";
 import { openDialog } from "../../services/dialog.js";
+import commandRegistry from "../../services/command_registry.js";
 
 const TPL = /*html*/`<div class="jump-to-note-dialog modal mx-auto" tabindex="-1" role="dialog">
     <div class="modal-dialog modal-lg" role="document">
@@ -34,7 +35,8 @@ export default class JumpToNoteDialog extends BasicWidget {
     private modal!: bootstrap.Modal;
     private $autoComplete!: JQuery<HTMLElement>;
     private $results!: JQuery<HTMLElement>;
-    private $showInFullTextButton!: JQuery<HTMLElement>;
+    private $modalFooter!: JQuery<HTMLElement>;
+    private isCommandMode: boolean = false;
 
     constructor() {
         super();
@@ -48,13 +50,44 @@ export default class JumpToNoteDialog extends BasicWidget {
 
         this.$autoComplete = this.$widget.find(".jump-to-note-autocomplete");
         this.$results = this.$widget.find(".jump-to-note-results");
-        this.$showInFullTextButton = this.$widget.find(".show-in-full-text-button");
-        this.$showInFullTextButton.on("click", (e) => this.showInFullText(e));
+        this.$modalFooter = this.$widget.find(".modal-footer");
+        this.$modalFooter.find(".show-in-full-text-button").on("click", (e) => this.showInFullText(e));
 
         shortcutService.bindElShortcut(this.$widget, "ctrl+return", (e) => this.showInFullText(e));
+
+        // Monitor input changes to detect command mode switches
+        this.$autoComplete.on("input", () => {
+            this.updateCommandModeState();
+        });
+    }
+
+    private updateCommandModeState() {
+        const currentValue = String(this.$autoComplete.val() || "");
+        const newCommandMode = currentValue.startsWith(">");
+
+        if (newCommandMode !== this.isCommandMode) {
+            this.isCommandMode = newCommandMode;
+            this.updateButtonVisibility();
+        }
+    }
+
+    private updateButtonVisibility() {
+        if (this.isCommandMode) {
+            this.$modalFooter.hide();
+        } else {
+            this.$modalFooter.show();
+        }
     }
 
     async jumpToNoteEvent() {
+        await this.openDialog();
+    }
+
+    async commandPaletteEvent() {
+        await this.openDialog(true);
+    }
+
+    private async openDialog(commandMode = false) {
         const dialogPromise = openDialog(this.$widget);
         if (utils.isMobile()) {
             dialogPromise.then(($dialog) => {
@@ -81,50 +114,89 @@ export default class JumpToNoteDialog extends BasicWidget {
         }
 
         // first open dialog, then refresh since refresh is doing focus which should be visible
-        this.refresh();
+        this.refresh(commandMode);
 
         this.lastOpenedTs = Date.now();
     }
 
-    async refresh() {
+    async refresh(commandMode = false) {
         noteAutocompleteService
             .initNoteAutocomplete(this.$autoComplete, {
                 allowCreatingNotes: true,
                 hideGoToSelectedNoteButton: true,
                 allowJumpToSearchNotes: true,
-                container: this.$results[0]
+                container: this.$results[0],
+                isCommandPalette: true
             })
             // clear any event listener added in previous invocation of this function
             .off("autocomplete:noteselected")
+            .off("autocomplete:commandselected")
             .on("autocomplete:noteselected", function (event, suggestion, dataset) {
                 if (!suggestion.notePath) {
                     return false;
                 }
 
                 appContext.tabManager.getActiveContext()?.setNote(suggestion.notePath);
+            })
+            .on("autocomplete:commandselected", async (event, suggestion, dataset) => {
+                if (!suggestion.commandId) {
+                    return false;
+                }
+
+                this.modal.hide();
+                await commandRegistry.executeCommand(suggestion.commandId);
             });
 
-        // if you open the Jump To dialog soon after using it previously, it can often mean that you
-        // actually want to search for the same thing (e.g., you opened the wrong note at first try)
-        // so we'll keep the content.
-        // if it's outside of this time limit, then we assume it's a completely new search and show recent notes instead.
-        if (Date.now() - this.lastOpenedTs > KEEP_LAST_SEARCH_FOR_X_SECONDS * 1000) {
-            noteAutocompleteService.showRecentNotes(this.$autoComplete);
+        if (commandMode) {
+            // Start in command mode - manually trigger command search
+            this.$autoComplete.autocomplete("val", ">");
+            this.isCommandMode = true;
+            this.updateButtonVisibility();
+
+            // Manually populate with all commands immediately
+            noteAutocompleteService.showAllCommands(this.$autoComplete);
+
+            this.$autoComplete.trigger("focus");
         } else {
-            this.$autoComplete
-                // hack, the actual search value is stored in <pre> element next to the search input
-                // this is important because the search input value is replaced with the suggestion note's title
-                .autocomplete("val", this.$autoComplete.next().text())
-                .trigger("focus")
-                .trigger("select");
+            // if you open the Jump To dialog soon after using it previously, it can often mean that you
+            // actually want to search for the same thing (e.g., you opened the wrong note at first try)
+            // so we'll keep the content.
+            // if it's outside of this time limit, then we assume it's a completely new search and show recent notes instead.
+            if (Date.now() - this.lastOpenedTs > KEEP_LAST_SEARCH_FOR_X_SECONDS * 1000) {
+                this.isCommandMode = false;
+                this.updateButtonVisibility();
+                noteAutocompleteService.showRecentNotes(this.$autoComplete);
+            } else {
+                this.$autoComplete
+                    // hack, the actual search value is stored in <pre> element next to the search input
+                    // this is important because the search input value is replaced with the suggestion note's title
+                    .autocomplete("val", this.$autoComplete.next().text())
+                    .trigger("focus")
+                    .trigger("select");
+
+                // Update command mode state based on the restored value
+                this.updateCommandModeState();
+
+                // If we restored a command mode value, manually trigger command display
+                if (this.isCommandMode) {
+                    // Clear the value first, then set it to ">" to trigger a proper change
+                    this.$autoComplete.autocomplete("val", "");
+                    noteAutocompleteService.showAllCommands(this.$autoComplete);
+                }
+            }
         }
     }
 
-    showInFullText(e: JQuery.TriggeredEvent) {
+    showInFullText(e: JQuery.TriggeredEvent | KeyboardEvent) {
         // stop from propagating upwards (dangerous, especially with ctrl+enter executable javascript notes)
         e.preventDefault();
         e.stopPropagation();
 
+        // Don't perform full text search in command mode
+        if (this.isCommandMode) {
+            return;
+        }
+
         const searchString = String(this.$autoComplete.val());
 
         this.triggerCommand("searchNotes", { searchString });

apps/client/src/widgets/dialogs/popup_editor.ts

@@ -49,7 +49,7 @@ const TPL = /*html*/`\
             left: 0;
             right: 0;
             background: var(--modal-background-color);
-            z-index: 1000;
+            z-index: 998;
         }
 
         .modal.popup-editor-dialog .note-detail-file {
@@ -106,7 +106,11 @@ export default class PopupEditorDialog extends Container<BasicWidget> {
             focus: false
         });
 
-        await this.noteContext.setNote(noteIdOrPath);
+        await this.noteContext.setNote(noteIdOrPath, {
+            viewScope: {
+                readOnlyTemporarilyDisabled: true
+            }
+        });
 
         const activeEl = document.activeElement;
         if (activeEl && "blur" in activeEl) {

apps/client/src/widgets/dialogs/sort_child_notes.ts

@@ -88,7 +88,9 @@ export default class SortChildNotesDialog extends BasicWidget {
         this.$widget = $(TPL);
         this.$form = this.$widget.find(".sort-child-notes-form");
 
-        this.$form.on("submit", async () => {
+        this.$form.on("submit", async (e) => {
+            e.preventDefault();
+
             const sortBy = this.$form.find("input[name='sort-by']:checked").val();
             const sortDirection = this.$form.find("input[name='sort-direction']:checked").val();
             const foldersFirst = this.$form.find("input[name='sort-folders-first']").is(":checked");

apps/client/src/widgets/find.ts

@@ -97,6 +97,7 @@ const TPL = /*html*/`
     </div>
 </div>`;
 
+const SUPPORTED_NOTE_TYPES = ["text", "code", "render", "mindMap", "doc"];
 export default class FindWidget extends NoteContextAwareWidget {
 
     private searchTerm: string | null;
@@ -188,7 +189,7 @@ export default class FindWidget extends NoteContextAwareWidget {
             return;
         }
 
-        if (!["text", "code", "render", "mindMap"].includes(this.note?.type ?? "")) {
+        if (!SUPPORTED_NOTE_TYPES.includes(this.note?.type ?? "")) {
             return;
         }
 
@@ -251,6 +252,7 @@ export default class FindWidget extends NoteContextAwareWidget {
                 const readOnly = await this.noteContext?.isReadOnly();
                 return readOnly ? this.htmlHandler : this.textHandler;
             case "mindMap":
+            case "doc":
                 return this.htmlHandler;
             default:
                 console.warn("FindWidget: Unsupported note type for find widget", this.note?.type);
@@ -354,7 +356,7 @@ export default class FindWidget extends NoteContextAwareWidget {
     }
 
     isEnabled() {
-        return super.isEnabled() && ["text", "code", "render", "mindMap"].includes(this.note?.type ?? "");
+        return super.isEnabled() && SUPPORTED_NOTE_TYPES.includes(this.note?.type ?? "");
     }
 
     async entitiesReloadedEvent({ loadResults }: EventData<"entitiesReloaded">) {

apps/client/src/widgets/floating_buttons/help_button.ts

@@ -35,7 +35,8 @@ export const byBookType: Record<ViewTypeOptions, string | null> = {
     grid: "8QqnMzx393bx",
     calendar: "xWbu3jpNWapp",
     table: "2FvYrpmOXm29",
-    geoMap: "81SGnPGMk7Xc"
+    geoMap: "81SGnPGMk7Xc",
+    board: "CtBQqbwXDx1w"
 };
 
 export default class ContextualHelpButton extends NoteContextAwareWidget {

apps/client/src/widgets/note_list.ts

@@ -3,8 +3,6 @@ import NoteListRenderer from "../services/note_list_renderer.js";
 import type FNote from "../entities/fnote.js";
 import type { CommandListener, CommandListenerData, CommandMappings, CommandNames, EventData, EventNames } from "../components/app_context.js";
 import type ViewMode from "./view_widgets/view_mode.js";
-import AttributeDetailWidget from "./attribute_widgets/attribute_detail.js";
-import { Attribute } from "../services/attribute_parser.js";
 
 const TPL = /*html*/`
 <div class="note-list-widget">
@@ -39,7 +37,6 @@ export default class NoteListWidget extends NoteContextAwareWidget {
     private noteIdRefreshed?: string;
     private shownNoteId?: string | null;
     private viewMode?: ViewMode<any> | null;
-    private attributeDetailWidget: AttributeDetailWidget;
     private displayOnlyCollections: boolean;
 
     /**
@@ -47,9 +44,7 @@ export default class NoteListWidget extends NoteContextAwareWidget {
      */
     constructor(displayOnlyCollections: boolean) {
         super();
-        this.attributeDetailWidget = new AttributeDetailWidget()
-                .contentSized()
-                .setParent(this);
+
         this.displayOnlyCollections = displayOnlyCollections;
     }
 
@@ -72,7 +67,6 @@ export default class NoteListWidget extends NoteContextAwareWidget {
         this.$widget = $(TPL);
         this.contentSized();
         this.$content = this.$widget.find(".note-list-widget-content");
-        this.$widget.append(this.attributeDetailWidget.render());
 
         const observer = new IntersectionObserver(
             (entries) => {
@@ -91,23 +85,6 @@ export default class NoteListWidget extends NoteContextAwareWidget {
         setTimeout(() => observer.observe(this.$widget[0]), 10);
     }
 
-    addNoteListItemEvent() {
-        const attr: Attribute = {
-            type: "label",
-            name: "label:myLabel",
-            value: "promoted,single,text"
-        };
-
-        this.attributeDetailWidget!.showAttributeDetail({
-            attribute: attr,
-            allAttributes: [ attr ],
-            isOwned: true,
-            x: 100,
-            y: 200,
-            focus: "name"
-        });
-    }
-
     checkRenderStatus() {
         // console.log("this.isIntersecting", this.isIntersecting);
         // console.log(`${this.noteIdRefreshed} === ${this.noteId}`, this.noteIdRefreshed === this.noteId);
@@ -123,8 +100,7 @@ export default class NoteListWidget extends NoteContextAwareWidget {
         const noteListRenderer = new NoteListRenderer({
             $parent: this.$content,
             parentNote: note,
-            parentNotePath: this.notePath,
-            noteIds: note.getChildNoteIds()
+            parentNotePath: this.notePath
         });
         this.$widget.toggleClass("full-height", noteListRenderer.isFullHeight);
         await noteListRenderer.renderList();
@@ -169,12 +145,6 @@ export default class NoteListWidget extends NoteContextAwareWidget {
             this.refresh();
             this.checkRenderStatus();
         }
-
-        // Inform the view mode of changes and refresh if needed.
-        if (this.viewMode && this.viewMode.onEntitiesReloaded(e)) {
-            this.refresh();
-            this.checkRenderStatus();
-        }
     }
 
     buildTouchBarCommand(data: CommandListenerData<"buildTouchBar">) {

apps/client/src/widgets/note_tree.ts

@@ -727,9 +727,9 @@ export default class NoteTreeWidget extends NoteContextAwareWidget {
                 for (const key in hotKeys) {
                     const handler = hotKeys[key];
 
-                    $(this.tree.$container).on("keydown", null, key, (evt) => {
+                    shortcutService.bindElShortcut($(this.tree.$container), key, () => {
                         const node = this.tree.getActiveNode();
-                        return handler(node, evt);
+                        return handler(node, {} as JQuery.KeyDownEvent);
                         // return false from the handler will stop default handling.
                     });
                 }
@@ -1552,7 +1552,7 @@ export default class NoteTreeWidget extends NoteContextAwareWidget {
         const hotKeyMap: Record<string, (node: Fancytree.FancytreeNode, e: JQuery.KeyDownEvent) => boolean> = {};
 
         for (const action of actions) {
-            for (const shortcut of action.effectiveShortcuts) {
+            for (const shortcut of action.effectiveShortcuts ?? []) {
                 hotKeyMap[shortcutService.normalizeShortcut(shortcut)] = (node) => {
                     const notePath = treeService.getNotePath(node);
 

apps/client/src/widgets/ribbon_widgets/book_properties.ts

@@ -5,6 +5,16 @@ import type FNote from "../../entities/fnote.js";
 import type { EventData } from "../../components/app_context.js";
 import { bookPropertiesConfig, BookProperty } from "./book_properties_config.js";
 import attributes from "../../services/attributes.js";
+import type { ViewTypeOptions } from "../../services/note_list_renderer.js";
+
+const VIEW_TYPE_MAPPINGS: Record<ViewTypeOptions, string> = {
+    grid: t("book_properties.grid"),
+    list: t("book_properties.list"),
+    calendar: t("book_properties.calendar"),
+    table: t("book_properties.table"),
+    geoMap: t("book_properties.geo-map"),
+    board: t("book_properties.board")
+};
 
 const TPL = /*html*/`
 <div class="book-properties-widget">
@@ -23,24 +33,37 @@ const TPL = /*html*/`
             align-items: center;
         }
 
-        .book-properties-container > * {
+        .book-properties-container > div {
             margin-right: 15px;
         }
 
+        .book-properties-container > .type-number > label {
+            display: flex;
+            align-items: baseline;
+        }
+
         .book-properties-container input[type="checkbox"] {
             margin-right: 5px;
         }
+
+        .book-properties-container label {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            text-overflow: clip;
+            white-space: nowrap;
+        }
     </style>
 
     <div style="display: flex; align-items: baseline">
         <span style="white-space: nowrap">${t("book_properties.view_type")}:&nbsp; &nbsp;</span>
 
         <select class="view-type-select form-select form-select-sm">
-            <option value="grid">${t("book_properties.grid")}</option>
-            <option value="list">${t("book_properties.list")}</option>
-            <option value="calendar">${t("book_properties.calendar")}</option>
-            <option value="table">${t("book_properties.table")}</option>
-            <option value="geoMap">${t("book_properties.geo-map")}</option>
+            ${Object.entries(VIEW_TYPE_MAPPINGS)
+                .filter(([type]) => type !== "raster")
+                .map(([type, label]) => `
+                <option value="${type}">${label}</option>
+            `).join("")}
         </select>
     </div>
 
@@ -110,7 +133,7 @@ export default class BookPropertiesWidget extends NoteContextAwareWidget {
             return;
         }
 
-        if (!["list", "grid", "calendar", "table", "geoMap"].includes(type)) {
+        if (!VIEW_TYPE_MAPPINGS.hasOwnProperty(type)) {
             throw new Error(t("book_properties.invalid_view_type", { type }));
         }
 
@@ -127,6 +150,7 @@ export default class BookPropertiesWidget extends NoteContextAwareWidget {
 
     renderBookProperty(property: BookProperty) {
         const $container = $("<div>");
+        $container.addClass(`type-${property.type}`);
         const note = this.note;
         if (!note) {
             return $container;
@@ -168,6 +192,56 @@ export default class BookPropertiesWidget extends NoteContextAwareWidget {
                 });
                 $container.append($button);
                 break;
+            case "number":
+                const $numberInput = $("<input>", {
+                    type: "number",
+                    class: "form-control form-control-sm",
+                    value: note.getLabelValue(property.bindToLabel) || "",
+                    width: property.width ?? 100,
+                    min: property.min ?? 0
+                });
+                $numberInput.on("change", () => {
+                    const value = $numberInput.val();
+                    if (value === "") {
+                        attributes.removeOwnedLabelByName(note, property.bindToLabel);
+                    } else {
+                        attributes.setLabel(note.noteId, property.bindToLabel, String(value));
+                    }
+                });
+                $container.append($("<label>")
+                    .text(property.label)
+                    .append("&nbsp;".repeat(2))
+                    .append($numberInput));
+                break;
+            case "combobox":
+                const $select = $("<select>", {
+                    class: "form-select form-select-sm"
+                });
+                const actualValue = note.getLabelValue(property.bindToLabel) ?? property.defaultValue ?? "";
+                for (const option of property.options) {
+                    if ("items" in option) {
+                        const $optGroup = $("<optgroup>", { label: option.name });
+                        for (const item of option.items) {
+                            buildComboBoxItem(item, actualValue).appendTo($optGroup);
+                        }
+                        $optGroup.appendTo($select);
+                    } else {
+                        buildComboBoxItem(option, actualValue).appendTo($select);
+                    }
+                }
+                $select.on("change", () => {
+                    const value = $select.val();
+                    if (value === null || value === "") {
+                        attributes.removeOwnedLabelByName(note, property.bindToLabel);
+                    } else {
+                        attributes.setLabel(note.noteId, property.bindToLabel, String(value));
+                    }
+                });
+                $container.append($("<label>")
+                    .text(property.label)
+                    .append("&nbsp;".repeat(2))
+                    .append($select));
+                break;
         }
 
         return $container;
@@ -175,3 +249,14 @@ export default class BookPropertiesWidget extends NoteContextAwareWidget {
 
 
 }
+
+function buildComboBoxItem({ value, label }: { value: string, label: string }, actualValue: string) {
+    const $option = $("<option>", {
+        value,
+        text: label
+    });
+    if (actualValue === value) {
+        $option.prop("selected", true);
+    }
+    return $option;
+}

apps/client/src/widgets/ribbon_widgets/book_properties_config.ts

@@ -3,8 +3,7 @@ import FNote from "../../entities/fnote";
 import attributes from "../../services/attributes";
 import { ViewTypeOptions } from "../../services/note_list_renderer"
 import NoteContextAwareWidget from "../note_context_aware_widget";
-
-export type BookProperty = CheckBoxProperty | ButtonProperty;
+import { DEFAULT_MAP_LAYER_NAME, MAP_LAYERS, type MapLayer } from "../view_widgets/geo_view/map_layer";
 
 interface BookConfig {
     properties: BookProperty[];
@@ -24,6 +23,37 @@ interface ButtonProperty {
     onClick: (context: BookContext) => void;
 }
 
+interface NumberProperty {
+    type: "number",
+    label: string;
+    bindToLabel: string;
+    width?: number;
+    min?: number;
+}
+
+interface ComboBoxItem {
+    value: string;
+    label: string;
+}
+
+interface ComboBoxGroup {
+    name: string;
+    items: ComboBoxItem[];
+}
+
+interface ComboBoxProperty {
+    type: "combobox",
+    label: string;
+    bindToLabel: string;
+    /**
+     * The default value is used when the label is not set.
+     */
+    defaultValue?: string;
+    options: (ComboBoxItem | ComboBoxGroup)[];
+}
+
+export type BookProperty = CheckBoxProperty | ButtonProperty | NumberProperty | ComboBoxProperty;
+
 interface BookContext {
     note: FNote;
     triggerCommand: NoteContextAwareWidget["triggerCommand"];
@@ -82,9 +112,58 @@ export const bookPropertiesConfig: Record<ViewTypeOptions, BookConfig> = {
         ]
     },
     geoMap: {
-        properties: []
+        properties: [
+            {
+                label: t("book_properties_config.map-style"),
+                type: "combobox",
+                bindToLabel: "map:style",
+                defaultValue: DEFAULT_MAP_LAYER_NAME,
+                options: [
+                    {
+                        name: t("book_properties_config.raster"),
+                        items: Object.entries(MAP_LAYERS)
+                            .filter(([_, layer]) => layer.type === "raster")
+                            .map(buildMapLayer)
+                    },
+                    {
+                        name: t("book_properties_config.vector_light"),
+                        items: Object.entries(MAP_LAYERS)
+                            .filter(([_, layer]) => layer.type === "vector" && !layer.isDarkTheme)
+                            .map(buildMapLayer)
+                    },
+                    {
+                        name: t("book_properties_config.vector_dark"),
+                        items: Object.entries(MAP_LAYERS)
+                            .filter(([_, layer]) => layer.type === "vector" && layer.isDarkTheme)
+                            .map(buildMapLayer)
+                    }
+                ]
+            },
+            {
+                label: t("book_properties_config.show-scale"),
+                type: "checkbox",
+                bindToLabel: "map:scale"
+            }
+        ]
     },
     table: {
+        properties: [
+            {
+                label: t("book_properties_config.max-nesting-depth"),
+                type: "number",
+                bindToLabel: "maxNestingDepth",
+                width: 65
+            }
+        ]
+    },
+    board: {
         properties: []
     }
 };
+
+function buildMapLayer([ id, layer ]: [ string, MapLayer ]): ComboBoxItem {
+    return {
+        value: id,
+        label: layer.name
+    };
+}

apps/client/src/widgets/ribbon_widgets/promoted_attributes.ts

@@ -53,12 +53,56 @@ const TPL = /*html*/`
         word-break:keep-all;
         white-space: nowrap;
     }
+
     .promoted-attribute-cell input[type="checkbox"] {
         width: 22px !important;
         flex-grow: 0;
         width: unset;
     }
 
+    /* Restore default apperance */
+    .promoted-attribute-cell input[type="number"],
+    .promoted-attribute-cell input[type="checkbox"] {
+        appearance: auto;
+    }
+
+    .promoted-attribute-cell input[type="color"] {
+        width: 24px;
+        height: 24px;
+        margin-top: 2px;
+        appearance: none;
+        padding: 0;
+        border: 0;
+        outline: none;
+        border-radius: 25% !important;
+    }
+
+    .promoted-attribute-cell input[type="color"]::-webkit-color-swatch-wrapper {
+        padding: 0;
+    }
+
+    .promoted-attribute-cell input[type="color"]::-webkit-color-swatch {
+        border: none;
+        border-radius: 25%;
+    }
+
+    .promoted-attribute-label-color input[type="hidden"][value=""] + input[type="color"] {
+        position: relative;
+        opacity: 0.5;
+    }
+
+    .promoted-attribute-label-color input[type="hidden"][value=""] + input[type="color"]:after {
+        content: "";
+        position: absolute;
+        top: 10px;
+        left: 0px;
+        right: 0;
+        height: 2px;
+        background: rgba(0, 0, 0, 0.5);
+        transform: rotate(45deg);
+        pointer-events: none;
+    }
+
     </style>
 
     <div class="promoted-attributes-container"></div>
@@ -258,6 +302,35 @@ export default class PromotedAttributesWidget extends NoteContextAwareWidget {
                     .on("click", () => window.open($input.val() as string, "_blank"));
 
                 $input.after($openButton);
+            } else if (definition.labelType === "color") {
+                const defaultColor = "#ffffff";
+                $input.prop("type", "hidden");
+                $input.val(valueAttr.value ?? "");
+
+                // We insert a separate input since the color input does not support empty value.
+                // This is a workaround to allow clearing the color input.
+                const $colorInput = $("<input>")
+                    .prop("type", "color")
+                    .prop("value", valueAttr.value || defaultColor)
+                    .addClass("form-control promoted-attribute-input")
+                    .on("change", e => setValue((e.target as HTMLInputElement).value, e));
+                $input.after($colorInput);
+
+                const $clearButton = $("<span>")
+                    .addClass("input-group-text bx bxs-tag-x")
+                    .prop("title", t("promoted_attributes.remove_color"))
+                    .on("click", e => setValue("", e));
+
+                const setValue = (color: string, event: JQuery.TriggeredEvent<HTMLElement, undefined, HTMLElement, HTMLElement>) => {
+                    $input.val(color);
+                    if (!color) {
+                        $colorInput.val(defaultColor);
+                    }
+                    event.target = $input[0]; // Set the event target to the main input
+                    this.promotedAttributeChanged(event);
+                };
+
+                $colorInput.after($clearButton);
             } else {
                 ws.logError(t("promoted_attributes.unknown_label_type", { type: definition.labelType }));
             }

apps/client/src/widgets/search_result.ts

@@ -68,7 +68,6 @@ export default class SearchResultWidget extends NoteContextAwareWidget {
         const noteListRenderer = new NoteListRenderer({
             $parent: this.$content,
             parentNote: note,
-            noteIds: note.getChildNoteIds(),
             showNotePath: true
         });
         await noteListRenderer.renderList();

apps/client/src/widgets/tab_row.ts

@@ -8,6 +8,7 @@ import appContext, { type CommandNames, type CommandListenerData, type EventData
 import froca from "../services/froca.js";
 import attributeService from "../services/attributes.js";
 import type NoteContext from "../components/note_context.js";
+import { setupHorizontalScrollViaWheel } from "./widget_utils.js";
 
 const isDesktop = utils.isDesktop();
 
@@ -386,15 +387,7 @@ export default class TabRowWidget extends BasicWidget {
     };
 
     setupScrollEvents() {
-        this.$tabScrollingContainer.on('wheel', (event) => {
-            const wheelEvent = event.originalEvent as WheelEvent;
-            if (utils.isCtrlKey(event) || event.altKey || event.shiftKey) {
-                return;
-            }
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            event.currentTarget.scrollLeft += wheelEvent.deltaY + wheelEvent.deltaX;
-        });
+        setupHorizontalScrollViaWheel(this.$tabScrollingContainer);
 
         this.$scrollButtonLeft[0].addEventListener('click', () => this.scrollTabContainer(-210));
         this.$scrollButtonRight[0].addEventListener('click', () => this.scrollTabContainer(210));

apps/client/src/widgets/type_widgets/abstract_split_type_widget.ts

@@ -130,7 +130,8 @@ export default abstract class AbstractSplitTypeWidget extends TypeWidget {
 
     constructor() {
         super();
-        this.editorTypeWidget = new EditableCodeTypeWidget();
+
+        this.editorTypeWidget = new EditableCodeTypeWidget(true);
         this.editorTypeWidget.updateBackgroundColor = () => {};
         this.editorTypeWidget.isEnabled = () => true;
 
@@ -146,6 +147,8 @@ export default abstract class AbstractSplitTypeWidget extends TypeWidget {
     doRender(): void {
         this.$widget = $(TPL);
 
+        this.spacedUpdate.setUpdateInterval(750);
+
         // Preview pane
         this.$previewCol = this.$widget.find(".note-detail-split-preview-col");
         this.$preview = this.$widget.find(".note-detail-split-preview");

apps/client/src/widgets/type_widgets/book.ts

@@ -45,12 +45,11 @@ export default class BookTypeWidget extends TypeWidget {
         }
 
         switch (this.note?.getAttributeValue("label", "viewType")) {
-            case "calendar":
-            case "table":
-            case "geoMap":
-                return false;
-            default:
+            case "list":
+            case "grid":
                 return true;
+            default:
+                return false;
         }
     }
 

apps/client/src/widgets/type_widgets/canvas.ts

@@ -166,7 +166,6 @@ export default class ExcalidrawTypeWidget extends TypeWidget {
             onChange: () => this.onChangeHandler(),
             viewModeEnabled: options.is("databaseReadonly"),
             zenModeEnabled: false,
-            gridModeEnabled: false,
             isCollaborating: false,
             detectScroll: false,
             handleKeyboardGlobally: false,

apps/client/src/widgets/type_widgets/canvas_el.ts

@@ -153,7 +153,8 @@ export default class Canvas {
             appState: {
                 scrollX: appState.scrollX,
                 scrollY: appState.scrollY,
-                zoom: appState.zoom
+                zoom: appState.zoom,
+                gridModeEnabled: appState.gridModeEnabled
             }
         };
 

apps/client/src/widgets/type_widgets/ckeditor/snippets.ts

@@ -59,7 +59,7 @@ async function handleContentUpdate(affectedNoteIds: string[]) {
     const templateNoteIds = new Set(templateCache.keys());
     const affectedTemplateNoteIds = templateNoteIds.intersection(updatedNoteIds);
 
-    await froca.getNotes(affectedNoteIds);
+    await froca.getNotes(affectedNoteIds, true);
 
     let fullReloadNeeded = false;
     for (const affectedTemplateNoteId of affectedTemplateNoteIds) {

apps/client/src/widgets/type_widgets/editable_code.ts

@@ -28,6 +28,16 @@ const TPL = /*html*/`
 
 export default class EditableCodeTypeWidget extends AbstractCodeTypeWidget {
 
+    private debounceUpdate: boolean;
+
+    /**
+     * @param debounceUpdate if true, the update will be debounced to prevent excessive updates. Especially useful if the editor is linked to a live preview.
+     */
+    constructor(debounceUpdate: boolean = false) {
+        super();
+        this.debounceUpdate = debounceUpdate;
+    }
+
     static getType() {
         return "editableCode";
     }
@@ -46,7 +56,13 @@ export default class EditableCodeTypeWidget extends AbstractCodeTypeWidget {
         return {
             placeholder: t("editable_code.placeholder"),
             vimKeybindings: options.is("vimKeymapEnabled"),
-            onContentChanged: () => this.spacedUpdate.scheduleUpdate(),
+            onContentChanged: () => {
+                if (this.debounceUpdate) {
+                    this.spacedUpdate.resetUpdateTimer();
+                }
+
+                this.spacedUpdate.scheduleUpdate();
+            },
             tabIndex: 300
         }
     }

apps/client/src/widgets/type_widgets/editable_text.ts

@@ -265,7 +265,12 @@ export default class EditableTextTypeWidget extends AbstractTextTypeWidget {
     }
 
     focus() {
-        this.$editor.trigger("focus");
+        const editor = this.watchdog.editor;
+        if (editor) {
+            editor.editing.view.focus();
+        } else {
+            this.$editor.trigger("focus");
+        }
     }
 
     scrollToEnd() {

apps/client/src/widgets/type_widgets/options/shortcuts.ts

@@ -3,7 +3,7 @@ import utils from "../../../services/utils.js";
 import dialogService from "../../../services/dialog.js";
 import OptionsWidget from "./options_widget.js";
 import { t } from "../../../services/i18n.js";
-import type { OptionNames, KeyboardShortcut } from "@triliumnext/commons";
+import type { OptionNames, KeyboardShortcut, KeyboardShortcutWithRequiredActionName } from "@triliumnext/commons";
 
 const TPL = /*html*/`
 <div class="options-section shortcuts-options-section tn-no-card">
@@ -75,10 +75,10 @@ export default class KeyboardShortcutsOptions extends OptionsWidget {
             for (const action of actions) {
                 const $tr = $("<tr>");
 
-                if (action.separator) {
+                if ("separator" in action) {
                     $tr.append($('<td class="separator" colspan="4">').attr("style", "background-color: var(--accented-background-color); font-weight: bold;").text(action.separator));
                 } else if (action.defaultShortcuts && action.actionName) {
-                    $tr.append($("<td>").text(action.actionName))
+                    $tr.append($("<td>").text(action.friendlyName))
                         .append(
                             $("<td>").append(
                                 $(`<input type="text" class="form-control">`)
@@ -145,9 +145,9 @@ export default class KeyboardShortcutsOptions extends OptionsWidget {
                     return;
                 }
 
-                const action = globActions.find((act) => act.actionName === actionName);
+                const action = globActions.find((act) => "actionName" in act && act.actionName === actionName) as KeyboardShortcutWithRequiredActionName;
 
-                if (!action || !action.actionName) {
+                if (!action) {
                     this.$widget.find(el).hide();
                     return;
                 }
@@ -157,6 +157,7 @@ export default class KeyboardShortcutsOptions extends OptionsWidget {
                     .toggle(
                         !!(
                             action.actionName.toLowerCase().includes(filter) ||
+                            (action.friendlyName && action.friendlyName.toLowerCase().includes(filter)) ||
                             (action.defaultShortcuts ?? []).some((shortcut) => shortcut.toLowerCase().includes(filter)) ||
                             (action.effectiveShortcuts ?? []).some((shortcut) => shortcut.toLowerCase().includes(filter)) ||
                             (action.description && action.description.toLowerCase().includes(filter))

apps/client/src/widgets/type_widgets/options/text_notes/date_time_format.ts

@@ -52,7 +52,8 @@ export default class DateTimeFormatOptions extends OptionsWidget {
     }
 
     async optionsLoaded(options: OptionMap) {
-        const shortcutKey = (await keyboardActionsService.getAction("insertDateTimeToText")).effectiveShortcuts.join(", ");
+        const action = await keyboardActionsService.getAction("insertDateTimeToText");
+        const shortcutKey = (action.effectiveShortcuts ?? []).join(", ");
         const $link = await linkService.createLink("_hidden/_options/_optionsShortcuts", {
             "title": shortcutKey,
             "showTooltip": false

apps/client/src/widgets/type_widgets/type_widget.ts

@@ -71,6 +71,17 @@ export default abstract class TypeWidget extends NoteContextAwareWidget {
         }
     }
 
+    activeNoteChangedEvent() {
+        if (!this.isActiveNoteContext()) {
+            return;
+        }
+
+        // Restore focus to the editor when switching tabs, but only if the note tree is not already focused.
+        if (!document.activeElement?.classList.contains("fancytree-title")) {
+            this.focus();
+        }
+    }
+
     /**
      * {@inheritdoc}
      *

apps/client/src/widgets/view_widgets/board_view/api.ts

@@ -0,0 +1,180 @@
+import appContext from "../../../components/app_context";
+import FNote from "../../../entities/fnote";
+import attributes from "../../../services/attributes";
+import { executeBulkActions } from "../../../services/bulk_action";
+import note_create from "../../../services/note_create";
+import ViewModeStorage from "../view_mode_storage";
+import { BoardData } from "./config";
+import { ColumnMap, getBoardData } from "./data";
+
+export default class BoardApi {
+
+    private constructor(
+        private _columns: string[],
+        private _parentNoteId: string,
+        private viewStorage: ViewModeStorage<BoardData>,
+        private byColumn: ColumnMap,
+        private persistedData: BoardData,
+        private _statusAttribute: string) {}
+
+    get columns() {
+        return this._columns;
+    }
+
+    get statusAttribute() {
+        return this._statusAttribute;
+    }
+
+    getColumn(column: string) {
+        return this.byColumn.get(column);
+    }
+
+    async changeColumn(noteId: string, newColumn: string) {
+        await attributes.setLabel(noteId, this._statusAttribute, newColumn);
+    }
+
+    openNote(noteId: string) {
+        appContext.triggerCommand("openInPopup", { noteIdOrPath: noteId });
+    }
+
+    async insertRowAtPosition(
+            column: string,
+            relativeToBranchId: string,
+            direction: "before" | "after",
+            open: boolean = true) {
+        const { note } = await note_create.createNote(this._parentNoteId, {
+            activate: false,
+            targetBranchId: relativeToBranchId,
+            target: direction,
+            title: "New item"
+        });
+
+        if (!note) {
+            throw new Error("Failed to create note");
+        }
+
+        const { noteId } = note;
+        await this.changeColumn(noteId, column);
+        if (open) {
+            this.openNote(noteId);
+        }
+
+        return note;
+    }
+
+    async renameColumn(oldValue: string, newValue: string, noteIds: string[]) {
+        // Change the value in the notes.
+        await executeBulkActions(noteIds, [
+            {
+                name: "updateLabelValue",
+                labelName: this._statusAttribute,
+                labelValue: newValue
+            }
+        ]);
+
+        // Rename the column in the persisted data.
+        for (const column of this.persistedData.columns || []) {
+            if (column.value === oldValue) {
+                column.value = newValue;
+            }
+        }
+        await this.viewStorage.store(this.persistedData);
+    }
+
+    async removeColumn(column: string) {
+        // Remove the value from the notes.
+        const noteIds = this.byColumn.get(column)?.map(item => item.note.noteId) || [];
+        await executeBulkActions(noteIds, [
+            {
+                name: "deleteLabel",
+                labelName: this._statusAttribute
+            }
+        ]);
+
+        this.persistedData.columns = (this.persistedData.columns ?? []).filter(col => col.value !== column);
+        this.viewStorage.store(this.persistedData);
+    }
+
+    async createColumn(columnValue: string) {
+        // Add the new column to persisted data if it doesn't exist
+        if (!this.persistedData.columns) {
+            this.persistedData.columns = [];
+        }
+
+        const existingColumn = this.persistedData.columns.find(col => col.value === columnValue);
+        if (!existingColumn) {
+            this.persistedData.columns.push({ value: columnValue });
+            await this.viewStorage.store(this.persistedData);
+        }
+
+        return columnValue;
+    }
+
+    async reorderColumns(newColumnOrder: string[]) {
+        // Update the column order in persisted data
+        if (!this.persistedData.columns) {
+            this.persistedData.columns = [];
+        }
+
+        // Create a map of existing column data
+        const columnDataMap = new Map();
+        this.persistedData.columns.forEach(col => {
+            columnDataMap.set(col.value, col);
+        });
+
+        // Reorder columns based on new order
+        this.persistedData.columns = newColumnOrder.map(columnValue => {
+            return columnDataMap.get(columnValue) || { value: columnValue };
+        });
+
+        // Update internal columns array
+        this._columns = newColumnOrder;
+
+        await this.viewStorage.store(this.persistedData);
+    }
+
+    async refresh(parentNote: FNote) {
+        // Refresh the API data by re-fetching from the parent note
+        const statusAttribute = parentNote.getLabelValue("board:groupBy") ?? "status";
+        this._statusAttribute = statusAttribute;
+
+        // Use the current in-memory persisted data instead of restoring from storage
+        // This ensures we don't lose recent updates like column renames
+        const { byColumn, newPersistedData } = await getBoardData(parentNote, statusAttribute, this.persistedData);
+        
+        // Update internal state
+        this.byColumn = byColumn;
+        
+        if (newPersistedData) {
+            this.persistedData = newPersistedData;
+            this.viewStorage.store(this.persistedData);
+        }
+
+        // Use the order from persistedData.columns, then add any new columns found
+        const orderedColumns = this.persistedData.columns?.map(col => col.value) || [];
+        const allColumns = Array.from(byColumn.keys());
+        const newColumns = allColumns.filter(col => !orderedColumns.includes(col));
+        this._columns = [...orderedColumns, ...newColumns];
+    }
+
+    static async build(parentNote: FNote, viewStorage: ViewModeStorage<BoardData>) {
+        const statusAttribute = parentNote.getLabelValue("board:groupBy") ?? "status";
+
+        let persistedData = await viewStorage.restore() ?? {};
+        const { byColumn, newPersistedData } = await getBoardData(parentNote, statusAttribute, persistedData);
+        
+        // Use the order from persistedData.columns, then add any new columns found
+        const orderedColumns = persistedData.columns?.map(col => col.value) || [];
+        const allColumns = Array.from(byColumn.keys());
+        const newColumns = allColumns.filter(col => !orderedColumns.includes(col));
+        const columns = [...orderedColumns, ...newColumns];
+
+        if (newPersistedData) {
+            persistedData = newPersistedData;
+            viewStorage.store(persistedData);
+        }
+
+        return new BoardApi(columns, parentNote.noteId, viewStorage, byColumn, persistedData, statusAttribute);
+    }
+
+}

apps/client/src/widgets/view_widgets/board_view/column_drag_handler.ts

@@ -0,0 +1,278 @@
+import BoardApi from "./api";
+import { DragContext, BaseDragHandler } from "./drag_types";
+
+export class ColumnDragHandler implements BaseDragHandler {
+    private $container: JQuery<HTMLElement>;
+    private api: BoardApi;
+    private context: DragContext;
+
+    constructor(
+        $container: JQuery<HTMLElement>,
+        api: BoardApi,
+        context: DragContext,
+    ) {
+        this.$container = $container;
+        this.api = api;
+        this.context = context;
+    }
+
+    setupColumnDrag($columnEl: JQuery<HTMLElement>, columnValue: string) {
+        const $titleEl = $columnEl.find('h3[data-column-value]');
+
+        $titleEl.attr("draggable", "true");
+
+        // Delay drag start to allow click detection
+        let dragStartTimer: number | null = null;
+
+        $titleEl.on("mousedown", (e) => {
+            // Don't interfere with editing mode or input field interactions
+            if ($titleEl.hasClass('editing') || $(e.target).is('input')) {
+                return;
+            }
+            
+            // Clear any existing timer
+            if (dragStartTimer) {
+                clearTimeout(dragStartTimer);
+                dragStartTimer = null;
+            }
+
+            // Set a short delay before enabling dragging
+            dragStartTimer = window.setTimeout(() => {
+                $titleEl.attr("draggable", "true");
+                dragStartTimer = null;
+            }, 150);
+        });
+
+        $titleEl.on("mouseup mouseleave", (e) => {
+            // Don't interfere with editing mode
+            if ($titleEl.hasClass('editing') || $(e.target).is('input')) {
+                return;
+            }
+            
+            // Cancel drag start timer on mouse up or leave
+            if (dragStartTimer) {
+                clearTimeout(dragStartTimer);
+                dragStartTimer = null;
+            }
+        });
+
+        $titleEl.on("dragstart", (e) => {
+            // Only start dragging if the target is not an input (for inline editing)
+            if ($(e.target).is('input') || $titleEl.hasClass('editing')) {
+                e.preventDefault();
+                return false;
+            }
+
+            this.context.draggedColumn = columnValue;
+            this.context.draggedColumnElement = $columnEl;
+            $columnEl.addClass("column-dragging");
+
+            const originalEvent = e.originalEvent as DragEvent;
+            if (originalEvent.dataTransfer) {
+                originalEvent.dataTransfer.effectAllowed = "move";
+                originalEvent.dataTransfer.setData("text/plain", columnValue);
+            }
+
+            // Prevent note dragging when column is being dragged
+            e.stopPropagation();
+
+            // Setup global drag tracking for better drop indicator positioning
+            this.setupGlobalColumnDragTracking();
+        });
+
+        $titleEl.on("dragend", () => {
+            $columnEl.removeClass("column-dragging");
+            this.context.draggedColumn = null;
+            this.context.draggedColumnElement = null;
+            this.cleanupColumnDropIndicators();
+            this.cleanupGlobalColumnDragTracking();
+
+            // Re-enable draggable
+            $titleEl.attr("draggable", "true");
+        });
+    }
+
+    setupColumnDropZone($columnEl: JQuery<HTMLElement>) {
+        $columnEl.on("dragover", (e) => {
+            // Only handle column drops when a column is being dragged
+            if (this.context.draggedColumn && !this.context.draggedNote) {
+                e.preventDefault();
+                const originalEvent = e.originalEvent as DragEvent;
+                if (originalEvent.dataTransfer) {
+                    originalEvent.dataTransfer.dropEffect = "move";
+                }
+
+                // Don't highlight columns - we only care about the drop indicator position
+            }
+        });
+
+        $columnEl.on("drop", async (e) => {
+            if (this.context.draggedColumn && !this.context.draggedNote) {
+                e.preventDefault();
+                console.log("Column drop event triggered for column:", this.context.draggedColumn);
+
+                // Use the drop indicator position to determine where to place the column
+                await this.handleColumnDrop();
+            }
+        });
+    }
+
+    cleanup() {
+        this.cleanupColumnDropIndicators();
+        this.context.draggedColumn = null;
+        this.context.draggedColumnElement = null;
+        this.cleanupGlobalColumnDragTracking();
+    }
+
+    private setupGlobalColumnDragTracking() {
+        // Add container-level drag tracking for better indicator positioning
+        this.$container.on("dragover.columnDrag", (e) => {
+            if (this.context.draggedColumn) {
+                e.preventDefault();
+                const originalEvent = e.originalEvent as DragEvent;
+                this.showColumnDropIndicator(originalEvent.clientX);
+            }
+        });
+
+        // Add container-level drop handler for column reordering
+        this.$container.on("drop.columnDrag", async (e) => {
+            if (this.context.draggedColumn) {
+                e.preventDefault();
+                console.log("Container drop event triggered for column:", this.context.draggedColumn);
+                await this.handleColumnDrop();
+            }
+        });
+    }
+
+    private cleanupGlobalColumnDragTracking() {
+        this.$container.off("dragover.columnDrag");
+        this.$container.off("drop.columnDrag");
+    }
+
+    private cleanupColumnDropIndicators() {
+        // Remove column drop indicators
+        this.$container.find(".column-drop-indicator").remove();
+    }
+
+    private showColumnDropIndicator(mouseX: number) {
+        // Clean up existing indicators
+        this.cleanupColumnDropIndicators();
+
+        // Get all columns (excluding the dragged one if it exists)
+        let $allColumns = this.$container.find('.board-column');
+        if (this.context.draggedColumnElement) {
+            $allColumns = $allColumns.not(this.context.draggedColumnElement);
+        }
+
+        let $targetColumn: JQuery<HTMLElement> = $();
+        let insertBefore = false;
+
+        // Find which column the mouse is closest to
+        $allColumns.each((_, columnEl) => {
+            const $column = $(columnEl);
+            const rect = columnEl.getBoundingClientRect();
+            const columnMiddle = rect.left + rect.width / 2;
+
+            if (mouseX >= rect.left && mouseX <= rect.right) {
+                // Mouse is over this column
+                $targetColumn = $column;
+                insertBefore = mouseX < columnMiddle;
+                return false; // Break the loop
+            }
+        });
+
+        // If no column found under mouse, find the closest one
+        if ($targetColumn.length === 0) {
+            let closestDistance = Infinity;
+            $allColumns.each((_, columnEl) => {
+                const $column = $(columnEl);
+                const rect = columnEl.getBoundingClientRect();
+                const columnCenter = rect.left + rect.width / 2;
+                const distance = Math.abs(mouseX - columnCenter);
+
+                if (distance < closestDistance) {
+                    closestDistance = distance;
+                    $targetColumn = $column;
+                    insertBefore = mouseX < columnCenter;
+                }
+            });
+        }
+
+        if ($targetColumn.length > 0) {
+            const $dropIndicator = $("<div>").addClass("column-drop-indicator");
+
+            if (insertBefore) {
+                $targetColumn.before($dropIndicator);
+            } else {
+                $targetColumn.after($dropIndicator);
+            }
+
+            $dropIndicator.addClass("show");
+        }
+    }
+
+    private async handleColumnDrop() {
+        console.log("handleColumnDrop called for:", this.context.draggedColumn);
+
+        if (!this.context.draggedColumn || !this.context.draggedColumnElement) {
+            console.log("No dragged column or element found");
+            return;
+        }
+
+        try {
+            // Find the drop indicator to determine insert position
+            const $dropIndicator = this.$container.find(".column-drop-indicator.show");
+            console.log("Drop indicator found:", $dropIndicator.length > 0);
+
+            if ($dropIndicator.length > 0) {
+                // Get current column order from the API (source of truth)
+                const currentOrder = [...this.api.columns];
+
+                let newOrder = [...currentOrder];
+
+                // Remove dragged column from current position
+                newOrder = newOrder.filter(col => col !== this.context.draggedColumn);
+
+                // Determine insertion position based on drop indicator position
+                const $nextColumn = $dropIndicator.next('.board-column');
+                const $prevColumn = $dropIndicator.prev('.board-column');
+
+                let insertIndex = -1;
+
+                if ($nextColumn.length > 0) {
+                    // Insert before the next column
+                    const nextColumnValue = $nextColumn.attr('data-column');
+                    if (nextColumnValue) {
+                        insertIndex = newOrder.indexOf(nextColumnValue);
+                    }
+                } else if ($prevColumn.length > 0) {
+                    // Insert after the previous column
+                    const prevColumnValue = $prevColumn.attr('data-column');
+                    if (prevColumnValue) {
+                        insertIndex = newOrder.indexOf(prevColumnValue) + 1;
+                    }
+                } else {
+                    // Insert at the beginning
+                    insertIndex = 0;
+                }
+
+                // Insert the dragged column at the determined position
+                if (insertIndex >= 0 && insertIndex <= newOrder.length) {
+                    newOrder.splice(insertIndex, 0, this.context.draggedColumn);
+                } else {
+                    // Fallback: insert at the end
+                    newOrder.push(this.context.draggedColumn);
+                }
+
+                // Update column order in API
+                await this.api.reorderColumns(newOrder);
+            } else {
+                console.warn("No drop indicator found for column drop");
+            }
+        } catch (error) {
+            console.error("Failed to reorder columns:", error);
+        } finally {
+            this.cleanupColumnDropIndicators();
+        }
+    }
+}

apps/client/src/widgets/view_widgets/board_view/config.ts

@@ -0,0 +1,7 @@
+export interface BoardColumnData {
+    value: string;
+}
+
+export interface BoardData {
+    columns?: BoardColumnData[];
+}

apps/client/src/widgets/view_widgets/board_view/context_menu.ts

@@ -0,0 +1,93 @@
+import contextMenu, { ContextMenuEvent } from "../../../menus/context_menu.js";
+import link_context_menu from "../../../menus/link_context_menu.js";
+import branches from "../../../services/branches.js";
+import dialog from "../../../services/dialog.js";
+import { t } from "../../../services/i18n.js";
+import BoardApi from "./api.js";
+import type BoardView from "./index.js";
+
+interface ShowNoteContextMenuArgs {
+    $container: JQuery<HTMLElement>;
+    api: BoardApi;
+    boardView: BoardView;
+}
+
+export function setupContextMenu({ $container, api, boardView }: ShowNoteContextMenuArgs) {
+    $container.on("contextmenu", ".board-note", showNoteContextMenu);
+    $container.on("contextmenu", ".board-column h3", showColumnContextMenu);
+
+    function showColumnContextMenu(event: ContextMenuEvent) {
+        event.preventDefault();
+        event.stopPropagation();
+
+        const $el = $(event.currentTarget);
+        const column = $el.closest(".board-column").data("column");
+
+        contextMenu.show({
+            x: event.pageX,
+            y: event.pageY,
+            items: [
+                {
+                    title: t("board_view.delete-column"),
+                    uiIcon: "bx bx-trash",
+                    async handler() {
+                        const confirmed = await dialog.confirm(t("board_view.delete-column-confirmation"));
+                        if (!confirmed) {
+                            return;
+                        }
+
+                        await api.removeColumn(column);
+                    }
+                }
+            ],
+            selectMenuItemHandler() {}
+        });
+    }
+
+    function showNoteContextMenu(event: ContextMenuEvent) {
+        event.preventDefault();
+        event.stopPropagation();
+
+        const $el = $(event.currentTarget);
+        const noteId = $el.data("note-id");
+        const branchId = $el.data("branch-id");
+        const column = $el.closest(".board-column").data("column");
+        if (!noteId) return;
+
+        contextMenu.show({
+            x: event.pageX,
+            y: event.pageY,
+            items: [
+                ...link_context_menu.getItems(),
+                { title: "----" },
+                {
+                    title: t("board_view.move-to"),
+                    uiIcon: "bx bx-transfer",
+                    items: api.columns.map(columnToMoveTo => ({
+                        title: columnToMoveTo,
+                        enabled: columnToMoveTo !== column,
+                        handler: () => api.changeColumn(noteId, columnToMoveTo)
+                    }))
+                },
+                { title: "----" },
+                {
+                    title: t("board_view.insert-above"),
+                    uiIcon: "bx bx-list-plus",
+                    handler: () => boardView.insertItemAtPosition(column, branchId, "before")
+                },
+                {
+                    title: t("board_view.insert-below"),
+                    uiIcon: "bx bx-empty",
+                    handler: () => boardView.insertItemAtPosition(column, branchId, "after")
+                },
+                { title: "----" },
+                {
+                    title: t("board_view.delete-note"),
+                    uiIcon: "bx bx-trash",
+                    handler: () => branches.deleteNotes([ branchId ], false, false)
+                }
+            ],
+            selectMenuItemHandler: ({ command }) =>  link_context_menu.handleLinkContextMenuItem(command, noteId),
+        });
+    }
+}

apps/client/src/widgets/view_widgets/board_view/data.ts

@@ -0,0 +1,84 @@
+import FBranch from "../../../entities/fbranch";
+import FNote from "../../../entities/fnote";
+import { BoardData } from "./config";
+
+export type ColumnMap = Map<string, {
+    branch: FBranch;
+    note: FNote;
+}[]>;
+
+export async function getBoardData(parentNote: FNote, groupByColumn: string, persistedData: BoardData) {
+    const byColumn: ColumnMap = new Map();
+
+    // First, scan all notes to find what columns actually exist
+    await recursiveGroupBy(parentNote.getChildBranches(), byColumn, groupByColumn);
+
+    // Get all columns that exist in the notes
+    const columnsFromNotes = [...byColumn.keys()];
+    
+    // Get existing persisted columns and preserve their order
+    const existingPersistedColumns = persistedData.columns || [];
+    const existingColumnValues = existingPersistedColumns.map(c => c.value);
+    
+    // Find truly new columns (exist in notes but not in persisted data)
+    const newColumnValues = columnsFromNotes.filter(col => !existingColumnValues.includes(col));
+    
+    // Build the complete correct column list: existing + new
+    const allColumns = [
+        ...existingPersistedColumns, // Preserve existing order
+        ...newColumnValues.map(value => ({ value })) // Add new columns
+    ];
+    
+    // Remove duplicates (just in case) and ensure we only keep columns that exist in notes or are explicitly preserved
+    const deduplicatedColumns = allColumns.filter((column, index) => {
+        const firstIndex = allColumns.findIndex(c => c.value === column.value);
+        return firstIndex === index; // Keep only the first occurrence
+    });
+    
+    // Ensure all persisted columns have empty arrays in byColumn (even if no notes use them)
+    for (const column of deduplicatedColumns) {
+        if (!byColumn.has(column.value)) {
+            byColumn.set(column.value, []);
+        }
+    }
+
+    // Return updated persisted data only if there were changes
+    let newPersistedData: BoardData | undefined;
+    const hasChanges = newColumnValues.length > 0 || 
+                      existingPersistedColumns.length !== deduplicatedColumns.length ||
+                      !existingPersistedColumns.every((col, idx) => deduplicatedColumns[idx]?.value === col.value);
+                      
+    if (hasChanges) {
+        newPersistedData = {
+            ...persistedData,
+            columns: deduplicatedColumns
+        };
+    }
+
+    return {
+        byColumn,
+        newPersistedData
+    };
+}
+
+async function recursiveGroupBy(branches: FBranch[], byColumn: ColumnMap, groupByColumn: string) {
+    for (const branch of branches) {
+        const note = await branch.getNote();
+        if (!note) {
+            continue;
+        }
+
+        const group = note.getLabelValue(groupByColumn);
+        if (!group) {
+            continue;
+        }
+
+        if (!byColumn.has(group)) {
+            byColumn.set(group, []);
+        }
+        byColumn.get(group)!.push({
+            branch,
+            note
+        });
+    }
+}

apps/client/src/widgets/view_widgets/board_view/differential_renderer.ts

@@ -0,0 +1,539 @@
+import { BoardDragHandler } from "./drag_handler";
+import BoardApi from "./api";
+import appContext from "../../../components/app_context";
+import FNote from "../../../entities/fnote";
+import ViewModeStorage from "../view_mode_storage";
+import { BoardData } from "./config";
+import { t } from "../../../services/i18n.js";
+
+export interface BoardState {
+    columns: { [key: string]: { note: any; branch: any }[] };
+    columnOrder: string[];
+}
+
+export class DifferentialBoardRenderer {
+    private $container: JQuery<HTMLElement>;
+    private api: BoardApi;
+    private dragHandler: BoardDragHandler;
+    private lastState: BoardState | null = null;
+    private onCreateNewItem: (column: string) => void;
+    private updateTimeout: number | null = null;
+    private pendingUpdate = false;
+    private parentNote: FNote;
+    private viewStorage: ViewModeStorage<BoardData>;
+    private onRefreshApi: () => Promise<void>;
+
+    constructor(
+        $container: JQuery<HTMLElement>,
+        api: BoardApi,
+        dragHandler: BoardDragHandler,
+        onCreateNewItem: (column: string) => void,
+        parentNote: FNote,
+        viewStorage: ViewModeStorage<BoardData>,
+        onRefreshApi: () => Promise<void>
+    ) {
+        this.$container = $container;
+        this.api = api;
+        this.dragHandler = dragHandler;
+        this.onCreateNewItem = onCreateNewItem;
+        this.parentNote = parentNote;
+        this.viewStorage = viewStorage;
+        this.onRefreshApi = onRefreshApi;
+    }
+
+    async renderBoard(refreshApi = false): Promise<void> {
+        // Refresh API data if requested
+        if (refreshApi) {
+            await this.onRefreshApi();
+        }
+
+        // Debounce rapid updates
+        if (this.updateTimeout) {
+            clearTimeout(this.updateTimeout);
+        }
+
+        this.updateTimeout = window.setTimeout(async () => {
+            await this.performUpdate();
+            this.updateTimeout = null;
+        }, 16); // ~60fps
+    }
+
+    private async performUpdate(): Promise<void> {
+        // Clean up any stray drag indicators before updating
+        this.dragHandler.cleanup();
+
+        const currentState = this.getCurrentState();
+
+        if (!this.lastState) {
+            // First render - do full render
+            await this.fullRender(currentState);
+        } else {
+            // Differential render - only update what changed
+            await this.differentialRender(this.lastState, currentState);
+        }
+
+        this.lastState = currentState;
+    }
+
+    private getCurrentState(): BoardState {
+        const columns: { [key: string]: { note: any; branch: any }[] } = {};
+        const columnOrder: string[] = [];
+
+        for (const column of this.api.columns) {
+            columnOrder.push(column);
+            columns[column] = this.api.getColumn(column) || [];
+        }
+
+        return { columns, columnOrder };
+    }
+
+    private async fullRender(state: BoardState): Promise<void> {
+        this.$container.empty();
+
+        for (const column of state.columnOrder) {
+            const columnItems = state.columns[column];
+            const $columnEl = this.createColumn(column, columnItems);
+            this.$container.append($columnEl);
+        }
+
+        this.addAddColumnButton();
+    }
+
+    private async differentialRender(oldState: BoardState, newState: BoardState): Promise<void> {
+        // Store scroll positions before making changes
+        const scrollPositions = this.saveScrollPositions();
+
+        // Handle column additions/removals
+        this.updateColumns(oldState, newState);
+
+        // Handle card updates within existing columns
+        for (const column of newState.columnOrder) {
+            this.updateColumnCards(column, oldState.columns[column] || [], newState.columns[column]);
+        }
+
+        // Restore scroll positions
+        this.restoreScrollPositions(scrollPositions);
+    }
+
+    private saveScrollPositions(): { [column: string]: number } {
+        const positions: { [column: string]: number } = {};
+        this.$container.find('.board-column').each((_, el) => {
+            const column = $(el).attr('data-column');
+            if (column) {
+                positions[column] = el.scrollTop;
+            }
+        });
+        return positions;
+    }
+
+    private restoreScrollPositions(positions: { [column: string]: number }): void {
+        this.$container.find('.board-column').each((_, el) => {
+            const column = $(el).attr('data-column');
+            if (column && positions[column] !== undefined) {
+                el.scrollTop = positions[column];
+            }
+        });
+    }
+
+    private updateColumns(oldState: BoardState, newState: BoardState): void {
+        // Check if column order has changed
+        const orderChanged = !this.arraysEqual(oldState.columnOrder, newState.columnOrder);
+
+        if (orderChanged) {
+            // If order changed, we need to reorder the columns in the DOM
+            this.reorderColumns(newState.columnOrder);
+        }
+
+        // Remove columns that no longer exist
+        for (const oldColumn of oldState.columnOrder) {
+            if (!newState.columnOrder.includes(oldColumn)) {
+                this.$container.find(`[data-column="${oldColumn}"]`).remove();
+            }
+        }
+
+        // Add new columns
+        for (const newColumn of newState.columnOrder) {
+            if (!oldState.columnOrder.includes(newColumn)) {
+                const columnItems = newState.columns[newColumn];
+                const $columnEl = this.createColumn(newColumn, columnItems);
+
+                // Insert at correct position
+                const insertIndex = newState.columnOrder.indexOf(newColumn);
+                const $existingColumns = this.$container.find('.board-column');
+
+                if (insertIndex === 0) {
+                    this.$container.prepend($columnEl);
+                } else if (insertIndex >= $existingColumns.length) {
+                    this.$container.find('.board-add-column').before($columnEl);
+                } else {
+                    $($existingColumns[insertIndex - 1]).after($columnEl);
+                }
+            }
+        }
+    }
+
+    private arraysEqual(a: string[], b: string[]): boolean {
+        return a.length === b.length && a.every((val, index) => val === b[index]);
+    }
+
+    private reorderColumns(newOrder: string[]): void {
+        // Get all existing column elements
+        const $columns = this.$container.find('.board-column');
+        const $addColumnButton = this.$container.find('.board-add-column');
+
+        // Create a map of column elements by their data-column attribute
+        const columnElements = new Map<string, JQuery<HTMLElement>>();
+        $columns.each((_, el) => {
+            const $el = $(el);
+            const columnValue = $el.attr('data-column');
+            if (columnValue) {
+                columnElements.set(columnValue, $el);
+            }
+        });
+
+        // Remove all columns from DOM (but keep references)
+        $columns.detach();
+
+        // Re-insert columns in the new order
+        let $insertAfter: JQuery<HTMLElement> | null = null;
+        for (const columnValue of newOrder) {
+            const $columnEl = columnElements.get(columnValue);
+            if ($columnEl) {
+                if ($insertAfter) {
+                    $insertAfter.after($columnEl);
+                } else {
+                    // Insert at the beginning
+                    this.$container.prepend($columnEl);
+                }
+                $insertAfter = $columnEl;
+            }
+        }
+
+        // Ensure add column button is at the end
+        if ($addColumnButton.length) {
+            this.$container.append($addColumnButton);
+        }
+    }
+
+    private updateColumnCards(column: string, oldCards: { note: any; branch: any }[], newCards: { note: any; branch: any }[]): void {
+        const $column = this.$container.find(`[data-column="${column}"]`);
+        if (!$column.length) return;
+
+        const $cardContainer = $column;
+        const oldCardIds = oldCards.map(item => item.note.noteId);
+        const newCardIds = newCards.map(item => item.note.noteId);
+
+        // Remove cards that no longer exist
+        $cardContainer.find('.board-note').each((_, el) => {
+            const noteId = $(el).attr('data-note-id');
+            if (noteId && !newCardIds.includes(noteId)) {
+                $(el).addClass('fade-out');
+                setTimeout(() => $(el).remove(), 150);
+            }
+        });
+
+        // Add or update cards
+        for (let i = 0; i < newCards.length; i++) {
+            const item = newCards[i];
+            const noteId = item.note.noteId;
+            const $existingCard = $cardContainer.find(`[data-note-id="${noteId}"]`);
+            const isNewCard = !oldCardIds.includes(noteId);
+
+            if ($existingCard.length) {
+                // Check for changes in title, icon, or color
+                const currentTitle = $existingCard.text().trim();
+                const currentIconClass = $existingCard.attr('data-icon-class');
+                const currentColorClass = $existingCard.attr('data-color-class') || '';
+
+                const newIconClass = item.note.getIcon();
+                const newColorClass = item.note.getColorClass() || '';
+
+                let hasChanges = false;
+
+                // Update title if changed
+                if (currentTitle !== item.note.title) {
+                    $existingCard.contents().filter(function() {
+                        return this.nodeType === 3; // Text nodes
+                    }).remove();
+                    $existingCard.append(document.createTextNode(item.note.title));
+                    hasChanges = true;
+                }
+
+                // Update icon if changed
+                if (currentIconClass !== newIconClass) {
+                    const $icon = $existingCard.find('.icon');
+                    $icon.removeClass().addClass('icon').addClass(newIconClass);
+                    $existingCard.attr('data-icon-class', newIconClass);
+                    hasChanges = true;
+                }
+
+                // Update color if changed
+                if (currentColorClass !== newColorClass) {
+                    // Remove old color class if it exists
+                    if (currentColorClass) {
+                        $existingCard.removeClass(currentColorClass);
+                    }
+                    // Add new color class if it exists
+                    if (newColorClass) {
+                        $existingCard.addClass(newColorClass);
+                    }
+                    $existingCard.attr('data-color-class', newColorClass);
+                    hasChanges = true;
+                }
+
+                // Add subtle animation if there were changes
+                if (hasChanges) {
+                    $existingCard.addClass('card-updated');
+                    setTimeout(() => $existingCard.removeClass('card-updated'), 300);
+                }
+
+                // Ensure card is in correct position
+                this.ensureCardPosition($existingCard, i, $cardContainer);
+            } else {
+                // Create new card
+                const $newCard = this.createCard(item.note, item.branch, column);
+                $newCard.addClass('fade-in').css('opacity', '0');
+
+                // Insert at correct position
+                if (i === 0) {
+                    $cardContainer.find('h3').after($newCard);
+                } else {
+                    const $prevCard = $cardContainer.find('.board-note').eq(i - 1);
+                    if ($prevCard.length) {
+                        $prevCard.after($newCard);
+                    } else {
+                        $cardContainer.find('.board-new-item').before($newCard);
+                    }
+                }
+
+                // Trigger fade in animation
+                setTimeout(() => $newCard.css('opacity', '1'), 10);
+            }
+        }
+    }
+
+    private ensureCardPosition($card: JQuery<HTMLElement>, targetIndex: number, $container: JQuery<HTMLElement>): void {
+        const $allCards = $container.find('.board-note');
+        const currentIndex = $allCards.index($card);
+
+        if (currentIndex !== targetIndex) {
+            if (targetIndex === 0) {
+                $container.find('h3').after($card);
+            } else {
+                const $targetPrev = $allCards.eq(targetIndex - 1);
+                if ($targetPrev.length) {
+                    $targetPrev.after($card);
+                }
+            }
+        }
+    }
+
+    private createColumn(column: string, columnItems: { note: any; branch: any }[]): JQuery<HTMLElement> {
+        const $columnEl = $("<div>")
+            .addClass("board-column")
+            .attr("data-column", column);
+
+        // Create header
+        const $titleEl = $("<h3>").attr("data-column-value", column);
+
+        // Create title text
+        const $titleText = $("<span>").text(column);
+
+        // Create edit icon
+        const $editIcon = $("<span>")
+            .addClass("edit-icon icon bx bx-edit-alt")
+            .attr("title", "Click to edit column title");
+
+        $titleEl.append($titleText, $editIcon);
+        $columnEl.append($titleEl);
+
+        // Setup column dragging
+        this.dragHandler.setupColumnDrag($columnEl, column);
+
+        // Handle wheel events for scrolling
+        $columnEl.on("wheel", (event) => {
+            const el = $columnEl[0];
+            const needsScroll = el.scrollHeight > el.clientHeight;
+            if (needsScroll) {
+                event.stopPropagation();
+            }
+        });
+
+        // Setup drop zones for both notes and columns
+        this.dragHandler.setupNoteDropZone($columnEl, column);
+        this.dragHandler.setupColumnDropZone($columnEl);
+
+        // Add cards
+        for (const item of columnItems) {
+            if (item.note) {
+                const $noteEl = this.createCard(item.note, item.branch, column);
+                $columnEl.append($noteEl);
+            }
+        }
+
+        // Add "New item" button
+        const $newItemEl = $("<div>")
+            .addClass("board-new-item")
+            .attr("data-column", column)
+            .html(`<span class="icon bx bx-plus"></span> ${t("board_view.new-item")}`);
+
+        $newItemEl.on("click", () => this.onCreateNewItem(column));
+        $columnEl.append($newItemEl);
+
+        return $columnEl;
+    }
+
+    private createCard(note: any, branch: any, column: string): JQuery<HTMLElement> {
+        const $iconEl = $("<span>")
+            .addClass("icon")
+            .addClass(note.getIcon());
+
+        const colorClass = note.getColorClass() || '';
+
+        const $noteEl = $("<div>")
+            .addClass("board-note")
+            .attr("data-note-id", note.noteId)
+            .attr("data-branch-id", branch.branchId)
+            .attr("data-current-column", column)
+            .attr("data-icon-class", note.getIcon())
+            .attr("data-color-class", colorClass)
+            .text(note.title);
+
+        // Add color class to the card if it exists
+        if (colorClass) {
+            $noteEl.addClass(colorClass);
+        }
+
+        $noteEl.prepend($iconEl);
+        $noteEl.on("click", () => appContext.triggerCommand("openInPopup", { noteIdOrPath: note.noteId }));
+
+        // Setup drag functionality
+        this.dragHandler.setupNoteDrag($noteEl, note, branch);
+
+        return $noteEl;
+    }
+
+    private addAddColumnButton(): void {
+        if (this.$container.find('.board-add-column').length === 0) {
+            const $addColumnEl = $("<div>")
+                .addClass("board-add-column")
+                .html(`<span class="icon bx bx-plus"></span> ${t("board_view.add-column")}`);
+
+            this.$container.append($addColumnEl);
+        }
+    }
+
+    forceFullRender(): void {
+        this.lastState = null;
+        if (this.updateTimeout) {
+            clearTimeout(this.updateTimeout);
+            this.updateTimeout = null;
+        }
+    }
+
+    async flushPendingUpdates(): Promise<void> {
+        if (this.updateTimeout) {
+            clearTimeout(this.updateTimeout);
+            this.updateTimeout = null;
+            await this.performUpdate();
+        }
+    }
+
+    startInlineEditing(noteId: string): void {
+        // Use setTimeout to ensure the card is rendered before trying to edit it
+        setTimeout(() => {
+            const $card = this.$container.find(`[data-note-id="${noteId}"]`);
+            if ($card.length) {
+                this.makeCardEditable($card, noteId);
+            }
+        }, 100);
+    }
+
+    private makeCardEditable($card: JQuery<HTMLElement>, noteId: string): void {
+        if ($card.hasClass('editing')) {
+            return; // Already editing
+        }
+
+        // Get the current title (get text without icon)
+        const $icon = $card.find('.icon');
+        const currentTitle = $card.text().trim();
+
+        // Add editing class and store original click handler
+        $card.addClass('editing');
+        $card.off('click'); // Remove any existing click handlers temporarily
+
+        // Create input element
+        const $input = $('<input>')
+            .attr('type', 'text')
+            .val(currentTitle)
+            .css({
+                background: 'transparent',
+                border: 'none',
+                outline: 'none',
+                fontFamily: 'inherit',
+                fontSize: 'inherit',
+                color: 'inherit',
+                flex: '1',
+                minWidth: '0',
+                padding: '0',
+                marginLeft: '0.25em'
+            });
+
+        // Create a flex container to keep icon and input inline
+        const $editContainer = $('<div>')
+            .css({
+                display: 'flex',
+                alignItems: 'center',
+                width: '100%'
+            });
+
+        // Replace content with icon + input in flex container
+        $editContainer.append($icon.clone(), $input);
+        $card.empty().append($editContainer);
+        $input.focus().select();
+
+        const finishEdit = async (save = true) => {
+            if (!$card.hasClass('editing')) {
+                return; // Already finished
+            }
+
+            $card.removeClass('editing');
+
+            let finalTitle = currentTitle;
+            if (save) {
+                const newTitle = $input.val() as string;
+                if (newTitle.trim() && newTitle !== currentTitle) {
+                    try {
+                        // Update the note title using the board view's server call
+                        import('../../../services/server').then(async ({ default: server }) => {
+                            await server.put(`notes/${noteId}/title`, { title: newTitle.trim() });
+                            finalTitle = newTitle.trim();
+                        });
+                    } catch (error) {
+                        console.error("Failed to update note title:", error);
+                    }
+                }
+            }
+
+            // Restore the card content
+            const iconClass = $card.attr('data-icon-class') || 'bx bx-file';
+            const $newIcon = $('<span>').addClass('icon').addClass(iconClass);
+            $card.text(finalTitle);
+            $card.prepend($newIcon);
+
+            // Re-attach click handler for quick edit (for existing cards)
+            $card.on('click', () => appContext.triggerCommand("openInPopup", { noteIdOrPath: noteId }));
+        };
+
+        $input.on('blur', () => finishEdit(true));
+        $input.on('keydown', (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                finishEdit(true);
+            } else if (e.key === 'Escape') {
+                e.preventDefault();
+                finishEdit(false);
+            }
+        });
+    }
+}

apps/client/src/widgets/view_widgets/board_view/drag_handler.ts

@@ -0,0 +1,45 @@
+import BoardApi from "./api";
+import { DragContext } from "./drag_types";
+import { NoteDragHandler } from "./note_drag_handler";
+import { ColumnDragHandler } from "./column_drag_handler";
+
+export class BoardDragHandler {
+    private noteDragHandler: NoteDragHandler;
+    private columnDragHandler: ColumnDragHandler;
+
+    constructor(
+        $container: JQuery<HTMLElement>,
+        api: BoardApi,
+        context: DragContext,
+    ) {
+        // Initialize specialized drag handlers
+        this.noteDragHandler = new NoteDragHandler($container, api, context);
+        this.columnDragHandler = new ColumnDragHandler($container, api, context);
+    }
+
+    // Note drag methods - delegate to NoteDragHandler
+    setupNoteDrag($noteEl: JQuery<HTMLElement>, note: any, branch: any) {
+        this.noteDragHandler.setupNoteDrag($noteEl, note, branch);
+    }
+
+    setupNoteDropZone($columnEl: JQuery<HTMLElement>, column: string) {
+        this.noteDragHandler.setupNoteDropZone($columnEl, column);
+    }
+
+    // Column drag methods - delegate to ColumnDragHandler
+    setupColumnDrag($columnEl: JQuery<HTMLElement>, columnValue: string) {
+        this.columnDragHandler.setupColumnDrag($columnEl, columnValue);
+    }
+
+    setupColumnDropZone($columnEl: JQuery<HTMLElement>) {
+        this.columnDragHandler.setupColumnDropZone($columnEl);
+    }
+
+    cleanup() {
+        this.noteDragHandler.cleanup();
+        this.columnDragHandler.cleanup();
+    }
+}
+
+// Export the drag context type for external use
+export type { DragContext } from "./drag_types";

apps/client/src/widgets/view_widgets/board_view/drag_types.ts

@@ -0,0 +1,11 @@
+export interface DragContext {
+    draggedNote: any;
+    draggedBranch: any;
+    draggedNoteElement: JQuery<HTMLElement> | null;
+    draggedColumn: string | null;
+    draggedColumnElement: JQuery<HTMLElement> | null;
+}
+
+export interface BaseDragHandler {
+    cleanup(): void;
+}

apps/client/src/widgets/view_widgets/board_view/index.ts

@@ -0,0 +1,650 @@
+import { setupHorizontalScrollViaWheel } from "../../widget_utils";
+import ViewMode, { ViewModeArgs } from "../view_mode";
+import noteCreateService from "../../../services/note_create";
+import { EventData } from "../../../components/app_context";
+import { BoardData } from "./config";
+import SpacedUpdate from "../../../services/spaced_update";
+import { setupContextMenu } from "./context_menu";
+import BoardApi from "./api";
+import { BoardDragHandler, DragContext } from "./drag_handler";
+import { DifferentialBoardRenderer } from "./differential_renderer";
+
+const TPL = /*html*/`
+<div class="board-view">
+    <style>
+        .board-view {
+            overflow-x: auto;
+            position: relative;
+            height: 100%;
+            user-select: none;
+        }
+
+        .board-view-container {
+            height: 100%;
+            display: flex;
+            gap: 1em;
+            padding: 1em;
+            padding-bottom: 0;
+            align-items: flex-start;
+        }
+
+        .board-view-container .board-column {
+            width: 250px;
+            flex-shrink: 0;
+            border: 2px solid transparent;
+            border-radius: 8px;
+            padding: 0.5em;
+            background-color: var(--accented-background-color);
+            transition: border-color 0.2s ease;
+            overflow-y: auto;
+            max-height: 100%;
+        }
+
+        .board-view-container .board-column.drag-over {
+            border-color: var(--main-text-color);
+            background-color: var(--hover-item-background-color);
+        }
+
+        .board-view-container .board-column h3 {
+            font-size: 1em;
+            margin-bottom: 0.75em;
+            padding: 0.5em 0.5em 0.5em 0.5em;
+            border-bottom: 1px solid var(--main-border-color);
+            cursor: grab;
+            position: relative;
+            transition: background-color 0.2s ease, border-radius 0.2s ease;
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            box-sizing: border-box;
+            background-color: transparent;
+        }
+
+        .board-view-container .board-column h3:active {
+            cursor: grabbing;
+        }
+
+        .board-view-container .board-column h3.editing {
+            cursor: default;
+        }
+
+        .board-view-container .board-column h3:hover {
+            background-color: var(--hover-item-background-color);
+            border-radius: 4px;
+        }
+
+        .board-view-container .board-column h3.editing {
+            background-color: var(--main-background-color);
+            border: 1px solid var(--main-text-color);
+            border-radius: 4px;
+        }
+
+        .board-view-container .board-column.column-dragging {
+            opacity: 0.6;
+            transform: scale(0.98);
+            transition: opacity 0.2s ease, transform 0.2s ease;
+        }
+
+        .board-view-container .board-column h3 input {
+            background: transparent;
+            border: none;
+            outline: none;
+            font-size: inherit;
+            font-weight: inherit;
+            color: inherit;
+            width: 100%;
+            font-family: inherit;
+        }
+
+        .board-view-container .board-column h3 .edit-icon {
+            opacity: 0;
+            margin-left: 0.5em;
+            transition: opacity 0.2s ease;
+            color: var(--muted-text-color);
+        }
+
+        .board-view-container .board-column h3:hover .edit-icon {
+            opacity: 1;
+        }
+
+        .board-view-container .board-column h3.editing .edit-icon {
+            display: none;
+        }
+
+        .board-view-container .board-note {
+            box-shadow: 1px 1px 4px rgba(0, 0, 0, 0.25);
+            margin: 0.65em 0;
+            padding: 0.5em;
+            border-radius: 5px;
+            cursor: move;
+            position: relative;
+            background-color: var(--main-background-color);
+            border: 1px solid var(--main-border-color);
+            transition: transform 0.2s ease, box-shadow 0.2s ease, opacity 0.15s ease;
+            opacity: 1;
+        }
+
+        .board-view-container .board-note.fade-in {
+            animation: fadeIn 0.15s ease-in;
+        }
+
+        .board-view-container .board-note.fade-out {
+            animation: fadeOut 0.15s ease-out forwards;
+        }
+
+        @keyframes fadeIn {
+            from { opacity: 0; transform: translateY(-10px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+
+        @keyframes fadeOut {
+            from { opacity: 1; transform: translateY(0); }
+            to { opacity: 0; transform: translateY(-10px); }
+        }
+
+        .board-view-container .board-note.card-updated {
+            animation: cardUpdate 0.3s ease-in-out;
+        }
+
+        @keyframes cardUpdate {
+            0% { transform: scale(1); }
+            50% { transform: scale(1.02); box-shadow: 0 4px 12px rgba(0, 0, 0, 0.2); }
+            100% { transform: scale(1); }
+        }
+
+        .board-view-container .board-note:hover {
+            transform: translateY(-2px);
+            box-shadow: 2px 4px 8px rgba(0, 0, 0, 0.35);
+        }
+
+        .board-view-container .board-note.dragging {
+            opacity: 0.8;
+            transform: rotate(5deg);
+            z-index: 1000;
+            box-shadow: 4px 8px 16px rgba(0, 0, 0, 0.5);
+        }
+
+        .board-view-container .board-note.editing {
+            box-shadow: 2px 4px 8px rgba(0, 0, 0, 0.35);
+            border-color: var(--main-text-color);
+        }
+
+        .board-view-container .board-note.editing input {
+            background: transparent;
+            border: none;
+            outline: none;
+            font-family: inherit;
+            font-size: inherit;
+            color: inherit;
+            width: 100%;
+            padding: 0;
+        }
+
+        .board-view-container .board-note .icon {
+            margin-right: 0.25em;
+        }
+
+        .board-drop-indicator {
+            height: 3px;
+            background-color: var(--main-text-color);
+            border-radius: 2px;
+            margin: 0.25em 0;
+            opacity: 0;
+            transition: opacity 0.2s ease;
+        }
+
+        .board-drop-indicator.show {
+            opacity: 1;
+        }
+
+        .column-drop-indicator {
+            width: 4px;
+            background-color: var(--main-text-color);
+            border-radius: 2px;
+            opacity: 0;
+            transition: opacity 0.2s ease;
+            height: 100%;
+            z-index: 1000;
+            box-shadow: 0 0 8px rgba(0, 0, 0, 0.3);
+            flex-shrink: 0;
+        }
+
+        .column-drop-indicator.show {
+            opacity: 1;
+        }
+
+        .board-new-item {
+            margin-top: 0.5em;
+            padding: 0.5em;
+            border-radius: 5px;
+            color: var(--muted-text-color);
+            cursor: pointer;
+            transition: all 0.2s ease;
+            background-color: transparent;
+        }
+
+        .board-new-item:hover {
+            border-color: var(--main-text-color);
+            color: var(--main-text-color);
+            background-color: var(--hover-item-background-color);
+        }
+
+        .board-new-item .icon {
+            margin-right: 0.25em;
+        }
+
+        .board-add-column {
+            width: 180px;
+            flex-shrink: 0;
+            height: 60px;
+            border-radius: 8px;
+            padding: 0.5em;
+            background-color: var(--accented-background-color);
+            transition: all 0.2s ease;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            cursor: pointer;
+            color: var(--muted-text-color);
+            font-size: 0.9em;
+            align-self: flex-start;
+        }
+
+        .board-add-column:hover {
+            border-color: var(--main-text-color);
+            color: var(--main-text-color);
+            background-color: var(--hover-item-background-color);
+        }
+
+        .board-add-column .icon {
+            margin-right: 0.5em;
+            font-size: 1.2em;
+        }
+
+        .board-drag-preview {
+            position: fixed;
+            z-index: 10000;
+            pointer-events: none;
+            opacity: 0.8;
+            transform: rotate(5deg);
+            box-shadow: 4px 8px 16px rgba(0, 0, 0, 0.5);
+            background-color: var(--main-background-color);
+            border: 1px solid var(--main-border-color);
+            border-radius: 5px;
+            padding: 0.5em;
+            font-size: 0.9em;
+            max-width: 200px;
+            word-wrap: break-word;
+        }
+    </style>
+
+    <div class="board-view-container"></div>
+</div>
+`;
+
+export default class BoardView extends ViewMode<BoardData> {
+
+    private $root: JQuery<HTMLElement>;
+    private $container: JQuery<HTMLElement>;
+    private spacedUpdate: SpacedUpdate;
+    private dragContext: DragContext;
+    private persistentData: BoardData;
+    private api?: BoardApi;
+    private dragHandler?: BoardDragHandler;
+    private renderer?: DifferentialBoardRenderer;
+
+    constructor(args: ViewModeArgs) {
+        super(args, "board");
+
+        this.$root = $(TPL);
+        setupHorizontalScrollViaWheel(this.$root);
+        this.$container = this.$root.find(".board-view-container");
+        this.spacedUpdate = new SpacedUpdate(() => this.onSave(), 5_000);
+        this.persistentData = {
+            columns: []
+        };
+        this.dragContext = {
+            draggedNote: null,
+            draggedBranch: null,
+            draggedNoteElement: null,
+            draggedColumn: null,
+            draggedColumnElement: null
+        };
+
+        args.$parent.append(this.$root);
+    }
+
+    async renderList(): Promise<JQuery<HTMLElement> | undefined> {
+        if (!this.renderer) {
+            // First time setup
+            this.$container.empty();
+            await this.initializeRenderer();
+        }
+
+        await this.renderer!.renderBoard();
+        return this.$root;
+    }
+
+    private async initializeRenderer() {
+        this.api = await BoardApi.build(this.parentNote, this.viewStorage);
+        this.dragHandler = new BoardDragHandler(
+            this.$container,
+            this.api,
+            this.dragContext
+        );
+
+        this.renderer = new DifferentialBoardRenderer(
+            this.$container,
+            this.api,
+            this.dragHandler,
+            (column: string) => this.createNewItem(column),
+            this.parentNote,
+            this.viewStorage,
+            () => this.refreshApi()
+        );
+
+        setupContextMenu({
+            $container: this.$container,
+            api: this.api,
+            boardView: this
+        });
+
+        // Setup column title editing and add column functionality
+        this.setupBoardInteractions();
+    }
+
+    private async refreshApi(): Promise<void> {
+        if (!this.api) {
+            throw new Error("API not initialized");
+        }
+
+        await this.api.refresh(this.parentNote);
+    }
+
+    private setupBoardInteractions() {
+        // Handle column title editing with click detection that works with dragging
+        this.$container.on('mousedown', 'h3[data-column-value]', (e) => {
+            const $titleEl = $(e.currentTarget);
+
+            // Don't interfere with editing mode
+            if ($titleEl.hasClass('editing') || $(e.target).is('input')) {
+                return;
+            }
+
+            const startTime = Date.now();
+            let hasMoved = false;
+            const startX = e.clientX;
+            const startY = e.clientY;
+
+            const handleMouseMove = (moveEvent: JQuery.MouseMoveEvent) => {
+                const deltaX = Math.abs(moveEvent.clientX - startX);
+                const deltaY = Math.abs(moveEvent.clientY - startY);
+                if (deltaX > 5 || deltaY > 5) {
+                    hasMoved = true;
+                }
+            };
+
+            const handleMouseUp = (upEvent: JQuery.MouseUpEvent) => {
+                const duration = Date.now() - startTime;
+                $(document).off('mousemove', handleMouseMove);
+                $(document).off('mouseup', handleMouseUp);
+
+                // If it was a quick click without much movement, treat as edit request
+                if (duration < 500 && !hasMoved && upEvent.button === 0) {
+                    const columnValue = $titleEl.attr('data-column-value');
+                    if (columnValue) {
+                        const columnItems = this.api?.getColumn(columnValue) || [];
+                        this.startEditingColumnTitle($titleEl, columnValue, columnItems);
+                    }
+                }
+            };
+
+            $(document).on('mousemove', handleMouseMove);
+            $(document).on('mouseup', handleMouseUp);
+        });
+
+        // Handle add column button
+        this.$container.on('click', '.board-add-column', (e) => {
+            e.stopPropagation();
+            this.startCreatingNewColumn($(e.currentTarget));
+        });
+    }
+
+    private createTitleStructure(title: string): { $titleText: JQuery<HTMLElement>; $editIcon: JQuery<HTMLElement> } {
+        const $titleText = $("<span>").text(title);
+        const $editIcon = $("<span>")
+            .addClass("edit-icon icon bx bx-edit-alt")
+            .attr("title", "Click to edit column title");
+
+        return { $titleText, $editIcon };
+    }
+
+    private startEditingColumnTitle($titleEl: JQuery<HTMLElement>, columnValue: string, columnItems: { branch: any; note: any; }[]) {
+        if ($titleEl.hasClass("editing")) {
+            return; // Already editing
+        }
+
+        const $titleSpan = $titleEl.find("span").first(); // Get the text span
+        const currentTitle = $titleSpan.text();
+        $titleEl.addClass("editing");
+
+        // Disable dragging while editing
+        $titleEl.attr("draggable", "false");
+
+        const $input = $("<input>")
+            .attr("type", "text")
+            .val(currentTitle)
+            .attr("placeholder", "Column title");
+
+        // Prevent events from bubbling to parent drag handlers
+        $input.on('mousedown mouseup click', (e) => {
+            e.stopPropagation();
+        });
+
+        $titleEl.empty().append($input);
+        $input.focus().select();
+
+        const finishEdit = async (save: boolean = true) => {
+            if (!$titleEl.hasClass("editing")) {
+                return; // Already finished
+            }
+
+            $titleEl.removeClass("editing");
+
+            // Re-enable dragging after editing
+            $titleEl.attr("draggable", "true");
+
+            let finalTitle = currentTitle;
+            if (save) {
+                const newTitle = $input.val() as string;
+                if (newTitle.trim() && newTitle !== currentTitle) {
+                    await this.renameColumn(columnValue, newTitle.trim(), columnItems);
+                    finalTitle = newTitle.trim();
+                }
+            }
+
+            // Recreate the title structure
+            const { $titleText, $editIcon } = this.createTitleStructure(finalTitle);
+            $titleEl.empty().append($titleText, $editIcon);
+        };
+
+        $input.on("blur", () => finishEdit(true));
+        $input.on("keydown", (e) => {
+            if (e.key === "Enter") {
+                e.preventDefault();
+                finishEdit(true);
+            } else if (e.key === "Escape") {
+                e.preventDefault();
+                finishEdit(false);
+            }
+        });
+    }
+
+    private async renameColumn(oldValue: string, newValue: string, columnItems: { branch: any; note: any; }[]) {
+        try {
+            // Get all note IDs in this column
+            const noteIds = columnItems.map(item => item.note.noteId);
+
+            // Use the API to rename the column (update all notes)
+            // This will trigger onEntitiesReloaded which will automatically refresh the board
+            await this.api?.renameColumn(oldValue, newValue, noteIds);
+        } catch (error) {
+            console.error("Failed to rename column:", error);
+        }
+    }
+
+    private async createNewItem(column: string) {
+        try {
+            // Get the parent note path
+            const parentNotePath = this.parentNote.noteId;
+
+            // Create a new note as a child of the parent note
+            const { note: newNote } = await noteCreateService.createNote(parentNotePath, {
+                activate: false,
+                title: "New item"
+            });
+
+            if (newNote) {
+                // Set the status label to place it in the correct column
+                await this.api?.changeColumn(newNote.noteId, column);
+
+                // Refresh the board to show the new item
+                await this.renderList();
+
+                // Start inline editing of the newly created card
+                this.startInlineEditingCard(newNote.noteId);
+            }
+        } catch (error) {
+            console.error("Failed to create new item:", error);
+        }
+    }
+
+    async insertItemAtPosition(column: string, relativeToBranchId: string, direction: "before" | "after"): Promise<void> {
+        try {
+            // Create the note without opening it
+            const newNote = await this.api?.insertRowAtPosition(column, relativeToBranchId, direction, false);
+
+            if (newNote) {
+                // Refresh the board to show the new item
+                await this.renderList();
+
+                // Start inline editing of the newly created card
+                this.startInlineEditingCard(newNote.noteId);
+            }
+        } catch (error) {
+            console.error("Failed to insert new item:", error);
+        }
+    }
+
+    private startInlineEditingCard(noteId: string) {
+        this.renderer?.startInlineEditing(noteId);
+    }
+
+    forceFullRefresh() {
+        this.renderer?.forceFullRender();
+        return this.renderList();
+    }
+
+    private startCreatingNewColumn($addColumnEl: JQuery<HTMLElement>) {
+        if ($addColumnEl.hasClass("editing")) {
+            return; // Already editing
+        }
+
+        $addColumnEl.addClass("editing");
+
+        const $input = $("<input>")
+            .attr("type", "text")
+            .attr("placeholder", "Enter column name...")
+            .css({
+                background: "var(--main-background-color)",
+                border: "1px solid var(--main-text-color)",
+                borderRadius: "4px",
+                padding: "0.5em",
+                color: "var(--main-text-color)",
+                fontFamily: "inherit",
+                fontSize: "inherit",
+                width: "100%",
+                textAlign: "center"
+            });
+
+        $addColumnEl.empty().append($input);
+        $input.focus();
+
+        const finishEdit = async (save: boolean = true) => {
+            if (!$addColumnEl.hasClass("editing")) {
+                return; // Already finished
+            }
+
+            $addColumnEl.removeClass("editing");
+
+            if (save) {
+                const columnName = $input.val() as string;
+                if (columnName.trim()) {
+                    await this.createNewColumn(columnName.trim());
+                }
+            }
+
+            // Restore the add button
+            $addColumnEl.html('<span class="icon bx bx-plus"></span>Add Column');
+        };
+
+        $input.on("blur", () => finishEdit(true));
+        $input.on("keydown", (e) => {
+            if (e.key === "Enter") {
+                e.preventDefault();
+                finishEdit(true);
+            } else if (e.key === "Escape") {
+                e.preventDefault();
+                finishEdit(false);
+            }
+        });
+    }
+
+    private async createNewColumn(columnName: string) {
+        try {
+            // Check if column already exists
+            if (this.api?.columns.includes(columnName)) {
+                console.warn("A column with this name already exists.");
+                return;
+            }
+
+            // Create the new column
+            await this.api?.createColumn(columnName);
+
+            // Refresh the board to show the new column
+            await this.renderList();
+        } catch (error) {
+            console.error("Failed to create new column:", error);
+        }
+    }
+
+    async onEntitiesReloaded({ loadResults }: EventData<"entitiesReloaded">) {
+        // Check if any changes affect our board
+        const hasRelevantChanges =
+            // React to changes in status attribute for notes in this board
+            loadResults.getAttributeRows().some(attr => attr.name === this.api?.statusAttribute && this.noteIds.includes(attr.noteId!)) ||
+            // React to changes in note title
+            loadResults.getNoteIds().some(noteId => this.noteIds.includes(noteId)) ||
+            // React to changes in branches for subchildren (e.g., moved, added, or removed notes)
+            loadResults.getBranchRows().some(branch => this.noteIds.includes(branch.noteId!)) ||
+            // React to changes in note icon or color.
+            loadResults.getAttributeRows().some(attr => [ "iconClass", "color" ].includes(attr.name ?? "") && this.noteIds.includes(attr.noteId ?? "")) ||
+            // React to attachment change
+            loadResults.getAttachmentRows().some(att => att.ownerId === this.parentNote.noteId && att.title === "board.json") ||
+            // React to changes in "groupBy"
+            loadResults.getAttributeRows().some(attr => attr.name === "board:groupBy" && attr.noteId === this.parentNote.noteId);
+
+        if (hasRelevantChanges && this.renderer) {
+            // Use differential rendering with API refresh
+            await this.renderer.renderBoard(true);
+        }
+
+        // Don't trigger full view refresh - let differential renderer handle it
+        return false;
+    }
+
+    private onSave() {
+        this.viewStorage.store(this.persistentData);
+    }
+
+}

apps/client/src/widgets/view_widgets/board_view/note_drag_handler.ts

@@ -0,0 +1,322 @@
+import branchService from "../../../services/branches";
+import BoardApi from "./api";
+import { DragContext, BaseDragHandler } from "./drag_types";
+
+export class NoteDragHandler implements BaseDragHandler {
+    private $container: JQuery<HTMLElement>;
+    private api: BoardApi;
+    private context: DragContext;
+
+    constructor(
+        $container: JQuery<HTMLElement>,
+        api: BoardApi,
+        context: DragContext,
+    ) {
+        this.$container = $container;
+        this.api = api;
+        this.context = context;
+    }
+
+    setupNoteDrag($noteEl: JQuery<HTMLElement>, note: any, branch: any) {
+        $noteEl.attr("draggable", "true");
+
+        // Mouse drag events
+        this.setupMouseDrag($noteEl, note, branch);
+
+        // Touch drag events
+        this.setupTouchDrag($noteEl, note, branch);
+    }
+
+    setupNoteDropZone($columnEl: JQuery<HTMLElement>, column: string) {
+        $columnEl.on("dragover", (e) => {
+            // Only handle note drops when a note is being dragged
+            if (this.context.draggedNote && !this.context.draggedColumn) {
+                e.preventDefault();
+                const originalEvent = e.originalEvent as DragEvent;
+                if (originalEvent.dataTransfer) {
+                    originalEvent.dataTransfer.dropEffect = "move";
+                }
+
+                $columnEl.addClass("drag-over");
+                this.showDropIndicator($columnEl, e);
+            }
+        });
+
+        $columnEl.on("dragleave", (e) => {
+            // Only remove drag-over if we're leaving the column entirely
+            const rect = $columnEl[0].getBoundingClientRect();
+            const originalEvent = e.originalEvent as DragEvent;
+            const x = originalEvent.clientX;
+            const y = originalEvent.clientY;
+
+            if (x < rect.left || x > rect.right || y < rect.top || y > rect.bottom) {
+                $columnEl.removeClass("drag-over");
+                this.cleanupNoteDropIndicators($columnEl);
+            }
+        });
+
+        $columnEl.on("drop", async (e) => {
+            if (this.context.draggedNote && !this.context.draggedColumn) {
+                e.preventDefault();
+                $columnEl.removeClass("drag-over");
+
+                if (this.context.draggedNote && this.context.draggedNoteElement && this.context.draggedBranch) {
+                    await this.handleNoteDrop($columnEl, column);
+                }
+            }
+        });
+    }
+
+    cleanup() {
+        this.cleanupAllDropIndicators();
+        this.$container.find('.board-column').removeClass('drag-over');
+    }
+
+    private setupMouseDrag($noteEl: JQuery<HTMLElement>, note: any, branch: any) {
+        $noteEl.on("dragstart", (e) => {
+            this.context.draggedNote = note;
+            this.context.draggedBranch = branch;
+            this.context.draggedNoteElement = $noteEl;
+            $noteEl.addClass("dragging");
+
+            // Set drag data
+            const originalEvent = e.originalEvent as DragEvent;
+            if (originalEvent.dataTransfer) {
+                originalEvent.dataTransfer.effectAllowed = "move";
+                originalEvent.dataTransfer.setData("text/plain", note.noteId);
+            }
+        });
+
+        $noteEl.on("dragend", () => {
+            $noteEl.removeClass("dragging");
+            this.context.draggedNote = null;
+            this.context.draggedBranch = null;
+            this.context.draggedNoteElement = null;
+
+            // Clean up all drop indicators properly
+            this.cleanupAllDropIndicators();
+        });
+    }
+
+    private setupTouchDrag($noteEl: JQuery<HTMLElement>, note: any, branch: any) {
+        let isDragging = false;
+        let startY = 0;
+        let startX = 0;
+        let dragThreshold = 10; // Minimum distance to start dragging
+        let $dragPreview: JQuery<HTMLElement> | null = null;
+
+        $noteEl.on("touchstart", (e) => {
+            const touch = (e.originalEvent as TouchEvent).touches[0];
+            startX = touch.clientX;
+            startY = touch.clientY;
+            isDragging = false;
+            $dragPreview = null;
+        });
+
+        $noteEl.on("touchmove", (e) => {
+            e.preventDefault(); // Prevent scrolling
+            const touch = (e.originalEvent as TouchEvent).touches[0];
+            const deltaX = Math.abs(touch.clientX - startX);
+            const deltaY = Math.abs(touch.clientY - startY);
+
+            // Start dragging if we've moved beyond threshold
+            if (!isDragging && (deltaX > dragThreshold || deltaY > dragThreshold)) {
+                isDragging = true;
+                this.context.draggedNote = note;
+                this.context.draggedBranch = branch;
+                this.context.draggedNoteElement = $noteEl;
+                $noteEl.addClass("dragging");
+
+                // Create drag preview
+                $dragPreview = this.createDragPreview($noteEl, touch.clientX, touch.clientY);
+            }
+
+            if (isDragging && $dragPreview) {
+                // Update drag preview position
+                $dragPreview.css({
+                    left: touch.clientX - ($dragPreview.outerWidth() || 0) / 2,
+                    top: touch.clientY - ($dragPreview.outerHeight() || 0) / 2
+                });
+
+                // Find element under touch point
+                const elementBelow = document.elementFromPoint(touch.clientX, touch.clientY);
+                if (elementBelow) {
+                    const $columnEl = $(elementBelow).closest('.board-column');
+
+                    if ($columnEl.length > 0) {
+                        // Remove drag-over from all columns
+                        this.$container.find('.board-column').removeClass('drag-over');
+                        $columnEl.addClass('drag-over');
+
+                        // Show drop indicator
+                        this.showDropIndicatorAtPoint($columnEl, touch.clientY);
+                    } else {
+                        // Remove all drag indicators if not over a column
+                        this.$container.find('.board-column').removeClass('drag-over');
+                        this.cleanupAllDropIndicators();
+                    }
+                }
+            }
+        });
+
+        $noteEl.on("touchend", async (e) => {
+            if (isDragging) {
+                const touch = (e.originalEvent as TouchEvent).changedTouches[0];
+                const elementBelow = document.elementFromPoint(touch.clientX, touch.clientY);
+                if (elementBelow) {
+                    const $columnEl = $(elementBelow).closest('.board-column');
+
+                    if ($columnEl.length > 0) {
+                        const column = $columnEl.attr('data-column');
+                        if (column && this.context.draggedNote && this.context.draggedNoteElement && this.context.draggedBranch) {
+                            await this.handleNoteDrop($columnEl, column);
+                        }
+                    }
+                }
+
+                // Clean up
+                $noteEl.removeClass("dragging");
+                this.context.draggedNote = null;
+                this.context.draggedBranch = null;
+                this.context.draggedNoteElement = null;
+                this.$container.find('.board-column').removeClass('drag-over');
+                this.cleanupAllDropIndicators();
+
+                // Remove drag preview
+                if ($dragPreview) {
+                    $dragPreview.remove();
+                    $dragPreview = null;
+                }
+            }
+            isDragging = false;
+        });
+    }
+
+    private createDragPreview($noteEl: JQuery<HTMLElement>, x: number, y: number): JQuery<HTMLElement> {
+        // Clone the note element for the preview
+        const $preview = $noteEl.clone();
+
+        $preview
+            .addClass('board-drag-preview')
+            .css({
+                position: 'fixed',
+                left: x - ($noteEl.outerWidth() || 0) / 2,
+                top: y - ($noteEl.outerHeight() || 0) / 2,
+                pointerEvents: 'none',
+                zIndex: 10000
+            })
+            .appendTo('body');
+
+        return $preview;
+    }
+
+    private showDropIndicator($columnEl: JQuery<HTMLElement>, e: JQuery.DragOverEvent) {
+        const originalEvent = e.originalEvent as DragEvent;
+        const mouseY = originalEvent.clientY;
+        this.showDropIndicatorAtY($columnEl, mouseY);
+    }
+
+    private showDropIndicatorAtPoint($columnEl: JQuery<HTMLElement>, touchY: number) {
+        this.showDropIndicatorAtY($columnEl, touchY);
+    }
+
+    private showDropIndicatorAtY($columnEl: JQuery<HTMLElement>, y: number) {
+        const columnRect = $columnEl[0].getBoundingClientRect();
+        const relativeY = y - columnRect.top;
+
+        // Clean up any existing drop indicators in this column first
+        this.cleanupNoteDropIndicators($columnEl);
+
+        // Create a new drop indicator
+        const $dropIndicator = $("<div>").addClass("board-drop-indicator");
+
+        // Find the best position to insert the note
+        const $notes = this.context.draggedNoteElement ?
+            $columnEl.find(".board-note").not(this.context.draggedNoteElement) :
+            $columnEl.find(".board-note");
+        let insertAfterElement: HTMLElement | null = null;
+
+        $notes.each((_, noteEl) => {
+            const noteRect = noteEl.getBoundingClientRect();
+            const noteMiddle = noteRect.top + noteRect.height / 2 - columnRect.top;
+
+            if (relativeY > noteMiddle) {
+                insertAfterElement = noteEl;
+            }
+        });
+
+        // Position the drop indicator
+        if (insertAfterElement) {
+            $(insertAfterElement).after($dropIndicator);
+        } else {
+            // Insert at the beginning (after the header)
+            const $header = $columnEl.find("h3");
+            $header.after($dropIndicator);
+        }
+
+        $dropIndicator.addClass("show");
+    }
+
+    private async handleNoteDrop($columnEl: JQuery<HTMLElement>, column: string) {
+        const draggedNoteElement = this.context.draggedNoteElement;
+        const draggedNote = this.context.draggedNote;
+        const draggedBranch = this.context.draggedBranch;
+
+        if (draggedNote && draggedNoteElement && draggedBranch) {
+            const currentColumn = draggedNoteElement.attr("data-current-column");
+
+            // Capture drop indicator position BEFORE removing it
+            const dropIndicator = $columnEl.find(".board-drop-indicator.show");
+            let targetBranchId: string | null = null;
+            let moveType: "before" | "after" | null = null;
+
+            if (dropIndicator.length > 0) {
+                // Find the note element that the drop indicator is positioned relative to
+                const nextNote = dropIndicator.next(".board-note");
+                const prevNote = dropIndicator.prev(".board-note");
+
+                if (nextNote.length > 0) {
+                    targetBranchId = nextNote.attr("data-branch-id") || null;
+                    moveType = "before";
+                } else if (prevNote.length > 0) {
+                    targetBranchId = prevNote.attr("data-branch-id") || null;
+                    moveType = "after";
+                }
+            }
+
+            try {
+                // Handle column change
+                if (currentColumn !== column) {
+                    await this.api.changeColumn(draggedNote.noteId, column);
+                }
+
+                // Handle position change (works for both same column and different column moves)
+                if (targetBranchId && moveType) {
+                    if (moveType === "before") {
+                        await branchService.moveBeforeBranch([draggedBranch.branchId], targetBranchId);
+                    } else if (moveType === "after") {
+                        await branchService.moveAfterBranch([draggedBranch.branchId], targetBranchId);
+                    }
+                }
+
+                // Update the data attributes
+                draggedNoteElement.attr("data-current-column", column);
+            } catch (error) {
+                console.error("Failed to update note position:", error);
+            } finally {
+                // Always clean up drop indicators after drop operation
+                this.cleanupAllDropIndicators();
+            }
+        }
+    }
+
+    private cleanupAllDropIndicators() {
+        // Remove all drop indicators from the DOM to prevent layout issues
+        this.$container.find(".board-drop-indicator").remove();
+    }
+
+    private cleanupNoteDropIndicators($columnEl: JQuery<HTMLElement>) {
+        // Remove note drop indicators from a specific column
+        $columnEl.find(".board-drop-indicator").remove();
+    }
+}

apps/client/src/widgets/view_widgets/calendar_view.ts

@@ -113,7 +113,6 @@ export default class CalendarView extends ViewMode<{}> {
 
     private $root: JQuery<HTMLElement>;
     private $calendarContainer: JQuery<HTMLElement>;
-    private noteIds: string[];
     private calendar?: Calendar;
     private isCalendarRoot: boolean;
     private lastView?: string;
@@ -124,15 +123,10 @@ export default class CalendarView extends ViewMode<{}> {
 
         this.$root = $(TPL);
         this.$calendarContainer = this.$root.find(".calendar-container");
-        this.noteIds = args.noteIds;
         this.isCalendarRoot = false;
         args.$parent.append(this.$root);
     }
 
-    get isFullHeight(): boolean {
-        return true;
-    }
-
     async renderList(): Promise<JQuery<HTMLElement> | undefined> {
         this.isCalendarRoot = this.parentNote.hasLabel("calendarRoot") || this.parentNote.hasLabel("workspaceCalendarRoot");
         const isEditable = !this.isCalendarRoot;
@@ -396,7 +390,7 @@ export default class CalendarView extends ViewMode<{}> {
         }
     }
 
-    onEntitiesReloaded({ loadResults }: EventData<"entitiesReloaded">) {
+    async onEntitiesReloaded({ loadResults }: EventData<"entitiesReloaded">) {
         // Refresh note IDs if they got changed.
         if (loadResults.getBranchRows().some((branch) => branch.parentNoteId === this.parentNote.noteId)) {
             this.noteIds = this.parentNote.getChildNoteIds();
@@ -407,9 +401,14 @@ export default class CalendarView extends ViewMode<{}> {
             return true;
         }
 
+        // Refresh on note title change.
+        if (loadResults.getNoteIds().some(noteId => this.noteIds.includes(noteId))) {
+            this.calendar?.refetchEvents();
+        }
+
         // Refresh dataset on subnote change.
-        if (this.calendar && loadResults.getAttributeRows().some((a) => this.noteIds.includes(a.noteId ?? ""))) {
-            this.calendar.refetchEvents();
+        if (loadResults.getAttributeRows().some((a) => this.noteIds.includes(a.noteId ?? ""))) {
+            this.calendar?.refetchEvents();
         }
     }
 
@@ -438,7 +437,7 @@ export default class CalendarView extends ViewMode<{}> {
             events.push(await CalendarView.buildEvent(dateNote, { startDate }));
 
             if (dateNote.hasChildren()) {
-                const childNoteIds = dateNote.getChildNoteIds();
+                const childNoteIds = await dateNote.getSubtreeNoteIds();
                 for (const childNoteId of childNoteIds) {
                     childNoteToDateMapping[childNoteId] = startDate;
                 }
@@ -464,13 +463,6 @@ export default class CalendarView extends ViewMode<{}> {
         for (const note of notes) {
             const startDate = CalendarView.#getCustomisableLabel(note, "startDate", "calendar:startDate");
 
-            if (note.hasChildren()) {
-                const childrenEventData = await this.buildEvents(note.getChildNoteIds());
-                if (childrenEventData.length > 0) {
-                    events.push(childrenEventData);
-                }
-            }
-
             if (!startDate) {
                 continue;
             }

apps/client/src/widgets/view_widgets/geo_view/index.ts

@@ -1,6 +1,6 @@
 import ViewMode, { ViewModeArgs } from "../view_mode.js";
 import L from "leaflet";
-import type { GPX, LatLng, LeafletMouseEvent, Map, Marker } from "leaflet";
+import type { GPX, LatLng, Layer, LeafletMouseEvent, Map, Marker } from "leaflet";
 import "leaflet/dist/leaflet.css";
 import SpacedUpdate from "../../../services/spaced_update.js";
 import { t } from "../../../services/i18n.js";
@@ -10,6 +10,8 @@ import toast from "../../../services/toast.js";
 import { CommandListenerData, EventData } from "../../../components/app_context.js";
 import { createNewNote, moveMarker, setupDragging } from "./editing.js";
 import { openMapContextMenu } from "./context_menu.js";
+import attributes from "../../../services/attributes.js";
+import { DEFAULT_MAP_LAYER_NAME, MAP_LAYERS } from "./map_layer.js";
 
 const TPL = /*html*/`
 <div class="geo-view">
@@ -83,6 +85,11 @@ const TPL = /*html*/`
             white-space: no-wrap;
             overflow: hidden;
         }
+
+        .geo-map-container.dark .leaflet-div-icon .title-label {
+            color: white;
+            text-shadow: -1px -1px 0 black, 1px -1px 0 black, -1px 1px 0 black, 1px 1px 0 black;
+        }
     </style>
 
     <div class="geo-map-container"></div>
@@ -138,10 +145,32 @@ export default class GeoView extends ViewMode<MapData> {
         const map = L.map(this.$container[0], {
             worldCopyJump: true
         });
-        L.tileLayer("https://tile.openstreetmap.org/{z}/{x}/{y}.png", {
-            attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors',
-            detectRetina: true
-        }).addTo(map);
+
+        const layerName = this.parentNote.getLabelValue("map:style") ?? DEFAULT_MAP_LAYER_NAME;
+        let layer: Layer;
+        const layerData = MAP_LAYERS[layerName];
+
+        if (layerData.type === "vector") {
+            const style = (typeof layerData.style === "string" ? layerData.style : await layerData.style());
+            await import("@maplibre/maplibre-gl-leaflet");
+
+            layer = L.maplibreGL({
+                style: style as any
+            });
+        } else {
+            layer = L.tileLayer(layerData.url, {
+                attribution: layerData.attribution,
+                detectRetina: true
+            });
+        }
+
+        if (this.parentNote.hasLabel("map:scale")) {
+            L.control.scale().addTo(map);
+        }
+
+        this.$container.toggleClass("dark", !!layerData.isDarkTheme);
+
+        layer.addTo(map);
 
         this.map = map;
 
@@ -226,7 +255,7 @@ export default class GeoView extends ViewMode<MapData> {
 
         // Add the new markers.
         this.currentMarkerData = {};
-        const notes = await this.parentNote.getChildNotes();
+        const notes = await this.parentNote.getSubtreeNotes();
         const draggable = !this.isReadOnly;
         for (const childNote of notes) {
             if (childNote.mime === "application/gpx+xml") {
@@ -243,10 +272,6 @@ export default class GeoView extends ViewMode<MapData> {
         }
     }
 
-    get isFullHeight(): boolean {
-        return true;
-    }
-
     #changeState(newState: State) {
         this._state = newState;
         this.$container.toggleClass("placing-note", newState === State.NewNote);
@@ -255,7 +280,7 @@ export default class GeoView extends ViewMode<MapData> {
         }
     }
 
-    onEntitiesReloaded({ loadResults }: EventData<"entitiesReloaded">): boolean | void {
+    async onEntitiesReloaded({ loadResults }: EventData<"entitiesReloaded">) {
         // If any of the children branches are altered.
         if (loadResults.getBranchRows().find((branch) => branch.parentNoteId === this.parentNote.noteId)) {
             this.#reloadMarkers();
@@ -265,9 +290,14 @@ export default class GeoView extends ViewMode<MapData> {
         // If any of note has its location attribute changed.
         // TODO: Should probably filter by parent here as well.
         const attributeRows = loadResults.getAttributeRows();
-        if (attributeRows.find((at) => [LOCATION_ATTRIBUTE, "color"].includes(at.name ?? ""))) {
+        if (attributeRows.find((at) => [LOCATION_ATTRIBUTE, "color", "iconClass"].includes(at.name ?? ""))) {
             this.#reloadMarkers();
         }
+
+        // Full reload if map layer is changed.
+        if (loadResults.getAttributeRows().some(attr => (attr.name?.startsWith("map:") && attributes.isAffecting(attr, this.parentNote)))) {
+            return true;
+        }
     }
 
     async geoMapCreateChildNoteEvent({ ntxId }: EventData<"geoMapCreateChildNote">) {
@@ -334,3 +364,4 @@ export default class GeoView extends ViewMode<MapData> {
     }
 
 }
+

apps/client/src/widgets/view_widgets/geo_view/map_layer.ts

@@ -0,0 +1,53 @@
+export interface MapLayer {
+    name: string;
+    isDarkTheme?: boolean;
+}
+
+interface VectorLayer extends MapLayer {
+    type: "vector";
+    style: string | (() => Promise<{}>)
+}
+
+interface RasterLayer extends MapLayer {
+    type: "raster";
+    url: string;
+    attribution: string;
+}
+
+export const MAP_LAYERS: Record<string, VectorLayer | RasterLayer> = {
+    "openstreetmap": {
+        name: "OpenStreetMap",
+        type: "raster",
+        url: "https://tile.openstreetmap.org/{z}/{x}/{y}.png",
+        attribution: '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+    },
+    "versatiles-colorful": {
+        name: "VersaTiles Colorful",
+        type: "vector",
+        style: async () => (await import("./styles/colorful/en.json")).default
+    },
+    "versatiles-eclipse": {
+        name: "VersaTiles Eclipse",
+        type: "vector",
+        style: async () => (await import("./styles/eclipse/en.json")).default,
+        isDarkTheme: true
+    },
+    "versatiles-graybeard": {
+        name: "VersaTiles Graybeard",
+        type: "vector",
+        style: async () => (await import("./styles/graybeard/en.json")).default
+    },
+    "versatiles-neutrino": {
+        name: "VersaTiles Neutrino",
+        type: "vector",
+        style: async () => (await import("./styles/neutrino/en.json")).default
+    },
+    "versatiles-shadow": {
+        name: "VersaTiles Shadow",
+        type: "vector",
+        style: async () => (await import("./styles/shadow/en.json")).default,
+        isDarkTheme: true
+    }
+};
+
+export const DEFAULT_MAP_LAYER_NAME: keyof typeof MAP_LAYERS = "versatiles-colorful";