fix(standalone): error due to SQL returning bigint

; Conflicts:
;	apps/client/src/widgets/layout/StatusBar.tsx

.github/workflows/deploy-app.yml

@@ -0,0 +1,65 @@
+name: Deploy Standalone App
+
+on:
+  # Trigger on push to main branch
+  push:
+    branches:
+      - main
+    # Only run when docs files change
+    paths:
+      - 'apps/client/**'
+      - 'apps/client-standalone/**'
+      - 'packages/trilium-core/**'
+
+  # Allow manual triggering from Actions tab
+  workflow_dispatch:
+
+  # Run on pull requests for preview deployments
+  pull_request:
+    paths:
+      - 'apps/client/**'
+      - 'apps/client-standalone/**'
+      - 'packages/trilium-core/**'
+jobs:
+  build-and-deploy:
+    name: Build and Deploy App
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    # Required permissions for deployment
+    permissions:
+      contents: read
+      deployments: write
+      pull-requests: write # For PR preview comments
+      id-token: write # For OIDC authentication (if needed)
+
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v6
+
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: '24'
+          cache: 'pnpm'
+
+      - name: Install Dependencies
+        run: pnpm install --frozen-lockfile
+
+      - name: Trigger build of app
+        run: pnpm --filter=client-standalone build
+
+      - name: Deploy
+        uses: ./.github/actions/deploy-to-cloudflare-pages
+        if: github.repository == vars.REPO_MAIN
+        with:
+          project_name: "trilium-app"
+          comment_body: "🖥️ App preview is ready"
+          production_url: "https://app.triliumnotes.org"
+          deploy_dir: "apps/client-standalone/dist"
+          cloudflare_api_token: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          cloudflare_account_id: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
+          github_token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/dev.yml

@@ -1,9 +1,9 @@
 name: Dev
 on:
   push:
-    branches: [ main ]
+    branches: [ main, standalone ]
   pull_request:
-    branches: [ main ]
+    branches: [ main, standalone ]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

.github/workflows/i18n.yml

@@ -1,30 +0,0 @@
-name: Internationalization
-on:
-  push:
-    branches:
-      - "weblate:*"
-  workflow_dispatch:
-  pull_request:
-    paths:
-      - "apps/client/src/translations/**"
-      - ".github/workflows/i18n.yml"
-
-permissions:
-  contents: read
-
-jobs:
-  i18n-check:
-    name: Check i18n translations
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-      - uses: pnpm/action-setup@v4
-      - name: Set up node & dependencies
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          cache: 'pnpm'
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-      - name: Check translations
-        run: pnpm tsx scripts/translation/check-translation-coverage.ts

.github/workflows/website.yml

@@ -34,7 +34,7 @@ jobs:
           cache: "pnpm"
 
       - name: Install dependencies
-        run: pnpm install --filter website --frozen-lockfile --ignore-scripts
+        run: pnpm install --filter website --frozen-lockfile
 
       - name: Build the website
         run: pnpm website:build

.nvmrc

@@ -1 +1 @@
-24.13.0
+24.12.0

README.md

@@ -165,17 +165,6 @@ pnpm install
 pnpm edit-docs:edit-docs
 ```
 
-Alternatively, if you have Nix installed:
-```shell
-# Run directly
-nix run .#edit-docs
-
-# Or install to your profile
-nix profile install .#edit-docs
-trilium-edit-docs
-```
-
-
 ### Building the Executable
 Download the repository, install dependencies using `pnpm` and then build the desktop app for Windows:
 ```shell

apps/build-docs/package.json

@@ -11,7 +11,7 @@
   "license": "AGPL-3.0-only",
   "packageManager": "pnpm@10.28.0",
   "devDependencies": {
-    "@redocly/cli": "2.14.5",
+    "@redocly/cli": "2.14.4",
     "archiver": "7.0.1",
     "fs-extra": "11.3.3",
     "react": "19.2.3",

apps/client-standalone/.env

@@ -0,0 +1,4 @@
+# The development license key for premium CKEditor features.
+# Note: This key must only be used for the Trilium Notes project.
+VITE_CKEDITOR_KEY=eyJhbGciOiJFUzI1NiJ9.eyJleHAiOjE3ODcyNzA0MDAsImp0aSI6IjkyMWE1MWNlLTliNDMtNGRlMC1iOTQwLTc5ZjM2MDBkYjg1NyIsImRpc3RyaWJ1dGlvbkNoYW5uZWwiOiJ0cmlsaXVtIiwiZmVhdHVyZXMiOlsiVFJJTElVTSJdLCJ2YyI6ImU4YzRhMjBkIn0.hny77p-U4-jTkoqbwPytrEar5ylGCWBN7Ez3SlB8i6_mJCBIeCSTOlVQk_JMiOEq3AGykUMHzWXzjdMFwgniOw
+VITE_CKEDITOR_ENABLE_INSPECTOR=false

apps/client-standalone/.env.production

@@ -0,0 +1 @@
+VITE_CKEDITOR_ENABLE_INSPECTOR=false

apps/client-standalone/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@triliumnext/client-standalone",
+  "version": "0.101.3",
+  "description": "Standalone client for TriliumNext with SQLite WASM backend",
+  "private": true,
+  "license": "AGPL-3.0-only",
+  "scripts": {
+    "build": "cross-env NODE_OPTIONS=--max-old-space-size=4096 vite build",
+    "dev": "vite dev",
+    "test": "vitest",
+    "start-prod": "pnpm build && pnpm http-server dist -p 8888",
+    "coverage": "vitest --coverage"
+  },
+  "dependencies": {
+    "@excalidraw/excalidraw": "0.18.0",
+    "@fullcalendar/core": "6.1.20",
+    "@fullcalendar/daygrid": "6.1.20",
+    "@fullcalendar/interaction": "6.1.20",
+    "@fullcalendar/list": "6.1.20",
+    "@fullcalendar/multimonth": "6.1.20",
+    "@fullcalendar/timegrid": "6.1.20",
+    "@maplibre/maplibre-gl-leaflet": "0.1.3",
+    "@mermaid-js/layout-elk": "0.2.0",
+    "@mind-elixir/node-menu": "5.0.1",
+    "@popperjs/core": "2.11.8",
+    "@preact/signals": "2.5.1",
+    "@sqlite.org/sqlite-wasm": "3.51.1-build2",
+    "@triliumnext/ckeditor5": "workspace:*",
+    "@triliumnext/codemirror": "workspace:*",
+    "@triliumnext/commons": "workspace:*",
+    "@triliumnext/core": "workspace:*",
+    "@triliumnext/highlightjs": "workspace:*",
+    "@triliumnext/share-theme": "workspace:*",
+    "@triliumnext/split.js": "workspace:*",
+    "@zumer/snapdom": "2.0.1",
+    "autocomplete.js": "0.38.1",
+    "bootstrap": "5.3.8",
+    "boxicons": "2.1.4",
+    "clsx": "2.1.1",
+    "color": "5.0.3",
+    "debounce": "3.0.0",
+    "draggabilly": "3.0.0",
+    "force-graph": "1.51.0",
+    "globals": "17.0.0",
+    "i18next": "25.7.3",
+    "i18next-http-backend": "3.0.2",
+    "jquery": "3.7.1",
+    "jquery.fancytree": "2.38.5",
+    "js-sha1": "0.7.0",
+    "js-sha512": "0.9.0",
+    "jsplumb": "2.15.6",
+    "katex": "0.16.27",
+    "knockout": "3.5.1",
+    "leaflet": "1.9.4",
+    "leaflet-gpx": "2.2.0",
+    "mark.js": "8.11.1",
+    "marked": "17.0.1",
+    "mermaid": "11.12.2",
+    "mind-elixir": "5.4.0",
+    "normalize.css": "8.0.1",
+    "panzoom": "9.4.3",
+    "preact": "10.28.2",
+    "react-i18next": "16.5.1",
+    "react-window": "2.2.3",
+    "reveal.js": "5.2.1",
+    "svg-pan-zoom": "3.6.2",
+    "tabulator-tables": "6.3.1",
+    "vanilla-js-wheel-zoom": "9.0.4"
+  },
+  "devDependencies": {
+    "@ckeditor/ckeditor5-inspector": "5.0.0",
+    "@preact/preset-vite": "2.10.2",
+    "@types/bootstrap": "5.2.10",
+    "@types/jquery": "3.5.33",
+    "@types/leaflet": "1.9.21",
+    "@types/leaflet-gpx": "1.3.8",
+    "@types/mark.js": "8.11.12",
+    "@types/reveal.js": "5.2.2",
+    "@types/tabulator-tables": "6.3.1",
+    "copy-webpack-plugin": "13.0.1",
+    "cross-env": "7.0.3",
+    "happy-dom": "20.0.11",
+    "script-loader": "0.7.2",
+    "vite-plugin-static-copy": "3.1.4"
+  }
+}

apps/client-standalone/public/_headers

@@ -0,0 +1,3 @@
+/*
+  Cross-Origin-Opener-Policy: same-origin
+  Cross-Origin-Embedder-Policy: require-corp

apps/client-standalone/public/manifest.webmanifest

@@ -0,0 +1,20 @@
+{
+    "name": "Trilium Notes",
+    "short_name": "Trilium",
+    "description": "Trilium Notes is a hierarchical note taking application with focus on building large personal knowledge bases.",
+    "theme_color": "#333333",
+    "background_color": "#1F1F1F",
+    "display": "standalone",
+    "scope": "/",
+    "start_url": "/",
+    "display_override": [
+        "window-controls-overlay"
+    ],
+    "icons": [
+        {
+            "src": "assets/icon.png",
+            "sizes": "512x512",
+            "type": "image/png"
+        }
+    ]
+}

apps/client-standalone/src/desktop.ts

@@ -0,0 +1,2 @@
+// Re-export desktop from client
+export * from "../../client/src/desktop";

apps/client-standalone/src/index.html

@@ -0,0 +1,35 @@
+<!DOCTYPE html>
+<html lang="en">
+    <head>
+        <meta charset="utf-8">
+        <link rel="shortcut icon" href="favicon.ico">
+        <meta name="mobile-web-app-capable" content="yes">
+        <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
+        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, viewport-fit=cover" />
+        <link rel="manifest" crossorigin="use-credentials" href="manifest.webmanifest">
+        <title>Trilium Notes</title>
+    </head>
+
+    <body id="trilium-app">
+        <noscript>Trilium requires JavaScript to be enabled.</noscript>
+
+        <script>
+            // hide body to reduce flickering on the startup. This is done through JS and not CSS to not hide <noscript>
+            document.getElementsByTagName("body")[0].style.display = "none";
+        </script>
+
+        <div class="dropdown-menu dropdown-menu-sm" id="context-menu-container" style="display: none"></div>
+
+        <!-- Required for match the PWA's top bar color with the theme -->
+        <!-- This works even when the user directly changes --root-background in CSS -->
+        <div id="background-color-tracker" style="position: absolute; visibility: hidden; color: var(--root-background); transition: color 1ms;"></div>
+
+        <!-- Bootstrap (request server for required information) -->
+        <script src="./main.ts" type="module"></script>
+
+        <!-- Required for correct loading of scripts in Electron -->
+        <script>
+            if (typeof module === 'object') {window.module = module; module = undefined;}
+        </script>
+    </body>
+</html>

apps/client-standalone/src/lightweight/browser_router.ts

@@ -0,0 +1,254 @@
+/**
+ * Browser-compatible router that mimics Express routing patterns.
+ * Supports path parameters (e.g., /api/notes/:noteId) and query strings.
+ */
+
+import { getContext, routes } from "@triliumnext/core";
+
+export interface BrowserRequest {
+    method: string;
+    url: string;
+    path: string;
+    params: Record<string, string>;
+    query: Record<string, string | undefined>;
+    body?: unknown;
+}
+
+export interface BrowserResponse {
+    status: number;
+    headers: Record<string, string>;
+    body: ArrayBuffer | null;
+}
+
+export type RouteHandler = (req: BrowserRequest) => unknown | Promise<unknown>;
+
+interface Route {
+    method: string;
+    pattern: RegExp;
+    paramNames: string[];
+    handler: RouteHandler;
+}
+
+const encoder = new TextEncoder();
+
+/**
+ * Convert an Express-style path pattern to a RegExp.
+ * Supports :param syntax for path parameters.
+ *
+ * Examples:
+ *   /api/notes/:noteId -> /^\/api\/notes\/([^\/]+)$/
+ *   /api/notes/:noteId/revisions -> /^\/api\/notes\/([^\/]+)\/revisions$/
+ */
+function pathToRegex(path: string): { pattern: RegExp; paramNames: string[] } {
+    const paramNames: string[] = [];
+
+    // Escape special regex characters except for :param patterns
+    const regexPattern = path
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&') // Escape special chars
+        .replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, paramName) => {
+            paramNames.push(paramName);
+            return '([^/]+)';
+        });
+
+    return {
+        pattern: new RegExp(`^${regexPattern}$`),
+        paramNames
+    };
+}
+
+/**
+ * Parse query string into an object.
+ */
+function parseQuery(search: string): Record<string, string | undefined> {
+    const query: Record<string, string | undefined> = {};
+    if (!search || search === '?') return query;
+
+    const params = new URLSearchParams(search);
+    for (const [key, value] of params) {
+        query[key] = value;
+    }
+    return query;
+}
+
+/**
+ * Convert a result to a JSON response.
+ */
+function jsonResponse(obj: unknown, status = 200, extraHeaders: Record<string, string> = {}): BrowserResponse {
+    const parsedObj = routes.convertEntitiesToPojo(obj);
+    const body = encoder.encode(JSON.stringify(parsedObj)).buffer as ArrayBuffer;
+    return {
+        status,
+        headers: { "content-type": "application/json; charset=utf-8", ...extraHeaders },
+        body
+    };
+}
+
+/**
+ * Convert a string to a text response.
+ */
+function textResponse(text: string, status = 200, extraHeaders: Record<string, string> = {}): BrowserResponse {
+    const body = encoder.encode(text).buffer as ArrayBuffer;
+    return {
+        status,
+        headers: { "content-type": "text/plain; charset=utf-8", ...extraHeaders },
+        body
+    };
+}
+
+/**
+ * Browser router class that handles route registration and dispatching.
+ */
+export class BrowserRouter {
+    private routes: Route[] = [];
+
+    /**
+     * Register a route handler.
+     */
+    register(method: string, path: string, handler: RouteHandler): void {
+        const { pattern, paramNames } = pathToRegex(path);
+        this.routes.push({
+            method: method.toUpperCase(),
+            pattern,
+            paramNames,
+            handler
+        });
+    }
+
+    /**
+     * Convenience methods for common HTTP methods.
+     */
+    get(path: string, handler: RouteHandler): void {
+        this.register('GET', path, handler);
+    }
+
+    post(path: string, handler: RouteHandler): void {
+        this.register('POST', path, handler);
+    }
+
+    put(path: string, handler: RouteHandler): void {
+        this.register('PUT', path, handler);
+    }
+
+    patch(path: string, handler: RouteHandler): void {
+        this.register('PATCH', path, handler);
+    }
+
+    delete(path: string, handler: RouteHandler): void {
+        this.register('DELETE', path, handler);
+    }
+
+    /**
+     * Dispatch a request to the appropriate handler.
+     */
+    async dispatch(method: string, urlString: string, body?: unknown, headers?: Record<string, string>): Promise<BrowserResponse> {
+        const url = new URL(urlString);
+        const path = url.pathname;
+        const query = parseQuery(url.search);
+        const upperMethod = method.toUpperCase();
+
+        // Parse JSON body if it's an ArrayBuffer and content-type suggests JSON
+        let parsedBody = body;
+        if (body instanceof ArrayBuffer && headers) {
+            const contentType = headers['content-type'] || headers['Content-Type'] || '';
+            if (contentType.includes('application/json')) {
+                try {
+                    const text = new TextDecoder().decode(body);
+                    if (text.trim()) {
+                        parsedBody = JSON.parse(text);
+                    }
+                } catch (e) {
+                    console.warn('[Router] Failed to parse JSON body:', e);
+                    // Keep original body if JSON parsing fails
+                    parsedBody = body;
+                }
+            }
+        }
+        // Find matching route
+        for (const route of this.routes) {
+            if (route.method !== upperMethod) continue;
+
+            const match = path.match(route.pattern);
+            if (!match) continue;
+
+            // Extract path parameters
+            const params: Record<string, string> = {};
+            for (let i = 0; i < route.paramNames.length; i++) {
+                params[route.paramNames[i]] = decodeURIComponent(match[i + 1]);
+            }
+
+            const request: BrowserRequest = {
+                method: upperMethod,
+                url: urlString,
+                path,
+                params,
+                query,
+                body: parsedBody
+            };
+
+            try {
+                const result = await getContext().init(async () => await route.handler(request));
+                return this.formatResult(result);
+            } catch (error) {
+                return this.formatError(error, `Error handling ${method} ${path}`);
+            }
+        }
+
+        // No route matched
+        return textResponse(`Not found: ${method} ${path}`, 404);
+    }
+
+    /**
+     * Format a handler result into a response.
+     * Follows the same patterns as the server's apiResultHandler.
+     */
+    private formatResult(result: unknown): BrowserResponse {
+        // Handle [statusCode, response] format
+        if (Array.isArray(result) && result.length > 0 && Number.isInteger(result[0])) {
+            const [statusCode, response] = result;
+            return jsonResponse(response, statusCode);
+        }
+
+        // Handle undefined (no content) - 204 should have no body
+        if (result === undefined) {
+            return {
+                status: 204,
+                headers: {},
+                body: null
+            };
+        }
+
+        // Default: JSON response with 200
+        return jsonResponse(result, 200);
+    }
+
+    /**
+     * Format an error into a response.
+     */
+    private formatError(error: unknown, context: string): BrowserResponse {
+        console.error('[Router] Handler error:', context, error);
+
+        // Check for known error types
+        if (error && typeof error === 'object') {
+            const err = error as { constructor?: { name?: string }; message?: string };
+
+            if (err.constructor?.name === 'NotFoundError') {
+                return jsonResponse({ message: err.message || 'Not found' }, 404);
+            }
+
+            if (err.constructor?.name === 'ValidationError') {
+                return jsonResponse({ message: err.message || 'Validation error' }, 400);
+            }
+        }
+
+        // Generic error
+        const message = error instanceof Error ? error.message : String(error);
+        return jsonResponse({ message }, 500);
+    }
+}
+
+/**
+ * Create a new router instance.
+ */
+export function createRouter(): BrowserRouter {
+    return new BrowserRouter();
+}

apps/client-standalone/src/lightweight/browser_routes.ts

@@ -0,0 +1,98 @@
+/**
+ * Browser route definitions.
+ * This integrates with the shared route builder from @triliumnext/core.
+ */
+
+import { BootstrapDefinition } from '@triliumnext/commons';
+import { getSharedBootstrapItems, routes } from '@triliumnext/core';
+
+import packageJson from '../../package.json' with { type: 'json' };
+import { type BrowserRequest,BrowserRouter } from './browser_router';
+
+type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+
+/**
+ * Wraps a core route handler to work with the BrowserRouter.
+ * Core handlers expect an Express-like request object with params, query, and body.
+ */
+function wrapHandler(handler: (req: any) => unknown) {
+    return (req: BrowserRequest) => {
+        // Create an Express-like request object
+        const expressLikeReq = {
+            params: req.params,
+            query: req.query,
+            body: req.body
+        };
+        return handler(expressLikeReq);
+    };
+}
+
+/**
+ * Creates an apiRoute function compatible with buildSharedApiRoutes.
+ * This bridges the core's route registration to the BrowserRouter.
+ */
+function createApiRoute(router: BrowserRouter) {
+    return (method: HttpMethod, path: string, handler: (req: any) => unknown) => {
+        router.register(method, path, wrapHandler(handler));
+    };
+}
+
+/**
+ * Register all API routes on the browser router using the shared builder.
+ *
+ * @param router - The browser router instance
+ */
+export function registerRoutes(router: BrowserRouter): void {
+    const apiRoute = createApiRoute(router);
+    routes.buildSharedApiRoutes(apiRoute);
+    apiRoute('get', '/bootstrap', bootstrapRoute);
+
+    // Dummy routes for compatibility.
+    apiRoute("get", "/api/script/widgets", () => []);
+    apiRoute("get", "/api/script/startup", () => []);
+    apiRoute("get", "/api/system-checks", () => ({ isCpuArchMismatch: false }));
+    apiRoute("get", "/api/search/:searchString", () => []);
+    apiRoute("get", "/api/search-templates", () => []);
+    apiRoute("get", "/api/autocomplete", () => []);
+}
+
+function bootstrapRoute() {
+
+    const assetPath = ".";
+
+    return {
+        ...getSharedBootstrapItems(assetPath),
+        appPath: assetPath,
+        device: false, // Let the client detect device type.
+        csrfToken: "dummy-csrf-token",
+        themeCssUrl: false,
+        themeUseNextAsBase: "next",
+        triliumVersion: packageJson.version,
+        baseApiUrl: "../api/",
+        headingStyle: "plain",
+        layoutOrientation: "vertical",
+        platform: "web",
+        isDev: import.meta.env.DEV,
+        isMainWindow: true,
+        isElectron: false,
+        isStandalone: true,
+        hasNativeTitleBar: false,
+        hasBackgroundEffects: true,
+
+        // TODO: Fill properly
+        currentLocale: { id: "en", name: "English", rtl: false },
+        isRtl: false,
+        instanceName: null,
+        appCssNoteIds: [],
+        TRILIUM_SAFE_MODE: false
+    } satisfies BootstrapDefinition;
+}
+
+/**
+ * Create and configure a router with all routes registered.
+ */
+export function createConfiguredRouter(): BrowserRouter {
+    const router = new BrowserRouter();
+    registerRoutes(router);
+    return router;
+}

apps/client-standalone/src/lightweight/cls_provider.ts

@@ -0,0 +1,46 @@
+import { ExecutionContext } from "@triliumnext/core";
+
+export default class BrowserExecutionContext implements ExecutionContext {
+    private store: Map<string, any> | null = null;
+
+    get<T = any>(key: string): T | undefined {
+        return this.store?.get(key);
+    }
+
+    set(key: string, value: any): void {
+        if (!this.store) {
+            throw new Error("ExecutionContext not initialized");
+        }
+        this.store.set(key, value);
+    }
+
+    reset(): void {
+        this.store = null;
+    }
+
+    init<T>(callback: () => T): T {
+        // Create a fresh context for this request
+        const prev = this.store;
+        this.store = new Map();
+
+        try {
+            const result = callback();
+            
+            // If the result is a Promise, we need to handle cleanup after it resolves
+            if (result && typeof result === 'object' && 'then' in result && 'catch' in result) {
+                const promise = result as unknown as Promise<any>;
+                return promise.finally(() => {
+                    this.store = prev;
+                }) as T;
+            } else {
+                // Synchronous result, clean up immediately
+                this.store = prev;
+                return result;
+            }
+        } catch (error) {
+            // Always clean up on error (for synchronous errors)
+            this.store = prev;
+            throw error;
+        }
+    }
+}

apps/client-standalone/src/lightweight/crypto_provider.ts

@@ -0,0 +1,145 @@
+import type { CryptoProvider } from "@triliumnext/core";
+import { sha1 } from "js-sha1";
+import { sha512 } from "js-sha512";
+
+interface Cipher {
+    update(data: Uint8Array): Uint8Array;
+    final(): Uint8Array;
+}
+
+const CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+
+/**
+ * Crypto provider for browser environments using the Web Crypto API.
+ */
+export default class BrowserCryptoProvider implements CryptoProvider {
+
+    createHash(algorithm: "sha1" | "sha512", content: string | Uint8Array): Uint8Array {
+        const data = typeof content === "string" ? content :
+                new TextDecoder().decode(content);
+
+        const hexHash = algorithm === "sha1" ? sha1(data) : sha512(data);
+
+        // Convert hex string to Uint8Array
+        const bytes = new Uint8Array(hexHash.length / 2);
+        for (let i = 0; i < hexHash.length; i += 2) {
+            bytes[i / 2] = parseInt(hexHash.substr(i, 2), 16);
+        }
+        return bytes;
+    }
+
+    createCipheriv(algorithm: "aes-128-cbc", key: Uint8Array, iv: Uint8Array): Cipher {
+        // Web Crypto API doesn't support streaming cipher like Node.js
+        // We need to implement a wrapper that collects data and encrypts on final()
+        return new WebCryptoCipher(algorithm, key, iv, "encrypt");
+    }
+
+    createDecipheriv(algorithm: "aes-128-cbc", key: Uint8Array, iv: Uint8Array): Cipher {
+        return new WebCryptoCipher(algorithm, key, iv, "decrypt");
+    }
+
+    randomBytes(size: number): Uint8Array {
+        const bytes = new Uint8Array(size);
+        crypto.getRandomValues(bytes);
+        return bytes;
+    }
+
+    randomString(length: number): string {
+        const bytes = this.randomBytes(length);
+        let result = "";
+        for (let i = 0; i < length; i++) {
+            result += CHARS[bytes[i] % CHARS.length];
+        }
+        return result;
+    }
+}
+
+/**
+ * A cipher implementation that wraps Web Crypto API.
+ * Note: This buffers all data until final() is called, which differs from
+ * Node.js's streaming cipher behavior.
+ */
+class WebCryptoCipher implements Cipher {
+    private chunks: Uint8Array[] = [];
+    private algorithm: string;
+    private key: Uint8Array;
+    private iv: Uint8Array;
+    private mode: "encrypt" | "decrypt";
+    private finalized = false;
+
+    constructor(
+        algorithm: "aes-128-cbc",
+        key: Uint8Array,
+        iv: Uint8Array,
+        mode: "encrypt" | "decrypt"
+    ) {
+        this.algorithm = algorithm;
+        this.key = key;
+        this.iv = iv;
+        this.mode = mode;
+    }
+
+    update(data: Uint8Array): Uint8Array {
+        if (this.finalized) {
+            throw new Error("Cipher has already been finalized");
+        }
+        // Buffer the data - Web Crypto doesn't support streaming
+        this.chunks.push(data);
+        // Return empty array since we process everything in final()
+        return new Uint8Array(0);
+    }
+
+    final(): Uint8Array {
+        if (this.finalized) {
+            throw new Error("Cipher has already been finalized");
+        }
+        this.finalized = true;
+
+        // Web Crypto API is async, but we need sync behavior
+        // This is a fundamental limitation that requires architectural changes
+        // For now, throw an error directing users to use async methods
+        throw new Error(
+            "Synchronous cipher finalization not available in browser. " +
+            "The Web Crypto API is async-only. Use finalizeAsync() instead."
+        );
+    }
+
+    /**
+     * Async version that actually performs the encryption/decryption.
+     */
+    async finalizeAsync(): Promise<Uint8Array> {
+        if (this.finalized) {
+            throw new Error("Cipher has already been finalized");
+        }
+        this.finalized = true;
+
+        // Concatenate all chunks
+        const totalLength = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+        const data = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of this.chunks) {
+            data.set(chunk, offset);
+            offset += chunk.length;
+        }
+
+        // Copy key and iv to ensure they're plain ArrayBuffer-backed
+        const keyBuffer = new Uint8Array(this.key);
+        const ivBuffer = new Uint8Array(this.iv);
+
+        // Import the key
+        const cryptoKey = await crypto.subtle.importKey(
+            "raw",
+            keyBuffer,
+            { name: "AES-CBC" },
+            false,
+            [this.mode]
+        );
+
+        // Perform encryption/decryption
+        const result = this.mode === "encrypt"
+            ? await crypto.subtle.encrypt({ name: "AES-CBC", iv: ivBuffer }, cryptoKey, data)
+            : await crypto.subtle.decrypt({ name: "AES-CBC", iv: ivBuffer }, cryptoKey, data);
+
+        return new Uint8Array(result);
+    }
+}

apps/client-standalone/src/lightweight/messaging_provider.ts

@@ -0,0 +1,90 @@
+import type { WebSocketMessage } from "@triliumnext/commons";
+import type { MessagingProvider, MessageHandler } from "@triliumnext/core";
+
+/**
+ * Messaging provider for browser Worker environments.
+ *
+ * This provider uses the Worker's postMessage API to communicate
+ * with the main thread. It's designed to be used inside a Web Worker
+ * that runs the core services.
+ *
+ * Message flow:
+ * - Outbound (worker → main): Uses self.postMessage() with type: "WS_MESSAGE"
+ * - Inbound (main → worker): Listens to onmessage for type: "WS_MESSAGE"
+ */
+export default class WorkerMessagingProvider implements MessagingProvider {
+    private messageHandlers: MessageHandler[] = [];
+    private isDisposed = false;
+
+    constructor() {
+        // Listen for incoming messages from the main thread
+        self.addEventListener("message", this.handleIncomingMessage);
+    }
+
+    private handleIncomingMessage = (event: MessageEvent) => {
+        if (this.isDisposed) return;
+
+        const { type, message } = event.data || {};
+
+        if (type === "WS_MESSAGE" && message) {
+            // Dispatch to all registered handlers
+            for (const handler of this.messageHandlers) {
+                try {
+                    handler(message as WebSocketMessage);
+                } catch (e) {
+                    console.error("[WorkerMessagingProvider] Error in message handler:", e);
+                }
+            }
+        }
+    };
+
+    /**
+     * Send a message to all clients (in this case, the main thread).
+     * The main thread is responsible for further distribution if needed.
+     */
+    sendMessageToAllClients(message: WebSocketMessage): void {
+        if (this.isDisposed) {
+            console.warn("[WorkerMessagingProvider] Cannot send message - provider is disposed");
+            return;
+        }
+
+        try {
+            self.postMessage({
+                type: "WS_MESSAGE",
+                message
+            });
+        } catch (e) {
+            console.error("[WorkerMessagingProvider] Error sending message:", e);
+        }
+    }
+
+    /**
+     * Subscribe to incoming messages from the main thread.
+     */
+    onMessage(handler: MessageHandler): () => void {
+        this.messageHandlers.push(handler);
+
+        return () => {
+            this.messageHandlers = this.messageHandlers.filter(h => h !== handler);
+        };
+    }
+
+    /**
+     * Get the number of connected "clients".
+     * In worker context, there's always exactly 1 client (the main thread).
+     */
+    getClientCount(): number {
+        return this.isDisposed ? 0 : 1;
+    }
+
+    /**
+     * Clean up resources.
+     */
+    dispose(): void {
+        if (this.isDisposed) return;
+
+        this.isDisposed = true;
+        self.removeEventListener("message", this.handleIncomingMessage);
+        this.messageHandlers = [];
+    }
+}

apps/client-standalone/src/lightweight/sql_provider.ts

@@ -0,0 +1,618 @@
+import { type BindableValue, default as sqlite3InitModule } from "@sqlite.org/sqlite-wasm";
+import type { DatabaseProvider, RunResult, Statement, Transaction } from "@triliumnext/core";
+
+import demoDbSql from "./db.sql?raw";
+
+// Type definitions for SQLite WASM (the library doesn't export these directly)
+type Sqlite3Module = Awaited<ReturnType<typeof sqlite3InitModule>>;
+type Sqlite3Database = InstanceType<Sqlite3Module["oo1"]["DB"]>;
+type Sqlite3PreparedStatement = ReturnType<Sqlite3Database["prepare"]>;
+
+/**
+ * Wraps an SQLite WASM PreparedStatement to match the Statement interface
+ * expected by trilium-core.
+ */
+class WasmStatement implements Statement {
+    private isRawMode = false;
+    private isPluckMode = false;
+    private isFinalized = false;
+
+    constructor(
+        private stmt: Sqlite3PreparedStatement,
+        private db: Sqlite3Database,
+        private sqlite3: Sqlite3Module
+    ) {}
+
+    run(...params: unknown[]): RunResult {
+        if (this.isFinalized) {
+            throw new Error("Cannot call run() on finalized statement");
+        }
+
+        this.bindParams(params);
+        try {
+            // Use step() and then reset instead of stepFinalize()
+            // This allows the statement to be reused
+            this.stmt.step();
+            const changes = this.db.changes();
+            // Get the last insert row ID using the C API
+            const lastInsertRowid = this.db.pointer ? this.sqlite3.capi.sqlite3_last_insert_rowid(this.db.pointer) : 0;
+            this.stmt.reset();
+            return {
+                changes,
+                lastInsertRowid: typeof lastInsertRowid === "bigint" ? Number(lastInsertRowid) : lastInsertRowid
+            };
+        } catch (e) {
+            // Reset on error to allow reuse
+            this.stmt.reset();
+            throw e;
+        }
+    }
+
+    get(params: unknown): unknown {
+        if (this.isFinalized) {
+            throw new Error("Cannot call get() on finalized statement");
+        }
+
+        this.bindParams(Array.isArray(params) ? params : params !== undefined ? [params] : []);
+        try {
+            if (this.stmt.step()) {
+                if (this.isPluckMode) {
+                    // In pluck mode, return only the first column value
+                    const row = this.stmt.get([]);
+                    return Array.isArray(row) && row.length > 0 ? row[0] : undefined;
+                }
+                return this.isRawMode ? this.stmt.get([]) : this.stmt.get({});
+            }
+            return undefined;
+        } finally {
+            this.stmt.reset();
+        }
+    }
+
+    all(...params: unknown[]): unknown[] {
+        if (this.isFinalized) {
+            throw new Error("Cannot call all() on finalized statement");
+        }
+
+        this.bindParams(params);
+        const results: unknown[] = [];
+        try {
+            while (this.stmt.step()) {
+                if (this.isPluckMode) {
+                    // In pluck mode, return only the first column value for each row
+                    const row = this.stmt.get([]);
+                    if (Array.isArray(row) && row.length > 0) {
+                        results.push(row[0]);
+                    }
+                } else {
+                    results.push(this.isRawMode ? this.stmt.get([]) : this.stmt.get({}));
+                }
+            }
+            return results;
+        } finally {
+            this.stmt.reset();
+        }
+    }
+
+    iterate(...params: unknown[]): IterableIterator<unknown> {
+        if (this.isFinalized) {
+            throw new Error("Cannot call iterate() on finalized statement");
+        }
+
+        this.bindParams(params);
+        const stmt = this.stmt;
+        const isRaw = this.isRawMode;
+        const isPluck = this.isPluckMode;
+
+        return {
+            [Symbol.iterator]() {
+                return this;
+            },
+            next(): IteratorResult<unknown> {
+                if (stmt.step()) {
+                    if (isPluck) {
+                        const row = stmt.get([]);
+                        const value = Array.isArray(row) && row.length > 0 ? row[0] : undefined;
+                        return { value, done: false };
+                    }
+                    return { value: isRaw ? stmt.get([]) : stmt.get({}), done: false };
+                }
+                stmt.reset();
+                return { value: undefined, done: true };
+            }
+        };
+    }
+
+    raw(toggleState?: boolean): this {
+        // In raw mode, rows are returned as arrays instead of objects
+        // If toggleState is undefined, enable raw mode (better-sqlite3 behavior)
+        this.isRawMode = toggleState !== undefined ? toggleState : true;
+        return this;
+    }
+
+    pluck(toggleState?: boolean): this {
+        // In pluck mode, only the first column of each row is returned
+        // If toggleState is undefined, enable pluck mode (better-sqlite3 behavior)
+        this.isPluckMode = toggleState !== undefined ? toggleState : true;
+        return this;
+    }
+
+    private bindParams(params: unknown[]): void {
+        this.stmt.clearBindings();
+        if (params.length === 0) {
+            return;
+        }
+
+        // Handle single object with named parameters
+        if (params.length === 1 && typeof params[0] === "object" && params[0] !== null && !Array.isArray(params[0])) {
+            const inputBindings = params[0] as { [paramName: string]: BindableValue };
+
+            // SQLite WASM expects parameter names to include the prefix (@ : or $)
+            // better-sqlite3 automatically maps unprefixed names to @name
+            // We need to add the @ prefix for compatibility
+            const bindings: { [paramName: string]: BindableValue } = {};
+            for (const [key, value] of Object.entries(inputBindings)) {
+                // If the key already has a prefix, use it as-is
+                if (key.startsWith('@') || key.startsWith(':') || key.startsWith('$')) {
+                    bindings[key] = value;
+                } else {
+                    // Add @ prefix to match better-sqlite3 behavior
+                    bindings[`@${key}`] = value;
+                }
+            }
+
+            this.stmt.bind(bindings);
+        } else {
+            // Handle positional parameters - flatten and cast to BindableValue[]
+            const flatParams = params.flat() as BindableValue[];
+            if (flatParams.length > 0) {
+                this.stmt.bind(flatParams);
+            }
+        }
+    }
+
+    finalize(): void {
+        if (!this.isFinalized) {
+            try {
+                this.stmt.finalize();
+            } catch (e) {
+                console.warn("Error finalizing SQLite statement:", e);
+            } finally {
+                this.isFinalized = true;
+            }
+        }
+    }
+}
+
+/**
+ * SQLite database provider for browser environments using SQLite WASM.
+ *
+ * This provider wraps the official @sqlite.org/sqlite-wasm package to provide
+ * a DatabaseProvider implementation compatible with trilium-core.
+ *
+ * @example
+ * ```typescript
+ * const provider = new BrowserSqlProvider();
+ * await provider.initWasm(); // Initialize SQLite WASM module
+ * provider.loadFromMemory(); // Open an in-memory database
+ * // or
+ * provider.loadFromBuffer(existingDbBuffer); // Load from existing data
+ * ```
+ */
+export default class BrowserSqlProvider implements DatabaseProvider {
+    private db?: Sqlite3Database;
+    private sqlite3?: Sqlite3Module;
+    private _inTransaction = false;
+    private initPromise?: Promise<void>;
+    private initError?: Error;
+    private statementCache: Map<string, WasmStatement> = new Map();
+
+    // OPFS state tracking
+    private opfsDbPath?: string;
+
+    /**
+     * Get the SQLite WASM module version info.
+     * Returns undefined if the module hasn't been initialized yet.
+     */
+    get version(): { libVersion: string; sourceId: string } | undefined {
+        return this.sqlite3?.version;
+    }
+
+    /**
+     * Initialize the SQLite WASM module.
+     * This must be called before using any database operations.
+     * Safe to call multiple times - subsequent calls return the same promise.
+     *
+     * @returns A promise that resolves when the module is initialized
+     * @throws Error if initialization fails
+     */
+    async initWasm(): Promise<void> {
+        // Return existing promise if already initializing/initialized
+        if (this.initPromise) {
+            return this.initPromise;
+        }
+
+        // Fail fast if we already tried and failed
+        if (this.initError) {
+            throw this.initError;
+        }
+
+        this.initPromise = this.doInitWasm();
+        return this.initPromise;
+    }
+
+    private async doInitWasm(): Promise<void> {
+        try {
+            console.log("[BrowserSqlProvider] Initializing SQLite WASM...");
+            const startTime = performance.now();
+
+            this.sqlite3 = await sqlite3InitModule({
+                print: console.log,
+                printErr: console.error,
+            });
+
+            const initTime = performance.now() - startTime;
+            console.log(
+                `[BrowserSqlProvider] SQLite WASM initialized in ${initTime.toFixed(2)}ms:`,
+                this.sqlite3.version.libVersion
+            );
+        } catch (e) {
+            this.initError = e instanceof Error ? e : new Error(String(e));
+            console.error("[BrowserSqlProvider] SQLite WASM initialization failed:", this.initError);
+            throw this.initError;
+        }
+    }
+
+    /**
+     * Check if the SQLite WASM module has been initialized.
+     */
+    get isInitialized(): boolean {
+        return this.sqlite3 !== undefined;
+    }
+
+    // ==================== OPFS Support ====================
+
+    /**
+     * Check if the OPFS VFS is available.
+     * This requires:
+     * - Running in a Worker context
+     * - Browser support for OPFS APIs
+     * - COOP/COEP headers sent by the server (for SharedArrayBuffer)
+     *
+     * @returns true if OPFS VFS is available for use
+     */
+    isOpfsAvailable(): boolean {
+        this.ensureSqlite3();
+        // SQLite WASM automatically installs the OPFS VFS if the environment supports it
+        // We can check for its presence via sqlite3_vfs_find or the OpfsDb class
+        return this.sqlite3!.oo1.OpfsDb !== undefined;
+    }
+
+    /**
+     * Load or create a database stored in OPFS for persistent storage.
+     * The database will persist across browser sessions.
+     *
+     * Requires COOP/COEP headers to be set by the server:
+     * - Cross-Origin-Opener-Policy: same-origin
+     * - Cross-Origin-Embedder-Policy: require-corp
+     *
+     * @param path - The path for the database file in OPFS (e.g., "/trilium.db")
+     *               Paths without a leading slash are treated as relative to OPFS root.
+     *               Leading directories are created automatically.
+     * @param options - Additional options
+     * @throws Error if OPFS VFS is not available
+     *
+     * @example
+     * ```typescript
+     * const provider = new BrowserSqlProvider();
+     * await provider.initWasm();
+     * if (provider.isOpfsAvailable()) {
+     *     provider.loadFromOpfs("/my-database.db");
+     * } else {
+     *     console.warn("OPFS not available, using in-memory database");
+     *     provider.loadFromMemory();
+     * }
+     * ```
+     */
+    loadFromOpfs(path: string, options: { createIfNotExists?: boolean } = {}): void {
+        this.ensureSqlite3();
+
+        if (!this.isOpfsAvailable()) {
+            throw new Error(
+                "OPFS VFS is not available. This requires:\n" +
+                "1. Running in a Worker context\n" +
+                "2. Browser support for OPFS (Chrome 102+, Firefox 111+, Safari 17+)\n" +
+                "3. COOP/COEP headers from the server:\n" +
+                "   Cross-Origin-Opener-Policy: same-origin\n" +
+                "   Cross-Origin-Embedder-Policy: require-corp"
+            );
+        }
+
+        console.log(`[BrowserSqlProvider] Loading database from OPFS: ${path}`);
+        const startTime = performance.now();
+
+        try {
+            // OpfsDb automatically creates directories in the path
+            // Mode 'c' = create if not exists
+            const mode = options.createIfNotExists !== false ? 'c' : '';
+            this.db = new this.sqlite3!.oo1.OpfsDb(path, mode);
+            this.opfsDbPath = path;
+
+            // Configure the database for OPFS
+            // Note: WAL mode requires exclusive locking in OPFS environment
+            this.db.exec("PRAGMA journal_mode = DELETE");
+            this.db.exec("PRAGMA synchronous = NORMAL");
+
+            const loadTime = performance.now() - startTime;
+            console.log(`[BrowserSqlProvider] OPFS database loaded in ${loadTime.toFixed(2)}ms`);
+        } catch (e) {
+            const error = e instanceof Error ? e : new Error(String(e));
+            console.error(`[BrowserSqlProvider] Failed to load OPFS database: ${error.message}`);
+            throw error;
+        }
+    }
+
+    /**
+     * Check if the currently open database is stored in OPFS.
+     */
+    get isUsingOpfs(): boolean {
+        return this.opfsDbPath !== undefined;
+    }
+
+    /**
+     * Get the OPFS path of the currently open database.
+     * Returns undefined if not using OPFS.
+     */
+    get currentOpfsPath(): string | undefined {
+        return this.opfsDbPath;
+    }
+
+    /**
+     * Check if the database has been initialized with a schema.
+     * This is a simple sanity check that looks for the existence of core tables.
+     *
+     * @returns true if the database appears to be initialized
+     */
+    isDbInitialized(): boolean {
+        this.ensureDb();
+
+        // Check if the 'notes' table exists (a core table that must exist in an initialized DB)
+        const tableExists = this.db!.selectValue(
+            "SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'notes'"
+        );
+
+        return tableExists !== undefined;
+    }
+
+    // ==================== End OPFS Support ====================
+
+    loadFromFile(_path: string, _isReadOnly: boolean): void {
+        // Browser environment doesn't have direct file system access.
+        // Use OPFS for persistent storage.
+        throw new Error(
+            "loadFromFile is not supported in browser environment. " +
+            "Use loadFromMemory() for temporary databases, loadFromBuffer() to load from data, " +
+            "or loadFromOpfs() for persistent storage."
+        );
+    }
+
+    /**
+     * Create an empty in-memory database.
+     * Data will be lost when the page is closed.
+     *
+     * For persistent storage, use loadFromOpfs() instead.
+     * To load demo data, call initializeDemoDatabase() after this.
+     */
+    loadFromMemory(): void {
+        this.ensureSqlite3();
+        console.log("[BrowserSqlProvider] Creating in-memory database...");
+        const startTime = performance.now();
+
+        this.db = new this.sqlite3!.oo1.DB(":memory:", "c");
+        this.opfsDbPath = undefined; // Not using OPFS
+        this.db.exec("PRAGMA journal_mode = WAL");
+
+        // Initialize with demo data for in-memory databases
+        // (since they won't persist anyway)
+        this.initializeDemoDatabase();
+
+        const loadTime = performance.now() - startTime;
+        console.log(`[BrowserSqlProvider] In-memory database created in ${loadTime.toFixed(2)}ms`);
+    }
+
+    /**
+     * Initialize the database with demo/starter data.
+     * This should only be called once when creating a new database.
+     *
+     * For OPFS databases, this is called automatically only if the database
+     * doesn't already exist.
+     */
+    initializeDemoDatabase(): void {
+        this.ensureDb();
+        console.log("[BrowserSqlProvider] Initializing database with demo data...");
+        const startTime = performance.now();
+
+        this.db!.exec(demoDbSql);
+
+        const loadTime = performance.now() - startTime;
+        console.log(`[BrowserSqlProvider] Demo data loaded in ${loadTime.toFixed(2)}ms`);
+    }
+
+    loadFromBuffer(buffer: Uint8Array): void {
+        this.ensureSqlite3();
+        // SQLite WASM can deserialize a database from a byte array
+        const p = this.sqlite3!.wasm.allocFromTypedArray(buffer);
+        try {
+            this.db = new this.sqlite3!.oo1.DB({ filename: ":memory:", flags: "c" });
+            this.opfsDbPath = undefined; // Not using OPFS
+
+            const rc = this.sqlite3!.capi.sqlite3_deserialize(
+                this.db.pointer!,
+                "main",
+                p,
+                buffer.byteLength,
+                buffer.byteLength,
+                this.sqlite3!.capi.SQLITE_DESERIALIZE_FREEONCLOSE |
+                this.sqlite3!.capi.SQLITE_DESERIALIZE_RESIZEABLE
+            );
+            if (rc !== 0) {
+                throw new Error(`Failed to deserialize database: ${rc}`);
+            }
+        } catch (e) {
+            this.sqlite3!.wasm.dealloc(p);
+            throw e;
+        }
+    }
+
+    backup(_destinationFile: string): void {
+        // In browser, we can serialize the database to a byte array
+        // For actual file backup, we'd need to use File System Access API or download
+        throw new Error(
+            "backup to file is not supported in browser environment. " +
+            "Use serialize() to get the database as a Uint8Array instead."
+        );
+    }
+
+    /**
+     * Serialize the database to a byte array.
+     * This can be used to save the database to IndexedDB, download it, etc.
+     */
+    serialize(): Uint8Array {
+        this.ensureDb();
+        // Use the convenience wrapper which handles all the memory management
+        return this.sqlite3!.capi.sqlite3_js_db_export(this.db!);
+    }
+
+    prepare(query: string): Statement {
+        this.ensureDb();
+
+        // Check if we already have this statement cached
+        if (this.statementCache.has(query)) {
+            return this.statementCache.get(query)!;
+        }
+
+        // Create new statement and cache it
+        const stmt = this.db!.prepare(query);
+        const wasmStatement = new WasmStatement(stmt, this.db!, this.sqlite3!);
+        this.statementCache.set(query, wasmStatement);
+        return wasmStatement;
+    }
+
+    transaction<T>(func: (statement: Statement) => T): Transaction {
+        this.ensureDb();
+
+        const self = this;
+        let savepointCounter = 0;
+
+        // Helper function to execute within a transaction
+        const executeTransaction = (beginStatement: string, ...args: unknown[]): T => {
+            // If we're already in a transaction, use SAVEPOINTs for nesting
+            // This mimics better-sqlite3's behavior
+            if (self._inTransaction) {
+                const savepointName = `sp_${++savepointCounter}_${Date.now()}`;
+                self.db!.exec(`SAVEPOINT ${savepointName}`);
+                try {
+                    const result = func.apply(null, args as [Statement]);
+                    self.db!.exec(`RELEASE SAVEPOINT ${savepointName}`);
+                    return result;
+                } catch (e) {
+                    self.db!.exec(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+                    throw e;
+                }
+            }
+
+            // Not in a transaction, start a new one
+            self._inTransaction = true;
+            self.db!.exec(beginStatement);
+            try {
+                const result = func.apply(null, args as [Statement]);
+                self.db!.exec("COMMIT");
+                return result;
+            } catch (e) {
+                self.db!.exec("ROLLBACK");
+                throw e;
+            } finally {
+                self._inTransaction = false;
+            }
+        };
+
+        // Create the transaction function that acts like better-sqlite3's Transaction interface
+        // In better-sqlite3, the transaction function is callable and has .deferred(), .immediate(), etc.
+        const transactionWrapper = Object.assign(
+            // Default call executes with BEGIN (same as immediate)
+            (...args: unknown[]): T => executeTransaction("BEGIN", ...args),
+            {
+                // Deferred transaction - locks acquired on first data access
+                deferred: (...args: unknown[]): T => executeTransaction("BEGIN DEFERRED", ...args),
+                // Immediate transaction - acquires write lock immediately
+                immediate: (...args: unknown[]): T => executeTransaction("BEGIN IMMEDIATE", ...args),
+                // Exclusive transaction - exclusive lock
+                exclusive: (...args: unknown[]): T => executeTransaction("BEGIN EXCLUSIVE", ...args),
+                // Default is same as calling directly
+                default: (...args: unknown[]): T => executeTransaction("BEGIN", ...args)
+            }
+        );
+
+        return transactionWrapper as unknown as Transaction;
+    }
+
+    get inTransaction(): boolean {
+        return this._inTransaction;
+    }
+
+    exec(query: string): void {
+        this.ensureDb();
+        this.db!.exec(query);
+    }
+
+    close(): void {
+        // Clean up all cached statements first
+        for (const statement of this.statementCache.values()) {
+            try {
+                statement.finalize();
+            } catch (e) {
+                // Ignore errors during cleanup
+                console.warn("Error finalizing statement during cleanup:", e);
+            }
+        }
+        this.statementCache.clear();
+
+        if (this.db) {
+            this.db.close();
+            this.db = undefined;
+        }
+
+        // Reset OPFS state
+        this.opfsDbPath = undefined;
+    }
+
+    /**
+     * Get the number of rows changed by the last INSERT, UPDATE, or DELETE statement.
+     */
+    changes(): number {
+        this.ensureDb();
+        return this.db!.changes();
+    }
+
+    /**
+     * Check if the database is currently open.
+     */
+    isOpen(): boolean {
+        return this.db !== undefined && this.db.isOpen();
+    }
+
+    private ensureSqlite3(): void {
+        if (!this.sqlite3) {
+            throw new Error(
+                "SQLite WASM module not initialized. Call initialize() first with the sqlite3 module."
+            );
+        }
+    }
+
+    private ensureDb(): void {
+        this.ensureSqlite3();
+        if (!this.db) {
+            throw new Error("Database not opened. Call loadFromMemory(), loadFromBuffer(), or loadFromOpfs() first.");
+        }
+    }
+}

apps/client-standalone/src/lightweight/translation_provider.ts

@@ -0,0 +1,16 @@
+import { LOCALE_IDS } from "@triliumnext/commons";
+import i18next from "i18next";
+import I18NextHttpBackend from "i18next-http-backend";
+
+export default async function translationProvider(locale: LOCALE_IDS) {
+    await i18next.use(I18NextHttpBackend).init({
+        lng: locale,
+        fallbackLng: "en",
+        ns: "server",
+        backend: {
+            loadPath: "server-assets/translations/{{lng}}/{{ns}}.json"
+        },
+        returnEmptyString: false,
+        debug: true
+    });
+}

apps/client-standalone/src/local-bridge.ts

@@ -0,0 +1,88 @@
+let localWorker: Worker | null = null;
+const pending = new Map();
+
+export function startLocalServerWorker() {
+    if (localWorker) return localWorker;
+
+    localWorker = new Worker(new URL("./local-server-worker.js", import.meta.url), { type: "module" });
+
+    // Handle worker errors during initialization
+    localWorker.onerror = (event) => {
+        console.error("[LocalBridge] Worker error:", event);
+        // Reject all pending requests
+        for (const [, resolver] of pending) {
+            resolver.reject(new Error(`Worker error: ${event.message}`));
+        }
+        pending.clear();
+    };
+
+    localWorker.onmessage = (event) => {
+        const msg = event.data;
+
+        // Handle worker error reports
+        if (msg?.type === "WORKER_ERROR") {
+            console.error("[LocalBridge] Worker reported error:", msg.error);
+            // Reject all pending requests with the error
+            for (const [, resolver] of pending) {
+                resolver.reject(new Error(msg.error?.message || "Unknown worker error"));
+            }
+            pending.clear();
+            return;
+        }
+
+        if (!msg || msg.type !== "LOCAL_RESPONSE") return;
+
+        const { id, response, error } = msg;
+        const resolver = pending.get(id);
+        if (!resolver) return;
+        pending.delete(id);
+
+        if (error) resolver.reject(new Error(error));
+        else resolver.resolve(response);
+    };
+
+    return localWorker;
+}
+
+export function attachServiceWorkerBridge() {
+    navigator.serviceWorker.addEventListener("message", async (event) => {
+        const msg = event.data;
+        if (!msg || msg.type !== "LOCAL_FETCH") return;
+
+        const port = event.ports && event.ports[0];
+        if (!port) return;
+
+        try {
+            startLocalServerWorker();
+
+            const id = msg.id;
+            const req = msg.request;
+
+            const response = await new Promise((resolve, reject) => {
+                pending.set(id, { resolve, reject });
+                // Transfer body to worker for efficiency (if present)
+                localWorker.postMessage({
+                    type: "LOCAL_REQUEST",
+                    id,
+                    request: req
+                }, req.body ? [req.body] : []);
+            });
+
+            port.postMessage({
+                type: "LOCAL_FETCH_RESPONSE",
+                id,
+                response
+            }, response.body ? [response.body] : []);
+        } catch (e) {
+            port.postMessage({
+                type: "LOCAL_FETCH_RESPONSE",
+                id: msg.id,
+                response: {
+                    status: 500,
+                    headers: { "content-type": "text/plain; charset=utf-8" },
+                    body: new TextEncoder().encode(String(e?.message || e)).buffer
+                }
+            });
+        }
+    });
+}

apps/client-standalone/src/local-server-worker.ts

@@ -0,0 +1,207 @@
+import { BrowserRouter } from './lightweight/browser_router';
+import { createConfiguredRouter } from './lightweight/browser_routes';
+import BrowserExecutionContext from './lightweight/cls_provider';
+import BrowserCryptoProvider from './lightweight/crypto_provider';
+import WorkerMessagingProvider from './lightweight/messaging_provider';
+import BrowserSqlProvider from './lightweight/sql_provider';
+import translationProvider from './lightweight/translation_provider';
+
+// Global error handlers - MUST be set up before any async imports
+self.onerror = (message, source, lineno, colno, error) => {
+    console.error("[Worker] Uncaught error:", message, source, lineno, colno, error);
+    // Try to notify the main thread about the error
+    try {
+        self.postMessage({
+            type: "WORKER_ERROR",
+            error: {
+                message: String(message),
+                source,
+                lineno,
+                colno,
+                stack: error?.stack
+            }
+        });
+    } catch (e) {
+        // Can't even post message, just log
+        console.error("[Worker] Failed to report error:", e);
+    }
+    return false; // Don't suppress the error
+};
+
+self.onunhandledrejection = (event) => {
+    console.error("[Worker] Unhandled rejection:", event.reason);
+    try {
+        self.postMessage({
+            type: "WORKER_ERROR",
+            error: {
+                message: String(event.reason?.message || event.reason),
+                stack: event.reason?.stack
+            }
+        });
+    } catch (e) {
+        console.error("[Worker] Failed to report rejection:", e);
+    }
+};
+
+console.log("[Worker] Error handlers installed");
+
+// Shared SQL provider instance
+const sqlProvider = new BrowserSqlProvider();
+
+// Messaging provider for worker-to-main-thread communication
+const messagingProvider = new WorkerMessagingProvider();
+
+// Core module, router, and initialization state
+let coreModule: typeof import("@triliumnext/core") | null = null;
+let router: BrowserRouter | null = null;
+let initPromise: Promise<void> | null = null;
+let initError: Error | null = null;
+
+/**
+ * Initialize SQLite WASM and load the core module.
+ * This happens once at worker startup.
+ */
+async function initialize(): Promise<void> {
+    if (initPromise) {
+        return initPromise; // Already initializing
+    }
+    if (initError) {
+        throw initError; // Failed before, don't retry
+    }
+
+    initPromise = (async () => {
+        try {
+            console.log("[Worker] Initializing SQLite WASM...");
+            await sqlProvider.initWasm();
+
+            // Try to use OPFS for persistent storage
+            if (sqlProvider.isOpfsAvailable()) {
+                console.log("[Worker] OPFS available, loading persistent database...");
+                sqlProvider.loadFromOpfs("/trilium.db");
+
+                // Check if database is initialized (schema exists)
+                if (!sqlProvider.isDbInitialized()) {
+                    console.log("[Worker] Database not initialized, loading demo data...");
+                    sqlProvider.initializeDemoDatabase();
+                    console.log("[Worker] Demo data loaded");
+                } else {
+                    console.log("[Worker] Existing initialized database loaded");
+                }
+            } else {
+                // Fall back to in-memory database (non-persistent)
+                console.warn("[Worker] OPFS not available, using in-memory database (data will not persist)");
+                console.warn("[Worker] To enable persistence, ensure COOP/COEP headers are set by the server");
+                sqlProvider.loadFromMemory();
+            }
+
+            console.log("[Worker] Database loaded");
+
+            console.log("[Worker] Loading @triliumnext/core...");
+            coreModule = await import("@triliumnext/core");
+            coreModule.initializeCore({
+                executionContext: new BrowserExecutionContext(),
+                crypto: new BrowserCryptoProvider(),
+                messaging: messagingProvider,
+                translations: translationProvider,
+                dbConfig: {
+                    provider: sqlProvider,
+                    isReadOnly: false,
+                    onTransactionCommit: () => {
+                        // No-op for now
+                    },
+                    onTransactionRollback: () => {
+                        // No-op for now
+                    }
+                }
+            });
+
+            console.log("[Worker] Supported routes", Object.keys(coreModule.routes));
+
+            // Create and configure the router
+            router = createConfiguredRouter();
+            console.log("[Worker] Router configured");
+
+            console.log("[Worker] Initializing becca...");
+            await coreModule.becca_loader.beccaLoaded;
+
+            console.log("[Worker] Initialization complete");
+        } catch (error) {
+            initError = error instanceof Error ? error : new Error(String(error));
+            console.error("[Worker] Initialization failed:", initError);
+            throw initError;
+        }
+    })();
+
+    return initPromise;
+}
+
+/**
+ * Ensure the worker is initialized before processing requests.
+ * Returns the router if initialization was successful.
+ */
+async function ensureInitialized() {
+    await initialize();
+    if (!router) {
+        throw new Error("Router not initialized");
+    }
+    return router;
+}
+
+interface LocalRequest {
+    method: string;
+    url: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+
+// Main dispatch
+async function dispatch(request: LocalRequest) {
+    const url = new URL(request.url);
+
+    console.log("[Worker] Dispatch:", url.pathname);
+
+    // Ensure initialization is complete and get the router
+    const appRouter = await ensureInitialized();
+
+    // Dispatch to the router
+    return appRouter.dispatch(request.method, request.url, request.body, request.headers);
+}
+
+// Start initialization immediately when the worker loads
+console.log("[Worker] Starting initialization...");
+initialize().catch(err => {
+    console.error("[Worker] Initialization failed:", err);
+    // Post error to main thread
+    self.postMessage({
+        type: "WORKER_ERROR",
+        error: {
+            message: String(err?.message || err),
+            stack: err?.stack
+        }
+    });
+});
+
+self.onmessage = async (event) => {
+    const msg = event.data;
+    if (!msg || msg.type !== "LOCAL_REQUEST") return;
+
+    const { id, request } = msg;
+
+    try {
+        const response = await dispatch(request);
+
+        // Transfer body back (if any) - use options object for proper typing
+        (self as unknown as Worker).postMessage({
+            type: "LOCAL_RESPONSE",
+            id,
+            response
+        }, { transfer: response.body ? [response.body] : [] });
+    } catch (e) {
+        console.error("[Worker] Dispatch error:", e);
+        (self as unknown as Worker).postMessage({
+            type: "LOCAL_RESPONSE",
+            id,
+            error: String((e as Error)?.message || e)
+        });
+    }
+};

apps/client-standalone/src/main.ts

@@ -0,0 +1,84 @@
+import { attachServiceWorkerBridge, startLocalServerWorker } from "./local-bridge.js";
+
+async function waitForServiceWorkerControl(): Promise<void> {
+    if (!("serviceWorker" in navigator)) {
+        throw new Error("Service Worker not supported in this browser");
+    }
+
+    // If already controlling, we're good
+    if (navigator.serviceWorker.controller) {
+        console.log("[Bootstrap] Service worker already controlling");
+        return;
+    }
+
+    console.log("[Bootstrap] Waiting for service worker to take control...");
+
+    // Register service worker
+    await navigator.serviceWorker.register("./sw.js", { scope: "/" });
+
+    // Wait for it to be ready (installed + activated)
+    await navigator.serviceWorker.ready;
+
+    // Check if we're now controlling
+    if (navigator.serviceWorker.controller) {
+        console.log("[Bootstrap] Service worker now controlling");
+        return;
+    }
+
+    // If not controlling yet, we need to reload the page for SW to take control
+    // This is standard PWA behavior on first install
+    console.log("[Bootstrap] Service worker installed but not controlling yet - reloading page");
+
+    // Wait a tiny bit for SW to fully activate
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    // Reload to let SW take control
+    window.location.reload();
+
+    // Throw to stop execution (page will reload)
+    throw new Error("Reloading for service worker activation");
+}
+
+async function bootstrap() {
+    /* fixes https://github.com/webpack/webpack/issues/10035 */
+    window.global = globalThis;
+
+    try {
+        // 1) Start local worker ASAP (so /bootstrap is fast)
+        startLocalServerWorker();
+
+        // 2) Bridge SW -> local worker
+        attachServiceWorkerBridge();
+
+        // 3) Wait for service worker to control the page (may reload on first install)
+        await waitForServiceWorkerControl();
+
+        await loadScripts();
+    } catch (err) {
+        // If error is from reload, it will stop here (page reloads)
+        // Otherwise, show error to user
+        if (err instanceof Error && err.message.includes("Reloading")) {
+            // Page is reloading, do nothing
+            return;
+        }
+
+        console.error("[Bootstrap] Fatal error:", err);
+        document.body.innerHTML = `
+            <div style="padding: 40px; max-width: 600px; margin: 0 auto; font-family: system-ui, sans-serif;">
+                <h1 style="color: #d32f2f;">Failed to Initialize</h1>
+                <p>The application failed to start. Please check the browser console for details.</p>
+                <pre style="background: #f5f5f5; padding: 16px; border-radius: 4px; overflow: auto;">${err instanceof Error ? err.message : String(err)}</pre>
+                <button onclick="location.reload()" style="padding: 12px 24px; background: #1976d2; color: white; border: none; border-radius: 4px; cursor: pointer; font-size: 16px;">
+                    Reload Page
+                </button>
+            </div>
+        `;
+        document.body.style.display = "block";
+    }
+}
+
+async function loadScripts() {
+    await import("../../client/src/index.js");
+}
+
+bootstrap();

apps/client-standalone/src/sw.ts

@@ -0,0 +1,185 @@
+// public/sw.js
+const VERSION = "localserver-v1.4";
+const STATIC_CACHE = `static-${VERSION}`;
+
+// Check if running in dev mode (passed via URL parameter)
+const isDev = true;
+
+if (isDev) {
+    console.log('[Service Worker] Running in DEV mode - caching disabled');
+}
+
+// Adjust these to your routes:
+const LOCAL_FIRST_PREFIXES = [
+    "/bootstrap",
+    "/api/",
+    "/sync/",
+    "/search/"
+];
+
+// Optional: basic precache list (keep small; you can expand later)
+const PRECACHE_URLS = [
+    // "/",
+    // "/index.html",
+    // "/manifest.webmanifest",
+    // "/favicon.ico",
+];
+
+self.addEventListener("install", (event) => {
+    event.waitUntil((async () => {
+        // Skip precaching in dev mode
+        if (!isDev) {
+            const cache = await caches.open(STATIC_CACHE);
+            await cache.addAll(PRECACHE_URLS);
+        }
+        self.skipWaiting();
+    })());
+});
+
+self.addEventListener("activate", (event) => {
+    event.waitUntil((async () => {
+    // Cleanup old caches
+        const keys = await caches.keys();
+        await Promise.all(keys.map((k) => (k === STATIC_CACHE ? Promise.resolve() : caches.delete(k))));
+        await self.clients.claim();
+    })());
+});
+
+function isLocalFirst(url) {
+    return LOCAL_FIRST_PREFIXES.some((p) => url.pathname.startsWith(p));
+}
+
+async function cacheFirst(request) {
+    // In dev mode, always bypass cache
+    if (isDev) {
+        return fetch(request);
+    }
+
+    const cache = await caches.open(STATIC_CACHE);
+    const cached = await cache.match(request);
+    if (cached) return cached;
+
+    const fresh = await fetch(request);
+    // Cache only successful GETs
+    if (request.method === "GET" && fresh.ok) cache.put(request, fresh.clone());
+    return fresh;
+}
+
+async function networkFirst(request) {
+    // In dev mode, always bypass cache
+    if (isDev) {
+        return fetch(request);
+    }
+
+    const cache = await caches.open(STATIC_CACHE);
+    try {
+        const fresh = await fetch(request);
+        // Cache only successful GETs
+        if (request.method === "GET" && fresh.ok) cache.put(request, fresh.clone());
+        return fresh;
+    } catch (error) {
+        // Fallback to cache if network fails
+        const cached = await cache.match(request);
+        if (cached) return cached;
+        throw error;
+    }
+}
+
+async function forwardToClientLocalServer(request, clientId) {
+    // Find a client to handle the request (prefer the initiating client if available)
+    let client = clientId ? await self.clients.get(clientId) : null;
+
+    if (!client) {
+        const all = await self.clients.matchAll({ type: "window", includeUncontrolled: true });
+        client = all[0] || null;
+    }
+
+    // If no page is available, fall back to network
+    if (!client) return fetch(request);
+
+    const reqUrl = request.url;
+    const headersObj = {};
+    for (const [k, v] of request.headers.entries()) headersObj[k] = v;
+
+    const body = (request.method === "GET" || request.method === "HEAD")
+        ? null
+        : await request.arrayBuffer();
+
+    const id = crypto.randomUUID();
+    const channel = new MessageChannel();
+
+    const responsePromise = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error("Local server timeout"));
+        }, 30_000);
+
+        channel.port1.onmessage = (event) => {
+            clearTimeout(timeout);
+            resolve(event.data);
+        };
+        channel.port1.onmessageerror = () => {
+            clearTimeout(timeout);
+            reject(new Error("Local server message error"));
+        };
+    });
+
+    // Send to the client with a reply port
+    client.postMessage({
+        type: "LOCAL_FETCH",
+        id,
+        request: {
+            url: reqUrl,
+            method: request.method,
+            headers: headersObj,
+            body // ArrayBuffer or null
+        }
+    }, [channel.port2]);
+
+    const localResp = await responsePromise;
+
+    if (!localResp || localResp.type !== "LOCAL_FETCH_RESPONSE" || localResp.id !== id) {
+    // Protocol mismatch; fall back
+        return fetch(request);
+    }
+
+    // localResp.response: { status, headers, body }
+    const { status, headers, body: respBody } = localResp.response;
+
+    const respHeaders = new Headers();
+    if (headers) {
+        for (const [k, v] of Object.entries(headers)) respHeaders.set(k, String(v));
+    }
+
+    return new Response(respBody ? respBody : null, {
+        status: status || 200,
+        headers: respHeaders
+    });
+}
+
+self.addEventListener("fetch", (event) => {
+    const url = new URL(event.request.url);
+
+    // Only handle same-origin
+    if (url.origin !== self.location.origin) return;
+
+    // HTML files: network-first to ensure updates are reflected immediately
+    if (event.request.mode === "navigate" || url.pathname.endsWith(".html")) {
+        event.respondWith(networkFirst(event.request));
+        return;
+    }
+
+    // Static assets: cache-first for performance
+    if (event.request.method === "GET" && !isLocalFirst(url)) {
+        event.respondWith(cacheFirst(event.request));
+        return;
+    }
+
+    // API-ish: local-first via bridge
+    if (isLocalFirst(url)) {
+        event.respondWith(forwardToClientLocalServer(event.request, event.clientId));
+        return;
+    }
+
+    // Default
+    event.respondWith(fetch(event.request));
+});

apps/client-standalone/src/vite-env.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_APP_TITLE: string
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}
+
+interface Window {
+  glob: {
+    assetPath: string;
+    themeCssUrl?: string;
+    themeUseNextAsBase?: string;
+    iconPackCss: string;
+    device: string;
+    headingStyle: string;
+    layoutOrientation: string;
+    platform: string;
+    isElectron: boolean;
+    hasNativeTitleBar: boolean;
+    hasBackgroundEffects: boolean;
+    currentLocale: {
+      id: string;
+      rtl: boolean;
+    };
+    activeDialog: any;
+  };
+  global: typeof globalThis;
+}

apps/client-standalone/tsconfig.app.json

@@ -0,0 +1,26 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": [
+      "ES2022",
+      "dom",
+      "dom.iterable"
+    ],
+    "skipLibCheck": true,
+    "types": [
+      "vite/client"
+    ],
+    "jsx": "react-jsx",
+    "jsxImportSource": "preact"
+  },
+  "include": [
+    "src/**/*",
+    "../client/src/**/*"
+  ],
+  "exclude": [
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts",
+    "../client/src/**/*.spec.ts",
+    "../client/src/**/*.test.ts"
+  ]
+}

apps/client-standalone/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.spec.json" }
+  ]
+}

apps/client-standalone/tsconfig.spec.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": [
+      "ES2022",
+      "dom",
+      "dom.iterable"
+    ],
+    "types": [
+      "vitest/globals",
+      "happy-dom"
+    ]
+  },
+  "include": [
+    "src/**/*.spec.ts",
+    "src/**/*.test.ts"
+  ]
+}

apps/client-standalone/vite.config.mts

@@ -0,0 +1,189 @@
+import prefresh from '@prefresh/vite';
+import { join } from 'path';
+import { defineConfig } from 'vite';
+import { viteStaticCopy } from 'vite-plugin-static-copy';
+
+const clientAssets = ["assets", "stylesheets", "fonts", "translations"];
+
+const isDev = process.env.NODE_ENV === "development";
+
+// Watch client files and trigger reload in development
+const clientWatchPlugin = () => ({
+    name: 'client-watch',
+    configureServer(server: any) {
+        if (isDev) {
+            // Watch client source files (adjusted for new root)
+            server.watcher.add('../../client/src/**/*');
+            server.watcher.on('change', (file: string) => {
+                if (file.includes('../../client/src/')) {
+                    server.ws.send({
+                        type: 'full-reload'
+                    });
+                }
+            });
+        }
+    }
+});
+
+// Always copy SQLite WASM files so they're available to the module
+const sqliteWasmPlugin = viteStaticCopy({
+    targets: [
+        {
+            src: "../../../node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3.wasm",
+            dest: "assets"
+        },
+        {
+            src: "../../../node_modules/@sqlite.org/sqlite-wasm/sqlite-wasm/jswasm/sqlite3-opfs-async-proxy.js",
+            dest: "assets"
+        }
+    ]
+});
+
+let plugins: any = [
+    sqliteWasmPlugin,  // Always include SQLite WASM files
+    viteStaticCopy({
+        targets: clientAssets.map((asset) => ({
+            src: `../../client/src/${asset}/*`,
+            dest: asset
+        })),
+        // Enable watching in development
+        ...(isDev && {
+            watch: {
+                reloadPageOnChange: true
+            }
+        })
+    }),
+    viteStaticCopy({
+        targets: [
+            {
+                src: "../../server/src/assets/*",
+                dest: "server-assets"
+            }
+        ]
+    }),
+    // Watch client files for changes in development
+    ...(isDev ? [
+        prefresh(),
+        clientWatchPlugin()
+    ] : [])
+];
+
+if (!isDev) {
+    plugins = [
+        ...plugins,
+        viteStaticCopy({
+            structured: true,
+            targets: [
+                {
+                    src: "../../../node_modules/@excalidraw/excalidraw/dist/prod/fonts/*",
+                    dest: "",
+                }
+            ]
+        })
+    ]
+}
+
+export default defineConfig(() => ({
+    root: join(__dirname, 'src'),  // Set src as root so index.html is served from /
+    envDir: __dirname,  // Load .env files from client-standalone directory, not src/
+    cacheDir: '../../../node_modules/.vite/apps/client-standalone',
+    base: "",
+    plugins,
+    esbuild: {
+        jsx: 'automatic',
+        jsxImportSource: 'preact',
+        jsxDev: isDev
+    },
+    css: {
+        transformer: 'lightningcss',
+        devSourcemap: isDev
+    },
+    publicDir: join(__dirname, 'public'),
+    resolve: {
+        alias: [
+            {
+                find: "react",
+                replacement: "preact/compat"
+            },
+            {
+                find: "react-dom",
+                replacement: "preact/compat"
+            },
+            {
+                find: "@client",
+                replacement: join(__dirname, "../client/src")
+            }
+        ],
+        dedupe: [
+            "react",
+            "react-dom",
+            "preact",
+            "preact/compat",
+            "preact/hooks"
+        ]
+    },
+    server: {
+        watch: {
+            // Watch workspace packages
+            ignored: ['!**/node_modules/@triliumnext/**'],
+            // Also watch client assets for live reload
+            usePolling: false,
+            interval: 100,
+            binaryInterval: 300
+        },
+        // Watch additional directories for changes
+        fs: {
+            allow: [
+                // Allow access to workspace root
+                '../../../',
+                // Explicitly allow client directory
+                '../../client/src/'
+            ]
+        },
+        headers: {
+            // Required for SharedArrayBuffer which is needed by SQLite WASM OPFS VFS
+            // See: https://sqlite.org/wasm/doc/trunk/persistence.md#coop-coep
+            "Cross-Origin-Opener-Policy": "same-origin",
+            "Cross-Origin-Embedder-Policy": "require-corp"
+        }
+    },
+    optimizeDeps: {
+        exclude: ['@sqlite.org/sqlite-wasm', '@triliumnext/core']
+    },
+    worker: {
+        format: "es" as const
+    },
+    commonjsOptions: {
+        transformMixedEsModules: true,
+    },
+    build: {
+        target: "esnext",
+        outDir: join(__dirname, 'dist'),
+        emptyOutDir: true,
+        rollupOptions: {
+            input: {
+                main: join(__dirname, 'src', 'index.html'),
+                sw: join(__dirname, 'src', 'sw.ts'),
+                'local-bridge': join(__dirname, 'src', 'local-bridge.ts'),
+                'local-server-worker': join(__dirname, 'src', 'local-server-worker.ts')
+            },
+            output: {
+                entryFileNames: (chunkInfo) => {
+                    // Service worker and other workers should be at root level
+                    if (chunkInfo.name === 'sw' || chunkInfo.name === 'local-server-worker') {
+                        return '[name].js';
+                    }
+                    return 'src/[name].js';
+                },
+                chunkFileNames: "src/[name].js",
+                assetFileNames: "src/[name].[ext]"
+            }
+        }
+    },
+    test: {
+        environment: "happy-dom"
+    },
+    define: {
+        "process.env.IS_PREACT": JSON.stringify("true"),
+    }
+}));

apps/client/package.json

@@ -44,7 +44,7 @@
     "draggabilly": "3.0.0",
     "force-graph": "1.51.0",
     "globals": "17.0.0",
-    "i18next": "25.7.4",
+    "i18next": "25.7.3",
     "i18next-http-backend": "3.0.2",
     "jquery": "3.7.1",
     "jquery.fancytree": "2.38.5",
@@ -60,7 +60,7 @@
     "normalize.css": "8.0.1",
     "panzoom": "9.4.3",
     "preact": "10.28.2",
-    "react-i18next": "16.5.3",
+    "react-i18next": "16.5.1",
     "react-window": "2.2.5",
     "reveal.js": "5.2.1",
     "svg-pan-zoom": "3.6.2",
@@ -78,7 +78,7 @@
     "@types/reveal.js": "5.2.2",
     "@types/tabulator-tables": "6.3.1",
     "copy-webpack-plugin": "13.0.1",
-    "happy-dom": "20.3.1",
+    "happy-dom": "20.0.11",
     "lightningcss": "1.30.2",
     "script-loader": "0.7.2",
     "vite-plugin-static-copy": "3.1.4"

apps/client/src/entities/fnote.ts

@@ -1,4 +1,4 @@
-import { getNoteIcon } from "@triliumnext/commons";
+import { MIME_TYPES_DICT } from "@triliumnext/commons";
 
 import cssClassManager from "../services/css_class_manager.js";
 import type { Froca } from "../services/froca-interface.js";
@@ -13,6 +13,25 @@ import type { AttributeType, default as FAttribute } from "./fattribute.js";
 const LABEL = "label";
 const RELATION = "relation";
 
+export const NOTE_TYPE_ICONS = {
+    file: "bx bx-file",
+    image: "bx bx-image",
+    code: "bx bx-code",
+    render: "bx bx-extension",
+    search: "bx bx-file-find",
+    relationMap: "bx bxs-network-chart",
+    book: "bx bx-book",
+    noteMap: "bx bxs-network-chart",
+    mermaid: "bx bx-selection",
+    canvas: "bx bx-pen",
+    webView: "bx bx-globe-alt",
+    launcher: "bx bx-link",
+    doc: "bx bxs-file-doc",
+    contentWidget: "bx bxs-widget",
+    mindMap: "bx bx-sitemap",
+    aiChat: "bx bx-bot"
+};
+
 /**
  * There are many different Note types, some of which are entirely opaque to the
  * end user. Those types should be used only for checking against, they are
@@ -563,18 +582,32 @@ export default class FNote {
     }
 
     getIcon() {
+        return `tn-icon ${this.#getIconInternal()}`;
+    }
+
+    #getIconInternal() {
         const iconClassLabels = this.getLabels("iconClass");
         const workspaceIconClass = this.getWorkspaceIconClass();
 
-        const icon = getNoteIcon({
-            noteId: this.noteId,
-            type: this.type,
-            mime: this.mime,
-            iconClass: iconClassLabels.length > 0 ? iconClassLabels[0].value : undefined,
-            workspaceIconClass,
-            isFolder: this.isFolder.bind(this)
-        });
-        return `tn-icon ${icon}`;
+        if (iconClassLabels && iconClassLabels.length > 0) {
+            return iconClassLabels[0].value;
+        } else if (workspaceIconClass) {
+            return workspaceIconClass;
+        } else if (this.noteId === "root") {
+            return "bx bx-home-alt-2";
+        }
+        if (this.noteId === "_share") {
+            return "bx bx-share-alt";
+        } else if (this.type === "text") {
+            if (this.isFolder()) {
+                return "bx bx-folder";
+            }
+            return "bx bx-note";
+        } else if (this.type === "code") {
+            const correspondingMimeType = MIME_TYPES_DICT.find(m => m.mime === this.mime);
+            return correspondingMimeType?.icon ?? NOTE_TYPE_ICONS.code;
+        }
+        return NOTE_TYPE_ICONS[this.type];
     }
 
     getColorClass() {

apps/client/src/index.ts

@@ -25,10 +25,37 @@ async function setupGlob() {
     window.global = globalThis; /* fixes https://github.com/webpack/webpack/issues/10035 */
     window.glob = {
         ...json,
-        activeDialog: null
+        activeDialog: null,
+        device: json.device || getDevice()
     };
 }
 
+function getDevice() {
+    // Respect user's manual override via URL.
+    const urlParams = new URLSearchParams(window.location.search);
+    if (urlParams.has("print")) {
+        return "print";
+    } else if (urlParams.has("desktop")) {
+        return "desktop";
+    } else if (urlParams.has("mobile")) {
+        return "mobile";
+    }
+
+    const deviceCookie = document.cookie.split("; ").find(row => row.startsWith("trilium-device="))?.split("=")[1];
+    if (deviceCookie === "desktop" || deviceCookie === "mobile") return deviceCookie;
+    return isMobile() ? "mobile" : "desktop";
+}
+
+// https://stackoverflow.com/a/73731646/944162
+function isMobile() {
+    const mQ = matchMedia?.("(pointer:coarse)");
+    if (mQ?.media === "(pointer:coarse)") return !!mQ.matches;
+
+    if ("orientation" in window) return true;
+    const userAgentsRegEx = /\b(Android|iPhone|iPad|iPod|Windows Phone|BlackBerry|webOS|IEMobile)\b/i;
+    return userAgentsRegEx.test(navigator.userAgent);
+}
+
 async function loadBootstrapCss() {
     // We have to selectively import Bootstrap CSS based on text direction.
     if (glob.isRtl) {
@@ -91,10 +118,16 @@ function setBodyAttributes() {
 }
 
 async function loadScripts() {
-    if (glob.device === "mobile") {
-        await import("./mobile.js");
-    } else {
-        await import("./desktop.js");
+    switch (glob.device) {
+        case "mobile":
+            await import("./mobile.js");
+            break;
+        case "print":
+            await import("./print.js");
+            break;
+        case "desktop":
+        default:
+            await import("./desktop.js");
     }
 }
 

apps/client/src/layouts/desktop_layout.tsx

@@ -46,6 +46,8 @@ import ScrollPadding from "../widgets/scroll_padding.js";
 import SearchResult from "../widgets/search_result.jsx";
 import SharedInfo from "../widgets/shared_info.jsx";
 import RightPanelContainer from "../widgets/sidebar/RightPanelContainer.jsx";
+import SqlResults from "../widgets/sql_result.js";
+import SqlTableSchemas from "../widgets/sql_table_schemas.js";
 import TabRowWidget from "../widgets/tab_row.js";
 import TabHistoryNavigationButtons from "../widgets/TabHistoryNavigationButtons.jsx";
 import TitleBarButtons from "../widgets/title_bar_buttons.jsx";
@@ -161,9 +163,11 @@ export default class DesktopLayout {
                                                                     .child(<SharedInfo />)
                                                                 )
                                                                 .optChild(!isNewLayout, <PromotedAttributes />)
+                                                                .child(<SqlTableSchemas />)
                                                                 .child(<NoteDetail />)
                                                                 .child(<NoteList media="screen" />)
                                                                 .child(<SearchResult />)
+                                                                .child(<SqlResults />)
                                                                 .child(<ScrollPadding />)
                                                         )
                                                         .child(<ApiLog />)

apps/client/src/services/doc_renderer.ts

@@ -5,7 +5,7 @@ import { formatCodeBlocks } from "./syntax_highlight.js";
 
 export default function renderDoc(note: FNote) {
     return new Promise<JQuery<HTMLElement>>((resolve) => {
-        let docName = note.getLabelValue("docName");
+        const docName = note.getLabelValue("docName");
         const $content = $("<div>");
 
         if (docName) {
@@ -16,7 +16,7 @@ export default function renderDoc(note: FNote) {
                 if (status === "error") {
                     const fallbackUrl = getUrl(docName, "en");
                     $content.load(fallbackUrl, async () => {
-                        await processContent(fallbackUrl, $content)
+                        await processContent(fallbackUrl, $content);
                         resolve($content);
                     });
                     return;
@@ -37,9 +37,9 @@ async function processContent(url: string, $content: JQuery<HTMLElement>) {
     const dir = url.substring(0, url.lastIndexOf("/"));
 
     // Images are relative to the docnote but that will not work when rendered in the application since the path breaks.
-    $content.find("img").each((i, el) => {
+    $content.find("img").each((_i, el) => {
         const $img = $(el);
-        $img.attr("src", dir + "/" + $img.attr("src"));
+        $img.attr("src", `${dir}/${$img.attr("src")}`);
     });
 
     formatCodeBlocks($content);
@@ -51,7 +51,17 @@ async function processContent(url: string, $content: JQuery<HTMLElement>) {
 function getUrl(docNameValue: string, language: string) {
     // Cannot have spaces in the URL due to how JQuery.load works.
     docNameValue = docNameValue.replaceAll(" ", "%20");
-
-    const basePath = window.glob.isDev ? window.glob.assetPath + "/.." : window.glob.assetPath;
-    return `${basePath}/doc_notes/${language}/${docNameValue}.html`;
+    // The user guide is available only in English, so make sure we are requesting correctly since 404s in standalone client are treated differently.
+    if (docNameValue.includes("User%20Guide")) language = "en";
+    return `${getBasePath()}/doc_notes/${language}/${docNameValue}.html`;
+}
+
+function getBasePath() {
+    if (window.glob.isStandalone) {
+        return `server-assets`;
+    }
+    if (window.glob.isDev) {
+        return `${window.glob.assetPath  }/..`;
+    }
+    return window.glob.assetPath;
 }

apps/client/src/services/note_autocomplete.ts

@@ -12,7 +12,7 @@ const SELECTED_NOTE_PATH_KEY = "data-note-path";
 const SELECTED_EXTERNAL_LINK_KEY = "data-external-link";
 
 // To prevent search lag when there are a large number of notes, set a delay based on the number of notes to avoid jitter.
-const notesCount = await server.get<number>(`autocomplete/notesCount`);
+const notesCount = 10000; // TODO: Replace with dynamic count from becca once available.
 let debounceTimeoutId: ReturnType<typeof setTimeout>;
 
 function getSearchDelay(notesCount: number): number {

apps/client/src/services/promoted_attribute_definition_parser.ts

@@ -1,14 +1,4 @@
-export type LabelType = "text" | "number" | "boolean" | "date" | "datetime" | "time" | "url" | "color";
-type Multiplicity = "single" | "multi";
-
-export interface DefinitionObject {
-    isPromoted?: boolean;
-    labelType?: LabelType;
-    multiplicity?: Multiplicity;
-    numberPrecision?: number;
-    promotedAlias?: string;
-    inverseRelation?: string;
-}
+import { DefinitionObject, LabelType, Multiplicity } from "@triliumnext/commons";
 
 function parse(value: string) {
     const tokens = value.split(",").map((t) => t.trim());

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

@@ -100,20 +100,6 @@ describe("shortcuts", () => {
             expect(consoleSpy).toHaveBeenCalled();
             consoleSpy.mockRestore();
         });
-
-        it("should match letter keys using code when key is a special character (macOS Alt behavior)", () => {
-            // On macOS, pressing Option/Alt + A produces 'å' as the key, but code is still 'KeyA'
-            const macOSAltAEvent = createKeyboardEvent("å", "KeyA");
-            expect(keyMatches(macOSAltAEvent, "a")).toBe(true);
-
-            // Option + H produces '˙'
-            const macOSAltHEvent = createKeyboardEvent("˙", "KeyH");
-            expect(keyMatches(macOSAltHEvent, "h")).toBe(true);
-
-            // Option + S produces 'ß'
-            const macOSAltSEvent = createKeyboardEvent("ß", "KeyS");
-            expect(keyMatches(macOSAltSEvent, "s")).toBe(true);
-        });
     });
 
     describe("matchesShortcut", () => {
@@ -214,33 +200,6 @@ describe("shortcuts", () => {
             expect(consoleSpy).toHaveBeenCalled();
             consoleSpy.mockRestore();
         });
-
-        it("should match Alt+letter shortcuts on macOS where key is a special character", () => {
-            // On macOS, pressing Option/Alt + A produces 'å' but code remains 'KeyA'
-            const macOSAltAEvent = createKeyboardEvent({
-                key: "å",
-                code: "KeyA",
-                altKey: true
-            });
-            expect(matchesShortcut(macOSAltAEvent, "alt+a")).toBe(true);
-
-            // Option/Alt + H produces '˙'
-            const macOSAltHEvent = createKeyboardEvent({
-                key: "˙",
-                code: "KeyH",
-                altKey: true
-            });
-            expect(matchesShortcut(macOSAltHEvent, "alt+h")).toBe(true);
-
-            // Combined with Ctrl: Ctrl+Alt+S where Alt produces 'ß'
-            const macOSCtrlAltSEvent = createKeyboardEvent({
-                key: "ß",
-                code: "KeyS",
-                ctrlKey: true,
-                altKey: true
-            });
-            expect(matchesShortcut(macOSCtrlAltSEvent, "ctrl+alt+s")).toBe(true);
-        });
     });
 
     describe("bindGlobalShortcut", () => {

apps/client/src/services/shortcuts.ts

@@ -213,11 +213,8 @@ export function keyMatches(e: KeyboardEvent, key: string): boolean {
     }
 
     // For letter keys, use the physical key code for consistency
-    // On macOS, Option/Alt key produces special characters, so we must use e.code
     if (key.length === 1 && key >= 'a' && key <= 'z') {
-        // e.code is like "KeyA", "KeyB", etc.
-        const expectedCode = `Key${key.toUpperCase()}`;
-        return e.code === expectedCode || e.key.toLowerCase() === key.toLowerCase();
+        return e.key.toLowerCase() === key.toLowerCase();
     }
 
     // For regular keys, check both key and code as fallback

apps/client/src/services/utils.ts

@@ -133,6 +133,8 @@ export function isElectron() {
     return !!(window && window.process && window.process.type);
 }
 
+export const isStandalone = window.glob.isStandalone;
+
 /**
  * Returns `true` if the client is running as a PWA, otherwise `false`.
  */
@@ -814,7 +816,7 @@ function compareVersions(v1: string, v2: string): number {
 /**
  * Compares two semantic version strings and returns `true` if the latest version is greater than the current version.
  */
-function isUpdateAvailable(latestVersion: string | null | undefined, currentVersion: string): boolean {
+export function isUpdateAvailable(latestVersion: string | null | undefined, currentVersion: string): boolean {
     if (!latestVersion) {
         return false;
     }

apps/client/src/services/ws.ts

@@ -304,7 +304,7 @@ async function sendPing() {
 }
 
 setTimeout(() => {
-    if (glob.device === "print") return;
+    if (glob.device === "print" || glob.isStandalone) return;
 
     ws = connectWebSocket();
 

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

@@ -1604,9 +1604,7 @@
     "clone-indicator-tooltip": "此笔记有 {{- count}} 个父级： {{- parents}}",
     "clone-indicator-tooltip-single": "此笔记已克隆（1 个额外的父级：{{- parent}}）",
     "subtree-hidden-tooltip_other": "从树中隐藏的 {{count}} 篇子笔记",
-    "subtree-hidden-moved-title": "已添加到 {{title}}",
-    "subtree-hidden-moved-description-collection": "此集合隐藏其树中的子笔记。",
-    "subtree-hidden-moved-description-other": "子笔记隐藏于此笔记的树中。"
+    "subtree-hidden-moved-title": "已添加到 {{title}}"
   },
   "title_bar_buttons": {
     "window-on-top": "保持此窗口置顶"

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

@@ -1,6 +1,6 @@
 {
   "about": {
-    "title": "Über Trilium Notizen",
+    "title": "Über Trilium Notes",
     "homepage": "Startseite:",
     "app_version": "App-Version:",
     "db_version": "DB-Version:",
@@ -26,12 +26,7 @@
     "widget-list-error": {
       "title": "Abruf der Liste von Widgets vom Server ist fehlgeschlagen"
     },
-    "open-script-note": "Script-Notiz öffnen",
-    "widget-render-error": {
-      "title": "Eine externe React Integration konnte nicht dargestellt werden"
-    },
-    "widget-missing-parent": "Der externen Integration fehlt die erforderliche Eigenschaft '{{property}}'\n\nFalls dieses Skript ohne UI-Element ausgeführt werden soll, benutze stattdessen '#run=frontendStartup'.",
-    "scripting-error": "Benutzerdefinierter Skriptfehler: {{title}}"
+    "open-script-note": "Script-Notiz öffnen"
   },
   "add_link": {
     "add_link": "Link hinzufügen",
@@ -215,7 +210,7 @@
     "modalTitle": "Infonachricht",
     "closeButton": "Schließen",
     "okButton": "OK",
-    "copy_to_clipboard": "In Zwischenablage kopieren"
+    "copy_to_clipboard": "In die Zwischenablage kopieren"
   },
   "jump_to_note": {
     "search_button": "Suche im Volltext",
@@ -703,8 +698,8 @@
     "export_as_image_png": "PNG (Raster)",
     "export_as_image_svg": "SVG (Vektor)",
     "note_map": "Notizen Karte",
-    "view_revisions": "Änderungshistorie...",
-    "advanced": "Fortgeschritten"
+    "view_revisions": "Notizrevisionen",
+    "advanced": "Erweitert"
   },
   "onclick_button": {
     "no_click_handler": "Das Schaltflächen-Widget „{{componentId}}“ hat keinen definierten Klick-Handler"
@@ -797,8 +792,7 @@
     "expand_all_levels": "Alle Ebenen erweitern",
     "expand_tooltip": "Erweitert die direkten Unterelemente dieser Sammlung (eine Ebene tiefer). Für weitere Optionen auf den Pfeil rechts klicken.",
     "expand_first_level": "Direkte Unterelemente erweitern",
-    "expand_nth_level": "{{depth}} Ebenen erweitern",
-    "hide_child_notes": "Unterknoten im Baum ausblenden"
+    "expand_nth_level": "{{depth}} Ebenen erweitern"
   },
   "edited_notes": {
     "no_edited_notes_found": "An diesem Tag wurden noch keine Notizen bearbeitet...",
@@ -811,7 +805,7 @@
     "file_type": "Dateityp",
     "file_size": "Dateigröße",
     "download": "Herunterladen",
-    "open": "Extern öffnen",
+    "open": "Offen",
     "upload_new_revision": "Neue Revision hochladen",
     "upload_success": "Neue Dateirevision wurde hochgeladen.",
     "upload_failed": "Das Hochladen einer neuen Dateirevision ist fehlgeschlagen.",
@@ -909,7 +903,7 @@
     "unknown_search_option": "Unbekannte Suchoption {{searchOptionName}}",
     "search_note_saved": "Suchnotiz wurde in {{-notePathTitle}} gespeichert",
     "actions_executed": "Aktionen wurden ausgeführt.",
-    "view_options": "Optionen anzeigen:"
+    "view_options": "Anzeigeoptionen:"
   },
   "similar_notes": {
     "title": "Ähnliche Notizen",
@@ -1015,9 +1009,9 @@
     "auto-detect-language": "Automatisch erkannt",
     "keeps-crashing": "Die Bearbeitungskomponente stürzt immer wieder ab. Bitte starten Sie Trilium neu. Wenn das Problem weiterhin besteht, erstellen Sie einen Fehlerbericht.",
     "editor_crashed_title": "Der Text Editor ist abgestürzt",
-    "editor_crashed_content": "Ihr Inhalt wurde erfolgreich wiederhergestellt, aber kürzlich gemachte Änderungen wurden unter Umständen nicht gespeichert.",
-    "editor_crashed_details_button": "Mehr Details anzeigen...",
-    "editor_crashed_details_intro": "Falls dieser Fehler häufiger auftritt, ziehen Sie in Betracht uns diesen über GitHub zu melden, indem Sie die folgenden Informationen bereitstellen.",
+    "editor_crashed_content": "Ihr Inhalt wurde erfolgreich wiederhergestellt, aber einzelne Ihrer letzten Änderungen waren möglicherweise noch nicht gespeichert.",
+    "editor_crashed_details_button": "Zeige mehr Details…",
+    "editor_crashed_details_intro": "Falls Sie diesen Fehler mehrmals sehen, melden Sie dies auf GitHub mit den folgenden Informationen.",
     "editor_crashed_details_title": "Technische Informationen"
   },
   "empty": {
@@ -1418,7 +1412,7 @@
     "will_be_deleted_in": "Dieser Anhang wird in {{time}} automatisch gelöscht",
     "will_be_deleted_soon": "Dieser Anhang wird bald automatisch gelöscht",
     "deletion_reason": ", da der Anhang nicht im Inhalt der Notiz verlinkt ist. Um das Löschen zu verhindern, füge den Anhangslink wieder in den Inhalt ein oder wandel den Anhang in eine Notiz um.",
-    "role_and_size": "Rolle: {{role}}, Größe: {{size}}, MIME: {{- mimeType}}",
+    "role_and_size": "Rolle: {{role}}, Größe: {{size}}",
     "link_copied": "Anhangslink in die Zwischenablage kopiert.",
     "unrecognized_role": "Unbekannte Anhangsrolle „{{role}}“."
   },
@@ -1469,13 +1463,10 @@
     "import-into-note": "In Notiz importieren",
     "apply-bulk-actions": "Massenaktionen anwenden",
     "converted-to-attachments": "{{count}} Notizen wurden als Anhang konvertiert.",
-    "convert-to-attachment-confirm": "Bist du sicher, dass du die ausgewählten Notizen in Anhänge ihrer übergeordneten Notizen umwandeln möchtest? Diese Operation wird nur auf Bildnotizes angewandt. Andere Notizen werden übersprungen.",
+    "convert-to-attachment-confirm": "Bist du sicher, dass du die ausgewählten Notizen in Anhänge ihrer übergeordneten Notizen umwandeln möchtest?",
     "open-in-popup": "Schnellbearbeitung",
     "archive": "Archiviere",
-    "unarchive": "Entarchivieren",
-    "open-in-a-new-window": "In neuem Fenster öffnen",
-    "hide-subtree": "Teilbaum ausblenden",
-    "show-subtree": "Teilbaum anzeigen"
+    "unarchive": "Entarchivieren"
   },
   "shared_info": {
     "shared_publicly": "Diese Notiz ist öffentlich geteilt auf {{- link}}.",
@@ -1565,16 +1556,7 @@
     "create-child-note": "Unternotiz anlegen",
     "unhoist": "Fokus verlassen",
     "toggle-sidebar": "Seitenleiste ein-/ausblenden",
-    "dropping-not-allowed": "Ablegen von Notizen an dieser Stelle ist nicht zulässig.",
-    "clone-indicator-tooltip": "Diese Notiz hat {{- count}} Elterknoten: {{- parents}}",
-    "clone-indicator-tooltip-single": "Diese Notiz ist geklont (1 weiterer Elternknoten: {{- parent}})",
-    "shared-indicator-tooltip": "Diese Notiz ist öffentlich einsehbar",
-    "shared-indicator-tooltip-with-url": "Diese Notiz ist unter {{- url}} öffentlich einsehbar",
-    "subtree-hidden-tooltip_one": "{{count}} Unterknoten, der im Baum ausgeblendet ist",
-    "subtree-hidden-tooltip_other": "{{count}} Unterknoten, die im Baum ausgeblendet sind",
-    "subtree-hidden-moved-title": "Zu {{title}} hinzugefügt",
-    "subtree-hidden-moved-description-collection": "Diese Sammlung blendet ihre Unternotizem im Baum aus.",
-    "subtree-hidden-moved-description-other": "Diese Sammlung blendet ihre Unterknoten im Baum aus."
+    "dropping-not-allowed": "Ablegen von Notizen an dieser Stelle ist nicht zulässig."
   },
   "title_bar_buttons": {
     "window-on-top": "Dieses Fenster immer oben halten"
@@ -1585,9 +1567,7 @@
     "printing_pdf": "PDF-Export läuft…",
     "print_report_title": "Druckreport",
     "print_report_collection_details_button": "Details anzeigen",
-    "print_report_collection_details_ignored_notes": "Ignorierte Notizen",
-    "print_report_collection_content_one": "{{count}} Notiz in der Sammlung konnte nicht gedruckt werden, weil sie nicht unterstützt ist oder geschützt ist.",
-    "print_report_collection_content_other": "{{count}} Notizen in der Sammlung konnten nicht gedruckt werden, weil sie nicht unterstützt sind oder geschützt sind."
+    "print_report_collection_details_ignored_notes": "Ignorierte Notizen"
   },
   "note_title": {
     "placeholder": "Titel der Notiz hier eingeben…",
@@ -1740,8 +1720,7 @@
     "open_note_in_new_tab": "Notiz in neuen Tab öffnen",
     "open_note_in_new_split": "Notiz in neuen geteilten Tab öffnen",
     "open_note_in_new_window": "Notiz in neuen Fenster öffnen",
-    "open_note_in_popup": "Schnellbearbeitung",
-    "open_note_in_other_split": "Notiz in neuer Spalte öffnen"
+    "open_note_in_popup": "Schnellbearbeitung"
   },
   "electron_integration": {
     "desktop-application": "Desktop Anwendung",
@@ -2009,9 +1988,8 @@
     "unknown_widget": "Unbekanntes Widget für '{{id}}'."
   },
   "note_language": {
-    "not_set": "Keine Sprache ausgewählt",
-    "configure-languages": "Konfiguriere Sprachen...",
-    "help-on-languages": "Zu Übersetzungen beitragen..."
+    "not_set": "Nicht gesetzt",
+    "configure-languages": "Konfiguriere Sprachen..."
   },
   "content_language": {
     "title": "Inhaltssprachen",
@@ -2029,8 +2007,7 @@
     "button_title": "Exportiere Diagramm als PNG"
   },
   "svg": {
-    "export_to_png": "Das Diagramm konnte als PNG nicht exportiert werden.",
-    "export_to_svg": "Das Diagramm konnte nicht als SVG exportiert werden."
+    "export_to_png": "Das Diagramm konnte als PNG nicht exportiert werden."
   },
   "code_theme": {
     "title": "Aussehen",
@@ -2078,7 +2055,7 @@
   "book_properties_config": {
     "hide-weekends": "Wochenenden ausblenden",
     "display-week-numbers": "Zeige Kalenderwoche",
-    "map-style": "Kartenstil",
+    "map-style": "Kartenstil:",
     "max-nesting-depth": "Maximale Verschachtelungstiefe:",
     "raster": "Raster",
     "vector_light": "Vektor (Hell)",
@@ -2131,20 +2108,14 @@
     "background_effects_title": "Hintergrundeffekte sind jetzt zuverlässig nutzbar",
     "background_effects_message": "Auf Windows-Geräten sind die Hintergrundeffekte nun vollständig stabil. Die Hintergrundeffekte verleihen der Benutzeroberfläche einen Farbakzent, indem der Hintergrund dahinter weichgezeichnet wird. Diese Technik wird auch in anderen Anwendungen wie dem Windows-Explorer eingesetzt.",
     "background_effects_button": "Aktiviere Hintergrundeffekte",
-    "dismiss": "Ablehnen",
-    "new_layout_title": "Neues Layout",
-    "new_layout_message": "Wir haben ein modernisiertes Layout für Trilium eingeführt. Die Multifunktionsleiste wurde entfernt und als neue Statusanzeige und ausklappbaren Sektionen (wie hervorgehobenen Attributen), welche Schlüsselfunktionen übernehmen, nahtlos in das Hauptinterface integriert.\n\nDas neue Layout ist standardmäßig aktiviert und kann temporär in Optionen → Anzeige deaktiviert werden.",
-    "new_layout_button": "Mehr Informationen"
+    "dismiss": "Ablehnen"
   },
   "settings": {
     "related_settings": "Ähnliche Einstellungen"
   },
   "settings_appearance": {
     "related_code_blocks": "Farbschema für Code-Blöcke in Textnotizen",
-    "related_code_notes": "Farbschema für Code-Notizen",
-    "ui": "Benutzeroberfläche",
-    "ui_old_layout": "Altes Layout",
-    "ui_new_layout": "Neues Layout"
+    "related_code_notes": "Farbschema für Code-Notizen"
   },
   "units": {
     "percentage": "%"
@@ -2180,88 +2151,6 @@
   "experimental_features": {
     "title": "Experimentelle Optionen",
     "disclaimer": "Diese Optionen sind experimentell und können Instabilitäten verursachen. Achtsam zu verwenden.",
-    "new_layout_name": "Neues Layout",
-    "new_layout_description": "Probiere das neue Layout für eine modernere Darstellung und verbesserte Benutzbarkeit aus. Kann sich in Zukunft stark ändern."
-  },
-  "server": {
-    "unknown_http_error_title": "Bei der Kommunikation mit dem Server ist ein Fehler aufgetreten",
-    "unknown_http_error_content": "Statuscode: {{statusCode}}\nURL: {{method}} {{url}}\nNachricht: {{message}}",
-    "traefik_blocks_requests": "Der Traefik Reverse-Proxy hat ein fatales Update bekommen, welche die Kommunikation mit dem Server stört."
-  },
-  "tab_history_navigation_buttons": {
-    "go-back": "Zur vorherigen Notiz zurück kehren",
-    "go-forward": "Zur nächsten Notiz"
-  },
-  "breadcrumb": {
-    "hoisted_badge": "Gehoben",
-    "hoisted_badge_title": "Abgesenkt",
-    "workspace_badge": "Arbeitsfläche",
-    "scroll_to_top_title": "Zum Anfang der Notiz springen",
-    "create_new_note": "Neue Unternotiz erstellen",
-    "empty_hide_archived_notes": "Archivierte Notizen ausblenden"
-  },
-  "breadcrumb_badges": {
-    "read_only_explicit": "Nicht Änderbar",
-    "read_only_explicit_description": "Diese Notiz wurde händisch als nicht änderbar markiert.\nKlicke hier um sie temporär zu bearbeiten.",
-    "read_only_auto": "Automatisch nicht änderbar",
-    "read_only_auto_description": "Diese Notiz wurde automatisch aus Leistungsgründen als nicht änderbar markiert. Dieses automatische Limit kann in den Einstellungen angepasst werden.\n\nKlicke hier, um sie temporär zu bearbeiten.",
-    "read_only_temporarily_disabled": "Temporär bearbeitbar",
-    "read_only_temporarily_disabled_description": "Diese Notiz ist aktuell bearbeitbar, ist aber normalerweise nicht änderbar. Sobald du zu einer anderen Notiz navigierst, kehrt diese Notiz in ihren Normalzustand zurück.\n\nKlicke hier, um die Notiz wieder nicht änderbar zu machen.",
-    "shared_publicly": "Öffentlich geteilt",
-    "shared_locally": "Lokal geteilt",
-    "shared_copy_to_clipboard": "Link in die Zwischenablage kopieren",
-    "shared_open_in_browser": "Link öffnen",
-    "shared_unshare": "Teilen aufheben",
-    "clipped_note": "Internetschnellverweis",
-    "clipped_note_description": "Diese Notiz wurde von {{url}} übernommen.\n\nKlicke hier, um zum Ursprung zu gehen.",
-    "execute_script": "Skript ausführen",
-    "execute_script_description": "Diese Notiz ist eine Skriptnotiz. Klicke hier, um das Skript auszuführen.",
-    "execute_sql": "SQL ausführen",
-    "execute_sql_description": "Diese Notiz ist eine SQL-Notiz. Klicke hier, um die SQL-Abfrage auszuführen.",
-    "save_status_saved": "Gespeichert",
-    "save_status_saving": "Speichern...",
-    "save_status_unsaved": "Nicht gespeichert",
-    "save_status_error": "Speichern fehlgeschlagen",
-    "save_status_saving_tooltip": "Änderungen werden gespeichert.",
-    "save_status_unsaved_tooltip": "Es gibt ungespeicherte Änderungen, welche gleich automatisch gespeichert werden.",
-    "save_status_error_tooltip": "Beim speichern der Notiz ist ein Fehler aufgetreten. Wenn möglich, versuche die Notiz woandershin zu kopieren und die Applikation neu zu laden."
-  },
-  "status_bar": {
-    "language_title": "Inhaltssprache ändern",
-    "note_info_title": "Notizinfo anzeigen (z.B.: Datum, Notizgröße)",
-    "backlinks_one": "{{count}} Rücklink",
-    "backlinks_other": "{{count}} Rücklinks",
-    "backlinks_title_one": "Rücklink anzeigen",
-    "backlinks_title_other": "Rücklinks anzeigen",
-    "attachments_one": "{{count}} Anhang",
-    "attachments_other": "{{count}} Anhänge",
-    "attachments_title_one": "Anhang in einem neuen Tab öffnen",
-    "attachments_title_other": "Anhänge in einem neuen Tab öffnen",
-    "attributes_one": "{{count}} Eigenschaft",
-    "attributes_other": "{{count}} Eigenschaften",
-    "attributes_title": "Eigene und gererbte Eigenschaften",
-    "note_paths_one": "{{count}} Pfad",
-    "note_paths_other": "{{count}} Pfade",
-    "note_paths_title": "Notizpfade",
-    "code_note_switcher": "Sprachmodus ändern"
-  },
-  "attributes_panel": {
-    "title": "Notizeigenschaften"
-  },
-  "right_pane": {
-    "empty_message": "Für diese Notiz gibt es nichts anzuzeigen",
-    "empty_button": "Anzeige ausblenden",
-    "toggle": "Rechte Anzeige umschalten",
-    "custom_widget_go_to_source": "Zum Ursprungscode"
-  },
-  "pdf": {
-    "attachments_one": "{{count}} Anhang",
-    "attachments_other": "{{count}} Anhänge",
-    "layers_one": "{{count}} Ebene",
-    "layers_other": "{{count}} Ebenen",
-    "pages_one": "{{count}} Seite",
-    "pages_other": "{{count}} Seiten",
-    "pages_alt": "Seite {{pageNumber}}",
-    "pages_loading": "Laden..."
+    "new_layout_name": "Neues Layout"
   }
 }

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

@@ -69,8 +69,5 @@
     "clear-color": "Clear note colour",
     "set-color": "Set note colour",
     "set-custom-color": "Set custom note colour"
-  },
-  "about": {
-    "title": "About Trilium Notes"
   }
 }

apps/client/src/translations/nb-NO/translation.json

@@ -60,23 +60,5 @@
   },
   "include_note": {
     "label_note": "Notat"
-  },
-  "prompt": {
-    "title": "Ledetekst",
-    "ok": "OK",
-    "defaultTitle": "Ledetekst"
-  },
-  "info": {
-    "closeButton": "Lukk",
-    "okButton": "OK"
-  },
-  "markdown_import": {
-    "import_button": "Importer"
-  },
-  "protected_session_password": {
-    "close_label": "Lukk"
-  },
-  "recent_changes": {
-    "undelete_link": "gjenopprett"
   }
 }

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

@@ -772,10 +772,7 @@
     "filter-default": "Icons default",
     "no_results": "Não foram encontrados icons.",
     "search_placeholder_filtered": "Procurar {{number}} icons no {{name}}",
-    "icon_tooltip": "{{name}}\nPacote de icons: {{iconPack}}",
-    "search_placeholder_one": "Procurar {{number}} icon nos {{count}} pacotes",
-    "search_placeholder_many": "Procurar {{number}} icons em {{count}} pacotes",
-    "search_placeholder_other": "Procurar {{number}} icons nos {{count}} pacotes"
+    "icon_tooltip": "{{name}}\nPacote de icons: {{iconPack}}"
   },
   "basic_properties": {
     "note_type": "Tipo da nota",
@@ -802,8 +799,7 @@
     "expand_nth_level": "Expandir {{depth}} níveis",
     "expand_all_levels": "Expandir todos os níveis",
     "include_archived_notes": "Mostrar notas arquivadas",
-    "expand_tooltip": "Expande a direcção dos descendentes desta colecção (um nível). Para mais opções, carregar na seta à direita.",
-    "hide_child_notes": "Esconder notas descendentes na árvore"
+    "expand_tooltip": "Expande a direcção dos descendentes desta colecção (um nível). Para mais opções, carregar na seta à direita."
   },
   "edited_notes": {
     "no_edited_notes_found": "Ainda não há nenhuma nota editada neste dia…",
@@ -1021,9 +1017,7 @@
     "editor_crashed_title": "O editor de texto quebrou",
     "editor_crashed_details_button": "Ver mais detalhes...",
     "editor_crashed_details_title": "Informação técnica",
-    "editor_crashed_details_intro": "Se teve este erro várias vezes, considerer reportar no GitHub disponibilizando a informação abaixo.",
-    "editor_crashed_content": "O seu conteudo foi recuperado com sucesso, mas alguns das alterações mais recentes podem não ter sido gravadas.",
-    "keeps-crashing": "Componente de edição a rebentar continuamente. Por favor tentar reiniciar Trilium. Se o problema persistir, considere abrir um bug report."
+    "editor_crashed_details_intro": "Se teve este erro várias vezes, considerer reportar no GitHub disponibilizando a informação abaixo."
   },
   "empty": {
     "open_note_instruction": "Abra uma nota a digitar o título da nota no campo abaixo ou escolha uma nota na árvore.",
@@ -1151,8 +1145,7 @@
     "title": "Largura do Conteúdo",
     "default_description": "Por padrão, o Trilium limita a largura máxima do conteúdo para melhorar a legibilidade em janelas maximizadas em ecrãs largos.",
     "max_width_label": "Largura máxima do conteúdo",
-    "max_width_unit": "pixels",
-    "centerContent": "Manter conteúdo centrado"
+    "max_width_unit": "pixels"
   },
   "native_title_bar": {
     "title": "Barra de Título Nativa (requer recarregar a app)",
@@ -1184,9 +1177,7 @@
     "title": "Desempenho",
     "enable-motion": "Ativar transições e animações",
     "enable-shadows": "Ativar sombras",
-    "enable-backdrop-effects": "Ativar efeitos de fundo para menus, popups e painéis",
-    "enable-smooth-scroll": "Activar deslocamento suave",
-    "app-restart-required": "(é necessário reiniciar a aplicação para aplicar as alterações)"
+    "enable-backdrop-effects": "Ativar efeitos de fundo para menus, popups e painéis"
   },
   "ai_llm": {
     "not_started": "Não iniciado",
@@ -1345,10 +1336,7 @@
     "title": "Editor"
   },
   "code_mime_types": {
-    "title": "Tipos MIME disponíveis no dropdown",
-    "tooltip_syntax_highlighting": "Destaque de sintaxe",
-    "tooltip_code_block_syntax": "Blocos de código nas notas de texto",
-    "tooltip_code_note_syntax": "Notas de código"
+    "title": "Tipos MIME disponíveis no dropdown"
   },
   "vim_key_bindings": {
     "use_vim_keybindings_in_code_notes": "Atribuições de teclas do Vim",
@@ -1468,13 +1456,7 @@
     "min-days-in-first-week": "Mínimo de dias da primeira semana",
     "first-week-info": "Primeira semana que contenha a primeira Quinta-feira do ano é baseado na <a href=\"https://en.wikipedia.org/wiki/ISO_week_date#First_week\">ISO 8601</a>.",
     "first-week-warning": "Alterar as opções de primeira semana pode causar duplicidade nas Notas Semanais existentes e estas Notas não serão atualizadas de acordo.",
-    "formatting-locale": "Formato de data e número",
-    "tuesday": "Terça-feira",
-    "wednesday": "Quarta-feira",
-    "thursday": "Quinta-feira",
-    "friday": "Sexta-feira",
-    "saturday": "Sábado",
-    "formatting-locale-auto": "Baseado na linguagem da aplicação"
+    "formatting-locale": "Formato de data e número"
   },
   "backup": {
     "automatic_backup": "Backup automático",
@@ -1567,8 +1549,7 @@
     "oauth_description_warning": "Para ativar o OAuth/OpenID, precisa definir a URL base do OAuth/OpenID, o client ID e o client secret no ficheiro config.ini e reiniciar a aplicação. Se quiser configurar via variáveis de ambiente, defina TRILIUM_OAUTH_BASE_URL, TRILIUM_OAUTH_CLIENT_ID e TRILIUM_OAUTH_CLIENT_SECRET.",
     "oauth_user_account": "Conta do Utilizador: ",
     "oauth_user_email": "E-mail do Utilizador: ",
-    "oauth_user_not_logged_in": "Não está logado!",
-    "oauth_missing_vars": "Configurações em falta: {{-variables}}"
+    "oauth_user_not_logged_in": "Não está logado!"
   },
   "shortcuts": {
     "keyboard_shortcuts": "Atalhos de Teclado",
@@ -1668,12 +1649,7 @@
     "apply-bulk-actions": "Aplicar ações em massa",
     "converted-to-attachments": "{{count}} notas foram convertidas em anexos.",
     "convert-to-attachment-confirm": "Tem certeza que deseja converter as notas selecionadas em anexos das suas notas-pai?",
-    "open-in-popup": "Edição rápida",
-    "open-in-a-new-window": "Abrir numa nova janela",
-    "archive": "Arquivar",
-    "unarchive": "Retirar do arquivo",
-    "hide-subtree": "Esconder sub-árvore",
-    "show-subtree": "Mostrar sub-árvore"
+    "open-in-popup": "Edição rápida"
   },
   "shared_info": {
     "shared_publicly": "Esta nota é partilhada publicamente em {{- link}}.",
@@ -1734,13 +1710,7 @@
   },
   "highlights_list_2": {
     "title": "Lista de Destaques",
-    "options": "Opções",
-    "no_highlights": "Sem destaques encontrados.",
-    "menu_configure": "Configurar lista de destaques...",
-    "modal_title": "Configurar list de destaques",
-    "title_with_count_one": "{{count}} destaque",
-    "title_with_count_many": "{{count}} destaques",
-    "title_with_count_other": "{{count}} destaques"
+    "options": "Opções"
   },
   "quick-search": {
     "placeholder": "Pesquisa rápida",
@@ -1763,43 +1733,16 @@
     "refresh-saved-search-results": "Atualizar resultados de pesquisa gravados",
     "create-child-note": "Criar nota filha",
     "unhoist": "Desafixar",
-    "toggle-sidebar": "Alternar barra lateral",
-    "dropping-not-allowed": "Largar notas nesta localização não é permitida",
-    "clone-indicator-tooltip": "Esta nota tem {{- count}} ascendentes: {{- parents}}",
-    "shared-indicator-tooltip": "Esta nota está partilhada publicamente",
-    "shared-indicator-tooltip-with-url": "Esta nota está partilhada publicamente em: {{- url}}",
-    "subtree-hidden-moved-title": "Adicionar ao {{title}}",
-    "subtree-hidden-moved-description-collection": "Esta colecção esconde as notas descendentes na árvore.",
-    "subtree-hidden-moved-description-other": "Notas descendentes estão escondidades na árvore para esta nota.",
-    "subtree-hidden-tooltip_one": "{{count}} nota descendentes escondidas da árvore",
-    "subtree-hidden-tooltip_many": "{{count}} notas descendentes escondidas da árvore",
-    "subtree-hidden-tooltip_other": "{{count}} notas descendentes escondidas da árvore",
-    "clone-indicator-tooltip-single": "Esta nota está clonada (1 additional parent: {{- parent}})"
+    "toggle-sidebar": "Alternar barra lateral"
   },
   "title_bar_buttons": {
     "window-on-top": "Manter Janela no Topo"
   },
   "note_detail": {
-    "could_not_find_typewidget": "Não foi possível encontrar typeWidget para o tipo '{{type}}'",
-    "print_report_collection_details_button": "Ver detalhes",
-    "printing": "Impressão em progresso...",
-    "printing_pdf": "Exportação PDF em progresso...",
-    "print_report_title": "Imprimir relatório",
-    "print_report_collection_details_ignored_notes": "Ignorar notas",
-    "print_report_collection_content_one": "{{count}} nota na colecção não pode ser impressa porque não é suportado ou está protegida.",
-    "print_report_collection_content_many": "{{count}} notas na colecção não podem ser impressas porque não é suportado ou estão protegidas.",
-    "print_report_collection_content_other": "{{count}} notas na colecção não podem ser impressas porque não é suportado ou estão protegidas."
+    "could_not_find_typewidget": "Não foi possível encontrar typeWidget para o tipo '{{type}}'"
   },
   "note_title": {
-    "placeholder": "digite o título da nota aqui...",
-    "promoted_attributes": "Atributos destacados",
-    "created_on": "Criado em <Value />",
-    "last_modified": "Modificado em <Value />",
-    "note_type_switcher_label": "Alterar de {{type}} para:",
-    "note_type_switcher_others": "Outro tipo de nota",
-    "note_type_switcher_templates": "Template",
-    "note_type_switcher_collection": "Colecção",
-    "edited_notes": "Notas editadas neste dia"
+    "placeholder": "digite o título da nota aqui..."
   },
   "search_result": {
     "no_notes_found": "Nenhuma nota encontrada para os parâmetros de pesquisa digitados.",
@@ -1828,8 +1771,7 @@
   },
   "toc": {
     "table_of_contents": "Tabela de Conteúdos",
-    "options": "Opções",
-    "no_headings": "Sem cabeçalhos."
+    "options": "Opções"
   },
   "watched_file_update_status": {
     "file_last_modified": "O ficheiro <code class=\"file-path\"></code> foi modificado pela última vez em <span class=\"file-last-modified\"></span>.",
@@ -1872,9 +1814,7 @@
   "ws": {
     "sync-check-failed": "A verificação de sincronização falhou!",
     "consistency-checks-failed": "A verificação de consistência falhou! Veja os logs para pormenores.",
-    "encountered-error": "Encontrado o erro \"{{message}}\", verifique o console.",
-    "lost-websocket-connection-title": "Perdida conexão com o servidor",
-    "lost-websocket-connection-message": "Verifique a configuração da proxy inversa (e.g. nginx ou Apache) para assegurar conexões WebSocket estão permitidas e não bloqueadas."
+    "encountered-error": "Encontrado o erro \"{{message}}\", verifique o console."
   },
   "hoisted_note": {
     "confirm_unhoisting": "A nota solicitada '{{requestedNote}}' está fora da árvore da nota fixada '{{hoistedNote}}' e precisa desafixar para aceder a nota. Quer prosseguir e desafixar?"
@@ -1930,8 +1870,7 @@
     "copy-link": "Copiar ligação",
     "paste": "Colar",
     "paste-as-plain-text": "Colar como texto sem formatação",
-    "search_online": "Pesquisar por \"{{term}}\" com {{searchEngine}}",
-    "search_in_trilium": "A procurar \"{{term}}\" no Trilium"
+    "search_online": "Pesquisar por \"{{term}}\" com {{searchEngine}}"
   },
   "image_context_menu": {
     "copy_reference_to_clipboard": "Copiar referência para a área de transferência",
@@ -1941,8 +1880,7 @@
     "open_note_in_new_tab": "Abrir nota em nova guia",
     "open_note_in_new_split": "Abrir nota em nova divisão",
     "open_note_in_new_window": "Abrir nota em nova janela",
-    "open_note_in_popup": "Edição rápida",
-    "open_note_in_other_split": "Abrir nota noutro separador"
+    "open_note_in_popup": "Edição rápida"
   },
   "electron_integration": {
     "desktop-application": "Aplicação Desktop",
@@ -1950,8 +1888,7 @@
     "native-title-bar-description": "Para Windows e macOS, manter a barra de título nativa desativada faz a aplicação parecer mais compacta. No Linux, manter a barra de título nativa ativada faz a aplicação se integrar melhor com o restante do sistema.",
     "background-effects": "Ativar efeitos de fundo (apenas Windows 11)",
     "restart-app-button": "Reiniciar a aplicação para ver as alterações",
-    "zoom-factor": "Fator de Zoom",
-    "background-effects-description": "O Mica adiciona um desfoque, fundo estiloso as janelas da aplicação, criando uma profundidade e aspecto moderno. \"Barra de titulo nativa\" deve estar inactiva."
+    "zoom-factor": "Fator de Zoom"
   },
   "note_autocomplete": {
     "search-for": "Pesquisar por \"{{term}}\"",
@@ -2011,8 +1948,7 @@
   },
   "note_language": {
     "not_set": "Não atribuído",
-    "configure-languages": "Configurar idiomas...",
-    "help-on-languages": "Ajuda nas linguagens de conteúdos..."
+    "configure-languages": "Configurar idiomas..."
   },
   "content_language": {
     "title": "Idiomas do conteúdo",
@@ -2030,8 +1966,7 @@
     "button_title": "Exportar diagrama como PNG"
   },
   "svg": {
-    "export_to_png": "O diagrama não pôde ser exportado como PNG.",
-    "export_to_svg": "O diagrama não pode ser exportado para SVG."
+    "export_to_png": "O diagrama não pôde ser exportado como PNG."
   },
   "code_theme": {
     "title": "Aparência",
@@ -2050,11 +1985,7 @@
   "editorfeatures": {
     "title": "Recursos",
     "emoji_completion_enabled": "Ativar auto-completar de Emoji",
-    "note_completion_enabled": "Ativar auto-completar de notas",
-    "emoji_completion_description": "Se activo, emojis podem ser facilmente inseridos em texto ao pressionar `:`, seguido do nome de um emoji.",
-    "note_completion_description": "Se activo, links para notas podem ser criadas ao escrever `@` seguido do titulo de uma nota.",
-    "slash_commands_enabled": "Activar comentários simples",
-    "slash_commands_description": "Se activo, editar comandos como inserir quebras de linha ou cabeçalhos podem ser activado/inactivado ao escrever `/`."
+    "note_completion_enabled": "Ativar auto-completar de notas"
   },
   "table_view": {
     "new-row": "Nova linha",
@@ -2096,16 +2027,7 @@
     "delete-column": "Apagar coluna",
     "delete-column-confirmation": "Tem certeza que deseja apagar esta coluna? O atributo correspondente também será apagado de todas as notas abaixo desta coluna.",
     "new-item": "Novo elemento",
-    "add-column": "Adicionar Coluna",
-    "delete-note": "Apagar nota...",
-    "remove-from-board": "Remover do quadro",
-    "archive-note": "Arquivar nota",
-    "new-item-placeholder": "Inserir titulo da nota...",
-    "add-column-placeholder": "Inserir nome da coluna...",
-    "edit-note-title": "Clicar para editar o titulo da nota",
-    "unarchive-note": "Remover nota do arquivo",
-    "edit-column-title": "Click para editar titulo da coluna",
-    "column-already-exists": "Esta coluna já existe no quadro."
+    "add-column": "Adicionar Coluna"
   },
   "command_palette": {
     "tree-action-name": "Árvore: {{name}}",
@@ -2136,146 +2058,16 @@
     "background_effects_title": "Efeitos de fundo estão estáveis agora",
     "background_effects_message": "Em dispositivos Windows, efeitos de fundo estão estáveis agora. Os efeitos de fundo adicionam um toque de cor à interface do utilizador borrando o plano de fundo atrás dela. Esta técnica também é usada noutras aplicações como o Windows Explorer.",
     "background_effects_button": "Ativar os efeitos de fundo",
-    "dismiss": "Dispensar",
-    "new_layout_title": "Novo titulo do layout",
-    "new_layout_button": "Mais informação",
-    "new_layout_message": "Estamos a introduzir um layout modernizado para o Trilium. A faixa foi removida e está integrada na interface principal, com uma nota barra de estado e secções expansíveis (como as propriedades próprias) a tomar papéis principais.\n\nO novo layout está activo por defeito, e pode ser temporáriamente disabilidade em Opções → Aparência."
+    "dismiss": "Dispensar"
   },
   "settings": {
     "related_settings": "Configurações relacionadas"
   },
   "settings_appearance": {
     "related_code_blocks": "Esquema de cores para blocos de código em notas de texto",
-    "related_code_notes": "Esquema de cores para notas de código",
-    "ui": "Interface do utilizador",
-    "ui_old_layout": "Layout antigo",
-    "ui_new_layout": "Nova aparência"
+    "related_code_notes": "Esquema de cores para notas de código"
   },
   "units": {
     "percentage": "%"
-  },
-  "experimental_features": {
-    "title": "Opções experimentais",
-    "new_layout_name": "Novo layout",
-    "new_layout_description": "Experimente o novo layout para um aspecto moderno e melhor estabilidade. Sujeito a grandes alterações nas próximas publicações.",
-    "disclaimer": "Estas opções são experimentais e podem causar instabilidade. Usar com cuidado."
-  },
-  "read-only-info": {
-    "read-only-note": "Actualmente a ver em modo de leitura.",
-    "edit-note": "Editar nota",
-    "auto-read-only-note": "Esta nota está a ser mostrada em modo de leitura para um carregamento mais rápido."
-  },
-  "presentation_view": {
-    "edit-slide": "Editar este slide",
-    "start-presentation": "Iniciar apresentação",
-    "slide-overview": "Alternar visão geral dos slides"
-  },
-  "calendar_view": {
-    "delete_note": "Apagar nota..."
-  },
-  "pagination": {
-    "page_title": "Página {{startIndex}} - {{endIndex}}",
-    "total_notes": "{{count}} notas"
-  },
-  "collections": {
-    "rendering_error": "Sem possíbilidade de mostrar conteúdos devido a um erro."
-  },
-  "note-color": {
-    "clear-color": "Remover cor da nota",
-    "set-color": "Atribuir cor da nota",
-    "set-custom-color": "Afectar cor personalizada da nota"
-  },
-  "popup-editor": {
-    "maximize": "Alterar para editor completo"
-  },
-  "server": {
-    "unknown_http_error_title": "Erro na comunicação com servidor",
-    "unknown_http_error_content": "Código de estado: {{statusCode}}\nURL: {{method}} {{url}}\nMessagem: {{message}}",
-    "traefik_blocks_requests": "Se está a usar o Traefik, este introduz uma alteração que afecta a comunicação com o servidor."
-  },
-  "tab_history_navigation_buttons": {
-    "go-back": "Ir para a nota anterior",
-    "go-forward": "Ir para nota seguinte"
-  },
-  "breadcrumb": {
-    "hoisted_badge": "Içado",
-    "workspace_badge": "Área de trabalho",
-    "scroll_to_top_title": "Saltar para o início da nota",
-    "create_new_note": "Criar nova nota descendente",
-    "empty_hide_archived_notes": "Esconder notas arquivadas",
-    "hoisted_badge_title": "Retirar de içado"
-  },
-  "breadcrumb_badges": {
-    "read_only_explicit": "Modo de leitura",
-    "read_only_auto": "Modo de leitura automático",
-    "read_only_temporarily_disabled": "Editável temporáriamente",
-    "read_only_auto_description": "Esta nota foi automaticamente colocada em modo de leitura por razões de performance. Este limite automatico é ajustável nas configurações.\n\nClicar para editar temporáriamente.",
-    "read_only_temporarily_disabled_description": "Esta nota está editável, mas normalmente está em modo de leitura. A nova vai regressar para mode de leitura assim que navegar para outra nota.\n\nClicar para reactivar o modo de leitura.",
-    "read_only_explicit_description": "Esta nota foi manualmente colocada em modo de leitura.\nClicar para editar temporáriamente.",
-    "shared_publicly": "Partilhado publicamente",
-    "shared_locally": "Partilhado localmente",
-    "shared_copy_to_clipboard": "Copiar link para a área de transferência",
-    "shared_open_in_browser": "Abrir link no browser",
-    "shared_unshare": "Remover partilha",
-    "clipped_note_description": "Esta nota foi retirar do {{url}}.\n\nClicar para navegar no código fonte da página.",
-    "clipped_note": "Web clipe",
-    "execute_script": "Correr script",
-    "execute_script_description": "Esta nota é uma nota de script. Clicar para executar o script.",
-    "execute_sql": "Correr SQL",
-    "execute_sql_description": "Esta nota é uma nota de SQL. Clicar para executar script SQL.",
-    "save_status_saved": "Guardar",
-    "save_status_saving": "A guardar...",
-    "save_status_unsaved": "Não gravado",
-    "save_status_error": "Gravar falhou",
-    "save_status_saving_tooltip": "Alterações estão a ser guardadas",
-    "save_status_unsaved_tooltip": "Existem alterações não guardadas. Serão guardadas automaticamente em breve.",
-    "save_status_error_tooltip": "Ocorreu um erro ao guardar a nota. Se possível, tente copiar os conteúdos da nota para outro local e reiniciar a aplicação."
-  },
-  "status_bar": {
-    "language_title": "Alterar lingua do conteúdo",
-    "note_info_title": "Ver informação da nota (e.g., datas, tamanho da nota)",
-    "backlinks_one": "{{count}} backlink",
-    "backlinks_many": "{{count}} backlinks",
-    "backlinks_other": "{{count}} backlinks",
-    "backlinks_title_one": "Ver backlink",
-    "backlinks_title_many": "Ver backlinks",
-    "backlinks_title_other": "Ver backlinks",
-    "attachments_one": "{{count}} anexo",
-    "attachments_many": "{{count}} anexos",
-    "attachments_other": "{{count}} anexos",
-    "attachments_title_one": "Ver anexo num novo separador",
-    "attachments_title_many": "Ver anexos num novo separador",
-    "attachments_title_other": "Ver anexos num novo separador",
-    "attributes_one": "{{count}} atributo",
-    "attributes_many": "{{count}} atributos",
-    "attributes_other": "{{count}} atributos",
-    "attributes_title": "Atributos próprios e herdados",
-    "note_paths_one": "{{count}} caminho",
-    "note_paths_many": "{{count}} caminhos",
-    "note_paths_other": "{{count}} caminhos",
-    "note_paths_title": "Caminhos da nota",
-    "code_note_switcher": "Alterar modo de linguagem"
-  },
-  "attributes_panel": {
-    "title": "Atributos da nota"
-  },
-  "right_pane": {
-    "empty_message": "Nada para mostrar nesta nota",
-    "empty_button": "Esconder painél",
-    "toggle": "Alterar painel direito",
-    "custom_widget_go_to_source": "Ir para código fonte"
-  },
-  "pdf": {
-    "attachments_one": "{{count}} anexo pdf",
-    "attachments_many": "{{count}} anexos pdf",
-    "attachments_other": "{{count}} anexos pdf",
-    "layers_one": "{{count}} camada",
-    "layers_many": "{{count}} camadas",
-    "layers_other": "{{count}} camadas",
-    "pages_one": "{{count}} página",
-    "pages_many": "{{count}} páginas",
-    "pages_other": "{{count}} páginas",
-    "pages_alt": "Página {{pageNumber}}",
-    "pages_loading": "A carregar..."
   }
 }

apps/client/src/types.d.ts

@@ -1,4 +1,4 @@
-import { IconRegistry, Locale } from "@triliumnext/commons";
+import { BootstrapDefinition } from "@triliumnext/commons";
 
 import appContext, { AppContext } from "./components/app_context";
 import type FNote from "./entities/fnote";
@@ -15,10 +15,9 @@ interface ElectronProcess {
     platform: string;
 }
 
-interface CustomGlobals {
+interface CustomGlobals extends BootstrapDefinition {
     isDesktop: typeof utils.isDesktop;
     isMobile: typeof utils.isMobile;
-    device: "mobile" | "desktop" | "print";
     getComponentByEl: typeof appContext.getComponentByEl;
     getHeaders: typeof server.getHeaders;
     getReferenceLinkTitle: (href: string) => Promise<string>;
@@ -31,32 +30,7 @@ interface CustomGlobals {
     SEARCH_HELP_TEXT: string;
     activeDialog: JQuery<HTMLElement> | null;
     componentId: string;
-    csrfToken: string;
-    baseApiUrl: string;
-    isProtectedSessionAvailable: boolean;
-    isDev: boolean;
-    isMainWindow: boolean;
-    maxEntityChangeIdAtLoad: number;
-    maxEntityChangeSyncIdAtLoad: number;
-    assetPath: string;
-    appPath: string;
-    instanceName: string;
-    appCssNoteIds: string[];
-    triliumVersion: string;
-    TRILIUM_SAFE_MODE: boolean;
-    platform?: typeof process.platform;
     linter: typeof lint;
-    hasNativeTitleBar: boolean;
-    hasBackgroundEffects: boolean;
-    isElectron: boolean;
-    isRtl: boolean;
-    iconRegistry: IconRegistry;
-    themeCssUrl: string;
-    themeUseNextAsBase?: "next" | "next-light" | "next-dark";
-    iconPackCss: string;
-    headingStyle: "plain" | "underline" | "markdown";
-    layoutOrientation: "vertical" | "horizontal";
-    currentLocale: Locale;
 }
 
 type RequireMethod = (moduleName: string) => any;

apps/client/src/widgets/NoteDetail.tsx

@@ -265,13 +265,9 @@ function useNoteInfo() {
     const [ note, setNote ] = useState<FNote | null | undefined>();
     const [ type, setType ] = useState<ExtendedNoteType>();
     const [ mime, setMime ] = useState<string>();
-    const refreshIdRef = useRef(0);
 
     function refresh() {
-        const refreshId = ++refreshIdRef.current;
-
         getExtendedWidgetType(actualNote, noteContext).then(type => {
-            if (refreshId !== refreshIdRef.current) return;
             setNote(actualNote);
             setType(type);
             setMime(actualNote?.mime);
@@ -322,8 +318,6 @@ export async function getExtendedWidgetType(note: FNote | null | undefined, note
         resultingType = "noteMap";
     } else if (type === "text" && (await noteContext?.isReadOnly())) {
         resultingType = "readOnlyText";
-    } else if (note.isTriliumSqlite()) {
-        resultingType = "sqlConsole";
     } else if ((type === "code" || type === "mermaid") && (await noteContext?.isReadOnly())) {
         resultingType = "readOnlyCode";
     } else if (type === "text") {
@@ -348,8 +342,9 @@ export function checkFullHeight(noteContext: NoteContext | undefined, type: Exte
 
     // https://github.com/zadam/trilium/issues/2522
     const isBackendNote = noteContext?.noteId === "_backendLog";
+    const isSqlNote = noteContext.note?.mime === "text/x-sqlite;schema=trilium";
     const isFullHeightNoteType = type && TYPE_MAPPINGS[type].isFullHeight;
-    return (!noteContext?.hasNoteList() && isFullHeightNoteType)
+    return (!noteContext?.hasNoteList() && isFullHeightNoteType && !isSqlNote)
         || noteContext?.viewScope?.viewMode === "attachments"
         || isBackendNote;
 }

apps/client/src/widgets/attribute_widgets/UserAttributesList.tsx

@@ -1,14 +1,16 @@
-import { useState } from "preact/hooks";
-import FNote from "../../entities/fnote";
 import "./UserAttributesList.css";
-import { useTriliumEvent } from "../react/hooks";
-import attributes from "../../services/attributes";
-import { DefinitionObject } from "../../services/promoted_attribute_definition_parser";
-import { formatDateTime } from "../../utils/formatters";
+
+import type { DefinitionObject } from "@triliumnext/commons";
 import { ComponentChildren, CSSProperties } from "preact";
+import { useState } from "preact/hooks";
+
+import FNote from "../../entities/fnote";
+import attributes from "../../services/attributes";
+import { getReadableTextColor } from "../../services/css_class_manager";
+import { formatDateTime } from "../../utils/formatters";
+import { useTriliumEvent } from "../react/hooks";
 import Icon from "../react/Icon";
 import NoteLink from "../react/NoteLink";
-import { getReadableTextColor } from "../../services/css_class_manager";
 
 interface UserAttributesListProps {
     note: FNote;
@@ -29,7 +31,7 @@ export default function UserAttributesDisplay({ note, ignoredAttributes }: UserA
         <div className="user-attributes">
             {userAttributes?.map(attr => buildUserAttribute(attr))}
         </div>
-    )
+    );
 
 }
 
@@ -46,13 +48,13 @@ function useNoteAttributesWithDefinitions(note: FNote, attributesToIgnore:  stri
 }
 
 function UserAttribute({ attr, children, style }: { attr: AttributeWithDefinitions, children: ComponentChildren, style?: CSSProperties }) {
-    const className = `${attr.type === "label" ? "label" + " " + attr.def.labelType : "relation"}`;
+    const className = attr.type === "label" ? `label ${attr.def.labelType}` : "relation";
 
     return (
         <span key={attr.friendlyName} className={`user-attribute type-${className}`} style={style}>
             {children}
         </span>
-    )
+    );
 }
 
 function buildUserAttribute(attr: AttributeWithDefinitions): ComponentChildren {
@@ -61,7 +63,7 @@ function buildUserAttribute(attr: AttributeWithDefinitions): ComponentChildren {
     let style: CSSProperties | undefined;
 
     if (attr.type === "label") {
-        let value = attr.value;
+        const value = attr.value;
         switch (attr.def.labelType) {
             case "number":
                 let formattedValue = value;
@@ -102,7 +104,7 @@ function buildUserAttribute(attr: AttributeWithDefinitions): ComponentChildren {
         content = <>{defaultLabel}<NoteLink notePath={attr.value} showNoteIcon /></>;
     }
 
-    return <UserAttribute attr={attr} style={style}>{content}</UserAttribute>
+    return <UserAttribute attr={attr} style={style}>{content}</UserAttribute>;
 }
 
 function getAttributesWithDefinitions(note: FNote, attributesToIgnore: string[] = []): AttributeWithDefinitions[] {

apps/client/src/widgets/buttons/global_menu.tsx

@@ -8,7 +8,7 @@ import { CommandNames } from "../../components/app_context";
 import Component from "../../components/component";
 import { ExperimentalFeature, ExperimentalFeatureId, experimentalFeatures, isExperimentalFeatureEnabled, toggleExperimentalFeature } from "../../services/experimental_features";
 import { t } from "../../services/i18n";
-import utils, { dynamicRequire, isElectron, isMobile, reloadFrontendApp } from "../../services/utils";
+import utils, { dynamicRequire, isElectron, isMobile, isStandalone, reloadFrontendApp } from "../../services/utils";
 import Dropdown from "../react/Dropdown";
 import { FormDropdownDivider, FormDropdownSubmenu, FormListHeader, FormListItem } from "../react/FormList";
 import { useStaticTooltip, useStaticTooltipWithKeyboardShortcut, useTriliumOption, useTriliumOptionBool, useTriliumOptionInt } from "../react/hooks";
@@ -249,7 +249,7 @@ function ToggleWindowOnTop() {
 function useTriliumUpdateStatus() {
     const [ latestVersion, setLatestVersion ] = useState<string>();
     const [ checkForUpdates ] = useTriliumOptionBool("checkForUpdates");
-    const isUpdateAvailable = utils.isUpdateAvailable(latestVersion, glob.triliumVersion);
+    const isUpdateAvailable = utils.isUpdateAvailable(latestVersion, window.glob.triliumVersion);
 
     async function updateVersionStatus() {
         const RELEASES_API_URL = "https://api.github.com/repos/TriliumNext/Trilium/releases/latest";
@@ -267,7 +267,7 @@ function useTriliumUpdateStatus() {
     }
 
     useEffect(() => {
-        if (!checkForUpdates) {
+        if (!checkForUpdates || !isStandalone) {
             setLatestVersion(undefined);
             return;
         }

apps/client/src/widgets/collections/table/columns.tsx

@@ -1,11 +1,12 @@
-import type { CellComponent, ColumnDefinition, EmptyCallback, FormatterParams, ValueBooleanCallback, ValueVoidCallback } from "tabulator-tables";
-import { LabelType } from "../../../services/promoted_attribute_definition_parser.js";
+import { LabelType } from "@triliumnext/commons";
 import { JSX } from "preact";
-import { renderReactWidget } from "../../react/react_utils.jsx";
-import Icon from "../../react/Icon.jsx";
 import { useEffect, useRef, useState } from "preact/hooks";
+import type { CellComponent, ColumnDefinition, EmptyCallback, FormatterParams, ValueBooleanCallback, ValueVoidCallback } from "tabulator-tables";
+
 import froca from "../../../services/froca.js";
+import Icon from "../../react/Icon.jsx";
 import NoteAutocomplete from "../../react/NoteAutocomplete.jsx";
+import { renderReactWidget } from "../../react/react_utils.jsx";
 
 type ColumnType = LabelType | "relation";
 
@@ -78,7 +79,7 @@ export function buildColumnDefinitions({ info, movableRows, existingColumnData,
             rowHandle: movableRows,
             width: calculateIndexColumnWidth(rowNumberHint, movableRows),
             formatter: wrapFormatter(({ cell, formatterParams }) => <div>
-                {(formatterParams as RowNumberFormatterParams).movableRows && <><span class="bx bx-dots-vertical-rounded"></span>{" "}</>}
+                {(formatterParams as RowNumberFormatterParams).movableRows && <><span class="bx bx-dots-vertical-rounded" />{" "}</>}
                 {cell.getRow().getPosition(true)}
             </div>),
             formatterParams: { movableRows } satisfies RowNumberFormatterParams
@@ -200,14 +201,14 @@ function wrapEditor(Component: (opts: EditorOpts) => JSX.Element): ((
     editorParams: {},
 ) => HTMLElement | false) {
     return (cell, _, success, cancel, editorParams) => {
-        const elWithParams = <Component cell={cell} success={success} cancel={cancel} editorParams={editorParams} />
+        const elWithParams = <Component cell={cell} success={success} cancel={cancel} editorParams={editorParams} />;
         return renderReactWidget(null, elWithParams)[0];
     };
 }
 
 function NoteFormatter({ cell }: FormatterOpts) {
     const noteId = cell.getValue();
-    const [ note, setNote ] = useState(noteId ? froca.getNoteFromCache(noteId) : null)
+    const [ note, setNote ] = useState(noteId ? froca.getNoteFromCache(noteId) : null);
 
     useEffect(() => {
         if (!noteId || note?.noteId === noteId) return;
@@ -231,5 +232,5 @@ function RelationEditor({ cell, success }: EditorOpts) {
             hideAllButtons: true
         }}
         noteIdChanged={success}
-    />
+    />;
 }

apps/client/src/widgets/collections/table/tabulator.tsx

@@ -1,20 +1,18 @@
+import { useContext, useEffect, useLayoutEffect, useRef } from "preact/hooks";
+import { EventCallBackMethods, Module, Options, Tabulator as VanillaTabulator } from "tabulator-tables";
 import "tabulator-tables/dist/css/tabulator.css";
 import "../../../../src/stylesheets/table.css";
-
-import { isValidElement, RefObject } from "preact";
-import { useContext, useEffect, useLayoutEffect, useRef } from "preact/hooks";
-import { JSX } from "preact/jsx-runtime";
-import { EventCallBackMethods, Module, Options, Tabulator as VanillaTabulator } from "tabulator-tables";
-
 import { ParentComponent, renderReactWidget } from "../../react/react_utils";
+import { JSX } from "preact/jsx-runtime";
+import { isValidElement, RefObject } from "preact";
 
 interface TableProps<T> extends Omit<Options, "data" | "footerElement" | "index"> {
-    tabulatorRef?: RefObject<VanillaTabulator>;
+    tabulatorRef: RefObject<VanillaTabulator>;
     className?: string;
     data?: T[];
     modules?: (new (table: VanillaTabulator) => Module)[];
     events?: Partial<EventCallBackMethods>;
-    index?: keyof T;
+    index: keyof T;
     footerElement?: string | HTMLElement | JSX.Element;
     onReady?: () => void;
 }
@@ -45,9 +43,7 @@ export default function Tabulator<T>({ className, columns, data, modules, tabula
 
         tabulator.on("tableBuilt", () => {
             tabulatorRef.current = tabulator;
-            if (externalTabulatorRef) {
-                externalTabulatorRef.current = tabulator;
-            }
+            externalTabulatorRef.current = tabulator;
             onReady?.();
         });
 
@@ -66,12 +62,12 @@ export default function Tabulator<T>({ className, columns, data, modules, tabula
             for (const [ eventName, handler ] of Object.entries(events)) {
                 tabulator.off(eventName as keyof EventCallBackMethods, handler);
             }
-        };
+        }
     }, Object.values(events ?? {}));
 
     // Change in data.
-    useEffect(() => { tabulatorRef.current?.setData(data); }, [ data ]);
-    useEffect(() => { columns && tabulatorRef.current?.setColumns(columns); }, [ data ]);
+    useEffect(() => { tabulatorRef.current?.setData(data) }, [ data ]);
+    useEffect(() => { columns && tabulatorRef.current?.setColumns(columns)}, [ data]);
 
     return (
         <div ref={containerRef} className={className} />

apps/client/src/widgets/dialogs/about.tsx

@@ -1,13 +1,14 @@
-import Modal from "../react/Modal.js";
+import type { AppInfo } from "@triliumnext/commons";
+import type { CSSProperties } from "preact/compat";
+import { useState } from "preact/hooks";
+
 import { t } from "../../services/i18n.js";
-import { formatDateTime } from "../../utils/formatters.js";
+import openService from "../../services/open.js";
 import server from "../../services/server.js";
 import utils from "../../services/utils.js";
-import openService from "../../services/open.js";
-import { useState } from "preact/hooks";
-import type { CSSProperties } from "preact/compat";
-import type { AppInfo } from "@triliumnext/commons";
+import { formatDateTime } from "../../utils/formatters.js";
 import { useTriliumEvent } from "../react/hooks.jsx";
+import Modal from "../react/Modal.js";
 
 export default function AboutDialog() {
     const [appInfo, setAppInfo] = useState<AppInfo | null>(null);
@@ -54,15 +55,15 @@ export default function AboutDialog() {
                     <tr>
                         <th>{t("about.build_revision")}</th>
                         <td className="selectable-text">
-                            {appInfo?.buildRevision && <a className="tn-link build-revision external" href={`https://github.com/TriliumNext/Trilium/commit/${appInfo.buildRevision}`} target="_blank" style={forceWordBreak}>{appInfo.buildRevision}</a>}
+                            {appInfo?.buildRevision && <a className="tn-link build-revision external" href={`https://github.com/TriliumNext/Trilium/commit/${appInfo.buildRevision}`} target="_blank" style={forceWordBreak} rel="noreferrer">{appInfo.buildRevision}</a>}
                         </td>
                     </tr>
-                    <tr>
+                    { appInfo?.dataDirectory && <tr>
                         <th>{t("about.data_directory")}</th>
                         <td className="data-directory">
                             {appInfo?.dataDirectory && (<DirectoryLink directory={appInfo.dataDirectory} style={forceWordBreak} />)}
                         </td>
-                    </tr>
+                    </tr>}
                 </tbody>
             </table>
         </Modal>
@@ -76,8 +77,8 @@ function DirectoryLink({ directory, style }: { directory: string, style?: CSSPro
             openService.openDirectory(directory);
         };
 
-        return <a className="tn-link selectable-text" href="#" onClick={onClick} style={style}>{directory}</a>
-    } else {
-        return <span className="selectable-text" style={style}>{directory}</span>;
-    }
+        return <a className="tn-link selectable-text" href="#" onClick={onClick} style={style}>{directory}</a>;
+    } 
+    return <span className="selectable-text" style={style}>{directory}</span>;
+    
 }

apps/client/src/widgets/dialogs/recent_changes.tsx

@@ -27,6 +27,7 @@ export default function RecentChangesDialog() {
     });
 
     useEffect(() => {
+        if (!ancestorNoteId) return;
         server.get<RecentChangeRow[]>(`recent-changes/${ancestorNoteId}`)
             .then(async (recentChanges) => {
                 // preload all notes into cache

apps/client/src/widgets/layout/InlineTitle.tsx

@@ -7,7 +7,6 @@ import { ComponentChild } from "preact";
 import { useLayoutEffect, useMemo, useRef, useState } from "preact/hooks";
 import { Trans } from "react-i18next";
 
-import FNote from "../../entities/fnote";
 import { ViewScope } from "../../services/link";
 import { formatDateTime } from "../../utils/formatters";
 import NoteIcon from "../note_icon";
@@ -23,12 +22,12 @@ const supportedNoteTypes = new Set<NoteType>([
 export default function InlineTitle() {
     const { note, parentComponent, viewScope } = useNoteContext();
     const type = useNoteProperty(note, "type");
-    const [ shown, setShown ] = useState(shouldShow(note, type, viewScope));
+    const [ shown, setShown ] = useState(shouldShow(note?.noteId, type, viewScope));
     const containerRef = useRef<HTMLDivElement>(null);
     const [ titleHidden, setTitleHidden ] = useState(false);
 
     useLayoutEffect(() => {
-        setShown(shouldShow(note, type, viewScope));
+        setShown(shouldShow(note?.noteId, type, viewScope));
     }, [ note, type, viewScope ]);
 
     useLayoutEffect(() => {
@@ -70,10 +69,9 @@ export default function InlineTitle() {
     );
 }
 
-function shouldShow(note: FNote | null | undefined, type: NoteType | undefined, viewScope: ViewScope | undefined) {
+function shouldShow(noteId: string | undefined, type: NoteType | undefined, viewScope: ViewScope | undefined) {
     if (viewScope?.viewMode !== "default") return false;
-    if (note?.noteId?.startsWith("_options")) return true;
-    if (note?.isTriliumSqlite()) return false;
+    if (noteId?.startsWith("_options")) return true;
     return type && supportedNoteTypes.has(type);
 }
 

apps/client/src/widgets/layout/NoteTypeSwitcher.tsx

@@ -39,7 +39,7 @@ export default function NoteTypeSwitcher() {
     const currentNoteTypeData = useMemo(() => NOTE_TYPES.find(t => t.type === currentNoteType), [ currentNoteType ]);
     const { builtinTemplates, collectionTemplates } = useBuiltinTemplates();
 
-    return (currentNoteType && supportedNoteTypes.has(currentNoteType) && !note?.isTriliumSqlite() &&
+    return (currentNoteType && supportedNoteTypes.has(currentNoteType) &&
         <div
             className="note-type-switcher"
             onWheel={onWheelHorizontalScroll}

apps/client/src/widgets/layout/StatusBar.tsx

@@ -1,6 +1,6 @@
 import "./StatusBar.css";
 
-import { Locale, NOTE_TYPE_ICONS, NoteType } from "@triliumnext/commons";
+import { Locale, NoteType } from "@triliumnext/commons";
 import { Dropdown as BootstrapDropdown } from "bootstrap";
 import clsx from "clsx";
 import { type ComponentChildren, RefObject } from "preact";
@@ -9,7 +9,7 @@ import { useCallback, useContext, useEffect, useMemo, useRef, useState } from "p
 
 import { CommandNames } from "../../components/app_context";
 import NoteContext from "../../components/note_context";
-import FNote from "../../entities/fnote";
+import FNote, { NOTE_TYPE_ICONS } from "../../entities/fnote";
 import attributes from "../../services/attributes";
 import { t } from "../../services/i18n";
 import { ViewScope } from "../../services/link";

apps/client/src/widgets/note_tree.ts

@@ -1232,9 +1232,7 @@ export default class NoteTreeWidget extends NoteContextAwareWidget {
             refreshCtx.noteIdsToUpdate.add(noteId);
         }
 
-        const hasNotesToUpdateOrReload = refreshCtx.noteIdsToUpdate.size + refreshCtx.noteIdsToReload.size > 0;
-        const hasNoteReorderingChange = loadResults.getNoteReorderings().length > 0;
-        if (hasNotesToUpdateOrReload || hasNoteReorderingChange) {
+        if (refreshCtx.noteIdsToUpdate.size + refreshCtx.noteIdsToReload.size > 0) {
             await this.#executeTreeUpdates(refreshCtx, loadResults);
         }
 
@@ -1395,7 +1393,6 @@ export default class NoteTreeWidget extends NoteContextAwareWidget {
 
             for (const parentNoteId of loadResults.getNoteReorderings()) {
                 for (const node of this.getNodesByNoteId(parentNoteId)) {
-                    console.log("Reordering ", node);
                     if (node.isLoaded()) {
                         this.sortChildren(node);
                     }

apps/client/src/widgets/note_types.tsx

@@ -12,7 +12,7 @@ import { TypeWidgetProps } from "./type_widgets/type_widget";
  * A `NoteType` altered by the note detail widget, taking into consideration whether the note is editable or not and adding special note types such as an empty one,
  * for protected session or attachment information.
  */
-export type ExtendedNoteType = Exclude<NoteType, "launcher" | "text" | "code"> | "empty" | "readOnlyCode" | "readOnlyText" | "editableText" | "editableCode" | "attachmentDetail" | "attachmentList" |  "protectedSession" | "aiChat" | "sqlConsole";
+export type ExtendedNoteType = Exclude<NoteType, "launcher" | "text" | "code"> | "empty" | "readOnlyCode" | "readOnlyText" | "editableText" | "editableCode" | "attachmentDetail" | "attachmentList" |  "protectedSession" | "aiChat";
 
 export type TypeWidget = ((props: TypeWidgetProps) => VNode | JSX.Element | undefined);
 type NoteTypeView = () => (Promise<{ default: TypeWidget } | TypeWidget> | TypeWidget);
@@ -140,10 +140,5 @@ export const TYPE_MAPPINGS: Record<ExtendedNoteType, NoteTypeMapping> = {
         view: () => import("./type_widgets/AiChat"),
         className: "ai-chat-widget-container",
         isFullHeight: true
-    },
-    sqlConsole: {
-        view: () => import("./type_widgets/SqlConsole"),
-        className: "sql-console-widget-container",
-        isFullHeight: true
     }
 };

apps/client/src/widgets/scroll_padding.tsx

@@ -1,14 +1,11 @@
 import { useEffect, useRef, useState } from "preact/hooks";
-
 import { useNoteContext } from "./react/hooks";
 
 export default function ScrollPadding() {
     const { note, parentComponent, ntxId, viewScope } = useNoteContext();
     const ref = useRef<HTMLDivElement>(null);
     const [height, setHeight] = useState<number>(10);
-    const isEnabled = ["text", "code"].includes(note?.type ?? "")
-        && viewScope?.viewMode === "default"
-        && !note?.isTriliumSqlite();
+    const isEnabled = ["text", "code"].includes(note?.type ?? "") && viewScope?.viewMode === "default";
 
     const refreshHeight = () => {
         if (!ref.current) return;
@@ -40,6 +37,6 @@ export default function ScrollPadding() {
             style={{ height }}
             onClick={() => parentComponent.triggerCommand("scrollToEnd", { ntxId })}
         />
-        : <div />
-    );
+        : <div></div>
+    )
 }

apps/client/src/widgets/sql_result.css

@@ -0,0 +1,7 @@
+.sql-result-widget {
+    padding: 15px;
+}
+
+.sql-console-result-container td {
+    white-space: preserve;
+}

apps/client/src/widgets/sql_result.tsx

@@ -0,0 +1,63 @@
+import { SqlExecuteResults } from "@triliumnext/commons";
+import { useNoteContext, useTriliumEvent } from "./react/hooks";
+import "./sql_result.css";
+import { useState } from "preact/hooks";
+import Alert from "./react/Alert";
+import { t } from "../services/i18n";
+
+export default function SqlResults() {
+    const { note, ntxId } = useNoteContext();
+    const [ results, setResults ] = useState<SqlExecuteResults>();
+
+    useTriliumEvent("sqlQueryResults", ({ ntxId: eventNtxId, results }) => {
+        if (eventNtxId !== ntxId) return;
+        setResults(results);
+    })
+
+    const isEnabled = note?.mime === "text/x-sqlite;schema=trilium";
+    return (
+        <div className={`sql-result-widget ${!isEnabled ? "hidden-ext" : ""}`}>
+            {isEnabled && (
+                results?.length === 1 && Array.isArray(results[0]) && results[0].length === 0 ? (
+                    <Alert type="info">
+                        {t("sql_result.no_rows")}
+                    </Alert>
+                ) : (
+                    <div className="sql-console-result-container selectable-text">
+                        {results?.map(rows => {
+                            // inserts, updates
+                            if (typeof rows === "object" && !Array.isArray(rows)) {
+                                return <pre>{JSON.stringify(rows, null, "\t")}</pre>
+                            }
+
+                            // selects
+                            return <SqlResultTable rows={rows} />
+                        })}
+                    </div>
+                )
+            )}
+        </div>
+    )
+}
+
+function SqlResultTable({ rows }: { rows: object[] }) {
+    if (!rows.length) return;
+
+    return (
+        <table className="table table-striped">
+            <thead>
+                <tr>
+                    {Object.keys(rows[0]).map(key => <th>{key}</th>)}
+                </tr>
+            </thead>
+
+            <tbody>
+                {rows.map(row => (
+                    <tr>
+                        {Object.values(row).map(cell => <td>{cell}</td>)}
+                    </tr>
+                ))}
+            </tbody>
+        </table>
+    )
+}

apps/client/src/widgets/sql_table_schemas.css

@@ -0,0 +1,43 @@
+.sql-table-schemas-widget {
+    padding: 12px;
+    padding-inline-end: 10%;
+    contain: none !important;
+}
+
+.sql-table-schemas > .dropdown {
+    display: inline-block !important;
+}
+
+.sql-table-schemas button.btn {
+    padding: 0.25rem 0.4rem;
+    font-size: 0.875rem;
+    line-height: 0.5;
+    border: 1px solid var(--button-border-color);
+    border-radius: var(--button-border-radius);
+    background: var(--button-background-color);
+    color: var(--button-text-color);
+    cursor: pointer;
+}
+
+.sql-console-result-container {
+    width: 100%;
+    font-size: smaller;
+    margin-top: 10px;
+    flex-grow: 1;
+    overflow: auto;
+    min-height: 0;
+}
+
+.table-schema td {
+    padding: 5px;
+}
+
+.dropdown .table-schema {
+    font-family: var(--monospace-font-family);
+    font-size: .85em;
+}
+
+/* Data type */
+.dropdown .table-schema td:nth-child(2) {
+    color: var(--muted-text-color);
+}

apps/client/src/widgets/sql_table_schemas.tsx

@@ -0,0 +1,51 @@
+import { useEffect, useState } from "preact/hooks";
+import { t } from "../services/i18n";
+import { useNoteContext } from "./react/hooks";
+import "./sql_table_schemas.css";
+import { SchemaResponse } from "@triliumnext/commons";
+import server from "../services/server";
+import Dropdown from "./react/Dropdown";
+
+export default function SqlTableSchemas() {
+    const { note } = useNoteContext();
+
+    const isEnabled = note?.mime === "text/x-sqlite;schema=trilium";
+    return (
+        <div className={`sql-table-schemas-widget ${!isEnabled ? "hidden-ext" : ""}`}>
+            {isEnabled && <SqlTableSchemasContent />}
+        </div>
+    )
+}
+
+function SqlTableSchemasContent() {
+    const [ schemas, setSchemas ] = useState<SchemaResponse[]>();
+
+    useEffect(() => {
+        server.get<SchemaResponse[]>("sql/schema").then(setSchemas);
+    }, []);
+
+    return schemas && (
+        <>
+            {t("sql_table_schemas.tables")}{": "}
+
+            <span className="sql-table-schemas">
+                {schemas.map(({ name, columns }) => (
+                    <>
+                        <Dropdown text={name} noSelectButtonStyle hideToggleArrow
+                        >
+                            <table className="table-schema">
+                                {columns.map(column => (
+                                    <tr>
+                                        <td>{column.name}</td>
+                                        <td>{column.type}</td>
+                                    </tr>
+                                ))}
+                            </table>
+                        </Dropdown>
+                        {" "}
+                    </>
+                ))}
+            </span>
+        </>
+    )
+}

apps/client/src/widgets/type_widgets/SqlConsole.css

@@ -1,77 +0,0 @@
-.sql-console-widget-container {
-    .note-detail-split.split-vertical {
-        flex-direction: column-reverse;
-    }
-
-    .note-detail-split-preview {
-        overflow: auto;
-    }
-
-    .sql-result-widget  {
-        height: 100%;
-
-        > .sql-console-result-container {
-            width: 100%;
-            height: 100%;
-            font-size: smaller;
-            flex-grow: 1;
-            overflow: auto;
-            min-height: 0;
-
-            > .tabulator {
-                height: 100%;
-                --cell-vert-padding-size: 4px;
-
-                > .tabulator-tableholder {
-                    padding: 0;
-                }
-
-                .tabulator-col-content {
-                    padding: 4px !important;
-                }
-            }
-        }
-    }
-
-    .sql-table-schemas-widget {
-        padding: 12px;
-        padding-inline-end: 10%;
-        contain: none !important;
-
-        .sql-table-schemas {
-            display: flex;
-            flex-wrap: wrap;
-            gap: 0.25em;
-        }
-
-        > .dropdown {
-            display: inline-block !important;
-        }
-
-        button.btn {
-            padding: 0.25rem 0.4rem;
-            font-size: 0.875rem;
-            line-height: 0.5;
-            border: 1px solid var(--button-border-color);
-            border-radius: var(--button-border-radius);
-            background: var(--button-background-color);
-            color: var(--button-text-color);
-            cursor: pointer;
-        }
-
-        .table-schema td {
-            padding: 5px;
-        }
-
-        .dropdown .table-schema {
-            font-family: var(--monospace-font-family);
-            font-size: .85em;
-        }
-
-        /* Data type */
-        .dropdown .table-schema td:nth-child(2) {
-            color: var(--muted-text-color);
-        }
-    }
-}
-

apps/client/src/widgets/type_widgets/SqlConsole.tsx

@@ -1,140 +0,0 @@
-import "./SqlConsole.css";
-
-import { SchemaResponse, SqlExecuteResults } from "@triliumnext/commons";
-import { useEffect, useState } from "preact/hooks";
-import { Fragment } from "preact/jsx-runtime";
-import { ClipboardModule, EditModule, ExportModule, FilterModule, FormatModule, FrozenColumnsModule, KeybindingsModule, ResizeColumnsModule, SelectRangeModule, SelectRowModule, SortModule } from "tabulator-tables";
-
-import { t } from "../../services/i18n";
-import server from "../../services/server";
-import Tabulator from "../collections/table/tabulator";
-import Alert from "../react/Alert";
-import Dropdown from "../react/Dropdown";
-import { useTriliumEvent } from "../react/hooks";
-import SplitEditor from "./helpers/SplitEditor";
-import { TypeWidgetProps } from "./type_widget";
-
-export default function SqlConsole(props: TypeWidgetProps) {
-    return (
-        <>
-            <SplitEditor
-                noteType="code"
-                {...props}
-                editorBefore={<SqlTableSchemas {...props} />}
-                previewContent={<SqlResults {...props} />}
-                splitOptions={{
-                    sizes: [ 70, 30 ]
-                }}
-            />
-        </>
-    );
-}
-
-function SqlResults({ note, ntxId }: TypeWidgetProps) {
-    const [ results, setResults ] = useState<SqlExecuteResults>();
-
-    useTriliumEvent("sqlQueryResults", ({ ntxId: eventNtxId, results }) => {
-        if (eventNtxId !== ntxId) return;
-        setResults(results);
-    });
-
-    const isEnabled = note?.mime === "text/x-sqlite;schema=trilium";
-    return (
-        <div className={`sql-result-widget ${!isEnabled ? "hidden-ext" : ""}`}>
-            {isEnabled && (
-                results?.length === 1 && Array.isArray(results[0]) && results[0].length === 0 ? (
-                    <Alert type="info">
-                        {t("sql_result.no_rows")}
-                    </Alert>
-                ) : (
-                    <div className="sql-console-result-container selectable-text">
-                        {results?.map((rows, index) => {
-                            // inserts, updates
-                            if (typeof rows === "object" && !Array.isArray(rows)) {
-                                return <pre key={index}>{JSON.stringify(rows, null, "\t")}</pre>;
-                            }
-
-                            // selects
-                            return <SqlResultTable key={index} rows={rows} />;
-                        })}
-                    </div>
-                )
-            )}
-        </div>
-    );
-}
-
-function SqlResultTable({ rows }: { rows: object[] }) {
-    if (!rows.length) return;
-
-    return (
-        <Tabulator
-            layout="fitDataFill"
-            modules={[ ResizeColumnsModule, SortModule, SelectRangeModule, ClipboardModule, KeybindingsModule, EditModule, ExportModule, SelectRowModule, FormatModule, FrozenColumnsModule, FilterModule ]}
-            selectableRange
-            clipboard="copy"
-            clipboardCopyRowRange="range"
-            clipboardCopyConfig={{
-                rowHeaders: false,
-                columnHeaders: false
-            }}
-            columns={[
-                {
-                    title: "#",
-                    formatter: "rownum",
-                    width: 60,
-                    hozAlign: "right",
-                    frozen: true
-                },
-                ...Object.keys(rows[0]).map(key => ({
-                    title: key,
-                    field: key,
-                    width: 250,
-                    minWidth: 100,
-                    widthGrow: 1,
-                    resizable: true,
-                    headerFilter: true as const
-                }))
-            ]}
-            data={rows}
-        />
-    );
-}
-
-export function SqlTableSchemas({ note }: TypeWidgetProps) {
-    const [ schemas, setSchemas ] = useState<SchemaResponse[]>();
-
-    useEffect(() => {
-        server.get<SchemaResponse[]>("sql/schema").then(setSchemas);
-    }, []);
-
-    const isEnabled = note?.mime === "text/x-sqlite;schema=trilium" && schemas;
-    return (
-        <div className={`sql-table-schemas-widget ${!isEnabled ? "hidden-ext" : ""}`}>
-            {isEnabled && (
-                <>
-                    {t("sql_table_schemas.tables")}{": "}
-
-                    <span class="sql-table-schemas">
-                        {schemas.map(({ name, columns }) => (
-                            <Fragment key={name}>
-                                <Dropdown text={name} noSelectButtonStyle hideToggleArrow
-                                >
-                                    <table className="table-schema">
-                                        {columns.map(column => (
-                                            <tr key={column.name}>
-                                                <td>{column.name}</td>
-                                                <td>{column.type}</td>
-                                            </tr>
-                                        ))}
-                                    </table>
-                                </Dropdown>
-                                {" "}
-                            </Fragment>
-                        ))}
-                    </span>
-                </>
-            )}
-        </div>
-    );
-}

apps/client/src/widgets/type_widgets/helpers/SplitEditor.tsx

@@ -1,15 +1,13 @@
-import "./SplitEditor.css";
-
-import Split from "@triliumnext/split.js";
-import { ComponentChildren } from "preact";
 import { useEffect, useRef } from "preact/hooks";
-
-import { DEFAULT_GUTTER_SIZE } from "../../../services/resizer";
 import utils, { isMobile } from "../../../services/utils";
-import ActionButton, { ActionButtonProps } from "../../react/ActionButton";
 import Admonition from "../../react/Admonition";
 import { useNoteLabelBoolean, useTriliumOption } from "../../react/hooks";
+import "./SplitEditor.css";
+import Split from "@triliumnext/split.js";
+import { DEFAULT_GUTTER_SIZE } from "../../../services/resizer";
 import { EditableCode, EditableCodeProps } from "../code/Code";
+import { ComponentChildren } from "preact";
+import ActionButton, { ActionButtonProps } from "../../react/ActionButton";
 
 export interface SplitEditorProps extends EditableCodeProps {
     className?: string;
@@ -17,7 +15,6 @@ export interface SplitEditorProps extends EditableCodeProps {
     splitOptions?: Split.Options;
     previewContent: ComponentChildren;
     previewButtons?: ComponentChildren;
-    editorBefore?: ComponentChildren;
 }
 
 /**
@@ -29,14 +26,13 @@ export interface SplitEditorProps extends EditableCodeProps {
  * - Can display errors to the user via {@link setError}.
  * - Horizontal or vertical orientation for the editor/preview split, adjustable via the switch split orientation button floating button.
  */
-export default function SplitEditor({ note, error, splitOptions, previewContent, previewButtons, className, editorBefore, ...editorProps }: SplitEditorProps) {
+export default function SplitEditor({ note, error, splitOptions, previewContent, previewButtons, className, ...editorProps }: SplitEditorProps) {
     const splitEditorOrientation = useSplitOrientation();
     const [ readOnly ] = useNoteLabelBoolean(note, "readOnly");
     const containerRef = useRef<HTMLDivElement>(null);
 
     const editor = (!readOnly &&
         <div className="note-detail-split-editor-col">
-            {editorBefore}
             <div className="note-detail-split-editor">
                 <EditableCode
                     note={note}
@@ -78,12 +74,12 @@ export default function SplitEditor({ note, error, splitOptions, previewContent,
     }, [ readOnly, splitEditorOrientation ]);
 
     return (
-        <div ref={containerRef} className={`note-detail-split note-detail-printable ${`split-${  splitEditorOrientation}`} ${readOnly ? "split-read-only" : ""} ${className ?? ""}`}>
+        <div ref={containerRef} className={`note-detail-split note-detail-printable ${"split-" + splitEditorOrientation} ${readOnly ? "split-read-only" : ""} ${className ?? ""}`}>
             {splitEditorOrientation === "horizontal"
-                ? <>{editor}{preview}</>
-                : <>{preview}{editor}</>}
+            ? <>{editor}{preview}</>
+            : <>{preview}{editor}</>}
         </div>
-    );
+    )
 }
 
 export function PreviewButton(props: Omit<ActionButtonProps, "titlePosition">) {
@@ -92,7 +88,7 @@ export function PreviewButton(props: Omit<ActionButtonProps, "titlePosition">) {
         className="tn-tool-button"
         noIconActionClass
         titlePosition="top"
-    />;
+    />
 }
 
 function useSplitOrientation() {

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

@@ -3,7 +3,6 @@ import froca from "../../../services/froca.js";
 import type LoadResults from "../../../services/load_results.js";
 import search from "../../../services/search.js";
 import type { TemplateDefinition } from "@triliumnext/ckeditor5";
-import appContext from "../../../components/app_context.js";
 import type FNote from "../../../entities/fnote.js";
 
 interface TemplateData {
@@ -21,20 +20,25 @@ const debouncedHandleContentUpdate = debounce(handleContentUpdate, 1000);
  * @returns the list of templates.
  */
 export default async function getTemplates() {
-    // Build the definitions and populate the cache.
-    const snippets = await search.searchForNotes("#textSnippet");
-    const definitions: TemplateDefinition[] = [];
-    for (const snippet of snippets) {
-        const { description } = await invalidateCacheFor(snippet);
+    try {
+        // Build the definitions and populate the cache.
+        const snippets = await search.searchForNotes("#textSnippet");
+        const definitions: TemplateDefinition[] = [];
+        for (const snippet of snippets) {
+            const { description } = await invalidateCacheFor(snippet);
 
-        definitions.push({
-            title: snippet.title,
-            data: () => templateCache.get(snippet.noteId)?.content ?? "",
-            icon: buildIcon(snippet),
-            description
-        });
+            definitions.push({
+                title: snippet.title,
+                data: () => templateCache.get(snippet.noteId)?.content ?? "",
+                icon: buildIcon(snippet),
+                description
+            });
+        }
+        return definitions;
+    } catch (e) {
+        logError("Error while building text snippet templates: ", e);
+        return [];
     }
-    return definitions;
 }
 
 async function invalidateCacheFor(snippet: FNote) {

apps/db-compare/package.json

@@ -5,7 +5,7 @@
   "description": "Tool to compare content of Trilium databases. Useful for debugging sync problems.",
   "dependencies": {
     "colors": "1.4.0",
-    "diff": "8.0.3",
+    "diff": "8.0.2",
     "sqlite": "5.1.1",
     "sqlite3": "5.1.7"
   },

apps/desktop/package.json

@@ -35,15 +35,15 @@
     "@triliumnext/commons": "workspace:*",
     "@triliumnext/server": "workspace:*",
     "copy-webpack-plugin": "13.0.1",
-    "electron": "40.0.0",
-    "@electron-forge/cli": "7.11.1",
-    "@electron-forge/maker-deb": "7.11.1",
-    "@electron-forge/maker-dmg": "7.11.1",
-    "@electron-forge/maker-flatpak": "7.11.1",
-    "@electron-forge/maker-rpm": "7.11.1",
-    "@electron-forge/maker-squirrel": "7.11.1",
-    "@electron-forge/maker-zip": "7.11.1",
-    "@electron-forge/plugin-auto-unpack-natives": "7.11.1",
+    "electron": "39.2.7",
+    "@electron-forge/cli": "7.10.2",
+    "@electron-forge/maker-deb": "7.10.2",
+    "@electron-forge/maker-dmg": "7.10.2",
+    "@electron-forge/maker-flatpak": "7.10.2",
+    "@electron-forge/maker-rpm": "7.10.2",
+    "@electron-forge/maker-squirrel": "7.10.2",
+    "@electron-forge/maker-zip": "7.10.2",
+    "@electron-forge/plugin-auto-unpack-natives": "7.10.2",
     "prebuild-install": "7.1.3"
   }
 }

apps/edit-docs/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@triliumnext/edit-docs",
-  "version": "0.101.3",
+  "version": "0.0.1",
   "private": true,
   "description": "Desktop version of Trilium which imports the demo database (presented to new users at start-up) or the user guide and other documentation and saves the modifications for committing.",
   "dependencies": {
@@ -12,13 +12,11 @@
     "@triliumnext/desktop": "workspace:*",
     "@types/fs-extra": "11.0.4",
     "copy-webpack-plugin": "13.0.1",
-    "electron": "40.0.0",
+    "electron": "39.2.7",
     "fs-extra": "11.3.3"
   },
   "scripts": {
-    "build": "tsx scripts/build.ts",
-    "test-build": "vitest --config vitest.build.config.mts",
-    "edit-docs": "cross-env TRILIUM_PORT=37741 TRILIUM_DATA_DIR=data TRILIUM_INTEGRATION_TEST=memory-no-store tsx ../../scripts/electron-start.mts src/edit-docs.ts",
+    "edit-docs": "cross-env TRILIUM_PORT=37741 TRILIUM_DATA_DIR=data TRILIUM_INTEGRATION_TEST=memory-no-store DOCS_ROOT=../../../docs USER_GUIDE_ROOT=\"../../server/src/assets/doc_notes/en/User Guide\" tsx ../../scripts/electron-start.mts src/edit-docs.ts",
     "edit-demo": "cross-env TRILIUM_PORT=37744 TRILIUM_DATA_DIR=data TRILIUM_INTEGRATION_TEST=memory-no-store DOCS_ROOT=../../../docs USER_GUIDE_ROOT=\"../../server/src/assets/doc_notes/en/User Guide\" tsx ../../scripts/electron-start.mts src/edit-demo.ts"
   }
 }

apps/edit-docs/scripts/build.ts

@@ -1,40 +0,0 @@
-import { writeFileSync } from "fs";
-import { join } from "path";
-
-import BuildHelper from "../../../scripts/build-utils";
-import originalPackageJson from "../package.json" with { type: "json" };
-
-const build = new BuildHelper("apps/edit-docs");
-
-async function main() {
-    await build.buildBackend(["src/edit-docs.ts", "src/utils.ts"]);
-
-    // Copy assets from server (needed for DB initialization)
-    build.copy("/apps/server/src/assets", "assets/");
-    build.triggerBuildAndCopyTo("packages/share-theme", "share-theme/assets/");
-    build.copy("/packages/share-theme/src/templates", "share-theme/templates/");
-    build.copy("/node_modules/ckeditor5/dist/ckeditor5-content.css", "ckeditor5-content.css");
-    build.buildFrontend();
-
-    // Copy node modules dependencies
-    build.copyNodeModules(["better-sqlite3", "bindings", "file-uri-to-path", "@electron/remote"]);
-
-    generatePackageJson();
-}
-
-function generatePackageJson() {
-    const { version, author, license, description, dependencies, devDependencies } = originalPackageJson;
-    const packageJson = {
-        name: "trilium-edit-docs",
-        main: "edit-docs.cjs",
-        version,
-        author,
-        license,
-        description,
-        dependencies: {"better-sqlite3": dependencies["better-sqlite3"]},
-        devDependencies: {electron: devDependencies.electron},
-    };
-    writeFileSync(join(build.outDir, "package.json"), JSON.stringify(packageJson, null, "\t"), "utf-8");
-}
-
-main();

apps/edit-docs/spec/build-checks/artifacts.spec.ts

@@ -1,48 +0,0 @@
-import { globSync } from "fs";
-import { join } from "path";
-import { it, describe, expect } from "vitest";
-
-describe("Check artifacts are present", () => {
-    const distPath = join(__dirname, "../../dist");
-
-    it("has the necessary node modules", async () => {
-        const paths = [
-            "node_modules/better-sqlite3",
-            "node_modules/bindings",
-            "node_modules/file-uri-to-path",
-            "node_modules/@electron/remote"
-        ];
-
-        ensurePathsExist(paths);
-    });
-
-    it("includes the client", async () => {
-        const paths = [
-            "public/assets",
-            "public/fonts",
-            "public/node_modules",
-            "public/src",
-            "public/stylesheets",
-            "public/translations"
-        ];
-
-        ensurePathsExist(paths);
-    });
-
-    it("includes necessary assets", async () => {
-        const paths = [
-            "assets",
-            "share-theme",
-            "ckeditor5-content.css"
-        ];
-
-        ensurePathsExist(paths);
-    });
-
-    function ensurePathsExist(paths: string[]) {
-        for (const path of paths) {
-            const result = globSync(join(distPath, path, "**"));
-            expect(result, path).not.toHaveLength(0);
-        }
-    }
-});

apps/edit-docs/src/edit-docs.ts

@@ -1,17 +1,14 @@
-import debounce from "@triliumnext/client/src/services/debounce.js";
-import cls from "@triliumnext/server/src/services/cls.js";
-import type { AdvancedExportOptions, ExportFormat } from "@triliumnext/server/src/services/export/zip/abstract_provider.js";
-import { initializeTranslations } from "@triliumnext/server/src/services/i18n.js";
-import { parseNoteMetaFile } from "@triliumnext/server/src/services/in_app_help.js";
-import type { NoteMetaFile } from "@triliumnext/server/src/services/meta/note_meta.js";
-import type NoteMeta from "@triliumnext/server/src/services/meta/note_meta.js";
 import fs from "fs/promises";
 import fsExtra from "fs-extra";
-import yaml from "js-yaml";
 import path from "path";
-
-import packageJson from "../package.json" with { type: "json" };
+import type { NoteMetaFile } from "@triliumnext/server/src/services/meta/note_meta.js";
+import { initializeTranslations } from "@triliumnext/server/src/services/i18n.js";
+import debounce from "@triliumnext/client/src/services/debounce.js";
 import { extractZip, importData, initializeDatabase, startElectron } from "./utils.js";
+import cls from "@triliumnext/server/src/services/cls.js";
+import type { AdvancedExportOptions, ExportFormat } from "@triliumnext/server/src/services/export/zip/abstract_provider.js";
+import { parseNoteMetaFile } from "@triliumnext/server/src/services/in_app_help.js";
+import type NoteMeta from "@triliumnext/server/src/services/meta/note_meta.js";
 
 interface NoteMapping {
     rootNoteId: string;
@@ -21,113 +18,47 @@ interface NoteMapping {
     exportOnly?: boolean;
 }
 
-interface Config {
-    baseUrl: string;
-    noteMappings: NoteMapping[];
+const { DOCS_ROOT, USER_GUIDE_ROOT } = process.env;
+if (!DOCS_ROOT || !USER_GUIDE_ROOT) {
+    throw new Error("Missing DOCS_ROOT or USER_GUIDE_ROOT environment variable.");
 }
 
-// Parse command-line arguments
-function parseArgs() {
-    const args = process.argv.slice(2);
-    let configPath: string | undefined;
-    let showHelp = false;
-    let showVersion = false;
+const BASE_URL = "https://docs.triliumnotes.org";
 
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--config' || args[i] === '-c') {
-            configPath = args[i + 1];
-            if (!configPath) {
-                console.error("Error: --config/-c requires a path argument");
-                process.exit(1);
-            }
-            i++; // Skip the next argument as it's the value
-        } else if (args[i] === '--help' || args[i] === '-h') {
-            showHelp = true;
-        } else if (args[i] === '--version' || args[i] === '-v') {
-            showVersion = true;
-        }
+const NOTE_MAPPINGS: NoteMapping[] = [
+    {
+        rootNoteId: "pOsGYCXsbNQG",
+        path: path.join(__dirname, DOCS_ROOT, "User Guide"),
+        format: "markdown"
+    },
+    {
+        rootNoteId: "pOsGYCXsbNQG",
+        path: path.join(__dirname, USER_GUIDE_ROOT),
+        format: "html",
+        ignoredFiles: ["index.html", "navigation.html", "style.css", "User Guide.html"],
+        exportOnly: true
+    },
+    {
+        rootNoteId: "jdjRLhLV3TtI",
+        path: path.join(__dirname, DOCS_ROOT, "Developer Guide"),
+        format: "markdown"
+    },
+    {
+        rootNoteId: "hD3V4hiu2VW4",
+        path: path.join(__dirname, DOCS_ROOT, "Release Notes"),
+        format: "markdown"
     }
-
-    return { configPath, showHelp, showVersion };
-}
-
-function getVersion(): string {
-    return packageJson.version;
-}
-
-function printHelp() {
-    const version = getVersion();
-    console.log(`
-Usage: trilium-edit-docs [options]
-
-Options:
-  -c, --config <path>  Path to the configuration file (default: edit-docs-config.yaml in the root)
-  -h, --help           Display this help message
-  -v, --version        Display version information
-
-Version: ${version}
-`);
-}
-
-function printVersion() {
-    const version = getVersion();
-    console.log(version);
-}
-
-const { configPath, showHelp, showVersion } = parseArgs();
-
-if (showHelp) {
-    printHelp();
-    process.exit(0);
-} else if (showVersion) {
-    printVersion();
-    process.exit(0);
-}
-
-// Configuration variables to be initialized
-let BASE_URL: string;
-let NOTE_MAPPINGS: NoteMapping[];
-
-// Load configuration from edit-docs-config.yaml
-async function loadConfig() {
-    let CONFIG_PATH = configPath
-        ? path.resolve(configPath)
-        : path.join(process.cwd(), "edit-docs-config.yaml");
-
-    const exists = await fs.access(CONFIG_PATH).then(() => true).catch(() => false);
-    if (!exists && !configPath) {
-        // Fallback to project root if running from within a subproject
-        CONFIG_PATH = path.join(__dirname, "../../../edit-docs-config.yaml");
-    }
-
-    const configContent = await fs.readFile(CONFIG_PATH, "utf-8");
-    const config = yaml.load(configContent) as Config;
-
-    BASE_URL = config.baseUrl;
-    // Resolve all paths relative to the config file's directory (for flexibility with external configs)
-    const CONFIG_DIR = path.dirname(CONFIG_PATH);
-    NOTE_MAPPINGS = config.noteMappings.map((mapping) => ({
-        ...mapping,
-        path: path.resolve(CONFIG_DIR, mapping.path)
-    }));
-}
+];
 
 async function main() {
-    await loadConfig();
     const initializedPromise = startElectron(() => {
         // Wait for the import to be finished and the application to be loaded before we listen to changes.
-        setTimeout(() => {
-            registerHandlers();
-        }, 10_000);
+        setTimeout(() => registerHandlers(), 10_000);
     });
 
     await initializeTranslations();
     await initializeDatabase(true);
 
-    // Wait for becca to be loaded before importing data
-    const beccaLoader = await import("@triliumnext/server/src/becca/becca_loader.js");
-    await beccaLoader.beccaLoaded;
-
     cls.init(async () => {
         for (const mapping of NOTE_MAPPINGS) {
             if (!mapping.exportOnly) {
@@ -185,9 +116,6 @@ async function exportData(noteId: string, format: ExportFormat, outputPath: stri
                         return components.join("/");
                     });
 
-                    // Remove data-list-item-id created by CKEditor for lists
-                    content = content.replace(/ data-list-item-id="[^"]*"/g, "");
-
                     return content;
 
                     function findAttachment(targetAttachmentId: string) {
@@ -214,7 +142,7 @@ async function exportData(noteId: string, format: ExportFormat, outputPath: stri
         }
     }
 
-    const minifyMeta = (format === "html" || format === "share");
+    const minifyMeta = (format === "html");
     await cleanUpMeta(outputPath, minifyMeta);
 }
 
@@ -267,6 +195,7 @@ async function registerHandlers() {
             return;
         }
 
+        console.log("Got entity changed", e.entityName, e.entity.title);
         debouncer();
     });
 }

apps/edit-docs/src/utils.ts

@@ -1,27 +1,23 @@
 import cls from "@triliumnext/server/src/services/cls.js";
-import TaskContext from "@triliumnext/server/src/services/task_context.js";
-import windowService from "@triliumnext/server/src/services/window.js";
-import archiver, { type Archiver } from "archiver";
-import electron from "electron";
-import type { WriteStream } from "fs";
 import fs from "fs/promises";
 import fsExtra from "fs-extra";
 import path from "path";
+import electron from "electron";
+import windowService from "@triliumnext/server/src/services/window.js";
+import archiver, { type Archiver } from "archiver";
+import type { WriteStream } from "fs";
+import TaskContext from "@triliumnext/server/src/services/task_context.js";
+import { resolve } from "path";
+import { deferred, DeferredPromise } from "../../../packages/commons/src";
 
-import { deferred, type DeferredPromise } from "../../../packages/commons/src/index.js";
-
-export function initializeDatabase(skipDemoDb: boolean): Promise<void> {
-    return new Promise<void>((resolve) => {
-        import("@triliumnext/server/src/services/sql_init.js").then((m) => {
-            const sqlInit = m.default;
-            cls.init(async () => {
-                if (!sqlInit.isDbInitialized()) {
-                    sqlInit.createInitialDatabase(skipDemoDb).then(() => resolve());
-                } else {
-                    sqlInit.dbReady.resolve();
-                    resolve();
-                }
-            });
+export function initializeDatabase(skipDemoDb: boolean) {
+    return new Promise<void>(async (resolve) => {
+        const sqlInit = (await import("@triliumnext/server/src/services/sql_init.js")).default;
+        cls.init(async () => {
+            if (!sqlInit.isDbInitialized()) {
+                await sqlInit.createInitialDatabase(skipDemoDb);
+            }
+            resolve();
         });
     });
 }
@@ -36,10 +32,11 @@ export function initializeDatabase(skipDemoDb: boolean): Promise<void> {
  */
 export function startElectron(callback: () => void): DeferredPromise<void> {
     const initializedPromise = deferred<void>();
-
-    const readyHandler = async () => {
+    electron.app.on("ready", async () => {
         await initializedPromise;
 
+        console.log("Electron is ready!");
+
         // Start the server.
         const startTriliumServer = (await import("@triliumnext/server/src/www.js")).default;
         await startTriliumServer();
@@ -48,15 +45,7 @@ export function startElectron(callback: () => void): DeferredPromise<void> {
         await windowService.createMainWindow(electron.app);
 
         callback();
-    };
-
-    // Handle race condition: Electron ready event may have already fired
-    if (electron.app.isReady()) {
-        readyHandler();
-    } else {
-        electron.app.on("ready", readyHandler);
-    }
-
+    });
     return initializedPromise;
 }
 
@@ -81,6 +70,7 @@ async function createImportZip(path: string) {
         zlib: { level: 0 }
     });
 
+    console.log("Archive path is ", resolve(path))
     archive.directory(path, "/");
 
     const outputStream = fsExtra.createWriteStream(inputFile);
@@ -95,16 +85,14 @@ async function createImportZip(path: string) {
 }
 
 function waitForEnd(archive: Archiver, stream: WriteStream) {
-    return new Promise<void>((res, rej) => {
-        stream.on("finish", res);
-        stream.on("error", rej);
-        archive.on("error", rej);
-        archive.finalize().catch(rej);
+    return new Promise<void>(async (res, rej) => {
+        stream.on("finish", () => res());
+        await archive.finalize();
     });
 }
 
 export async function extractZip(zipFilePath: string, outputPath: string, ignoredFiles?: Set<string>) {
-    const promise = deferred<void>();
+    const promise = deferred<void>()
     setTimeout(async () => {
         // Then extract the zip.
         const { readZipFile, readContent } = (await import("@triliumnext/server/src/services/import/zip.js"));

apps/edit-docs/vitest.build.config.mts

@@ -1,17 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vite';
-
-export default defineConfig(() => ({
-  root: __dirname,
-  cacheDir: '../../node_modules/.vite/apps/edit-docs',
-  plugins: [],
-  test: {
-    watch: false,
-    globals: true,
-    environment: "node",
-    include: ['spec/build-checks/**'],
-    reporters: [
-      "verbose"
-    ]
-  },
-}));

apps/server/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:24.13.0-bullseye-slim AS builder
+FROM node:24.12.0-bullseye-slim AS builder
 RUN corepack enable
 
 # Install native dependencies since we might be building cross-platform.
@@ -7,7 +7,7 @@ COPY ./docker/package.json ./docker/pnpm-workspace.yaml /usr/src/app/
 # We have to use --no-frozen-lockfile due to CKEditor patches
 RUN pnpm install --no-frozen-lockfile --prod && pnpm rebuild
 
-FROM node:24.13.0-bullseye-slim
+FROM node:24.12.0-bullseye-slim
 # Install only runtime dependencies
 RUN apt-get update && \
     apt-get install -y --no-install-recommends \

apps/server/Dockerfile.alpine

@@ -1,4 +1,4 @@
-FROM node:24.13.0-alpine AS builder
+FROM node:24.12.0-alpine AS builder
 RUN corepack enable
 
 # Install native dependencies since we might be building cross-platform.
@@ -7,7 +7,7 @@ COPY ./docker/package.json ./docker/pnpm-workspace.yaml /usr/src/app/
 # We have to use --no-frozen-lockfile due to CKEditor patches
 RUN pnpm install --no-frozen-lockfile --prod && pnpm rebuild
 
-FROM node:24.13.0-alpine
+FROM node:24.12.0-alpine
 # Install runtime dependencies
 RUN apk add --no-cache su-exec shadow
 

apps/server/Dockerfile.alpine.rootless

@@ -1,4 +1,4 @@
-FROM node:24.13.0-alpine AS builder
+FROM node:24.12.0-alpine AS builder
 RUN corepack enable
 
 # Install native dependencies since we might be building cross-platform.
@@ -7,7 +7,7 @@ COPY ./docker/package.json ./docker/pnpm-workspace.yaml /usr/src/app/
 # We have to use --no-frozen-lockfile due to CKEditor patches
 RUN pnpm install --no-frozen-lockfile --prod && pnpm rebuild
 
-FROM node:24.13.0-alpine
+FROM node:24.12.0-alpine
 # Create a non-root user with configurable UID/GID
 ARG USER=trilium
 ARG UID=1001

apps/server/Dockerfile.rootless

@@ -1,4 +1,4 @@
-FROM node:24.13.0-bullseye-slim AS builder
+FROM node:24.12.0-bullseye-slim AS builder
 RUN corepack enable
 
 # Install native dependencies since we might be building cross-platform.
@@ -7,7 +7,7 @@ COPY ./docker/package.json ./docker/pnpm-workspace.yaml /usr/src/app/
 # We have to use --no-frozen-lockfile due to CKEditor patches
 RUN pnpm install --no-frozen-lockfile --prod && pnpm rebuild
 
-FROM node:24.13.0-bullseye-slim
+FROM node:24.12.0-bullseye-slim
 # Create a non-root user with configurable UID/GID
 ARG USER=trilium
 ARG UID=1001

apps/server/package.json

@@ -36,9 +36,9 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "0.71.2",
-    "@braintree/sanitize-url": "7.1.1",
     "@electron/remote": "2.1.3",
     "@triliumnext/commons": "workspace:*",
+    "@triliumnext/core": "workspace:*",
     "@triliumnext/express-partial-content": "workspace:*",
     "@triliumnext/highlightjs": "workspace:*",
     "@triliumnext/turndown-plugin-gfm": "workspace:*",
@@ -49,16 +49,13 @@
     "@types/cookie-parser": "1.4.10",
     "@types/debounce": "1.2.4",
     "@types/ejs": "3.1.5",
-    "@types/escape-html": "1.0.4",
     "@types/express-http-proxy": "1.6.7",
     "@types/express-session": "1.18.2",
     "@types/fs-extra": "11.0.4",
     "@types/html": "1.0.4",
     "@types/ini": "4.1.1",
-    "@types/mime-types": "3.0.1",
     "@types/multer": "2.0.0",
     "@types/safe-compare": "1.1.2",
-    "@types/sanitize-html": "2.16.0",
     "@types/sax": "1.2.7",
     "@types/serve-favicon": "2.5.7",
     "@types/serve-static": "2.2.0",
@@ -82,11 +79,10 @@
     "csrf-csrf": "3.2.2",
     "debounce": "3.0.0",
     "debug": "4.4.3",
-    "ejs": "4.0.1",
-    "electron": "40.0.0",
+    "ejs": "3.1.10",
+    "electron": "39.2.7",
     "electron-debug": "4.1.0",
     "electron-window-state": "5.0.3",
-    "escape-html": "1.0.3",
     "express": "5.2.1",
     "express-http-proxy": "2.1.2",
     "express-openid-connect": "2.19.4",
@@ -99,7 +95,7 @@
     "html2plaintext": "2.1.4",
     "http-proxy-agent": "7.0.2",
     "https-proxy-agent": "7.0.6",
-    "i18next": "25.7.4",
+    "i18next": "25.7.3",
     "i18next-fs-backend": "2.6.1",
     "image-type": "6.0.0",
     "ini": "6.0.0",
@@ -108,15 +104,12 @@
     "jimp": "1.6.0",
     "lorem-ipsum": "2.0.8",
     "marked": "17.0.1",
-    "mime-types": "3.0.2",
     "multer": "2.0.2",
     "normalize-strings": "1.1.1",
     "ollama": "0.6.3",
     "openai": "6.16.0",
     "rand-token": "1.0.1",
-    "safe-compare": "1.1.4",
-    "sanitize-filename": "1.6.3",
-    "sanitize-html": "2.17.0",
+    "safe-compare": "1.1.4",    
     "sax": "1.4.4",
     "serve-favicon": "2.5.1",
     "stream-throttle": "0.1.3",
@@ -126,8 +119,7 @@
     "swagger-jsdoc": "6.2.8",
     "time2fa": "1.4.2",
     "tmp": "0.2.5",
-    "turnish": "1.7.1",
-    "unescape": "1.0.1",
+    "turndown": "7.2.2",
     "vite": "7.3.1",
     "ws": "8.19.0",
     "xml2js": "0.6.2",

apps/server/src/anonymize.ts

@@ -1,6 +1,6 @@
 import anonymizationService from "./services/anonymization.js";
 import sqlInit from "./services/sql_init.js";
-await import("./becca/entity_constructor.js");
+await import("@triliumnext/core");
 
 sqlInit.dbReady.then(async () => {
     try {

apps/server/src/app.ts

@@ -1,9 +1,8 @@
-import "./services/handlers.js";
-import "./becca/becca_loader.js";
+import("@triliumnext/core");
 
+import { erase } from "@triliumnext/core";
 import compression from "compression";
 import cookieParser from "cookie-parser";
-import { renderFile } from "ejs";
 import express from "express";
 import { auth } from "express-openid-connect";
 import helmet from "helmet";
@@ -16,7 +15,6 @@ import custom from "./routes/custom.js";
 import error_handlers from "./routes/error_handlers.js";
 import routes from "./routes/routes.js";
 import config from "./services/config.js";
-import { startScheduledCleanup } from "./services/erase.js";
 import log from "./services/log.js";
 import openID from "./services/open_id.js";
 import { RESOURCE_DIR } from "./services/resource_dir.js";
@@ -35,7 +33,7 @@ export default async function buildApp() {
 
     // view engine setup
     app.set("views", path.join(assetsDir, "views"));
-    app.engine("ejs", (filePath, options, callback) => renderFile(filePath, options, callback));
+    app.engine("ejs", (await import("ejs")).renderFile);
     app.set("view engine", "ejs");
 
     app.use((req, res, next) => {
@@ -109,7 +107,7 @@ export default async function buildApp() {
 
     await import("./services/scheduler.js");
 
-    startScheduledCleanup();
+    erase.startScheduledCleanup();
 
     if (utils.isElectron) {
         (await import("@electron/remote/main/index.js")).initialize();

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Advanced Usage/Sharing.html

@@ -38,17 +38,17 @@ class="image">
         </th>
         <td>
           <ul>
-            <li>Table of contents.</li>
-            <li>Syntax highlight of code blocks, provided a language is selected (does
+            <li data-list-item-id="e26b4ce9ba4e9dfe224d04e0f341925ed">Table of contents.</li>
+            <li data-list-item-id="e9707fdfa2c92d66690cf932f7e647253">Syntax highlight of code blocks, provided a language is selected (does
               not work if “Auto-detected” is enabled).</li>
-            <li>Rendering for math equations.</li>
-            <li><a href="#root/_help_nBAXQFj20hS1">Including notes</a> (only if the included
+            <li data-list-item-id="e84420a10c6d64bd107edb6e867c91d4b">Rendering for math equations.</li>
+            <li data-list-item-id="e10834dcd0619d77ae2e94d3695bedf58"><a href="#root/_help_nBAXQFj20hS1">Including notes</a> (only if the included
               notes are also shared).</li>
           </ul>
         </td>
         <td>
           <ul>
-            <li>Inline Mermaid diagrams are not rendered.</li>
+            <li data-list-item-id="e41cc4139377f9f88d653d1eb8ca47bb4">Inline Mermaid diagrams are not rendered.</li>
           </ul>
         </td>
       </tr>
@@ -57,12 +57,12 @@ class="image">
         </th>
         <td>
           <ul>
-            <li>Basic support (displaying the contents of the note in a monospace font).</li>
+            <li data-list-item-id="e291ae6d5130677b4c99f7c3bdbe974b4">Basic support (displaying the contents of the note in a monospace font).</li>
           </ul>
         </td>
         <td>
           <ul>
-            <li>No syntax highlight.</li>
+            <li data-list-item-id="e0270680bbdd7a129306e61e11691e36d">No syntax highlight.</li>
           </ul>
         </td>
       </tr>
@@ -95,12 +95,12 @@ class="image">
         </th>
         <td>
           <ul>
-            <li>The child notes are displayed in a fixed format.&nbsp;</li>
+            <li data-list-item-id="ea031e1d4149eb443ace756234490c5a4">The child notes are displayed in a fixed format.&nbsp;</li>
           </ul>
         </td>
         <td>
           <ul>
-            <li>More advanced view types such as the calendar view are not supported.</li>
+            <li data-list-item-id="ea4a9d424aec2afbaecc07bbf64b7bebd">More advanced view types such as the calendar view are not supported.</li>
           </ul>
         </td>
       </tr>
@@ -109,12 +109,12 @@ class="image">
         </th>
         <td>
           <ul>
-            <li>The diagram is displayed as a vector image.</li>
+            <li data-list-item-id="e582d283f2b1b30cbe5ae35d8e01b2bf2">The diagram is displayed as a vector image.</li>
           </ul>
         </td>
         <td>
           <ul>
-            <li>No further interaction supported.</li>
+            <li data-list-item-id="e33268686446e3c217077201bb5964364">No further interaction supported.</li>
           </ul>
         </td>
       </tr>
@@ -123,12 +123,12 @@ class="image">
         </th>
         <td>
           <ul>
-            <li>The diagram is displayed as a vector image.</li>
+            <li data-list-item-id="e443dd0e97c30cb12c77e8906a71569ea">The diagram is displayed as a vector image.</li>
           </ul>
         </td>
         <td>
           <ul>
-            <li>No further interaction supported.</li>
+            <li data-list-item-id="efe151ef3f3826c825416417525fb5fb2">No further interaction supported.</li>
           </ul>
         </td>
       </tr>
@@ -144,7 +144,7 @@ class="image">
         <td>The diagram is displayed as a vector image.</td>
         <td>
           <ul>
-            <li>No further interaction supported.</li>
+            <li data-list-item-id="ed3b4fb473042f6e32b4502d4fa11a767">No further interaction supported.</li>
           </ul>
         </td>
       </tr>
@@ -160,7 +160,7 @@ class="image">
         <td>Basic interaction (downloading the file).</td>
         <td>
           <ul>
-            <li>No further interaction supported.</li>
+            <li data-list-item-id="ed87e836a39d127ebcbb33e9e59045afb">No further interaction supported.</li>
           </ul>
         </td>
       </tr>
@@ -392,8 +392,8 @@ for (const attr of parentNote.attributes) {
           <p>Indicates to web crawlers that the page should not be indexed of this
             note by:</p>
           <ul>
-            <li>Setting the <code>X-Robots-Tag: noindex</code> HTTP header.</li>
-            <li>Setting the <code>noindex, follow</code> meta tag.</li>
+            <li data-list-item-id="e6baa9f60bf59d085fd31aa2cce07a0e7">Setting the <code>X-Robots-Tag: noindex</code> HTTP header.</li>
+            <li data-list-item-id="ec0d067db136ef9794e4f1033405880b7">Setting the <code>noindex, follow</code> meta tag.</li>
           </ul>
         </td>
       </tr>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Basic Concepts and Features/Import & Export/Evernote.html

@@ -1,82 +1,16 @@
-<p>Trilium can import ENEX files, which are used by Evernote for backup/export.
-  One ENEX file represents the content (notes and resources) of one notebook.</p>
+<p>Trilium can import ENEX files which are used by Evernote for backup/export.
+  One ENEX file represents content (notes and resources) of one notebook.</p>
 <h2>Export ENEX from Evernote</h2>
-<p>To export ENEX files from Evernote, you can use:</p>
-<ul>
-  <li>Evernote desktop application. See Evernote&nbsp;<a href="https://help.evernote.com/hc/en-us/articles/209005557-Export-Notes-and-Notebooks-as-ENEX-or-HTML">documentation</a>.
-    Note that the limitation of this method is that you can only export 100
-    notes at a time or one notebook at a time.</li>
-  <li>A third-party&nbsp;<a href="https://github.com/vzhd1701/evernote-backup">evernote-backup</a> CLI
-    tool. This tool can export all of your notebooks in bulk.</li>
-</ul>
+<p>To export ENEX file, you need to have a <em>legacy</em> desktop version
+  of Evernote (i.e. not web/mobile). Right click on notebook and select export
+  and follow the wizard.</p>
 <h2>Import ENEX in Trilium</h2>
-<p>Once you have your ENEX files, do the following to import them in Trilium:</p>
-<ol>
-  <li>In the Trilium note tree, right-click the note under which you want to
-    import one or more of your ENEX files. The notes in the files will be imported
-    as child notes of the selected note.</li>
-  <li>Click&nbsp;Import into note.</li>
-  <li>Choose your ENEX file or files and click&nbsp;Import.</li>
-  <li>During the import, you will see "Import in progress" message. If the import
-    is successful, the message will change to “Import finished successfully”
-    and then disappear.</li>
-  <li>We recommend you to check the imported notes and their attachments to
-    verify that you haven’t lost any data.</li>
-</ol>
-<p>A non-exhaustive list of what the importer preserves:</p>
-<ul>
-  <li>Attachments</li>
-  <li>The hierarchy of headings (these are shifted to start with H2 because
-    H1 is reserved for note title, see&nbsp;<a href="#root/pOsGYCXsbNQG/KSZ04uQ2D1St/iPIMuisry3hd/_help_Gr6xFaF6ioJ5">Headings</a>)</li>
-  <li
- >Tables</li>
-    <li>Bulleted lists</li>
-    <li>Numbered lists</li>
-    <li>Bold</li>
-    <li>Italics</li>
-    <li>Strikethrough</li>
-    <li>Highlights</li>
-    <li>Font colors</li>
-    <li>Soft line breaks</li>
-    <li>External links</li>
-</ul>
-<p>However, we do not guarantee that all of your formatting will be imported
-  100% correctly.</p>
+<p>Once you have ENEX file, you can import it to Trilium. Right click on
+  some note (to which you want to import the file), click on "Import" and
+  select the ENEX file.</p>
+<p>After importing the ENEX file, go over the imported notes and resources
+  to be sure the import went well, and you didn't lose any data.</p>
 <h2>Limitations</h2>
-<ul>
-  <li>The size limit of one import is 250Mb. If the total size of your files
-    is larger, you can increase the&nbsp;<a href="#root/pOsGYCXsbNQG/Otzi9La2YAUX/_help_WOcw2SLH6tbX">upload limit</a>,
-    or divide your files, and run the import as many times as necessary.</li>
-  <li
- >All resources (except for images) are created as notes’ attachments.</li>
-    <li
-   >If you have HTML inside ENEX files, the HTML formatting may be broken
-      or lost after import in Trilium. See&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/BgmBlOIl72jZ/_help_wy8So3yZZlH9">Reporting issues</a>.</li>
-</ul>
-<h3>Internal links</h3>
-<p>The importer cannot transform Evernote internal links into Trilium internal
-  links because Evernote internal note IDs are not preserved in ENEX files.</p>
-<p>If you want to restore the internal links in Trilium after you import
-  all of your ENEX files, you can use or adapt this custom script:&nbsp;
-  <a
-  class="reference-link" href="#root/_help_dj3j8dG4th4l">Process internal links by title</a>
-</p>
-<p>The script does the following:</p>
-<ol>
-  <li>It finds all Evernote internal links.</li>
-  <li>For each one, it checks if its link text matches a note title, and if
-    yes, it replaces the Evernote link with an internal Trilium link. If not,
-    it leaves the Evernote link in place.</li>
-  <li>If it finds more than one note with a matching note title, it leaves the
-    Evernote link in place.</li>
-  <li>It outputs the results in a log that you can see in the respective code
-    note in Trilium.</li>
-</ol>
-<p>The script has the following limitations:</p>
-<ul>
-  <li>It will not fix links to anchors and links to notes that you renamed in
-    Evernote after you created the links.</li>
-  <li>Some note titles might not be well identified, even if they exist. This
-    is especially the case if the note title contains some special characters.
-    Should this be problematic, consider&nbsp;<a class="reference-link" href="#root/_help_wy8So3yZZlH9">Reporting issues</a>.</li>
-</ul>
+<p>All resources (except for images) are created as note's attachments.</p>
+<p>HTML inside ENEX files is not exactly valid so some formatting maybe broken
+  or lost. You can report major problems into <a href="https://github.com/TriliumNext/Trilium/issues">Trilium issue tracker</a>.</p>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Basic Concepts and Features/Import & Export/Evernote/Process internal links by titl.js

@@ -1,35 +0,0 @@
-const query = `note.type = "text" and note.content *=* "evernote:///view/"`;
-const notes = api.searchForNotes(query);
-
-for (const note of notes) {
-    api.log(`Processing note ${note.title}...`);
-    
-    const content = note.getContent();
-    const $ = api.cheerio.load(content);
-    
-    $("a").each((i, el) => {
-        const $el = $(el);
-        
-        const url = $el.attr("href");
-        if (!url.startsWith("evernote:///")) return;
-
-        const text = $el.text();
-        const matchingNotes = api.searchForNotes(`note.title = "${text}"`);
-        if (matchingNotes.length === 0) {
-            api.log(`No matching notes for "${text}..."`);
-            return;
-        }
-
-        if (matchingNotes.length > 1) {
-            api.log(`Found multiple matching notes for "${text}". Skipping.`);
-            return;
-        }
-
-        const matchingNote = matchingNotes[0];
-        
-        api.log(`Found matching note: ${matchingNote.title} ${matchingNote.noteId}`);
-        $el.attr("href", `#root/${matchingNote.noteId}`);
-        $el.addClass("reference-link");
-    });
-    note.setContent($("body").html());   
-}

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Basic Concepts and Features/UI Elements/Note Tree/Hiding the subtree.html

@@ -8,37 +8,39 @@
   the number of items stays small. When a note has a large number of notes
   (in the order of thousands or tens of thousands), two problems arise:</p>
 <ul>
-  <li>Navigating between notes becomes cumbersome and the tree itself gets cluttered
+  <li data-list-item-id="e536c86d371061c12f76f7de2a0af67be">Navigating between notes becomes cumbersome and the tree itself gets cluttered
     with a large amount of notes.</li>
-  <li>The large amount of notes can slow down the application considerably.</li>
+  <li data-list-item-id="ecc37d6c4d0430254e98615842b94429d">The large amount of notes can slow down the application considerably.</li>
 </ul>
 <p>Since v0.102.0, Trilium allows the tree to hide the child notes of particular
-  notes. This works for both&nbsp;<a class="reference-link" href="#root/_help_GTwFsgaA0lCt">Collections</a>&nbsp;and
+  notes. This works for both&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/_help_GTwFsgaA0lCt">Collections</a>&nbsp;and
   normal notes.</p>
 <h2>Interaction</h2>
 <p>When the subtree of a note is hidden, there are a few subtle changes:</p>
 <ul>
-  <li>To indicate that the subtree is hidden, the note will not have an expand
+  <li data-list-item-id="ec1ce3d2030f36e4847f3bbd9468d28e3">To indicate that the subtree is hidden, the note will not have an expand
     button and it will display the number of children to the right.</li>
-  <li>It's not possible to add a new note directly from the tree.
+  <li
+  data-list-item-id="ea99d38ea6c8a816cf2ab7a7e73cfcac5">It's not possible to add a new note directly from the tree.
     <ul>
-      <li>For&nbsp;<a class="reference-link" href="#root/_help_GTwFsgaA0lCt">Collections</a>,
+      <li data-list-item-id="ef0132a903a11e9f667b2b2f4c4fff17a">For&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/_help_GTwFsgaA0lCt">Collections</a>,
         it's best to use the built-in mechanism to create notes (for example by
         creating a new point on a geo-map, or by adding a new row in a table).</li>
-      <li>For normal notes, it's still possible to create children via other means
-        such as using the&nbsp;<a class="reference-link" href="#root/_help_hrZ1D00cLbal">Internal (reference) links</a>&nbsp;system.</li>
+      <li
+      data-list-item-id="e7db44100046c8c79bf79841285aacd1f">For normal notes, it's still possible to create children via other means
+        such as using the&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/KSZ04uQ2D1St/iPIMuisry3hd/QEAPj01N5f7w/_help_hrZ1D00cLbal">Internal (reference) links</a>&nbsp;system.</li>
     </ul>
-  </li>
-  <li>Notes can be dragged from outside the note, case in which they will be
-    cloned into it.
-    <ul>
-      <li>Instead of switching to the child notes that were copied, the parent note
-        is highlighted instead.</li>
-      <li>A notification will indicate this behavior.</li>
-    </ul>
-  </li>
-  <li>Similarly, features such as cut/copy and then paste into the note will
-    also work.</li>
+    </li>
+    <li data-list-item-id="eb049f46cf91db6de113af1099a14944e">Notes can be dragged from outside the note, case in which they will be
+      cloned into it.
+      <ul>
+        <li data-list-item-id="e96d9b7a0755e9c054bab5db4fc1aa25e">Instead of switching to the child notes that were copied, the parent note
+          is highlighted instead.</li>
+        <li data-list-item-id="ec667e3f94a0cfa3fa41ce38d3ed6ee95">A notification will indicate this behavior.</li>
+      </ul>
+    </li>
+    <li data-list-item-id="eb64670dd7ace6764c18602b440f88049">Similarly, features such as cut/copy and then paste into the note will
+      also work.</li>
 </ul>
 <h2>Spotlighting</h2>
 <figure class="image image-style-align-right">
@@ -50,11 +52,12 @@
 <p>During this state, the note remains under its normal hierarchy, so that
   its easy to tell its location. In addition, this means that:</p>
 <ul>
-  <li>The note position is clearly visible when using the&nbsp;<a class="reference-link"
-    href="#root/_help_eIg8jdvaoNNd">Search</a>.</li>
-  <li>The note can still be operated on from the tree, such as adding a&nbsp;
+  <li data-list-item-id="e2490369eb3d99ca694dba23a3410abef">The note position is clearly visible when using the&nbsp;<a class="reference-link"
+    href="#root/pOsGYCXsbNQG/gh7bpGYxajRS/wArbEsdSae6g/_help_eIg8jdvaoNNd">Search</a>.</li>
+  <li
+  data-list-item-id="e041d3807f80dc77b022540b0551b8376">The note can still be operated on from the tree, such as adding a&nbsp;
     <a
-    class="reference-link" href="#root/_help_TBwsyfadTA18">Branch prefix</a>&nbsp;or moving it outside the collection.</li>
+    class="reference-link" href="#root/pOsGYCXsbNQG/gh7bpGYxajRS/BFs8mudNFgCS/IakOLONlIfGI/_help_TBwsyfadTA18">Branch prefix</a>&nbsp;or moving it outside the collection.</li>
 </ul>
 <p>The note appears in italics to indicate its temporary display. When switching
   to another note, the spotlighted note will disappear.</p>
@@ -64,27 +67,29 @@
     This is intentional to avoid displaying a partial state of the subtree.</p>
 </aside>
 <h2>Working with collections</h2>
-<p>By default, some of the&nbsp;<a class="reference-link" href="#root/_help_GTwFsgaA0lCt">Collections</a>&nbsp;will
+<p>By default, some of the&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/_help_GTwFsgaA0lCt">Collections</a>&nbsp;will
   automatically hide their child notes, for example the&nbsp;<a class="reference-link"
-  href="#root/_help_CtBQqbwXDx1w">Kanban Board</a>&nbsp;or the&nbsp;<a class="reference-link"
-  href="#root/_help_2FvYrpmOXm29">Table</a>.</p>
+  href="#root/pOsGYCXsbNQG/GTwFsgaA0lCt/_help_CtBQqbwXDx1w">Kanban Board</a>&nbsp;or
+  the&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/GTwFsgaA0lCt/_help_2FvYrpmOXm29">Table</a>.</p>
 <p>The reasoning behind this is that collections are generally opaque to
   the rest of the notes and they can generate a large amount of sub-notes
   since they intentionally lack structure (in order to allow easy swapping
   between views).</p>
 <p>Some types of collections have the child notes intentionally shown, for
   example the legacy ones (Grid and List), but also the&nbsp;<a class="reference-link"
-  href="#root/_help_zP3PMqaG71Ct">Presentation</a>&nbsp;which requires the tree
-  structure in order to organize and edit the slides.</p>
+  href="#root/pOsGYCXsbNQG/GTwFsgaA0lCt/_help_zP3PMqaG71Ct">Presentation</a>&nbsp;which
+  requires the tree structure in order to organize and edit the slides.</p>
 <p>To toggle this behavior:</p>
 <ul>
-  <li>In the&nbsp;<a class="reference-link" href="#root/_help_IjZS7iK5EXtb">New Layout</a>,
+  <li data-list-item-id="e6d8c8c98802d70f13df626ea1f062122">In the&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/gh7bpGYxajRS/Vc8PjrjAGuOp/_help_IjZS7iK5EXtb">New Layout</a>,
     press the Options button underneath the title and uncheck <em>Hide child notes in tree</em>.</li>
-  <li>Right click the collection note in the&nbsp;<a class="reference-link"
-    href="#root/_help_oPVyFC7WL2Lp">Note Tree</a>&nbsp;and select <em>Advanced</em> → <em>Show subtree</em>.</li>
+  <li
+  data-list-item-id="e2398432e127c54239d679a6b13d8390b">Right click the collection note in the&nbsp;<a class="reference-link"
+    href="#root/pOsGYCXsbNQG/gh7bpGYxajRS/Vc8PjrjAGuOp/_help_oPVyFC7WL2Lp">Note Tree</a>&nbsp;and
+    select <em>Advanced</em> → <em>Show subtree</em>.</li>
 </ul>
 <h2>Working with normal notes</h2>
 <p>It's possible to hide the subtree for normal notes as well, not just collections.
-  To do so, right click the note in the&nbsp;<a class="reference-link" href="#root/_help_oPVyFC7WL2Lp">Note Tree</a>&nbsp;and
+  To do so, right click the note in the&nbsp;<a class="reference-link" href="#root/pOsGYCXsbNQG/gh7bpGYxajRS/Vc8PjrjAGuOp/_help_oPVyFC7WL2Lp">Note Tree</a>&nbsp;and
   select <em>Advanced</em> → <em>Hide subtree.</em>
 </p>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Collections/Calendar.html

@@ -148,10 +148,10 @@
       <td>
         <p>Which view to display in the calendar:</p>
         <ul>
-          <li><code>timeGridWeek</code> for the <em>week</em> view;</li>
-          <li><code>dayGridMonth</code> for the <em>month</em> view;</li>
-          <li><code>multiMonthYear</code> for the <em>year</em> view;</li>
-          <li><code>listMonth</code> for the <em>list</em> view.</li>
+          <li data-list-item-id="e2cd230dc41f41fe91ee74d7d1fa87372"><code>timeGridWeek</code> for the <em>week</em> view;</li>
+          <li data-list-item-id="eee1dba4c6cc51ebd53d0a0dd52044cd6"><code>dayGridMonth</code> for the <em>month</em> view;</li>
+          <li data-list-item-id="ed8721a76a1865dac882415f662ed45b9"><code>multiMonthYear</code> for the <em>year</em> view;</li>
+          <li data-list-item-id="edf09a13759102d98dac34c33eb690c05"><code>listMonth</code> for the <em>list</em> view.</li>
         </ul>
         <p>Any other value will be dismissed and the default view (month) will be
           used instead.</p>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Installation & Setup/Server Installation.html

@@ -7,21 +7,20 @@
 <ul>
   <li><strong>Recommended</strong>: <a href="#root/_help_rWX5eY045zbE">Docker Installation</a> -
     Available for <strong>AMD64</strong> and <strong>ARM</strong> architectures.</li>
-  <li
- ><a href="#root/_help_3tW6mORuTHnB">Packaged Server Installation</a>
-    </li>
-    <li><a href="https://www.pikapods.com/pods?run=trilium-next">PikaPods managed hosting</a>
-    </li>
-    <li><a href="#root/_help_J1Bb6lVlwU5T">Manual Installation</a>
-    </li>
-    <li><a href="#root/_help_DCmT6e7clMoP">Kubernetes</a>
-    </li>
-    <li><a href="https://www.cloudron.io/store/com.github.trilium.cloudronapp.html">Cloudron</a>
-    </li>
-    <li><a href="https://homelabos.com/docs/software/trilium/">HomelabOS</a>
-    </li>
-    <li><a href="#root/_help_moVgBcoxE3EK">NixOS Module</a>
-    </li>
+  <li><a href="#root/_help_3tW6mORuTHnB">Packaged Server Installation</a>
+  </li>
+  <li><a href="https://www.pikapods.com/pods?run=trilium-next">PikaPods managed hosting</a>
+  </li>
+  <li><a href="#root/_help_J1Bb6lVlwU5T">Manual Installation</a>
+  </li>
+  <li><a href="#root/_help_DCmT6e7clMoP">Kubernetes</a>
+  </li>
+  <li><a href="https://www.cloudron.io/store/com.github.trilium.cloudronapp.html">Cloudron</a>
+  </li>
+  <li><a href="https://homelabos.com/docs/software/trilium/">HomelabOS</a>
+  </li>
+  <li><a href="#root/_help_moVgBcoxE3EK">NixOS Module</a>
+  </li>
 </ul>
 <p>The server installation includes both web and <a href="#root/_help_RDslemsQ6gCp">mobile frontends</a>.</p>
 <h2>Configuration</h2>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Note Types/Text.html

@@ -33,12 +33,12 @@
       </td>
       <td>
         <ul>
-          <li>Headings (section titles, paragraph)</li>
-          <li>Font size</li>
-          <li>Bold, italic, underline, strike-through</li>
-          <li>Superscript, subscript</li>
-          <li>Font color &amp; background color</li>
-          <li>Remove formatting</li>
+          <li data-list-item-id="e04c84d59d44645ee89b2a8541ed99f90">Headings (section titles, paragraph)</li>
+          <li data-list-item-id="e39d25bd3d8bd06185b9d259e5827d451">Font size</li>
+          <li data-list-item-id="e1f7e2a2f4b03449d82bdf5b5c6ea8d44">Bold, italic, underline, strike-through</li>
+          <li data-list-item-id="e3decae72884f65b4d538151b6a297072">Superscript, subscript</li>
+          <li data-list-item-id="e59adf00fef65304c163ae190fac5e92a">Font color &amp; background color</li>
+          <li data-list-item-id="ed3f09156147a2769e91db111c76376e2">Remove formatting</li>
         </ul>
       </td>
     </tr>
@@ -47,9 +47,9 @@
       </td>
       <td>
         <ul>
-          <li>Bulleted lists</li>
-          <li>Numbered lists</li>
-          <li>To-do lists</li>
+          <li data-list-item-id="ee87806a913900d85d8f018af81f41df8">Bulleted lists</li>
+          <li data-list-item-id="e3ae314e365fa418ca6e0f061d63834c5">Numbered lists</li>
+          <li data-list-item-id="ee84e08694165f95430046cb34f4cd123">To-do lists</li>
         </ul>
       </td>
     </tr>
@@ -58,8 +58,8 @@
       </td>
       <td>
         <ul>
-          <li>Block quotes</li>
-          <li>Admonitions</li>
+          <li data-list-item-id="e2892dc35a0d4b7ad65daffb8f9404daa">Block quotes</li>
+          <li data-list-item-id="e7297e3ad1002f8de15aa0bd66c6f3f22">Admonitions</li>
         </ul>
       </td>
     </tr>
@@ -68,10 +68,10 @@
       </td>
       <td>
         <ul>
-          <li>Basic tables</li>
-          <li>Merging cells</li>
-          <li>Styling tables and cells.</li>
-          <li>Table captions</li>
+          <li data-list-item-id="eb358a4567d93f66004f4195df2dda05a">Basic tables</li>
+          <li data-list-item-id="e6135a555d6c63c30e4b84806a4870830">Merging cells</li>
+          <li data-list-item-id="e29ac76563d0998b28fb1baf94dbdac8c">Styling tables and cells.</li>
+          <li data-list-item-id="e372446e81fdedada64b8bed89ca93d1a">Table captions</li>
         </ul>
       </td>
     </tr>
@@ -80,9 +80,9 @@
       </td>
       <td>
         <ul>
-          <li>Inline code</li>
-          <li>Code blocks</li>
-          <li>Keyboard shortcuts</li>
+          <li data-list-item-id="eb260b76afcbc07bd9d4ceec4e000e8a0">Inline code</li>
+          <li data-list-item-id="e9864352286369ebe7b41c1599f498de8">Code blocks</li>
+          <li data-list-item-id="ee62fb9ed7f349178e8f2a2bd9ec8cd74">Keyboard shortcuts</li>
         </ul>
       </td>
     </tr>
@@ -91,7 +91,7 @@
       </td>
       <td>
         <ul>
-          <li>Footnotes</li>
+          <li data-list-item-id="edf62ec004eff35cfcb7e361deef19aaf">Footnotes</li>
         </ul>
       </td>
     </tr>
@@ -100,7 +100,7 @@
       </td>
       <td>
         <ul>
-          <li>Images</li>
+          <li data-list-item-id="ebe6277e643041403489c3ceb30c36f7f">Images</li>
         </ul>
       </td>
     </tr>
@@ -109,8 +109,8 @@
       </td>
       <td>
         <ul>
-          <li>External links</li>
-          <li>Internal Trilium links</li>
+          <li data-list-item-id="e3f988be2f259bb40607cb61541955395">External links</li>
+          <li data-list-item-id="e3f91cc4f0cccd2c077cc306bacd68ef2">Internal Trilium links</li>
         </ul>
       </td>
     </tr>
@@ -119,7 +119,7 @@
       </td>
       <td>
         <ul>
-          <li>Include note</li>
+          <li data-list-item-id="eac8015a64bce7b749cc67d1599062007">Include note</li>
         </ul>
       </td>
     </tr>
@@ -128,12 +128,12 @@
       </td>
       <td>
         <ul>
-          <li>Symbols</li>
-          <li><a class="reference-link" href="#root/_help_YfYAtQBcfo5V">Math Equations</a>
+          <li data-list-item-id="e5cdf5d3885ec0ea67f924b4b8fe5c483">Symbols</li>
+          <li data-list-item-id="e95082e6642ed5b1eec6e4e116b899a40"><a class="reference-link" href="#root/_help_YfYAtQBcfo5V">Math Equations</a>
           </li>
-          <li>Mermaid diagrams</li>
-          <li>Horizontal ruler</li>
-          <li>Page break</li>
+          <li data-list-item-id="ecbef6a358a5b8d27f0d3e08bbc750aa9">Mermaid diagrams</li>
+          <li data-list-item-id="e6e97ee14dd29b7ccf53227107e5dc72d">Horizontal ruler</li>
+          <li data-list-item-id="e6198c7c535c249faec2e8906775f11de">Page break</li>
         </ul>
       </td>
     </tr>
@@ -142,12 +142,12 @@
       </td>
       <td>
         <ul>
-          <li>Indentation
+          <li data-list-item-id="e0c14456cb83d483b07ea432ef9d4728e">Indentation
             <ul>
-              <li>Markdown import</li>
+              <li data-list-item-id="e2029812c5e105c595590f70ee227631e">Markdown import</li>
             </ul>
           </li>
-          <li><a class="reference-link" href="#root/_help_2x0ZAX9ePtzV">Cut to subnote</a>
+          <li data-list-item-id="ea1ee012286e05190c89c9f4e64cf2036"><a class="reference-link" href="#root/_help_2x0ZAX9ePtzV">Cut to subnote</a>
           </li>
         </ul>
       </td>
@@ -157,11 +157,11 @@
       </td>
       <td>
         <ul>
-          <li><a class="reference-link" href="#root/_help_ZlN4nump6EbW">Slash Commands</a>
+          <li data-list-item-id="e1ab173193a533ccf33dccfd0cb916f1f"><a class="reference-link" href="#root/_help_ZlN4nump6EbW">Slash Commands</a>
           </li>
-          <li><a class="reference-link" href="#root/_help_KC1HB96bqqHX">Templates</a>
+          <li data-list-item-id="e564b978c09fe5adf476b331b1e0640e3"><a class="reference-link" href="#root/_help_KC1HB96bqqHX">Templates</a>
           </li>
-          <li><a class="reference-link" href="#root/_help_5wZallV2Qo1t">Format Painter</a>
+          <li data-list-item-id="e756306c31d9beffbba3820b6d1b9bc61"><a class="reference-link" href="#root/_help_5wZallV2Qo1t">Format Painter</a>
           </li>
         </ul>
       </td>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Scripting/Backend scripts/Events.html

@@ -19,14 +19,14 @@
       <td>
         <p>Defines on which events script should run. Possible values are:</p>
         <ul>
-          <li><code>frontendStartup</code> - when Trilium frontend starts up (or is refreshed),
+          <li data-list-item-id="e244b14e102cf1b0d4954e8fd455ea77b"><code>frontendStartup</code> - when Trilium frontend starts up (or is refreshed),
             but not on mobile.</li>
-          <li><code>mobileStartup</code> - when Trilium frontend starts up (or is refreshed),
+          <li data-list-item-id="ea8f8ca86e7b351dd86108848ccb9103a"><code>mobileStartup</code> - when Trilium frontend starts up (or is refreshed),
             on mobile.</li>
-          <li><code>backendStartup</code> - when Trilium backend starts up</li>
-          <li><code>hourly</code> - run once an hour. You can use additional label <code>runAtHour</code> to
+          <li data-list-item-id="e658488cf1a0862603088ef384e41b8b6"><code>backendStartup</code> - when Trilium backend starts up</li>
+          <li data-list-item-id="ef40ba992fc450d33a18ca4cb031eca66"><code>hourly</code> - run once an hour. You can use additional label <code>runAtHour</code> to
             specify at which hour, on the back-end.</li>
-          <li><code>daily</code> - run once a day, on the back-end</li>
+          <li data-list-item-id="e07458d4f55b6eb42468a5535b8425c5f"><code>daily</code> - run once a day, on the back-end</li>
         </ul>
       </td>
     </tr>

apps/server/src/assets/doc_notes/en/User Guide/User Guide/Scripting/Frontend Basics/Custom Widgets.html

@@ -107,10 +107,10 @@ class="ck-table-resized">
       </td>
       <td>
         <ul>
-          <li>The widget must export a <code>class</code> and not an instance of the class
+          <li data-list-item-id="ec06332efcc3039721606c052f0d913fa">The widget must export a <code>class</code> and not an instance of the class
             (e.g. <code>no new</code>) because it needs to be multiplied for each note,
             so that splits work correctly.</li>
-          <li>Since the <code>class</code> is exported instead of an instance, the <code>parentWidget</code> getter
+          <li data-list-item-id="e8da690a2a8df148f6b5fc04ba1611688">Since the <code>class</code> is exported instead of an instance, the <code>parentWidget</code> getter
             must be <code>static</code>, otherwise the widget is ignored.</li>
         </ul>
       </td>
@@ -124,7 +124,7 @@ class="ck-table-resized">
       </td>
       <td>
         <ul>
-          <li>Although not mandatory, it's best to use a <code>RightPanelWidget</code> instead
+          <li data-list-item-id="efe008d361e224f422582552648e1afe7">Although not mandatory, it's best to use a <code>RightPanelWidget</code> instead
             of a <code>BasicWidget</code> or a <code>NoteContextAwareWidget</code>.</li>
         </ul>
       </td>

apps/server/src/assets/translations/hi/server.json

@@ -26,9 +26,6 @@
     "quick-search": "क्विक सर्च बार को एक्टिवेट करें",
     "search-in-subtree": "एक्टिव नोट के सब-ट्री में नोट्स खोजें",
     "expand-subtree": "मौजूदा नोट के सब-ट्री को (subtree) एक्सपैंड करें",
-    "delete-note": "नोट डिलीट करें",
-    "move-note-up-in-hierarchy": "नोट एक लेवल ऊपर मूव करें",
-    "move-note-down-in-hierarchy": "नोट एक लेवल नीचे ले जाएँ",
-    "dialogs": "डायलॉग्स"
+    "delete-note": "नोट डिलीट करें"
   }
 }

apps/server/src/assets/translations/nb-NO/server.json

@@ -9,36 +9,9 @@
     "search-in-subtree": "Søk etter notater i det aktive notatets understruktur",
     "creating-and-moving-notes": "Lage og flytte notater",
     "dialogs": "Dialogbokser",
-    "other": "Andre",
-    "expand-subtree": "Utvid undertre for gjeldende notat"
+    "other": "Andre"
   },
   "setup_sync-from-desktop": {
     "step6-here": "her"
-  },
-  "set_password": {
-    "password": "Passord"
-  },
-  "setup": {
-    "next": "Neste",
-    "title": "Konfigurasjon"
-  },
-  "login": {
-    "title": "Logg inn",
-    "password": "Passord",
-    "button": "Logg inn"
-  },
-  "setup_sync-from-server": {
-    "server-host-placeholder": "https://<hostnavn>:<port>",
-    "proxy-server-placeholder": "https://<hostnavn>:<port>",
-    "note": "Obs:",
-    "password": "Passord",
-    "password-placeholder": "Passord",
-    "back": "Tilbake"
-  },
-  "setup_sync-in-progress": {
-    "outstanding-items-default": "N/A"
-  },
-  "share_page": {
-    "parent": "overordnet notat:"
   }
 }

apps/server/src/assets/translations/tr/server.json

@@ -11,8 +11,6 @@
     "move-note-up": "Notu bir üste taşı",
     "collapse-tree": "Tüm not ağacını daraltır",
     "collapse-subtree": "Geçerli notun alt ağacını daraltır",
-    "sort-child-notes": "Alt notları sırala",
-    "creating-and-moving-notes": "Notları oluşturma ve yerlerini değiştirme",
-    "create-note-into": "Aktif nota bağlı alt not oluştur"
+    "sort-child-notes": "Alt notları sırala"
   }
 }

apps/server/src/assets/views/print.ejs

@@ -1,32 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="utf-8">
-    <link rel="shortcut icon" href="favicon.ico">
-    <meta name="mobile-web-app-capable" content="yes">
-    <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, viewport-fit=cover" />
-    <link rel="manifest" crossorigin="use-credentials" href="../manifest.webmanifest">
-    <title>Trilium Notes</title>
-    <script src="../<%= appPath %>/runtime.js" crossorigin type="module"></script>
-</head>
-<body
-  id="trilium-print"
-  lang="<%= currentLocale.id %>" dir="<%= currentLocale.rtl ? 'rtl' : 'ltr' %>"
->
-<noscript><%= t("javascript-required") %></noscript>
-
-<script>
-    // hide body to reduce flickering on the startup. This is done through JS and not CSS to not hide <noscript>
-    document.getElementsByTagName("body")[0].style.display = "none";
-</script>
-
-<%- include("./partials/windowGlobal.ejs", locals) %>
-
-<!-- Required for correct loading of scripts in Electron -->
-<script>if (typeof module === 'object') {window.module = module; module = undefined;}</script>
-
-<script src="../<%= appPath %>/print.js" crossorigin type="module"></script>
-
-</body>
-</html>

apps/server/src/becca/becca.ts

@@ -1,7 +1,2 @@
-"use strict";
-
-import Becca from "./becca-interface.js";
-
-const becca = new Becca();
-
+import { becca } from "@triliumnext/core";
 export default becca;